Abstrakte Attribute in Python [Duplikat]

Was ist der kürzeste / eleganteste Weg, um den folgenden Scala-Code mit einem abstrakten Attribut in Python zu implementieren?

abstract class Controller {

    val path: String

}

Eine Unterklasse von Controllerwird vom Scala-Compiler erzwungen, um "Pfad" zu definieren. Eine Unterklasse würde folgendermaßen aussehen:

class MyController extends Controller {

    override val path = "/home"

}

Python hat hierfür eine integrierte Ausnahme, die jedoch erst zur Laufzeit auftritt.

class Base(object):
    @property
    def path(self):
        raise NotImplementedError


class SubClass(Base):
    path = 'blah'

Python 3.3+

from abc import ABCMeta, abstractmethod


class A(metaclass=ABCMeta):
    def __init__(self):
        # ...
        pass

    @property
    @abstractmethod
    def a(self):
        pass

    @abstractmethod
    def b(self):
        pass


class B(A):
    a = 1

    def b(self):
        pass

Wenn Sie nicht deklarieren aoder bin der abgeleiteten Klasse sind, Bwird Folgendes TypeErrorausgelöst:

TypeError: Abstrakte Klasse kann nicht Bmit abstrakten Methoden instanziiert werdena

Python 2.7

Hierfür gibt es einen @ abstractproperty- Dekorateur:

from abc import ABCMeta, abstractmethod, abstractproperty


class A:
    __metaclass__ = ABCMeta

    def __init__(self):
        # ...
        pass

    @abstractproperty
    def a(self):
        pass

    @abstractmethod
    def b(self):
        pass


class B(A):
    a = 1

    def b(self):
        pass

Seit diese Frage ursprünglich gestellt wurde, hat Python die Implementierung abstrakter Klassen geändert. Ich habe einen etwas anderen Ansatz verwendet, indem ich den abc.ABC-Formalismus in Python 3.6 verwendet habe. Hier definiere ich die Konstante als eine Eigenschaft, die in jeder Unterklasse definiert werden muss.

from abc import ABC, abstractmethod


class Base(ABC):

    @property
    @classmethod
    @abstractmethod
    def CONSTANT(cls):
        return NotImplementedError

    def print_constant(self):
        print(type(self).CONSTANT)


class Derived(Base):
    CONSTANT = 42

Dadurch wird die abgeleitete Klasse gezwungen, die Konstante zu definieren. Andernfalls wird eine TypeErrorAusnahme ausgelöst, wenn Sie versuchen, die Unterklasse zu instanziieren. Wenn Sie die Konstante für eine in der abstrakten Klasse implementierte Funktionalität verwenden möchten, müssen Sie über auf die Unterklassenkonstante zugreifentype(self).CONSTANT statt nurCONSTANT , da der Wert in der Basisklasse undefiniert ist.

Es gibt andere Möglichkeiten, dies zu implementieren, aber ich mag diese Syntax, da sie mir für den Leser am einfachsten und offensichtlichsten erscheint.

Die vorherigen Antworten haben alle nützliche Punkte berührt, aber ich bin der Meinung, dass die akzeptierte Antwort die Frage nicht direkt beantwortet, weil

• Die Frage fordert die Implementierung in einer abstrakten Klasse, aber die akzeptierte Antwort folgt nicht dem abstrakten Formalismus.
• Die Frage lautet, ob die Implementierung erzwungen wird. Ich würde argumentieren, dass die Durchsetzung in dieser Antwort strenger ist, da sie einen Laufzeitfehler verursacht, wenn die Unterklasse instanziiert wird, wenn sie CONSTANTnicht definiert ist. Die akzeptierte Antwort ermöglicht die Instanziierung des Objekts und gibt nur beim CONSTANTZugriff einen Fehler aus , wodurch die Durchsetzung weniger streng wird.

Dies ist kein Fehler bei den ursprünglichen Antworten. Seit der Veröffentlichung wurden wesentliche Änderungen an der Syntax der abstrakten Klasse vorgenommen, die in diesem Fall eine übersichtlichere und funktionalere Implementierung ermöglichen.

In Python 3.6+ können Sie ein Attribut einer abstrakten Klasse (oder einer beliebigen Variablen) mit Anmerkungen versehen, ohne einen Wert für dieses Attribut anzugeben .

class Controller:
    path: str

class MyController(Controller):
    path = "/home"

Dies führt zu sehr sauberem Code, bei dem es offensichtlich ist, dass das Attribut abstrakt ist. Code, der versucht, auf das Attribut zuzugreifen, wenn er nicht überschrieben wurde, löst einen aus AttributeError.

Sie können ein Attribut in der abstrakten Basisklasse abc.ABC mit einem Wert erstellen, z. B. NotImplementedwenn das Attribut nicht überschrieben und dann verwendet wird, wird zur Laufzeit ein Fehler angezeigt.

