ABC
Helper class，其 metaclass 為 ABCMeta。當一個 Class 繼承自 ABC 時，它就成為 Abstract Base Class。
PYTHON
abc.ABCABC 是包含多個 abstract 方法和 abstract 屬性的 Class，但需要 non-abstract subclass，來提供實現方法和屬性。
這是一種比建立自定義 metaclass 更方便的技術。
Example 1: Basic usage
PYTHON
from abc import ABC, abstractmethod
class Vehicle(ABC):
@abstractmethod
def max_speed(self):
pass
class Car(Vehicle):
@property
def max_speed(self):
return 200
car = Car()
print(f"Car's max speed: {car.max_speed} km/h") # Output: 200 km/hExample 2: Basic usage
PYTHON
from abc import ABC, abstractmethod
class Shape(ABC):
@abstractmethod
def area(self):
pass
@abstractmethod
def perimeter(self):
pass
class Rectangle(Shape):
def __init__(self, width, height):
self.width = width
self.height = height
def area(self):
return self.width * self.height
def perimeter(self):
return 2 * (self.width + self.height)
# Trying to instantiate Shape will raise an error
# shape = Shape()
# Working with a concrete implementation
rect = Rectangle(10, 20)
print(f"Rectangle area: {rect.area()}") # Output: 200
print(f"Rectangle perimeter: {rect.perimeter()}") # Output: 60ABCMeta
定義 Abstract Base Classes (ABCs) 的 metaclass。 Python 中的 metaclass 是 class 的 class，它定義了 class 的行為方式。 abc.ABCMeta 提供了在 ABC 中定義 abstract 方法和屬性的機制。
如果不想繼承 ABC，可以透過在 Class 中設定 metaclass=ABCMeta ，來建立 Abstract Base Class。
PYTHON
abc.ABCMeta雖然您可以直接使用 abc.ABCMeta，但從 abc.ABC 繼承通常更簡單且更具可讀性，它抽象化了 metaclasses 的直接使用。
Example 1: Basic usage
PYTHON
from abc import ABCMeta, abstractmethod
class Graphic(metaclass=ABCMeta):
@abstractmethod
def draw(self):
pass
class Circle(Graphic):
def draw(self):
print("Drawing a circle")
# Trying to instantiate Graphic will raise an error
# graphic = Graphic()
# Working with a concrete implementation
circle = Circle()
circle.draw() # Output: Drawing a circleExample 2: Basic usage
PYTHON
from abc import ABCMeta, abstractmethod, abstractproperty
class Vehicle(metaclass=ABCMeta):
@abstractproperty
def max_speed(self):
pass
class Car(Vehicle):
@property
def max_speed(self):
return 150
car = Car()
print(f"Car's max speed: {car.max_speed} km/h")register()
用於將具體 class 註冊為 abstract base class 的 "Virtual subclass"，這意味著即使它沒有繼承自 ABC，但仍能被 issubclass() 和 isinstance() 等函數識別為 subclass。
PYTHON
@ABC.registerPYTHON
ABC.register(Subclass)Virtual subclass: 視為另一個 Class 的 subclass，但實際上並沒有繼承自另一個 Class。
issubclass() 和 isinstance() 會將註冊的 classes，視為 subclasses，即使它們不是從傳統意義上的 ABC 繼承。
盡可能使用 register() 作為 decorator，因為它使 ABC 和註冊 class 之間的關係更加明顯。
請務必記錄 register() 的使用，因為一個 class 被視為 ABC 的 subclass 的原因，並不總是顯而易見的。
Example 1: Using Decorator
PYTHON
from abc import ABC, abstractmethod
class MyABC(ABC):
@abstractmethod
def do_something(self):
pass
@MyABC.register
class ConcreteClass:
@property
def do_something(self):
return "Doing something in ConcreteClass"
print(issubclass(ConcreteClass, MyABC)) # Output: True
print(issubclass(ConcreteClass, ABC)) # Output: True
x = ConcreteClass()
print(x.do_something) # Output: Doing something in ConcreteClassExample 2: Using Method Call
PYTHON
from abc import ABC, abstractmethod
class MyABC(ABC):
@abstractmethod
def do_something(self):
pass
class AnotherClass:
@property
def do_something_else(self):
return "Doing something in ConcreteClass"
# Registering using method call syntax
MyABC.register(AnotherClass)
# AnotherClass is now considered a subclass of MyABC
print(issubclass(AnotherClass, MyABC)) # Output: True
print(issubclass(AnotherClass, ABC)) # Output: True
x = AnotherClass()
print(x.do_something_else) # Output: Doing something in ConcreteClassExample 3: Basic usage
當一個 class 繼承自 parent class 時，parent class 會以其方法解析順序 (MRO) 出現，這是 Python 在呼叫方法時，查找方法的順序。
但是，如果一個 class 被註冊為 ABC 的虛擬 subclass，則該 ABC 不會出現在其 MRO 中。這表示 ABC 中定義的方法，不會自動可供虛擬 subclass 使用，而且您不能在虛擬 subclass 中使用 super() 來呼叫這些方法。
PYTHON
from abc import ABC, ABCMeta, abstractmethod
# Defining the ABC
class MyAbstractBaseClass(metaclass=ABCMeta):
@abstractmethod
def my_method(self):
pass
# Registering a virtual subclass
class UnrelatedClass:
def my_method(self):
print("Implementation in UnrelatedClass")
MyAbstractBaseClass.register(UnrelatedClass)
print(issubclass(UnrelatedClass, MyAbstractBaseClass)) # Outputs: True
print(issubclass(MyAbstractBaseClass, ABC)) # Outputs: False
print(issubclass(MyAbstractBaseClass, ABCMeta)) # Outputs: False
# =========================================================
# Defining the ABC
class MyAbstractBaseClass(ABC):
@abstractmethod
def my_method(self):
pass
# Registering a virtual subclass
class UnrelatedClass:
def my_method(self):
print("Implementation in UnrelatedClass")
MyAbstractBaseClass.register(UnrelatedClass)
print(issubclass(UnrelatedClass, MyAbstractBaseClass)) # Outputs: True
print(issubclass(MyAbstractBaseClass, ABC)) # Outputs: True
print(issubclass(MyAbstractBaseClass, ABCMeta)) # Outputs: FalseExample 4: 影像處理
PYTHON
import cv2
import numpy as np
from abc import ABC, abstractmethod
class ImageProcessor(ABC):
@abstractmethod
def process(self, image: np.ndarray) -> np.ndarray:
"""Process an image and return the result."""
pass
class GrayscaleConverter:
def process(self, image: np.ndarray) -> np.ndarray:
return cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# Registering with the abstract base class
ImageProcessor.register(GrayscaleConverter)
class ImageBlurrer:
def process(self, image: np.ndarray) -> np.ndarray:
return cv2.GaussianBlur(image, (5, 5), 0)
# Registering with the abstract base class
ImageProcessor.register(ImageBlurrer)
# Checking if the classes are registered as subclasses
print(issubclass(GrayscaleConverter, ImageProcessor))
print(issubclass(ImageBlurrer, ImageProcessor))
# Example usage
image = cv2.imread('113833397_p0.jpg')
grayscale_converter = GrayscaleConverter()
blurrer = ImageBlurrer()
gray_image = grayscale_converter.process(image)
blurred_image = blurrer.process(image)@abstractmethod
當此 decorator 應用於 abstract base class 中的方法時，表示該方法是抽象的。這意味著必須在 ABC 的任何非抽象 subclass 中重寫該方法。
PYTHON
@abc.abstractmethod@abc.abstractmethod 只能影響使用繼承衍生的 subclass； 使用 register() 註冊的 Virtual subclass 不受影響。
使用 abstract base classes 和 @abc.abstractmethod 主要為一組 subclasses 定義公共 interface。
清楚記錄每個抽象方法應該做什麼，因為這可以作為開發人員實作 subclasses 的指南。
當 @abc.abstractmethod 與其他 decorator 結合使用時，應將 abstractmethod 作為最內層 decorator。
例如: @property、@classmethod 和 @staticmethod。
Example 1: Basic usage
PYTHON
import abc
import math
class Shape(abc.ABC):
@abc.abstractmethod
def area(self):
"""Method to calculate the area of the shape."""
pass
class Circle(Shape):
def __init__(self, radius):
self.radius = radius
def area(self):
return math.pi * self.radius ** 2
class Rectangle(Shape):
def __init__(self, length, width):
self.length = length
self.width = width
def area(self):
return self.length * self.width
def print_area(shape):
print(f"The area of the {shape.__class__.__name__} is {shape.area()}")
# Create instances and use them
circle = Circle(5)
rectangle = Rectangle(4, 6)
print_area(circle) # Output: The area of the Circle is 78.539
print_area(rectangle) # Output: The area of the Rectangle is 24Example 2: Basic usage
PYTHON
import abc
class ElectronicDevice(abc.ABC):
@abc.abstractmethod
def turn_on(self):
pass
@abc.abstractmethod
def turn_off(self):
pass
@property
@abc.abstractmethod
def is_on(self):
pass
class Television(ElectronicDevice):
def __init__(self):
self._is_on = False
def turn_on(self):
if not self._is_on:
self._is_on = True
print("Television is now ON.")
def turn_off(self):
if self._is_on:
self._is_on = False
print("Television is now OFF.")
@property
def is_on(self):
return self._is_on
# Function to demonstrate usage
def test_device(device):
print(f"Is the device on? {device.is_on}")
device.turn_on()
print(f"Is the device on? {device.is_on}")
device.turn_off()
print(f"Is the device on? {device.is_on}")
# Create an instance and use it
tv = Television()
test_device(tv)執行結果:
Is the device on? No
Television is now ON.
Is the device on? Yes
Television is now OFF.
Is the device on? NoExample 3: 抽象 Properties
PYTHON
import abc
class Vehicle(abc.ABC):
@property
@abc.abstractmethod
def number_of_wheels(self):
"""Abstract property for the number of wheels in a vehicle."""
pass
class Car(Vehicle):
@property
def number_of_wheels(self):
return 4
class Motorcycle(Vehicle):
@property
def number_of_wheels(self):
return 2
# Testing the implementation
car = Car()
motorcycle = Motorcycle()
print(f"A car has {car.number_of_wheels} wheels.")
print(f"A motorcycle has {motorcycle.number_of_wheels} wheels.")
# Output: A car has 4 wheels..
# Output: A motorcycle has 2 wheels.Example 4: 混合具體方法和抽象方法
PYTHON
import abc
class Computer(abc.ABC):
@abc.abstractmethod
def processor(self):
"""Abstract method to define the type of processor."""
pass
def boot(self):
"""Concrete method to boot the computer."""
print(f"Booting up with a {self.processor()} processor.")
class Laptop(Computer):
def processor(self):
return "Intel Core i7"
class Server(Computer):
def processor(self):
return "AMD Ryzen 9"
# Testing the implementation
laptop = Laptop()
server = Server()
laptop.boot() # Output: Booting up with a Intel Core i7 processor.
server.boot() # Output: Booting up with a AMD Ryzen 9 processor.
Example 5: 影像處理
PYTHON
import abc
import cv2
import numpy as np
class ImageProcessor(abc.ABC):
@abc.abstractmethod
def process(self, image):
"""
Process an image and return the result.
"""
pass
def load_image(self, path):
"""
Load an image from a given path.
"""
return cv2.imread(path, cv2.IMREAD_COLOR)
def save_image(self, image, path):
"""
Save an image to a given path.
"""
cv2.imwrite(path, image)
class GaussianBlurProcessor(ImageProcessor):
def process(self, image):
"""
Apply Gaussian blur to the image.
"""
return cv2.GaussianBlur(image, (5, 5), 0)
class CannyEdgeProcessor(ImageProcessor):
def process(self, image):
"""
Apply Canny Edge Detection to the image.
"""
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
edges = cv2.Canny(gray, 100, 200)
return edges
def main():
input_path = '113833397_p0.jpg'
output_path_blur = 'output_blur.jpg'
output_path_edges = 'output_edges.jpg'
# Initialize processors
blur_processor = GaussianBlurProcessor()
edge_processor = CannyEdgeProcessor()
# Load image
image = blur_processor.load_image(input_path)
# Process and save images
blurred_image = blur_processor.process(image)
blur_processor.save_image(blurred_image, output_path_blur)
edge_image = edge_processor.process(image)
edge_processor.save_image(edge_image, output_path_edges)
if __name__ == "__main__":
main()Last updated
Was this helpful?
