如何在Python中使类或方法抽象?
我尝试像这样重新定义__new__():
class F:
def __new__(cls):
raise Exception("Unable to create an instance of abstract class %s" %cls)
但是现在，如果我创建一个从F继承的类G，像这样:
class G(F):
pass
然后，我也不能实例化G，因为它调用它的超类的__new__方法。
是否有更好的方法来定义抽象类?
当前回答
只是对@TimGilbert老派回答的一个快速补充…你可以让你的抽象基类的init()方法抛出一个异常，这将阻止它被实例化，不是吗?
>>> class Abstract(object):
... def __init__(self):
... raise NotImplementedError("You can't instantiate this class!")
...
>>> a = Abstract()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 3, in __init__
NotImplementedError: You can't instantiate this class!
其他回答
这个方法也很简单:
class A_abstract(object):
def __init__(self):
# quite simple, old-school way.
if self.__class__.__name__ == "A_abstract":
raise NotImplementedError("You can't instantiate this abstract class. Derive it, please.")
class B(A_abstract):
pass
b = B()
# here an exception is raised:
a = A_abstract()
老式的(pre-PEP 3119)方法是在调用抽象方法时在抽象类中引发NotImplementedError。
class Abstract(object):
def foo(self):
raise NotImplementedError('subclasses must override foo()!')
class Derived(Abstract):
def foo(self):
print 'Hooray!'
>>> d = Derived()
>>> d.foo()
Hooray!
>>> a = Abstract()
>>> a.foo()
Traceback (most recent call last): [...]
它没有像使用abc模块那样好的属性。您仍然可以实例化抽象基类本身，并且直到在运行时调用抽象方法时才会发现错误。
但是如果您处理的是一小组简单类，可能只有几个抽象方法，那么这种方法比费力地查阅abc文档要容易一些。
正如在其他答案中解释的那样，是的，您可以使用abc模块在Python中使用抽象类。下面我给出了一个实际的例子，使用抽象的@classmethod， @property和@abstractmethod(使用Python 3.6+)。对我来说，通常更容易从例子开始，我可以很容易地复制和粘贴;我希望这个答案对其他人也有用。
让我们首先创建一个基类base:
from abc import ABC, abstractmethod
class Base(ABC):
@classmethod
@abstractmethod
def from_dict(cls, d):
pass
@property
@abstractmethod
def prop1(self):
pass
@property
@abstractmethod
def prop2(self):
pass
@prop2.setter
@abstractmethod
def prop2(self, val):
pass
@abstractmethod
def do_stuff(self):
pass
我们的基类总是有一个from_dict类方法，一个属性prop1(只读)和一个属性prop2(也可以设置)，以及一个名为do_stuff的函数。现在基于Base构建的任何类都必须实现所有这四个方法/属性。请注意，对于一个抽象的方法，需要两个装饰器——classmethod和abstract property。
现在我们可以像这样创建一个a类:
class A(Base):
def __init__(self, name, val1, val2):
self.name = name
self.__val1 = val1
self._val2 = val2
@classmethod
def from_dict(cls, d):
name = d['name']
val1 = d['val1']
val2 = d['val2']
return cls(name, val1, val2)
@property
def prop1(self):
return self.__val1
@property
def prop2(self):
return self._val2
@prop2.setter
def prop2(self, value):
self._val2 = value
def do_stuff(self):
print('juhu!')
def i_am_not_abstract(self):
print('I can be customized')
所有必需的方法/属性都实现了，当然，我们还可以添加其他不属于Base的函数(这里:i_am_not_abstract)。
现在我们可以做:
a1 = A('dummy', 10, 'stuff')
a2 = A.from_dict({'name': 'from_d', 'val1': 20, 'val2': 'stuff'})
a1.prop1
# prints 10
a1.prop2
# prints 'stuff'
正如期望的那样，我们不能设置prop1:
a.prop1 = 100
将返回
AttributeError:不能设置属性
我们的from_dict方法也可以很好地工作:
a2.prop1
# prints 20
如果我们现在像这样定义第二个类B:
class B(Base):
def __init__(self, name):
self.name = name
@property
def prop1(self):
return self.name
并尝试像这样实例化一个对象:
b = B('iwillfail')
我们会得到一个错误
不能用抽象方法实例化抽象类B Do_stuff, from_dict, prop2
列出所有在Base中定义的东西，这些东西我们没有在B中实现。
这里有一个不需要处理ABC模块的非常简单的方法。
在你想要成为抽象类的类的__init__方法中，你可以检查self的“类型”。如果self类型是基类，则调用者试图实例化基类，因此引发异常。这里有一个简单的例子:
class Base():
def __init__(self):
if type(self) is Base:
raise Exception('Base is an abstract class and cannot be instantiated directly')
# Any initialization code
print('In the __init__ method of the Base class')
class Sub(Base):
def __init__(self):
print('In the __init__ method of the Sub class before calling __init__ of the Base class')
super().__init__()
print('In the __init__ method of the Sub class after calling __init__ of the Base class')
subObj = Sub()
baseObj = Base()
当运行时，它产生:
In the __init__ method of the Sub class before calling __init__ of the Base class
In the __init__ method of the Base class
In the __init__ method of the Sub class after calling __init__ of the Base class
Traceback (most recent call last):
File "/Users/irvkalb/Desktop/Demo files/Abstract.py", line 16, in <module>
baseObj = Base()
File "/Users/irvkalb/Desktop/Demo files/Abstract.py", line 4, in __init__
raise Exception('Base is an abstract class and cannot be instantiated directly')
Exception: Base is an abstract class and cannot be instantiated directly
这表明您可以实例化继承自基类的子类，但不能直接实例化基类。
我发现公认的答案和其他答案都很奇怪，因为它们把self传递给了一个抽象类。抽象类没有实例化，所以不能有self。
试试这个吧，很管用。
from abc import ABCMeta, abstractmethod
class Abstract(metaclass=ABCMeta):
@staticmethod
@abstractmethod
def foo():
"""An abstract method. No need to write pass"""
class Derived(Abstract):
def foo(self):
print('Hooray!')
FOO = Derived()
FOO.foo()
