Python Typing: Verbesserung der Codelesbarkeit

Einführung

In diesem Tutorial lernst du, wie du das Python-Modul typing verwendest, um deinem Code Typhinweise hinzuzufügen. Typhinweise helfen, deinen Code lesbarer und wartbarer zu machen, indem sie explizit die erwarteten Eingabe- und Ausgabetypen deiner Funktionen angeben.

Grundlegende Typen

Typhinweise sind ein in Python 3.5 eingeführtes Feature, und das Modul typing wurde in Python 3.5.2 hinzugefügt, um eine standardmäßige Menge an Typannotationen bereitzustellen. Importiere die relevanten Typen aus dem Modul typing, um mit Typhinweisen zu beginnen.

from typing import List, Tuple, Dict

Typhinweise für Grundtypen sind einfach. Verwende einfach den Typ selbst als Hinweis.

Öffne die Python-Shell, indem du den folgenden Befehl in der Konsole eingibst.

python3

1. Definiere eine Variable vom Typ int, weise ihr einen Wert zu und drucke ihn aus.

age: int = 25
print(age) ## Ausgabe: 25

2. Definiere eine Variable vom Typ float, weise einen Wert zu und drucke ihn aus.

temperature: float = 98.6
print(temperature) ## Ausgabe: 98.6

3. Definiere eine Variable vom Typ bool, weise ihr einen Wert zu und drucke ihn aus.

is_raining: bool = True
print(is_raining) ## Ausgabe: True

4. Definiere eine Variable vom Typ str, weise einen Wert zu und drucke ihn aus.

def greet(name: str) -> str:
    return f"Hello, {name}!"

print(greet("Alice")) ## Ausgabe: Hello, Alice!

5. Definiere eine Funktion, die zwei Argumente vom Typ int annimmt, diese multipliziert und das Ergebnis als int zurückgibt.

def multiply(x: int, y: int) -> int:
    return x * y

result = multiply(5, 10)
print(result) ## Ausgabe: 50

Container und Generics

Typhinweise für Containertypen (wie Listen, Wörterbücher und Mengen) können mit Generics spezifischer sein.

Tipps: Die Experimente mit den Seriennummern 1-3 können in der Python-Shell implementiert werden, und die Experimente mit der Seriennummer 4 werden in der WebIDE implementiert.

1. Definiere eine Variable vom Typ List[int], weise ihr einige Werte zu und drucke sie aus.

from typing import List
numbers: List[int] = [1, 2, 3, 4, 5]
print(numbers) ## Ausgabe: [1, 2, 3, 4, 5]

2. Definiere eine Variable vom Typ Dict[str, int], weise ihr einige Schlüssel-Wert-Paare zu und drucke sie aus.

from typing import Dict
ages: Dict[str, int] = {"Alice": 25, "Bob": 30, "Charlie": 35}
print(ages) ## Ausgabe: {'Alice': 25, 'Bob': 30, 'Charlie': 35}

3. Definiere eine Variable vom Typ Tuple[str, int, float], weise ihr einige Werte zu und drucke sie aus.

from typing import Tuple
person: Tuple[str, int, float] = ("Alice", 25, 5.7)
print(person) ## Ausgabe: ('Alice', 25, 5.7)

4. Definiere eine Funktion, die eine Liste von ganzen Zahlen als Argument nimmt und das Ergebnis als eine neue Menge von ganzen Zahlen zurückgibt.

Erstelle ein Projekt namens list_to_set.py in der WebIDE und gebe den folgenden Inhalt ein.

from typing import List, Set

def get_unique_elements(elements: List[int]) -> Set[int]:
    return set(elements)

numbers = [1, 2, 2, 3, 4, 4, 4, 5]
unique_numbers = get_unique_elements(numbers)
print(unique_numbers)  ## Ausgabe: {1, 2, 3, 4, 5}

Verwende den folgenden Befehl, um das Skript auszuführen.

python list_to_set.py

Benutzerdefinierte Typen

Du kannst auch benutzerdefinierte Typen und Klassen als Typhinweise verwenden.

Tipps: Dieses Experiment wird in der WebIDE implementiert.

1. Definiere eine Klasse Person mit typisierten Attributen name (str) und age (int) und eine Methode get_summary, die einen String zurückgibt, der den Namen und das Alter der Person zusammenfasst.

Erstelle ein Projekt namens str_and_int_to_str.py in der WebIDE und gebe den folgenden Inhalt ein.

class Person:
    def __init__(self, name: str, age: int):
        self.name = name
        self.age = age
    def get_summary(self) -> str:
        return f"{self.name} ist {self.age} Jahre alt."

person1 = Person("Alice", 25)
print(person1.get_summary()) ## Ausgabe: Alice ist 25 Jahre alt.

Verwende den folgenden Befehl, um das Skript auszuführen.

python str_and_int_to_str.py

2. Definiere eine Klasse Point mit typisierten Attributen x und y, beide vom Typ float, und eine Methode distance, die einen anderen Punkt als Argument nimmt und den Abstand zwischen den beiden Punkten zurückgibt.

Erstelle ein Projekt namens other_to_float.py in der WebIDE und gebe den folgenden Inhalt ein.

import math

class Point:
    def __init__(self, x: float, y: float):
        self.x = x
        self.y = y
    def distance(self, other: "Point") -> float:
        return math.sqrt((self.x - other.x)**2 + (self.y - other.y)**2)

point1 = Point(0, 0)
point2 = Point(3, 4)
print(point1.distance(point2)) ## Ausgabe: 5.0

Verwende den folgenden Befehl, um das Skript auszuführen.

python other_to_float.py

Typaliase

Typbezeichnungen können lesbarere Typhinweise schaffen, insbesondere für komplexe Typen.

