Kraft/sicherstellen, dass python-Klasse von Attributen des bestimmten Typs

Dies ist im Allgemeinen keine gute Idee, nach den Gründen, die @yak erwähnt in seinem Kommentar. Sie sind im Grunde zu, dass der Nutzer, von der Lieferung gültige Argumente, die über die richtigen Attribute/Verhalten, aber nicht in der vererbungsstruktur Sie hart codiert in.

Haftungsausschluss beiseite, es gibt ein paar Optionen für das, was Sie zu tun versuchen. Das Hauptproblem ist, dass es gibt keine privaten Attribute in Python. Also, wenn Sie müssen nur eine einfache alte Objekt-Referenz, sagen self._a Sie können nicht garantieren, dass die Benutzer nicht direkt festgelegt, obwohl Sie haben einen setter, die nicht Typ-überprüfung für Sie. Die folgenden Optionen zeigen, wie man wirklich durchzusetzen, die Art der überprüfung.

Überschreiben von __setattr__

Diese Methode ist nur geeignet für eine (sehr) geringe Anzahl von Parametern, dass Sie dies tun. Die __setattr__ Methode, welche aufgerufen wird, wenn Sie verwenden die Punktnotation, um weisen ein reguläres Attribut. Zum Beispiel,

class A:
    def __init__(self, a0):
        self.a = a0

Wenn wir jetzt tun A().a = 32 es nennen würde A().__setattr__('a', 32) unter der Haube. In der Tat self.a = a0 im __init__ verwendet self.__setattr__ als gut. Sie können diese nutzen, um die Durchsetzung der Typ-check:

 class A:
    def __init__(self, a0):
        self.a = a0
    def __setattr__(self, name, value):
        if name == 'a' and not isinstance(value, int):
            raise TypeError('A.a must be an int')
        super().__setattr__(name, value)

Der Nachteil dieser Methode ist, dass Sie haben, um eine separate if name == ... für jeden Typ, den Sie überprüfen möchten (oder if name in ... zu überprüfen, mehrere Namen für einen bestimmten Typ). Der Vorteil ist, dass es ist die einfachste Art und Weise zu machen es unmöglich für den Benutzer zu umgehen, den Typ zu überprüfen.

Eine Eigenschaft

Eigenschaften sind Objekte, ersetzen Sie Ihre normalen Attribut mit einem descriptor-Objekt (in der Regel durch die Verwendung eines decorator). Deskriptoren können __get__ und __set__ Methoden, die definieren, wie das zugrunde liegende Attribut zugegriffen wird. Dies ist eine Art, wie wenn man die entsprechenden if Niederlassung in __setattr__ und steckte es in eine Methode, die ausgeführt wird, nur für dieses Attribut. Hier ist ein Beispiel:

class A:
    def __init__(self, a0):
        self.a = a0
    @property
    def a(self):
        return self._a
    @a.setter
    def a(self, value):
        if not isinstance(value, int):
            raise TypeError('A.a must be an int')
        self._a = value

Einer etwas anderen Weise zu tun, das gleiche kann gefunden werden in @jsbueno Antwort.

Während Sie eine Eigenschaft auf diese Weise ist die nette und meist löst das problem, es gibt aber ein paar Probleme. Die erste ist, dass Sie eine "private" _a Attribut, das der Benutzer ändern kann, direkt, unter Umgehung Ihren Typ zu überprüfen. Das ist fast das gleiche problem, wie mit einem einfachen getter-und setter, außer dass jetzt a zugänglich ist wie die "richtige" Eigenschaft, die Weiterleitungen auf die Set-hinter den kulissen, so dass es weniger wahrscheinlich, dass der Benutzer, wird mess with _a. Das zweite Problem ist, dass Sie eine überflüssige getter, um die Eigenschaft der Arbeit als lese- /Schreibzugriff. Diese Fragen sind Gegenstand der diese Frage.

Schaffen Sie eine Echte Setter-Nur Descriptor

Diese Lösung ist wahrscheinlich die robusteste insgesamt. Es wird vorgeschlagen, in der akzeptierte Antwort zu der Frage oben erwähnt. Im Grunde, anstatt eine Eigenschaft, die eine Reihe von Rüschen und die Annehmlichkeiten, die Sie nicht loswerden kann, erstellen Sie Ihre eigenen Deskriptor (und Lackierer) und verwenden, dass für alle Attribute, die erforderlich Typprüfung:

class SetterProperty:
    def __init__(self, func, doc=None):
        self.func = func
        self.__doc__ = doc if doc is not None else func.__doc__
    def __set__(self, obj, value):
        return self.func(obj, value)

