from abc import ABCMeta
class Sized(metaclass=ABCMeta):
@classmethod
def __subclasshook__(cls, C):
if cls is Sized:
if any("__len__" in B.__dict__ for B in C.__mro__):
return True
return NotImplemented
class A(object):
pass
class B(object):
def __len__(self):
return 0
issubclass(A, Sized) # False
issubclass(B, Sized) # True
Return true if subclass should be considered a (direct or indirect) subclass of class. If defined, called to implement issubclass(subclass, class).
Note that these methods are looked up on the type (metaclass) of a class. They cannot be defined as class methods in the actual class. This is consistent with the lookup of special methods that are called on instances, only in this case the instance is itself a class.
这个方法是负责定制issubclass检查的特殊方法。就像“Note”声明它必须在元类上实现一样!
class YouWontFindSubclasses(type):
def __subclasscheck__(cls, subclass):
print(cls, subclass)
return False
class MyCls(metaclass=YouWontFindSubclasses):
pass
class MySubCls(MyCls):
pass
class SpecialSubs(type):
def __subclasscheck__(cls, subclass):
required_attrs = getattr(cls, '_required_attrs', [])
for attr in required_attrs:
if any(attr in sub.__dict__ for sub in subclass.__mro__):
continue
return False
return True
class MyCls(metaclass=SpecialSubs):
_required_attrs = ['__len__', '__iter__']
>>> issubclass(int, MyCls) # ints have no __len__ or __iter__
False
>>> issubclass(list, MyCls) # but lists and dicts have
True
>>> issubclass(dict, MyCls)
True
class Meta(type):
def __subclasscheck__(cls, subclass):
"""Just modify the behavior for classes that aren't genuine subclasses."""
if super().__subclasscheck__(subclass):
return True
else:
# Not a normal subclass, implement some customization here.
Check whether subclass is considered a subclass of this ABC. This means that you can customize the behavior of issubclass further without the need to call register() on every class you want to consider a subclass of the ABC. (This class method is called from the __subclasscheck__() method of the ABC.)
This method should return True, False or NotImplemented. If it returns True, the subclass is considered a subclass of this ABC. If it returns False, the subclass is not considered a subclass of this ABC, even if it would normally be one. If it returns NotImplemented, the subclass check is continued with the usual mechanism.
from abc import ABCMeta, abstractmethod
def _check_methods(C, *methods):
mro = C.__mro__
for method in methods:
for B in mro:
if method in B.__dict__:
if B.__dict__[method] is None:
return NotImplemented
break
else:
return NotImplemented
return True
class Hashable(metaclass=ABCMeta):
__slots__ = ()
@abstractmethod
def __hash__(self):
return 0
@classmethod
def __subclasshook__(cls, C):
if cls is Hashable:
return _check_methods(C, "__hash__")
return NotImplemented
因此,如果您检查某个东西是否是Hashable的子类,它将使用由if cls is Hashable保护的自定义__subclasshook__实现。但是,如果您有一个实现Hashable接口的实际类,您不希望它继承__subclasshook__机制,而希望它继承普通的子类机制。
例如:
class MyHashable(Hashable):
def __hash__(self):
return 10
>>> issubclass(int, MyHashable)
False
即使int实现了__hash__,并且__subclasshook__检查了__hash__实现,在本例中的结果是False。它仍然进入Hashable的__subclasshook__,但它立即返回NotImplemented,这向ABCMeta发出信号,表明它应该使用正常实现继续。如果没有if cls is Hashable,那么issubclass(int, MyHashable)将返回True!
^{} 和^{} 用于自定义
issubclass
函数的行为。 更多信息请参见abc source code。__subclasscheck__
查找类的类型(元类)。它不应该为普通类定义。__subclasshook__
检查子类是否被视为某些ABC的子类。这意味着您可以进一步定制issubclass
的行为,而无需对要考虑ABC的子类的每个类调用register()。这意味着您可以用一些条件在ABC类中定义
__subclasshook__
,并且满足该条件的所有类都将作为子类考虑。例如:
这两个方法都可以用于自定义^{} 内置函数的结果。
^{}
这个方法是负责定制
issubclass
检查的特殊方法。就像“Note”声明它必须在元类上实现一样!即使您有真正的子类,此实现也将返回False:
实际上,
__subclasscheck__
实现有更有趣的用途。例如:使用此实现,任何定义
__len__
和__iter__
的类都将在issubclass
检查中返回True
在这些示例中,我没有调用超类
__subclasscheck__
,因此禁用了正常的issubclass
行为(它由type.__subclasscheck__
实现)。但重要的是要知道,您也可以选择仅扩展正常行为而不是完全覆盖它:^{}
这里重要的一点是,它在类上定义为
classmethod
,并由abc.ABC.__subclasscheck__
调用。因此,只有在处理具有ABCMeta
元类的类时才能使用它:这只会进入第一个的
__subclasshook__
:注意,后续的
issubclass
调用不再进入__subclasshook__
,因为ABCMeta
缓存结果:注意,通常检查第一个参数是否是类本身。这是为了避免子类“继承”子类而不是使用常规的子类确定。
例如(来自CPython
collections.abc
模块):因此,如果您检查某个东西是否是
Hashable
的子类,它将使用由if cls is Hashable
保护的自定义__subclasshook__
实现。但是,如果您有一个实现Hashable
接口的实际类,您不希望它继承__subclasshook__
机制,而希望它继承普通的子类机制。例如:
即使
int
实现了__hash__
,并且__subclasshook__
检查了__hash__
实现,在本例中的结果是False
。它仍然进入Hashable
的__subclasshook__
,但它立即返回NotImplemented
,这向ABCMeta
发出信号,表明它应该使用正常实现继续。如果没有if cls is Hashable
,那么issubclass(int, MyHashable)
将返回True
!什么时候应该使用
__subclasscheck__
,什么时候应该使用__subclasshook__
?这要看情况。
__subclasshook__
可以在类而不是元类上实现,但需要使用ABCMeta
(或ABCMeta
的子类)作为元类,因为__subclasshook__
方法实际上只是Pythonsabc
模块引入的一个约定。您始终可以使用
__subclasscheck__
,但它必须在元类上实现。在实践中,如果您实现接口(因为这些接口通常使用
abc
),并且希望自定义子类机制,则使用__subclasshook__
。如果你想发明自己的约定(比如abc
),你可以使用__subclasscheck__
。所以在99.99%的正常(不好玩)情况下,你只需要__subclasshook__
。相关问题 更多 >
编程相关推荐