Der folgende Code verwendet einen PEP 484- Typhinweis, um PyCharm dabei zu helfen, den Typ des pathAttributs auch statisch korrekt zu analysieren .

import abc


class Controller(abc.ABC):
    path: str = NotImplemented

class MyController(Controller):
    path = "/home"

Für Python 3.3 + gibt es eine elegante Lösung

from abc import ABC, abstractmethod

class BaseController(ABC):
    @property
    @abstractmethod
    def path(self) -> str:
        ...

class Controller(BaseController):
    path = "/home"


# Instead of an elipsis, you can add a docstring,
# This approach provides more clarity
class AnotherBaseController(ABC):
    @property
    @abstractmethod
    def path(self) -> str:
    """
    :return: the url path of this controller
    """

Wie unterscheidet es sich von anderen Antworten:

1. ...in einer abstrakten Methode ist der Körper vorzuziehen als pass. Im Gegensatz zu pass, ...impliziert keine Operationen , wo passnur das Fehlen einer tatsächlichen Implementierung bedeutet ,

2. ...ist mehr zu empfehlen als zu werfen NotImplementedError(...). Dies führt automatisch zu einem äußerst ausführlichen Fehler, wenn die Implementierung eines abstrakten Felds in einer Unterklasse fehlt. Im Gegensatz dazu NotImplementedErrorsagt selbst nicht, warum die Implementierung fehlt. Darüber hinaus erfordert es Handarbeit, um es tatsächlich anzuheben.

Ab Python 3.6 können Sie __init_subclass__bei der Initialisierung nach den Klassenvariablen der untergeordneten Klasse suchen:

from abc import ABC

class A(ABC):
    @classmethod
    def __init_subclass__(cls):
        required_class_variables = [
            "foo",
            "bar"
        ]
        for var in required_class_variables:
            if not hasattr(cls, var):
                raise NotImplementedError(
                    f'Class {cls} lacks required `{var}` class attribute'
                )

Dies führt zu einem Fehler bei der Initialisierung der untergeordneten Klasse, wenn die fehlende Klassenvariable nicht definiert ist, sodass Sie nicht warten müssen, bis auf die fehlende Klassenvariable zugegriffen wird.

Ihre Basisklasse könnte eine __new__Methode implementieren , die nach Klassenattributen sucht:

class Controller(object):
    def __new__(cls, *args, **kargs):
        if not hasattr(cls,'path'): 
            raise NotImplementedError("'Controller' subclasses should have a 'path' attribute")
        return object.__new__(cls)

class C1(Controller):
    path = 42

class C2(Controller):
    pass


c1 = C1() 
# ok

c2 = C2()  
# NotImplementedError: 'Controller' subclasses should have a 'path' attribute

Auf diese Weise wird der Fehler bei der Instanziierung ausgelöst

Die Implementierung von Python3.6 könnte folgendermaßen aussehen:

In [20]: class X:
    ...:     def __init_subclass__(cls):
    ...:         if not hasattr(cls, 'required'):
    ...:             raise NotImplementedError

In [21]: class Y(X):
    ...:     required = 5
    ...:     

In [22]: Y()
Out[22]: <__main__.Y at 0x7f08408c9a20>

Ich habe nur ein bisschen @ James Antwort geändert , damit all diese Dekorateure nicht so viel Platz einnehmen. Wenn Sie mehrere solche abstrakten Eigenschaften definieren mussten, ist dies praktisch:

from abc import ABC, abstractmethod

def abstractproperty(func):
   return property(classmethod(abstractmethod(func)))

class Base(ABC):

    @abstractproperty
    def CONSTANT(cls): ...

    def print_constant(self):
        print(type(self).CONSTANT)


class Derived(Base):
    CONSTANT = 42

class BadDerived(Base):
    BAD_CONSTANT = 42

Derived()       # -> Fine
BadDerived()    # -> Error

Schauen Sie sich das Modul abc (Abtract Base Class) an: http://docs.python.org/library/abc.html

Meiner Meinung nach besteht die einfachste und häufigste Lösung darin, eine Ausnahme auszulösen, wenn eine Instanz der Basisklasse erstellt wird oder wenn auf ihre Eigenschaft zugegriffen wird.

Bastien Léonards Antwort erwähnt das abstrakte Basisklassenmodul und Brendan Abels Antwort befasst sich mit nicht implementierten Attributen, die Fehler verursachen. Um sicherzustellen, dass die Klasse nicht außerhalb des Moduls implementiert ist, können Sie dem Basisnamen einen Unterstrich voranstellen, der ihn als privat für das Modul kennzeichnet (dh nicht importiert).

dh

class _Controller(object):
    path = '' # There are better ways to declare attributes - see other answers

class MyController(_Controller):
    path = '/Home'

class AbstractStuff:
    @property
    @abc.abstractmethod
    def some_property(self):
        pass

Ab 3.3 abc.abstractpropertyist ich veraltet.