Est-il possible de faire abstraction de classes en Python?

Utiliser le abc module pour créer des classes abstraites. Utiliser le abstractmethod décorateur à déclarer une méthode abstraite, et de déclarer une classe abstraite à l'aide de l'une des trois façons, en fonction de votre version de Python.

En Python 3.4 et au-dessus, vous pouvez hériter de ABC. Dans les précédentes versions de Python, vous devez spécifier la classe de la métaclasse comme ABCMeta. La spécification de la métaclasse a une syntaxe différente en Python 3 et Python 2. Les trois possibilités sont illustrées ci-dessous:

# 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

Selon la façon dont vous l'utilisez, vous ne serez pas en mesure d'instancier une classe abstraite qui a des méthodes abstraites, mais sera en mesure d'instancier une sous-classe qui offre des définitions de ces méthodes:

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

Voici une façon très simple sans avoir à traiter avec le module ABC.

Dans le __init__ méthode de la classe que vous voulez être une classe abstraite, vous pouvez cocher la case "type" de l'auto. Si le type de l'auto est la classe de base, alors le visiteur tente d'instancier la classe de base, afin de lever une exception. Voici un exemple simple:

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

Lorsque vous exécutez, il produit:

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

Cela montre que vous pouvez créer une instance d'une sous-classe qui hérite d'une classe de base, mais vous ne peut pas instancier la classe de base directement.

Irv

La plupart des Précédentes réponses étaient correctes mais voici la réponse et un exemple pour Python 3.7. Oui, vous pouvez créer une classe abstraite et de la méthode. Juste pour rappel, parfois, une classe doit définir une méthode qui appartient logiquement à une classe, mais la classe ne peut pas spécifier la façon de mettre en œuvre la méthode. Par exemple, dans le des Parents et des Bébés classes ils ont tous les deux manger, mais la mise en œuvre sera différente pour chacun parce que les bébés et les parents mangent un autre type de nourriture et le nombre de fois ils mangent est différent. Alors, mangez de la méthode de sous-classes substitue AbstractClass.manger.

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

De SORTIE:

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

aussi ce qui fonctionne et est simple:

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

Dans votre extrait de code, vous pouvez également résoudre ce problème en fournissant une implémentation pour la __new__ méthode dans la sous-classe, de la même manière:

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

Mais c'est un hack et je vous le déconseille, sauf si vous savez ce que vous faites. Pour presque tous les cas, je vous conseille d'utiliser le abc module, que d'autres avant moi l'ont suggéré.

Également lorsque vous créez un nouveau (de base) de la classe, faire sous-classe object, comme ceci: class MyBaseClass(object):. Je ne sais pas si c'est beaucoup plus importante, mais il permet de conserver le style de la cohérence dans votre code