Erstelle ein Projekt namens type_aliases.py in der WebIDE und gebe den folgenden Inhalt ein.

from typing import List, Tuple

Coordinate = Tuple[float, float]
Path = List[Coordinate]

def get_distance(coord1: Coordinate, coord2: Coordinate) -> float:
    return ((coord1[0] - coord2[0])**2 + (coord1[1] - coord2[1])**2)**0.5

start = (0, 0)
end = (3, 4)
print(get_distance(start, end))  ## Ausgabe: 5.0

Verwende den folgenden Befehl, um das Skript auszuführen.

python type_aliases.py

Optional und None

Der Optional-Typ kann verwendet werden, wenn ein Wert entweder vom angegebenen Typ oder None sein kann.

1. Definiere eine Funktion, die ein optionales int-Argument akzeptiert, es wenn es nicht None ist mit 2 multipliziert und das Ergebnis als int zurückgibt oder None, wenn die Eingabe None war.

Erstelle ein Projekt namens option_and_none_1.py in der WebIDE und gebe den folgenden Inhalt ein.

from typing import Optional

def double_or_none(number: Optional[int]) -> Optional[int]:
    if number is not None:
        return number * 2
    else:
        return None

result1 = double_or_none(5)
result2 = double_or_none(None)
print(result1, result2) ## Ausgabe: 10 None

Verwende den folgenden Befehl, um das Skript auszuführen.

python option_and_none_1.py

2. Definiere eine Klasse Person mit einem typisierten Attribut address, das entweder eine gültige Adresszeichenfolge oder None sein kann.

Erstelle ein Projekt namens option_and_none_2.py in der WebIDE und gebe den folgenden Inhalt ein.

from typing import Optional

class Person:
    def __init__(self, name: str, age: int, address: Optional[str]):
        self.name = name
        self.age = age
        self.address = address

person1 = Person("Alice", 25, "123 Main St")
person2 = Person("Bob", 30, None)
print(person1.name, person1.age, person1.address) ## Ausgabe: Alice 25 123 Main St
print(person2.name, person2.age, person2.address) ## Ausgabe: Bob 30 None

Verwende den folgenden Befehl, um das Skript auszuführen.

python option_and_none_2.py

Aufrufbar

Der Callable-Typ wird verwendet, um den Typ einer Funktion oder Methode anzugeben.

Erstelle ein Projekt namens callable.py in der WebIDE und gebe den folgenden Inhalt ein.

from typing import Callable

def apply_function(value: int, func: Callable[[int], int]) -> int:
    return func(value)

def double(x: int) -> int:
    return x * 2

print(apply_function(5, double))  ## Ausgabe: 10

Verwende den folgenden Befehl, um das Skript auszuführen.

python callable.py

Typeddict

TypedDict ermöglicht es Ihnen, benutzerdefinierte Dictionaries mit bestimmten Schlüsseln und Werttypen zu erstellen.

Tipps: TypedDict wurde in Python 3.8 eingeführt. Sie müssen daher Python 3.8 oder höher ausführen, um es zu verwenden.

Hier ist ein Beispiel:

Erstelle ein Projekt namens typeddict.py in der WebIDE und gebe den folgenden Inhalt ein.

from typing import TypedDict

class PersonInfo(TypedDict):
    name: str
    age: int

def greet(person: PersonInfo) -> str:
    return f"Hello, {person['name']}! You are {person['age']} years old."

alice_info: PersonInfo = {"name": "Alice", "age": 30}
print(greet(alice_info))  ## Ausgabe: Hello, Alice! You are 30 years old.

Verwende den folgenden Befehl, um das Skript auszuführen.

python typeddict.py

Newtype

NewType ist ein Typhinweis aus dem typing-Modul in Python, der es Ihnen ermöglicht, einen neuen Typ zu erstellen, der lediglich eine Umhüllung um einen bestehenden Typ ist. Dies kann nützlich sein, um Variablen und Funktionsargumenten mehr semantische Bedeutung hinzuzufügen.

Hier ist ein Beispiel:

Erstelle ein Projekt namens newtype.py in der WebIDE und gebe den folgenden Inhalt ein.

Dann führe das folgende Python-Skript aus.

from typing import NewType

UserId = NewType("UserId", int)
OrderId = NewType("OrderId", int)

def get_order(order_id: OrderId) -> str:
    return f"Order with ID: {order_id}"

order_id = OrderId(123)
user_id = UserId(123)

print(get_order(order_id))  ## Ausgabe: Order with ID: 123

Verwende den folgenden Befehl, um das Skript auszuführen.

python newtype.py

Statische Typüberprüfung

In Python kann die statische Typüberprüfung mit Hilfe von Typhinweisen und einem statischen Typenprüfer wie mypy durchgeführt werden. Typhinweise geben die erwarteten Typen von Variablen, Funktionsargumenten und Rückgabewerten an. Hier ist ein Beispiel:

Zunächst installieren Sie mypy.

pip install mypy

Hier ist ein Beispiel:

Erstellen Sie ein Projekt namens mypy.py in der WebIDE und geben Sie den folgenden Inhalt ein.

def add_numbers(x: int, y: int) -> int:
    return x + y

result = add_numbers(2, 3)
print(result)

Führen Sie dann mypy auf Ihrem Skript aus.

mypy mypy.py

Dies gibt Ihnen Rückmeldungen zu allen in Ihrem Code gefundenen Typinkonsistenzen.

Zusammenfassung

Das war's! Sie wissen jetzt, wie Sie das Python-typing-Modul verwenden, um Typhinweise zu Ihrem Code hinzuzufügen. Typhinweise können die Lesbarkeit und Wartbarkeit Ihres Codes erheblich verbessern und es einfacher machen, mit größeren Codebasen umzugehen und mit anderen zusammenzuarbeiten.