是否可以创建抽象类?

如何在Python中使类或方法抽象?

我试着像这样重新定义__new__():

class F:
def __new__(cls):
raise Exception("Unable to create an instance of abstract class %s" %cls)

但现在如果我创建一个类G，它继承自F，如下所示:

class G(F):
pass

那么我也不能实例化G，因为它调用它的超类的__new__方法。

是否有更好的方法来定义抽象类?

283767 次浏览
小开
最佳答案

使用abc模块创建抽象类。使用abstractmethod装饰器来声明方法抽象，并使用三种方法之一来声明类抽象，这取决于你的Python版本。

在Python 3.4及以上版本中，你可以继承ABC。在早期版本的Python中，需要将类的元类指定为ABCMeta。指定元类在Python 3和Python 2中有不同的语法。三种可能性如下所示:

# Python 3.4+
from abc import ABC, abstractmethod
class Abstract(ABC):
@abstractmethod
def foo(self):
pass

# Python 3.0+
from abc import ABCMeta, abstractmethod
class Abstract(metaclass=ABCMeta):
@abstractmethod
def foo(self):
pass

# Python 2
from abc import ABCMeta, abstractmethod
class Abstract:
__metaclass__ = ABCMeta


@abstractmethod
def foo(self):
pass

无论使用哪种方式，都不能实例化具有抽象方法的抽象类，但可以实例化提供这些方法的具体定义的子类:

>>> Abstract()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: Can't instantiate abstract class Abstract with abstract methods foo
>>> class StillAbstract(Abstract):
...     pass
...
>>> StillAbstract()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: Can't instantiate abstract class StillAbstract with abstract methods foo
>>> class Concrete(Abstract):
...     def foo(self):
...         print('Hello, World')
...
>>> Concrete()
<__main__.Concrete object at 0x7fc935d28898>
小开

在你的代码片段中，你也可以通过在子类中提供__new__方法的实现来解决这个问题，类似地:

def G(F):
def __new__(cls):
# do something here

但这是一个黑客，我建议你不要这样做，除非你知道你在做什么。对于几乎所有的情况，我建议你使用abc模块，这是其他人在我之前建议过的。

另外，当你创建一个新的(基)类时，让它成为object的子类，就像这样:class MyBaseClass(object):。我不知道它是否还有那么重要，但它有助于保持代码的风格一致性

小开

老式的(pre-PEP 3119)方法是在调用抽象方法时在抽象类中调用raise 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文档要容易一些。

小开

这个将在python3中工作

from abc import ABCMeta, abstractmethod


class Abstract(metaclass=ABCMeta):


@abstractmethod
def foo(self):
pass


Abstract()
>>> TypeError: Can not instantiate abstract class Abstract with abstract methods foo
小开

只是对@TimGilbert老派回答的一个快速补充…你可以让你的抽象基类的初始化()方法抛出一个异常，这将阻止它被实例化，不是吗?

>>> 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()
小开

这里有一个不需要处理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

这表明您可以实例化继承自基类的子类，但不能直接实例化基类。

小开

以前的大多数答案是正确的，但下面是Python 3.7。的答案和示例。是的，你可以创建一个抽象类和方法。提醒一下，有时候一个类应该定义一个逻辑上属于一个类的方法，但是这个类不能指定如何实现这个方法。例如，在下面的父母和婴儿类，他们都吃，但实现将是不同的，因为婴儿和父母吃不同种类的食物，他们吃的次数是不同的。因此，eat方法子类重写了AbstractClass.eat。

from abc import ABC, abstractmethod


class AbstractClass(ABC):


def __init__(self, value):
self.value = value
super().__init__()


@abstractmethod
def eat(self):
pass


class Parents(AbstractClass):
def eat(self):
return "eat solid food "+ str(self.value) + " times each day"


class Babies(AbstractClass):
def eat(self):
return "Milk only "+ str(self.value) + " times or more each day"


