Tính trừu tượng trong Python

Câu trả lời của Oddthinking là không sai, nhưng tôi nghĩ rằng nó bỏ lỡ lý do thực tế, thực tế Python có ABC trong một thế giới của việc gõ vịt.

Nội dung chính Show

• Những lợi ích của lớp trừu tượng là gì?
• Mục đích của các lớp trừu tượng là gì?
• Khi nào tôi nên sử dụng Python lớp trừu tượng?
• Tại sao sự trừu tượng lại quan trọng trong Python?

Các phương pháp trừu tượng là gọn gàng, nhưng theo tôi, chúng không thực sự lấp đầy bất kỳ trường hợp sử dụng nào chưa được bao phủ bởi việc gõ vịt. Sức mạnh thực sự của các lớp cơ sở trừu tượng nằm ở cách chúng cho phép bạn tùy chỉnh hành vi của

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

38 và

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

0. .

Mã nguồn của Python là mẫu mực. Dưới đây là cách

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

4 được xác định trong thư viện tiêu chuẩn [tại thời điểm viết]:

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

Định nghĩa này của

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

1 nói rằng bất kỳ lớp nào có thuộc tính

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

6 đều được coi là một lớp con của container, ngay cả khi nó không phân lớp trực tiếp. Vì vậy, tôi có thể viết cái này:

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

Nói cách khác, nếu bạn thực hiện giao diện phù hợp, bạn là một lớp con! ABC cung cấp một cách chính thức để xác định các giao diện trong Python, trong khi vẫn đúng với tinh thần gõ vịt. Bên cạnh đó, điều này hoạt động theo cách tôn vinh nguyên tắc đóng cửa.

Mô hình đối tượng của Python trông rất giống với hệ thống OO "truyền thống" hơn [theo ý tôi là java*] - chúng tôi có các lớp yer, đối tượng yer, phương pháp yer - nhưng khi bạn gãi bề mặt, bạn sẽ tìm thấy thứ gì đó phong phú hơn và Linh hoạt hơn. Tương tự như vậy, khái niệm của Python về các lớp cơ sở trừu tượng có thể được nhận ra đối với một nhà phát triển Java, nhưng trong thực tế, chúng được dự định cho một mục đích rất khác.

Đôi khi tôi thấy mình viết các hàm đa hình có thể hoạt động trên một mục hoặc một bộ sưu tập các mục và tôi thấy

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

7 dễ đọc hơn nhiều so với

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

8 hoặc khối

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

9 tương đương. [Nếu bạn không biết Python, trong số ba người đó sẽ làm cho ý định của mã rõ ràng nhất?]

Điều đó nói rằng, tôi thấy rằng tôi hiếm khi cần phải viết ABC của riêng mình và tôi thường khám phá ra sự cần thiết của một thông qua việc tái cấu trúc. Nếu tôi thấy một hàm đa hình tạo ra nhiều kiểm tra thuộc tính hoặc nhiều chức năng thực hiện kiểm tra thuộc tính tương tự, mùi đó cho thấy sự tồn tại của ABC đang chờ được trích xuất.

*Không tham gia vào cuộc tranh luận về việc Java có phải là hệ thống OO "truyền thống" ...

Phụ lục: Mặc dù một lớp cơ sở trừu tượng có thể ghi đè hành vi của

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

38 và

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

0, nhưng nó vẫn không vào MRO của lớp con ảo. Đây là một cạm bẫy tiềm năng cho khách hàng: không phải mọi đối tượng mà

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

02 đều có các phương thức được xác định trên

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

03.: Even though an abstract base class can override the behaviour of

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

38 and

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

0, it still doesn't enter the MRO of the virtual subclass. This is a potential pitfall for clients: not every object for which

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

02 has the methods defined on

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

03.

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

0

Thật không may, đây là một trong những cái bẫy "không làm điều đó" [trong đó Python có tương đối ít!]: Tránh xác định ABC với cả phương pháp

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

1 và không Abstract. Hơn nữa, bạn nên làm cho định nghĩa của bạn về

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

1 phù hợp với tập hợp các phương thức trừu tượng mà ABC của bạn xác định.

Một lớp trừu tượng có thể được coi là một kế hoạch chi tiết cho các lớp khác. Nó cho phép bạn tạo một tập hợp các phương thức phải được tạo trong bất kỳ lớp con nào được xây dựng từ lớp trừu tượng. Một lớp chứa một hoặc nhiều phương thức trừu tượng được gọi là một lớp trừu tượng. Một phương pháp trừu tượng là một phương pháp có khai báo nhưng không có việc thực hiện. Trong khi chúng tôi đang thiết kế các đơn vị chức năng lớn, chúng tôi sử dụng một lớp trừu tượng. Khi chúng tôi muốn cung cấp một giao diện chung cho các triển khai khác nhau của một thành phần, chúng tôi sử dụng một lớp trừu tượng. [API] cho một tập hợp các lớp con. Khả năng này đặc biệt hữu ích trong các tình huống mà bên thứ ba sẽ cung cấp các triển khai, chẳng hạn như với các plugin, nhưng cũng có thể giúp bạn khi làm việc trong một nhóm lớn hoặc với một cơ sở mã lớn trong đó giữ cho tất cả các lớp trong tâm trí của bạn là khó khăn hoặc không thể. Python đi kèm với một mô -đun cung cấp cơ sở để xác định các lớp cơ sở trừu tượng [ABC] và tên mô -đun đó là ABC. ABC hoạt động bằng cách trang trí các phương pháp của lớp cơ sở là trừu tượng và sau đó đăng ký các lớp bê tông dưới dạng triển khai cơ sở trừu tượng. Một phương pháp trở nên trừu tượng khi được trang trí bằng từ khóa @abstractmethod. Ví dụ - & nbsp;
  
