Ist die Durchsetzung einer abstrakten Methode Umsetzung unpythonic?

Beim entwerfen von Klassen, die abstrakte Methoden können sehr hilfreich sein. Von dem was ich weiß, Python besitzt keinen Mechanismus für die Durchsetzung einer geerbten Klasse zum implementieren der abstrakten Methode. In meinem code (siehe Beispiel unten) ich einen Fehler bei assertion in der base-Klasse zu führen zu einem Laufzeitfehler, wenn nicht implementiert. Ist dies unpythonic?

class Dog(Animal):
  def speak(self):
   return "bark"

class Animal():
  def speak(self):
   assert(False) #abstract

InformationsquelleAutor Mike | 2011-07-04

oop python

12

Python eigentlich hat haben abstrakte Klassen abstrakte Formen Methoden:
```
>>> import abc
>>> 
>>> class IFoo(object):
...     __metaclass__ = abc.ABCMeta
...     
...     @abc.abstractmethod
...     def foo(self):
...         pass
... 
>>> foo = IFoo()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Cant instantiate abstract class IFoo with abstract methods foo
>>> class FooDerived(IFoo):
...     pass
... 
>>> foo = FooDerived()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Cant instantiate abstract class FooDerived with abstract methods foo
>>> class FooImplements(FooDerived):
...     def foo(self):
...         print "foo'ed"
... 
>>> foo = FooImplements()
>>> foo.foo()
foo'ed
>>> 
```
Auf der anderen Seite die fundamentale Frage "ist das pythonic" ist ein bisschen schwieriger zu sagen. Wenn Ihre Absicht ist es, die abstrakte Basis-Klasse, so dass Sie später überprüfen, um sicherzustellen, dass Werte, die von Ihr Erben, dann Nein, das ist nicht besonders pythonic, obwohl es möglich ist, beliebige Typen abstrakte Unterklassen Ihrer baseclass. Auf der anderen Seite, es ist völlig in Ordnung, um eine abstract baseclass, implementiert einige Funktionen basierend auf der Umsetzung in konkrete Unterklassen. Zum Beispiel collections.Sequence und collections.Mapping tun genau dies für die Liste, wie und dict wie Klassen, Unterklassen bieten kann __getitem__ und kann __contains__ und andere kostenlos.

Sicher, Sie sollten nie assert() außer zu dokumentieren, die Erwartungen der code; Wenn es eigentlich möglich, die geltend machen, zu scheitern, sollte nicht mit assert. Optimiert python (python -O script.py) nicht überprüft Behauptungen.

Edit: mehr Ausstellung:

Wenn Sie überprüft den Typ eines Wertes:
```
def foo(bar):
    if not isinstance(bar, AbstractBaz):
        raise ValueError, ("bar must be an instance of AbstractBaz, "
                           "got %s" % type(bar))
```
Wenn aus irgendeinem Grund Sie nicht verwenden können @abstractmethod, aber immer noch wollen, dass die Wirkung, Sie erhöhen sollten NotImplementedError. Sie können dies tun wollen, weil Sie eigentlich tun wollen, Instanzen von dieser Klasse, von denen einige vielleicht nicht implementieren müssen, um optionale Funktionalität. Sollten Sie dennoch berücksichtigt, für die Möglichkeit, dass die Funktion aufgerufen wurde, durch super(). In einer ersten Annäherung könnte wie folgt Aussehen.
```
class Foo(object):
    def bar(self, baz):
        if self.bar.im_func == Foo.bar.im_func:
            raise NotImplementedError, "Subclasses must implement bar"
```
InformationsquelleAutor SingleNegationElimination
5

ABC sind ein Artefakt von C++ und sind im Gegensatz zu duck-typing. Wenn die Klasse Tier nicht definieren speak es würde tun, was Sie wollen ohne Anstrengung auf allen.
```
>>> class Animal(object):
...     pass
... 
>>> class Dog(Animal):
...     def speak(self):
...             print "bark"
... 
>>> animal = Animal()
>>> dog = Dog()
>>> animal.speak()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Animal' object has no attribute 'speak'
>>> dog.speak()
bark
```
C++ und verwandten Sprachen Kraft, die Sie zum erstellen von Alphabeten, denn das ABC ist tatsächlich eine interface-Beschreibung. Python meidet compiler erzwungene interface-Deklarationen, wie Sie versuchen, zu dokumentieren – in-code – ein Vertrag, der besser durchgesetzt extra-sprachlichen Mittel.
- "Python meidet compiler erzwungene interface-Deklarationen, wie Sie versuchen, zu dokumentieren – in-code – ein Vertrag, der besser durchgesetzt extra-sprachliche Mittel." WTF??? Bitte klären Sie diese Aussage, es könnte machen es noch für andere nützlich.
- Weitere, Alphabeten und/oder abstrakte Methoden sind vollkommen gültig in der duck-typing Welt ist, wenn Sie erzwingen, dass die Benutzer Ihrer Bibliothek implementieren Sie eine Methode, sagen wir ein mix-in-Klasse. Wer kümmert sich, wenn es "unpythonic" oder gegen die indoktrinierte überzeugungen einer bestimmten Gemeinde, wenn es die richtige software engineering. Haben Sie einen Blick auf TokenMacGuy die Antwort von unten und ignorieren Sie diesen Kerl.
InformationsquelleAutor msw
2

Gut, wenn Sie nicht zählen die Methode speak in Ihre base-Klasse und irgendwie passiert, es zu benutzen, wird der code nicht sowieso. Die Frage ist, wie wahrscheinlich ist es und wie zu sagen, der Benutzer (ein NotImplementedError vielleicht passt hier besser als eine Behauptung).

InformationsquelleAutor Debilski
0

Mit python im Allgemeinen ist es nicht immer möglich ist, direkt zu Einschränkungen auf den code, zumindest aus der objektorientierten Sicht (Gedanken über abstrakte Klassen, eigenes Verfahren, ...).
Zur Durchsetzung einer Unterklasse zu implementieren ist eine Methode, möchten Sie vielleicht so etwas wie:
```
class Animal():
  def speak(self):
   raise NotImplementedError #abstract

class Dog(Animal):
  def speak(self):
   return "bark"

class MuteAnimal(Animal):
  pass
```
Bedeutet dies nicht, dass die Methode implementiert werden, die von der Unterklasse, aber es wird einfach ein Fehler ausgelöst, wenn die Methode sprechen, ist nicht implementiert.

InformationsquelleAutor Cinquo

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.