Was ist der kanonische Weg, um in Python nach Typ zu suchen?

Question 1

Wie überprüfe ich, ob ein Objekt von einem bestimmten Typ ist oder ob es von einem bestimmten Typ erbt?

Wie überprüfe ich, ob das Objekt o ist vom Typ str?

Question 2

Verwenden isinstance um zu prüfen ob o ist eine Instanz von str oder eine Unterklasse von str:

if isinstance(o, str):

Um zu überprüfen, ob die Art von o ist genau str, ausgenommen Unterklassen von str:

if type(o) is str:

Noch eine Alternative zu oben:

if issubclass(type(o), str):

Sehen Eingebaute Funktionen in der Python-Bibliotheksreferenz für relevante Informationen.

Suche nach Strings in Python 2

Für Python 2 ist dies eine bessere Möglichkeit, um zu überprüfen, ob o ist eine Zeichenfolge:

if isinstance(o, basestring):

da dies auch Unicode-Strings abfängt. unicode ist keine Unterklasse von str; wohingegen beide str und unicode sind Unterklassen von basestring. In Python3, basestring existiert nicht mehr, da es gibt eine strikte Trennung von Saiten (str) und Binärdaten (bytes).

Alternative, isinstance akzeptiert ein Tupel von Klassen. Dies wird zurückkehren True wenn o ist eine Instanz einer beliebigen Unterklasse von einer von (str, unicode):

if isinstance(o, (str, unicode)):

Question 3

Das die meisten Der pythonische Weg, den Typ eines Objekts zu überprüfen, ist … es nicht zu überprüfen.

Da Python ermutigt Duck-Typisierungsollten Sie nur try...except um die Methoden des Objekts so zu verwenden, wie Sie sie verwenden möchten. Wenn Ihre Funktion also nach einem beschreibbaren Dateiobjekt sucht, nicht Überprüfen Sie, ob es sich um eine Unterklasse von handelt fileversuchen Sie einfach, es zu verwenden .write() Methode!

Natürlich brechen diese schönen Abstraktionen manchmal zusammen isinstance(obj, cls) ist das, was Sie brauchen. Aber sparsam verwenden.

Question 4

isinstance(o, str) wird zurückkehren True wenn o ist ein str oder ist von einem Typ, der von erbt str.

type(o) is str wird zurückkehren True dann und nur dann, wenn o ist eine Str. Es wird zurückkehren False wenn o ist von einem Typ, der von erbt str.

Question 5

Nachdem die Frage gestellt und beantwortet wurde, Typhinweise wurden zu Python hinzugefügt. Typhinweise in Python ermöglichen die Überprüfung von Typen, jedoch auf eine ganz andere Art als in statisch typisierten Sprachen. Typhinweise in Python ordnen die erwarteten Typen von Argumenten Funktionen als zur Laufzeit zugängliche Daten zu, die Funktionen zugeordnet sind, und dies erlaubt für zu prüfende Typen. Beispiel für Typhinweis-Syntax:

def foo(i: int):
    return i

foo(5)
foo('oops')

In diesem Fall soll ein Fehler ausgelöst werden foo('oops') da der annotierte Typ des Arguments ist int. Der hinzugefügte Typhinweis nicht weil ein Fehler, der auftritt, wenn das Skript normal ausgeführt wird. Es fügt der Funktion jedoch Attribute hinzu, die die erwarteten Typen beschreiben, die andere Programme abfragen und verwenden können, um nach Typfehlern zu suchen.

Eines dieser anderen Programme, mit denen Sie den Typfehler finden können, ist mypy:

mypy script.py
script.py:12: error: Argument 1 to "foo" has incompatible type "str"; expected "int"

(Möglicherweise müssen Sie installieren mypy von Ihrem Paketmanager. Ich glaube nicht, dass es mit CPython kommt, aber es scheint ein gewisses Maß an “Offizialität” zu haben.)

Die Typprüfung auf diese Weise unterscheidet sich von der Typprüfung in statisch typisierten kompilierten Sprachen. Da Typen in Python dynamisch sind, muss die Typprüfung zur Laufzeit durchgeführt werden, was mit Kosten verbunden ist – sogar für korrekte Programme – wenn wir darauf bestehen, dass dies bei jeder Gelegenheit geschieht. Explizite Typprüfungen können auch restriktiver als nötig sein und unnötige Fehler verursachen (z. B. muss das Argument wirklich genau sein list Typ oder ist etwas Iterierbares ausreichend?).