class A:
    def __init__(self, a0):
        self.a = a0
    @SetterProperty
    def a(self, value):
        if not isinstance(value, int):
            raise TypeError('A.a must be an int')
        self.__dict__['a'] = value

Setter lagern der tatsächliche Wert direkt in die __dict__ von der Instanz zu vermeiden recursing in sich auf unbestimmte Zeit. Dies macht es möglich, den Wert eines Attributs ohne Angabe eine explizite getter. Da der Deskriptor a nicht die __get__ Methode, die Suche wird fortgesetzt, bis es feststellt, dass das Attribut im __dict__. Dadurch wird sichergestellt, dass alle sets gehen Sie durch die descriptor - /Set, während Sie erhält, ermöglichen den direkten Zugriff auf den Attribut-Wert.

Wenn Sie eine große Anzahl von Parametern, erfordern eine Prüfung wie diese, können Sie die Linie verschieben self.__dict__['a'] = value in der descriptor ist __set__ Methode:

class ValidatedSetterProperty:
    def __init__(self, func, name=None, doc=None):
        self.func = func
        self.__name__ = name if name is not None else func.__name__
        self.__doc__ = doc if doc is not None else func.__doc__
    def __set__(self, obj, value):
        ret = self.func(obj, value)
        obj.__dict__[self.__name__] = value

class A:
    def __init__(self, a0):
        self.a = a0
    @ValidatedSetterProperty
    def a(self, value):
        if not isinstance(value, int):
            raise TypeError('A.a must be an int')

Update

Python ist3.6 ist dies für Sie fast aus-der-box: https://docs.python.org/3.6/whatsnew/3.6.html#pep-487-descriptor-protocol-enhancements

TL;DR

Für eine sehr kleine Anzahl von Parametern, müssen Typ-überprüfung, überschreiben __setattr__ direkt. Für eine größere Anzahl von Parametern verwenden Sie die Set-nur-Deskriptor, wie oben gezeigt. Mit Eigenschaften, die direkt für diese Art von Anwendung stellt mehr Probleme, als es löst.

InformationsquelleAutor Mad Physicist

Hinweis 1: @Blckknght danke für deinen fairen Kommentar. Ich vermisste die Rekursion Problem in meiner viel zu einfache test-suite.

Anmerkung 2: ich schrieb diese Antwort, wenn ich ganz am Anfang war von learning Python. Jetzt würde ich eher verwenden, Python-Deskriptoren finden Sie unter e.g link1, link2.

Dank für die bisherigen Beiträge und einige denken, ich glaube, ich habe herausgefunden, eine viel mehr benutzerfreundliche Art und Weise, wie zu beschränken, ein class-Attribut zu sein, der bestimmte Art.

Zuerst erstellen wir eine Funktion, die universell tests für Typ:

def ensure_type(value, types):
    if isinstance(value, types):
        return value
    else:
        raise TypeError('Value {value} is {value_type}, but should be {types}!'.format(
            value=value, value_type=type(value), types=types))

Dann haben wir einfach zu verwenden und anwenden, die es in unseren Klassen über setter. Ich denke, das ist relativ einfach, und Folgen Sie TROCKEN, vor allem, wenn Sie exportieren Sie es in ein separates Modul für feed Ihre gesamte Projekt. Siehe Beispiel unten:

class Product:
    def __init__(self, name, quantity):
        self.name = name
        self.quantity = quantity

    @property
    def name(self):
        return self.__dict__['name']

    @name.setter
    def name(self, value):
        self.__dict__['name'] = ensure_type(value, str)

    @property
    def quantity(self):
        return self.quantity

    @quantity.setter
    def quantity(self, value):
        self.__dict__['quantity'] = ensure_type(value, int)

Tests sinnvolle Ergebnisse produzieren. Finden erste tests:

if __name__ == '__main__':
    from traceback import format_exc

    try:
        p1 = Product(667, 5)
    except TypeError as err:
        print(format_exc(1))

    try:
        p2 = Product('Knight who say...', '5')
    except TypeError as err:
        print(format_exc(1))

    p1 = Product('SPAM', 2)
    p2 = Product('...and Love', 7)
    print('Objects p1 and p2 created successfully!')

    try:
        p1.name = -191581
    except TypeError as err:
        print(format_exc(1))

    try:
        p2.quantity = 'EGGS'
    except TypeError as err:
        print(format_exc(1))

Tests, Ergebnis:

Traceback (most recent call last):
  File "/Users/BadPhoenix/Desktop/Coding/Coders-Lab/Week-2/WAR_PYT_S_05_OOP/2_Praca_domowa/day-1/stackoverflow.py", line 35, in <module>
    p1 = Product(667, 5)