food = 3
mom = Parents(food)
print("moms ----------")
print(mom.eat())


infant = Babies(food)
print("infants ----------")
print(infant.eat())

输出:

moms ----------
eat solid food 3 times each day
infants ----------
Milk only 3 times or more each day
小开
你也可以利用__new__方法为你的优势。你只是忘记了一些东西。 __new__方法总是返回new对象，所以你必须返回它的超类的new方法。

class F:
def __new__(cls):
if cls is F:
raise TypeError("Cannot create an instance of abstract class '{}'".format(cls.__name__))
return super().__new__(cls)

在使用新方法时，必须返回对象，而不是None关键字。这就是你错过的。

小开

正如在其他答案中解释的那样，是的，你可以使用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

我们的Base类总是有一个from_dict classmethod，一个property prop1(只读)和一个property prop2(也可以设置)以及一个名为do_stuff的函数。现在基于Base构建的任何类都必须实现所有这四个方法/属性。请注意，对于抽象方法，需要两个装饰器——classmethod和抽象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中没有实现的东西。

小开

我发现公认的答案，和所有其他奇怪，因为他们传递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()
小开 
 from abc import ABCMeta, abstractmethod


#Abstract class and abstract method declaration
class Jungle(metaclass=ABCMeta):
#constructor with default values
def __init__(self, name="Unknown"):
self.visitorName = name


def welcomeMessage(self):
print("Hello %s , Welcome to the Jungle" % self.visitorName)


# abstract method is compulsory to defined in child-class
@abstractmethod
def scarySound(self):
pass
小开

迟回答这里，但要回答另一个问题&;如何使抽象__abc0 &;在此，我提出以下几点。

# decorators.py
def abstract(f):
def _decorator(*_):
raise NotImplementedError(f"Method '{f.__name__}' is abstract")
return _decorator




# yourclass.py
class Vehicle:
def add_energy():
print("Energy added!")


@abstract
def get_make(): ...


@abstract
def get_model(): ...

类基类Vehicle仍然可以实例化用于单元测试(与ABC不同)，并且python会引发异常。哦，是的，为了方便起见，您还可以使用此方法在异常中获得抽象的方法名。

小开

你可以通过扩展< >强ABC < / >强(代表抽象基类;)来创建一个抽象类，并且可以在抽象类中使用< >强@abstractmethod < / >强创建抽象方法，如下所示:

from abc import ABC, abstractmethod


class Animal(ABC):
@abstractmethod
def sound(self):
pass

并且，要使用抽象类，它应该由子类扩展，并且子类应该覆盖抽象类的抽象方法，如下所示:

from abc import ABC, abstractmethod


class Animal(ABC):
@abstractmethod
def sound(self):
pass


class Cat(Animal): # Extends "Animal" abstract class
def sound(self): # Overrides "sound()" abstract method
print("Meow!!")


obj = Cat()
obj.sound()

输出:

Meow!!

并且，抽象方法可以有代码而不是pass，并且可以由子类调用，如下所示:

from abc import ABC, abstractmethod


class Animal(ABC):
@abstractmethod
def sound(self):
print("Wow!!") # Here


class Cat(Animal):
def sound(self):
super().sound() # Here
        

obj = Cat()
obj.sound()

输出:

Wow!!

而且，抽象类可以有变量和非抽象方法，可以由子类调用，非抽象方法不需要被子类覆盖，如下所示:

from abc import ABC, abstractmethod


class Animal(ABC):
@abstractmethod
def sound(self):
pass
    

def __init__(self): # Here
self.name = "John" # Here
    

x = "Hello" # Here
    

def test1(self): # Here
print("Test1")
    

@classmethod # Here
def test2(cls):
print("Test2")
        

@staticmethod # Here
def test3():
print("Test3")


class Cat(Animal):
def sound(self):
print(self.name) # Here
print(super().x) # Here
super().test1()  # Here
super().test2()  # Here
super().test3()  # Here