Der Vorteil der expliziten Typprüfung besteht darin, dass sie Fehler früher abfangen und klarere Fehlermeldungen ausgeben kann als Duck-Typing. Die genauen Anforderungen eines Ententyps können nur mit externer Dokumentation (hoffentlich gründlich und genau) ausgedrückt werden, und Fehler von inkompatiblen Typen können weit entfernt von ihrem Ursprung auftreten.

Die Typhinweise von Python sollen einen Kompromiss bieten, bei dem Typen angegeben und überprüft werden können, aber während der normalen Codeausführung keine zusätzlichen Kosten entstehen.

Das typing Das Paket bietet Typvariablen, die in Typhinweisen verwendet werden können, um erforderliche Verhaltensweisen auszudrücken, ohne dass bestimmte Typen erforderlich sind. Beispielsweise enthält es Variablen wie Iterable und Callable für Hinweise, um die Notwendigkeit für jeden Typ mit diesen Verhaltensweisen anzugeben.

Während Typhinweise die pythonischste Art sind, Typen zu überprüfen, ist es oft noch pythonischer, Typen überhaupt nicht zu überprüfen und sich auf Duck-Typing zu verlassen. Type Hints sind relativ neu und die Jury ist sich noch nicht einig, wann sie die pythonischste Lösung sind. Ein relativ unumstrittener, aber sehr allgemeiner Vergleich: Typhinweise bieten eine Form der Dokumentation, die erzwungen werden kann, Code früher und leichter verständliche Fehler generieren lässt, Fehler abfangen kann, die Duck-Typing nicht kann, und statisch überprüft werden kann (in einer ungewöhnlichen Sinn, aber es ist immer noch außerhalb der Laufzeit). Auf der anderen Seite war Ententypisierung lange Zeit der pythonische Weg, erlegt nicht den kognitiven Overhead des statischen Typisierens auf, ist weniger ausführlich und akzeptiert alle brauchbaren Typen und noch einige mehr.

Question 6

Im Python 3.10können Sie verwenden | in isinstance:

>>> isinstance('1223', int | str) 
True

>>> isinstance('abcd', int | str) 
True

Question 7

Sie können den Typ einer Variablen mit __name__ eines Typs überprüfen.

Ex:

>>> a = [1,2,3,4]  
>>> b = 1  
>>> type(a).__name__
'list'
>>> type(a).__name__ == 'list'
True
>>> type(b).__name__ == 'list'
False
>>> type(b).__name__
'int'

Question 8

Hier ist ein Beispiel, warum Ententippen böse ist, ohne zu wissen, wann es gefährlich ist.

Zum Beispiel: Hier ist der Python-Code (möglicherweise ohne richtige Einrückung), beachten Sie, dass diese Situation vermeidbar ist, indem Sie sich um die Funktionen isinstance und issubclassof kümmern, um sicherzustellen, dass Sie keine Bombe bekommen, wenn Sie wirklich eine Ente brauchen.

class Bomb:
    def talk(self):
        self.explode()

    def explode(self):
        print("BOOM!, The bomb explodes.")

class Duck:
    def talk(self):
        print("I am a duck, I will not blow up if you ask me to talk.")

class Kid:
    kids_duck = None

    def __init__(self):
        print("Kid comes around a corner and asks you for money so he could buy a duck.")

    def take_duck(self, duck):
        self.kids_duck = duck
        print("The kid accepts the duck, and happily skips along.")

    def do_your_thing(self):
        print("The kid tries to get the duck to talk.")
        self.kids_duck.talk()

my_kid = Kid()
my_kid.take_duck(Bomb())
my_kid.do_your_thing()

HINWEIS: Das Beispiel ist alt, naiv und die Gefahr wird stark übertrieben. Es bleibt als Proof of Concept ohne größere Änderungen außer dem Update auf Python 3. Ich erinnere mich nicht, was mich dazu veranlasst hat, dies ursprünglich zu schreiben.