是否有可能使抽象类在Python？(Is it possible to make abstract

我怎样才能使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__方法。

有没有更好的方法来定义一个抽象类？

Answer 1:

使用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>

Answer 2:

老派（预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文档。

Answer 3:

这里是无需处理与ABC模块一个非常简单的方法。

在__init__ ，你想成为一个抽象类的类的方法，你可以检查自己的“类型”。 如果自我的类型是基类，那么调用者试图实例化的基类，所以引发异常。 这里有一个简单的例子：

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

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

欧文

Answer 4:

这人会在Python 3合作

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

Answer 5:

以往大多数的答案是正确的，但在这里就是Python 3.7的答案和榜样。 是的，你可以创建一个抽象类和方法。 正如一个提醒，有时一类应该定义在逻辑上属于一类的方法，但该类不能指定如何实现的方法。 例如，在下面的家长和宝宝班他们都吃，但实施将是为每个不同的，因为婴儿和父母吃不同种类的食物和他们吃的是不同的次数。 所以，多吃方法的子类覆盖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())

OUTPUT：

moms ----------
eat solid food 3 times each day
infants ----------
Milk only 3 times or more each day

Answer 6:

是的，你可以与ABC（抽象基类）模块蟒蛇创建抽象类。

该网站将帮助你用它： http://docs.python.org/2/library/abc.html

Answer 7:

这也和工作很简单：

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

Answer 8:

在您的代码段，你也可以通过为实现解决这个__new__在子类中，同样的方法：

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

但是，这是一个黑客，我劝你反对它，除非你知道自己在做什么。 对于几乎所有的情况下，我建议你使用的abc模块，别人在我之前建议。

此外，当你创建一个新的（基地）类，使其子类object ，像这样： class MyBaseClass(object): 。 我不知道这是否是多显著了，但它可以帮助您的代码保持风格的一致性

Answer 9:

只是一个快速除了@ 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! 

文章来源: Is it possible to make abstract classes in Python?