TypeError: Value 667 is <class 'int'>, but should be <class 'str'>!

Traceback (most recent call last):
  File "/Users/BadPhoenix/Desktop/Coding/Coders-Lab/Week-2/WAR_PYT_S_05_OOP/2_Praca_domowa/day-1/stackoverflow.py", line 40, in <module>
    p2 = Product('Knights who say...', '5')
TypeError: Value 5 is <class 'str'>, but should be <class 'int'>!

Objects p1 and p2 created successfully!

Traceback (most recent call last):
  File "/Users/BadPhoenix/Desktop/Coding/Coders-Lab/Week-2/WAR_PYT_S_05_OOP/2_Praca_domowa/day-1/stackoverflow.py", line 49, in <module>
    p1.name = -191581
TypeError: Value -191581 is <class 'int'>, but should be <class 'str'>!

Traceback (most recent call last):
  File "/Users/BadPhoenix/Desktop/Coding/Coders-Lab/Week-2/WAR_PYT_S_05_OOP/2_Praca_domowa/day-1/stackoverflow.py", line 54, in <module>
    p2.quantity = 'EGGS'
TypeError: Value EGGS is <class 'str'>, but should be <class 'int'>!

InformationsquelleAutor CapedHero

Können Sie es tun, genau wie Sie sagen, Sie haben gesagt, Sie würden es tun, in C++; machen die Zuordnung zu Ihnen zu gehen durch eine setter-Methode und die Set-Methode den Typ überprüfen. Die Konzepte der "private Staat" und "public interfaces" in Python erfolgt mit Dokumentation und Konvention, und es ist ziemlich unmöglich, Kraft jedermann zu benutzen, Ihre setter anstatt direkt zuordnen der Variablen. Aber wenn man den Parametern Namen mit einem Unterstrich beginnt und dokumentieren Sie die setter, wie die Art und Weise zu verwenden, Ihre Klasse, das sollte es tun (nicht verwenden __names mit zwei Unterstrichen; es ist fast immer mehr ärger als es Wert ist, es sei denn, du bist eigentlich in der situation, die Sie sind entworfen, in der die widerstreitenden Attribut-Namen in einer Vererbungshierarchie). Nur besonders stumpfe Entwickler vermeiden die einfache Möglichkeit, mit der Klasse so, wie es dokumentiert die Arbeit zugunsten herauszufinden, was die internen Bezeichnungen und verwenden Sie direkt; oder Entwickler sind frustriert, dass Sie Ihre Klasse verhält sich ungewöhnlich (für Python) und nicht so dass Sie verwenden eine benutzerdefinierte Liste-wie Klasse anstelle einer Liste.

Können Sie Eigenschaften, wie in anderen Antworten beschrieben haben, um dies zu tun, während immer noch macht es so Aussehen, wie Sie die Zuweisung an Attribute direkt.

Persönlich finde ich die versuche zu erzwingen, geben Sicherheit in Python ziemlich sinnlos. Nicht, weil ich denke, dass statische Typ-überprüfung wird immer schlechter, aber weil selbst wenn man könnte hinzufügen, Typ-Anforderungen auf Ihrem Python-Variablen gearbeitet, 100% der Zeit, Sie einfach nicht wirksam bei der Aufrechterhaltung der Sicherheit, dass das Programm frei ist vom Typ Fehler, da Sie nur werfen von Ausnahmen zur Laufzeit.

Darüber nachdenken; wenn Ihr statisch kompilierte Programm erfolgreich kompiliert ohne Fehler, wissen Sie, dass es völlig frei von allen Fehlern, die der compiler erkennen kann (im Fall von Sprachen wie Haskell oder Quecksilber, das ist eine ziemlich gute Garantie, aber immer noch nicht abgeschlossen ist; im Fall von Sprachen wie C++ oder Java... meh).

Aber in Python, die Art der Fehler wird erst bemerkt, wenn es schon mal ausgeführt. Das bedeutet, selbst wenn Sie könnten, erhalten Sie die volle statische type enforcement überall in Ihrem Programm haben, müssen Sie die regelmäßige Ausführung von test-Suiten mit 100% code coverage, wirklich wissen, dein Programm ist frei von Fehler. Aber wenn Sie regelmäßig durchgeführte tests mit voller Abdeckung, die Sie würde wissen wenn Sie hatte jede Art Fehler, auch ohne den Versuch der Durchsetzung Typen! So ist der Vorteil wirklich nur doesn ' T scheinen es mir Wert. Sie wegwerfen Python ' s Stärke (Flexibilität), ohne zuzunehmen mehr als eine Kleinigkeit in einer seiner Schwächen (statische Fehlererkennung).

InformationsquelleAutor Ben