obj = Cat()
obj.sound()

输出:

John
Hello
Test1
Test2
Test3

并且，您可以在抽象类中定义抽象类和静态方法以及抽象getter、setter和delete，如下所示。*@abstractmethod必须是最内部的装饰器，否则会发生错误，你可以看到< >强劲我的答案< / >强，它解释了更多关于抽象的getter, setter和delete:

from abc import ABC, abstractmethod


class Person(ABC):


@classmethod
@abstractmethod # The innermost decorator
def test1(cls):
pass
    

@staticmethod
@abstractmethod # The innermost decorator
def test2():
pass


@property
@abstractmethod # The innermost decorator
def name(self):
pass


@name.setter
@abstractmethod # The innermost decorator
def name(self, name):
pass


@name.deleter
@abstractmethod # The innermost decorator
def name(self):
pass

然后，你需要在子类中重写它们，如下所示:

class Student(Person):
    

def __init__(self, name):
self._name = name
    

@classmethod
def test1(cls): # Overrides abstract class method
print("Test1")
    

@staticmethod
def test2(): # Overrides abstract static method
print("Test2")
    

@property
def name(self): # Overrides abstract getter
return self._name
    

@name.setter
def name(self, name): # Overrides abstract setter
self._name = name
    

@name.deleter
def name(self): # Overrides abstract deleter
del self._name

然后，你可以实例化子类并调用它们，如下所示:

obj = Student("John") # Instantiates "Student" class
obj.test1() # Class method
obj.test2() # Static method
print(obj.name) # Getter
obj.name = "Tom" # Setter
print(obj.name) # Getter
del obj.name # Deleter
print(hasattr(obj, "name"))

输出:

Test1
Test2
John
Tom
False

并且，如果你尝试实例化一个抽象类，如下所示:

from abc import ABC, abstractmethod


class Animal(ABC):
@abstractmethod
def sound(self):
pass


obj = Animal()

出现以下错误:

不能实例化抽象类Animal与抽象方法sound

并且，如果你没有在子类中重写抽象类的抽象方法，并且你实例化了子类，如下所示:

from abc import ABC, abstractmethod


class Animal(ABC):
@abstractmethod
def sound(self):
pass


class Cat(Animal):
pass # Doesn't override "sound()" abstract method


obj = Cat() # Here

出现以下错误:

不能用抽象方法实例化抽象类Cat

并且，如果你在非抽象类中定义了一个抽象方法，它没有扩展ABC，那么抽象方法是一个正常的实例方法，因此即使非抽象类被实例化，即使子类没有覆盖非抽象类的抽象方法，也不会出现错误，如下所示:

from abc import ABC, abstractmethod


class Animal: # Doesn't extend "ABC"
@abstractmethod # Here
def sound(self):
print("Wow!!")


class Cat(Animal):
pass # Doesn't override "sound()" abstract method


obj1 = Animal() # Here
obj1.sound()


obj2 = Cat() # Here
obj2.sound()

输出:

Wow!!
Wow!!

此外，你可以在下面替换Cat类扩展Animal类:

from abc import ABC, abstractmethod


class Animal(ABC):
@abstractmethod
def sound(self):
pass


# ↓↓↓ Here ↓↓↓


class Cat(Animal):
def sound(self):
print("Meow!!")


# ↑↑↑ Here ↑↑↑


print(issubclass(Cat, Animal))

下面的代码包含< >强注册()< / >强:

from abc import ABC, abstractmethod


class Animal(ABC):
@abstractmethod
def sound(self):
pass


# ↓↓↓ Here ↓↓↓


class Cat:
def sound(self):
print("Meow!!")
        

Animal.register(Cat)


# ↑↑↑ Here ↑↑↑


print(issubclass(Cat, Animal))

然后，上面的两个代码输出下面相同的结果，显示Cat类是Animal类的子类:

True

提交答案