Why use Abstract Base Classes : 
By defining an abstract base class, you can define a common Application Program Interface[API] for a set of subclasses. This capability is especially useful in situations where a third-party is going to provide implementations, such as with plugins, but can also help you when working in a large team or with a large code-base where keeping all classes in your mind is difficult or not possible. 
  
How Abstract Base classes work : 
By default, Python does not provide abstract classes. Python comes with a module that provides the base for defining Abstract Base classes[ABC] and that module name is ABC. ABC works by decorating methods of the base class as abstract and then registering concrete classes as implementations of the abstract base. A method becomes abstract when decorated with the keyword @abstractmethod. For Example –
 

Mã 1:

Python3

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

06

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

07

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

08

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

09

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

20

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

21

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

22

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

23

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

22

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

25

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

26

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

27

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

28

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

29

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

20

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

20

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

22

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

22

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

25

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

26

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

27

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

28

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

29

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

29

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

20

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

21

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

22

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

20

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

22

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

20

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

24

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

29

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

29

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

20

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

23

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

22

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

22

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

25

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

26

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

27

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

28

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

22

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

25

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

26

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

27

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

28

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

29

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

29

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

20

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

75

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

22

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

20

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

22

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

22

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

25

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

26

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

27

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

28

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

29

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

29

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

20

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

97

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

22

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

20

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

22

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

382

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

20

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

24

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

386

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

22

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

25

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

26

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

27

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

28

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

382

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

20

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

26

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

386

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

20

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

78 
 

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

2

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

99

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

380

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

381
Code 2: 

Python3

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

06

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

07

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

08

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

09

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

20

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

21

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

22

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

25

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

26

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

27

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

28

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

29

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

20

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

20

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

22

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

22

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

25

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

26

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

27

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

28

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

29

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

29

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

20

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

28

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

22

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

20

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

22

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

22

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

25

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

26

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

27

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

28

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

29

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

29

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

20

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

40

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

22

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

20

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

22

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

22

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

25

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

26

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

27

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

28

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

29

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

29

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

20

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

52

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

22

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

20

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

22

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

22

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

25

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

26

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

27

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

28

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

29

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

29

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

20

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

64

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

22

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

20

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

22

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

69

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

20

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

24

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

73

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

22

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

25

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

26

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

27

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

28

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

69

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

20

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

26

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

73

Output:   
 

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

2

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

20

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

78
Implementation Through Subclassing : 
By subclassing directly from the base, we can avoid the need to register the class explicitly. In this case, the Python class management is used to recognize PluginImplementation as implementing the abstract PluginBase. 
 

Python3

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

99

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

380

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

381

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

383

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

380

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

385

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

99

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

380

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

389

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

29

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

20

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

383

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

380

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

03

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

99

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

380

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

389

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

29

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

29

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

20

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

003

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

22

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

29

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

006

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

0

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

008

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

29

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

006

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

38

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

012

Output:   
 

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

2

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

383

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

380

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

03
  
Concrete Methods in Abstract Base Classes : 
Concrete classes contain only concrete [normal]methods whereas abstract classes may contain both concrete methods and abstract methods. The concrete class provides an implementation of abstract methods, the abstract base class can also provide an implementation by invoking the methods via super[]. 
 

Hãy xem qua ví dụ để gọi phương thức bằng Super []: & nbsp; & nbsp;

Python3

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

08

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

83

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

06

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

07

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

08

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

09

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

20

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

020

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

22

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

25

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

023

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

27

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

28

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

29

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

29

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

20

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

029

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

22

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

20

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

032

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

22

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

25

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

023

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

27

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

28

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

29

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

039

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

040

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

29

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

29

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

20

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

044

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

22

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

20

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

032

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

049

Output:   
 

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

2

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

046

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

380

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

048
  
Abstract Properties : 
Abstract classes include attributes in addition to methods, you can require the attributes in concrete classes by defining them with @abstractproperty. 
 

Python3

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

08

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

83

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

06

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

07

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

08

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

09

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

20

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

020

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

22

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

059

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

060

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

22

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

25

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

023

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

27

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

28

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

20

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

032

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

046

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

380

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

048

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

22

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

072

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

22

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

25

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

023

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

27

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

28

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

20

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

032

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

081

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

082

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

22

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

046

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

380

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

086

class Container[metaclass=ABCMeta]:
    __slots__ = []

    @abstractmethod
    def __contains__[self, x]:
        return False

    @classmethod
    def __subclasshook__[cls, C]:
        if cls is Container:
            if any["__contains__" in B.__dict__ for B in C.__mro__]:
                return True
        return NotImplemented

22

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

29

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

089

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

046

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

380

class ContainAllTheThings[object]:
    def __contains__[self, item]:
        return True

>>> issubclass[ContainAllTheThings, collections.Container]
True
>>> isinstance[ContainAllTheThings[], collections.Container]
True

048

Trong chương trình trên, chúng ta có thể gọi các phương thức trong các lớp trừu tượng bằng cách sử dụng Super []. & NBSP; & nbsp; & nbsp; thuộc tính trừu tượng: & nbsp; các lớp trừu tượng bao gồm các thuộc tính ngoài các phương thức, bạn có thể yêu cầu các thuộc tính trong các lớp cụ thể bằng cách xác định chúng với @Tóm tắtProperty. & NBSP; & NBSP;