Einführung

MyPy¹ ist ein statischer Typprüfer für Python. Im Gegensatz zu statisch typisierten Sprachen wie C oder Java ist Python dynamisch typisiert. Das bedeutet, dass Sie in Python den Typ einer Variablen nicht explizit deklarieren müssen; es wird zur Laufzeit abgeleitet. Zum Beispiel:

Python (dynamisch typisiert)

num = 4                # `num` is inferred as an integer
newString = "new string"  # `newString` is inferred as a string

Im Gegensatz dazu müssen Sie bei statisch typisierten Sprachen den Typ jeder Variablen zur Kompilierungszeit angeben. Dies hilft, typbezogene Fehler während der Entwicklung und nicht zur Laufzeit zu erkennen.

C (statisch typisiert)

int num = 4;            // `num` is declared as an integer
std::string newString = "new string";  // `newString` is declared as a string

Warum MyPy verwenden?

In dynamisch typisierten Sprachen wie Python können zur Laufzeit Typfehler auftreten, die zu Fehlern führen können, die schwerer aufzuspüren sind. MyPy behebt dieses Problem, indem es Ihnen ermöglicht, Ihrem Python-Code Typhinweise hinzuzufügen, die vor der Ausführung statisch überprüft werden können. Dies bietet mehrere Vorteile:

• Frühzeitige Fehlererkennung: Identifizieren Sie typbezogene Fehler während der Entwicklung, anstatt sie zur Laufzeit zu bemerken.
• Verbesserte Code-Lesbarkeit: Typhinweise verdeutlichen die erwarteten Typen von Variablen und Funktionsargumenten und verbessern so die Code-Lesbarkeit.
• Bessere IDE-Unterstützung: Bietet verbesserte Code-Vervollständigung und Inline-Dokumentation in IDEs, die Typhinweise unterstützen.

Beispiel mit MyPy

Hier ist ein einfaches Beispiel, das die Verwendung von Typhinweisen mit MyPy demonstriert:

Ohne Typhinweise

def add(a, b):
    return a   b

print(add(5, 3))      # Output: 8
print(add("hello", "world"))  # Output: helloworld

Im obigen Code kann die Add-Funktion sowohl Ganzzahlen als auch Zeichenfolgen akzeptieren, was möglicherweise nicht das beabsichtigte Verhalten ist.

Mit Typhinweisen

def add(a: int, b: int) -> int:
    return a   b

print(add(5, 3))      # Output: 8
# mypy will report an error for the following line:
# print(add("hello", "world"))  # TypeError: Expected int, got str

Durch das Einfügen von Typhinweisen (a: int, b: int) geben Sie an, dass add nur mit Ganzzahlen funktionieren soll. MyPy prüft den Code anhand dieser Typhinweise und erkennt potenzielle typbezogene Probleme frühzeitig.

MyPy installieren und ausführen

Um mit MyPy zu beginnen:

1. Installation: MyPy mit pip installieren:

   python3 -m pip install mypy

1. MyPy ausführen: Nach der Installation können Sie MyPy ausführen, um Ihren Code auf Typfehler zu überprüfen. Verwenden Sie den folgenden Befehl:

   mypy program.py

Dieser Befehl prüft Ihren Code statisch, ähnlich wie ein Compiler die Syntax in C prüft. Es meldet alle gefundenen Typfehler, ohne den Code tatsächlich auszuführen.

Durch die effektive Nutzung von MyPy können Sie die Vorteile der statischen Typisierung in Python integrieren und gleichzeitig die Flexibilität seiner dynamischen Natur genießen.

Lassen Sie uns ein Beispiel mit MyPy programmieren

Ohne MyPy

def greeting(name):
    return 'Hello '   name

# These calls will fail when the program runs, but MyPy will not report an error
greeting(123)
greeting(b"Aniket")

Mit MyPy

Durch das Hinzufügen von Typanmerkungen (auch als Typhinweise bezeichnet) kann MyPy potenzielle Probleme erkennen:

def greeting(name: str) -> str:
    return 'Hello '   name

greeting(3)         # mypy will report: Argument 1 to "greeting" has incompatible type "int"; expected "str"
greeting(b'Alice')  # mypy will report: Argument 1 to "greeting" has incompatible type "bytes"; expected "str"
greeting("World!")  # No error

Hier:

• name: str-Annotation gibt an, dass das Namensargument eine Zeichenfolge sein soll.
• -> str-Annotation gibt an, dass die Funktionsbegrüßung einen String zurückgibt.

Wann man MyPy verwenden sollte

MyPy ist in mehreren Situationen nützlich:

• Fehler frühzeitig erkennen: Verwenden Sie MyPy, um typbezogene Fehler zu finden, bevor Sie Ihren Code ausführen. Dies hilft, Fehler frühzeitig zu erkennen und die Codezuverlässigkeit zu verbessern.

• Machen Sie den Code klarer: Durch das Hinzufügen von Typhinweisen wird Ihr Code leichter verständlich. Es zeigt, welche Arten von Werten erwartet werden, was anderen (und Ihrem zukünftigen Selbst) hilft, Ihren Code besser zu verstehen.

• Alten Code aktualisieren: Beim Aktualisieren von altem Code hilft MyPy dabei, Typprobleme zu finden, indem Sie Typhinweise hinzufügen, wodurch der Übergang reibungsloser verläuft.

• Prototypen verbessern: Beim Erstellen neuer Funktionen oder Prototypen hilft MyPy durch die Durchsetzung von Typregeln sicherzustellen, dass der neue Code korrekt mit vorhandenem Code funktioniert.

• Große Projekte verwalten: In großen Projekten mit vielen Mitwirkenden hilft MyPy dabei, den Code konsistent zu halten und typbezogene Fehler zu verhindern.

• IDE-Funktionen verbessern: Wenn Sie eine IDE verwenden, verbessert MyPy Funktionen wie Code-Vervollständigung und Navigation und erleichtert so die Entwicklung.

Mit MyPy können Sie besseren und zuverlässigeren Python-Code schreiben und gleichzeitig die Flexibilität von Python genießen.

Ein offizielles schnelles Cheatsheet für mypy

1. Offizielle Dokumentation ↩