Typen in Python

Dieser Artikel erklärt die Typen in Python.

YouTube Video

Typen in Python

Das typing-Modul in Python wird verwendet, um Typ-Hinweise in Python einzuführen. Es wurde ursprünglich in Python 3.5 eingeführt und dient dazu, die Lesbarkeit und Wartbarkeit des Codes zu verbessern. Typ-Hinweise beeinflussen nicht die Laufzeit des Codes, ermöglichen jedoch Typ-Prüfungen mit IDEs und statischen Analysetools.

Grundlagen der Typ-Hinweise

Typ-Hinweise verdeutlichen die Absicht des Codes, indem sie die Typen von Funktionen und Variablen explizit angeben. Im folgenden Beispiel werden Typen für die Argumente und den Rückgabewert angegeben.

1def add_numbers(a: int, b: int) -> int:
2    return a + b
3
4result: int = add_numbers(5, 10)
5print(result)  # 15

Im obigen Code sind a und b vom Typ Integer (int), und der Rückgabewert der Funktion wird ebenfalls als Integer explizit angegeben. Auch mit Typ-Hinweisen werden Typen nicht strikt durchgesetzt, aber während der Entwicklung können Warnungen angezeigt werden, wenn Typen nicht übereinstimmen.

Wichtige Typ-Hinweise

Das typing-Modul in Python bietet verschiedene Klassen und Funktionen zur Definition von Typ-Hinweisen. Nachfolgend finden Sie eine Liste häufig verwendeter Typ-Hinweise.

• int: Ganzzahl
• str: Zeichenkette
• float: Gleitkommazahl
• bool: Wahrheitswert
• List: Liste
• Dict: Wörterbuch
• Tuple: Tupel
• Set: Menge

List-Typ

Der Listentyp wird mit der List-Klasse angegeben. Sie können den Typ der Elemente in einer Liste auch explizit angeben.

1from typing import List
2
3def sum_list(numbers: List[int]) -> int:
4    return sum(numbers)
5
6print(sum_list([1, 2, 3]))  # 6

In diesem Beispiel wird erwartet, dass alle Elemente der Liste vom Typ int sind.

Dict-Typ

Ein Dictionary-Typ wird mit Dict definiert. Die Typen von Schlüsseln und Werten können festgelegt werden.

1from typing import Dict
2
3def get_student_age(students: Dict[str, int], name: str) -> int:
4    return students.get(name, 0)
5
6students = {"Alice": 23, "Bob": 19}
7print(get_student_age(students, "Alice"))  # 23

In diesem Beispiel verwendet das Dictionary str als Schlüsseltyp und int als Werttyp.

Tuple-Typ

Tupel werden mit dem Tuple-Typ angegeben. Den Typ jedes Elements in einem Tupel können Sie individuell angeben.

1from typing import Tuple
2
3def get_person() -> Tuple[str, int]:
4    return "Alice", 30
5
6name, age = get_person()
7print(name, age)  # Alice 30

Hier wird gezeigt, dass die Funktion get_person ein Tupel zurückgibt, das einen String und eine Ganzzahl enthält.

Union-Typ

Der Union-Typ wird verwendet, um explizit anzugeben, dass mehrere Typen akzeptiert werden.

1from typing import Union
2
3def process_value(value: Union[int, float]) -> float:
4    return value * 2.0
5
6print(process_value(10))  # 20.0
7print(process_value(3.5))  # 7.0

In diesem Beispiel nimmt die Funktion process_value entweder ein int oder float als Argument und gibt ein Ergebnis vom Typ float zurück.

Optional-Typ

Der Optional-Typ wird verwendet, wenn eine Variable None sein kann. Er wird als Kurzform für Union[Type, None] bereitgestellt.

1from typing import Optional
2
3def greet(name: Optional[str] = None) -> str:
4    if name is None:
5        return "Hello, Guest!"
6    return f"Hello, {name}!"
7
8print(greet())  # Hello, Guest!
9print(greet("Alice"))  # Hello, Alice!

Hier wird gezeigt, dass, wenn name nicht angegeben ist, es als None behandelt wird.

Generische Typen

Generische Typen sind eine Möglichkeit, abstrakt darzustellen, welche Art von Elementen eine Datenstruktur enthält. Im Modul typing können Sie generische Typen mit TypeVar definieren.

1from typing import TypeVar, List
2
3T = TypeVar('T')
4
5def get_first_element(elements: List[T]) -> T:
6    return elements[0]
7
8print(get_first_element([1, 2, 3]))  # 1
9print(get_first_element(["a", "b", "c"]))  # a

In diesem Beispiel ist get_first_element eine Funktion, die das erste Element einer Liste zurückgibt, und sie funktioniert unabhängig vom Typ der Liste.

Typalias

Ein Typalias ist eine Möglichkeit, komplexe Typdefinitionen zu vereinfachen, indem man ihnen einen klaren Namen gibt.

1from typing import List, Tuple
2
3Coordinates = List[Tuple[int, int]]
4
5def get_coordinates() -> Coordinates:
6    return [(0, 0), (1, 1), (2, 2)]
7
8print(get_coordinates())  # [(0, 0), (1, 1), (2, 2)]

In diesem Beispiel wird ein Typalias Coordinates definiert, um einfach einen Typ mit Tupeln in einer Liste darzustellen.

Zusammenfassung

Das Modul typing in Python ist sehr nützlich, um die Lesbarkeit und Wartbarkeit von Code zu verbessern. Durch die richtige Verwendung von Typ-Hinweisen können Sie Typkonflikte und Fehler vermeiden, insbesondere bei groß angelegten Projekten oder in der Teamentwicklung. Typen sind lediglich ein Entwicklungswerkzeug und haben keinen Einfluss auf das Laufzeitverhalten, wodurch die Flexibilität des Codes erhalten bleibt.

Sie können den obigen Artikel mit Visual Studio Code auf unserem YouTube-Kanal verfolgen. Bitte schauen Sie sich auch den YouTube-Kanal an.

YouTube Video