Anmerkungen in Python

1. Variable Anmerkungen in Python
2. Funktionsanmerkungen in Python

Python ist eine robuste und dynamisch typisierte Programmiersprache. Es hat eine einfache Syntax, die dem Schreiben von einfachem Englisch ähnelt, und wird von einem riesigen Pool an Bibliotheken und Funktionen unterstützt.

Eine solche Funktion sind Anmerkungen. Anmerkungen sind beliebige Python-Ausdrücke, die Hinweise auf den Datentyp von Variablen, Funktionsparametern und den Rückgabetyp der Funktion geben.

Anmerkungen zielen darauf ab, die Lesbarkeit und das Verständnis des Quellcodes zu verbessern, und werden von Bibliotheken von Drittanbietern interpretiert, um effektive und zeitsparende Dienste wie Syntaxhinweise, Datentypprüfung, Datentyphinweise in IDEs oder die automatische Vervollständigung von integrierten Entwicklungsumgebungen bereitzustellen Code und automatisierte oder KI-gesteuerte Dokumentationserstellung.

Es gibt zwei Arten von Anmerkungen in Python: Funktionsanmerkungen und Variablenanmerkungen. In diesem Artikel werden wir anhand relevanter Beispiele über beide Annotationstypen in Python sprechen.

Variable Anmerkungen in Python

Variablenannotationen sind Ausdrücke, die darauf abzielen, Details zu den Datentypen von Variablen in Python bereitzustellen. Variable Anmerkungen haben die folgende Syntax.

<variable > : < expression > = < initial value >

Anmerkungsausdrücke werden zwischen dem Variablennamen und seinem Anfangswert geschrieben, wobei ein Doppelpunkt oder : vorangestellt wird. Schauen wir uns einige Beispiele an, um dies besser zu verstehen. Siehe den folgenden Python-Code.

name: str = "Vaibhav"
age: int = 20
language: str = "Python"
student: bool = True
height: float = 5.9
print("name:", name)
print("age:", age)
print("language:", language)
print("student:", student)
print("height:", height)

Ausgabe:

name: Vaibhav
age: 20
language: Python
student: True
height: 5.9

Im obigen Beispiel verwenden wir eingebaute Python-Datentypen für Ausdrücke. Wir können auch Zeichenketten verwenden und detaillierte und kurze Beschreibungen der vorhandenen Variablen bereitstellen.

Der folgende Python-Code veranschaulicht dies.

name: "Name of the person" = "Vaibhav"
age: "Age of the person" = 20
language: "Favorite programming language of the person" = "Python"
student: "Is the person a student?" = True
height: "Height of the person in feet" = 5.9
print("name:", name)
print("age:", age)
print("language:", language)
print("student:", student)
print("height:", height)

Ausgabe:

name: Vaibhav
age: 20
language: Python
student: True
height: 5.9

Wir können das Attribut __annotations___ verwenden, um auf alle Anmerkungen zuzugreifen.

Dieses Attribut ist ein Dictionary, in dem Schlüssel die Variablen und Werte die Anmerkungsausdrücke sind. Beachten Sie, dass dieses Attribut nur Details zu den Variablen und nicht zu den Funktionen bereitstellt.

Siehe dazu den folgenden Python-Code.

name: "Name of the person" = "Vaibhav"
age: "Age of the person" = 20
language: "Favorite programming language of the person" = "Python"
student: "Is the person a student?" = True
height: "Height of the person in feet" = 5.9
print(__annotations__)

Ausgabe:

{'name': 'Name of the person', 'age': 'Age of the person', 'language': 'Favorite programming language of the person', 'student': 'Is the person a student?', 'height': 'Height of the person in feet'}

Für das erste Beispiel sieht die Ausgabe wie folgt aus.

{'name': < class 'str' > , 'age': < class 'int' > , 'language': < class 'str' > , 'student': < class 'bool' > , 'height': < class 'float' > }

Bisher haben wir nur primitive Datentypen wie int, float und str besprochen.

Lassen Sie uns nun verstehen, wie Annotationsausdrücke für komplexe Datentypen wie Liste, Tupel, set, Liste von Objekten usw. geschrieben werden. Dazu verwenden wir das Modul typing.

Das Modul typing ist Teil der Standardbibliothek von Python. Lassen Sie uns anhand eines Beispiels verstehen, wie Sie es für komplexe Datentypen verwenden.

Siehe dazu den folgenden Python-Code.

from typing import List, Tuple, Set


def user():
    return {"name": "Vaibhav", "username": "vaibhav", "password": "vaibhav"}


class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y


middlewares: List[str] = []
points: Tuple[Point] = tuple([Point(0, 0), Point(1, 1)])
numbers: Set[int] = set([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
users: List[dict] = [user()]
utils: List["function"] = [sum, len, sorted]
pairs: List[List[int]] = [[1, 2], [2, 3], [3, 4]]
print("middlewares:", middlewares, end="\n\n")
print("points:", points, end="\n\n")
print("numbers:", numbers, end="\n\n")
print("utils:", utils, end="\n\n")
print("users:", users, end="\n\n")
print("pairs:", pairs, end="\n\n")
print(__annotations__)

Ausgabe:

middlewares: []

points: (<__main__.Point object at 0x7fc658e454c0>, <__main__.Point object at 0x7fc658cef610>)

numbers: {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

utils: [<built-in function sum>, <built-in function len>, <built-in function sorted>]

users: [{'name': 'Vaibhav', 'username': 'vaibhav', 'password': 'vaibhav'}]

pairs: [[1, 2], [2, 3], [3, 4]]

{'middlewares': typing.List[str], 'points': typing.Tuple[__main__.Point], 'numbers': typing.Set[int], 'users': typing.List[dict], 'utils': typing.List[ForwardRef('function')], 'pairs': typing.List[typing.List[int]]}

Das Modul typing hat die Klassen List, Tuple und Set für list, tuple bzw. set, die als ihre generischen Versionen fungieren. Abgesehen von diesen dreien gibt es weitere generische Klassen wie Dict, FrozenSet, DefaultDict und OrderedDict.

Diese generischen Klassen können verwendet werden, um Anmerkungsausdrücke für Variablen bereitzustellen. Neben diesen Klassen werden in Klammern [] primitive Datentypen, String-Beschreibungen, Klassen oder andere generische Klassen aus demselben Modul platziert.

Beachten Sie, dass sie verwendet werden können, um Ausdrücke für Funktionen bereitzustellen, die wir gleich lernen werden. Um mehr über das typing-Modul zu erfahren, lesen Sie die offizielle Dokumentation hier.

Funktionsanmerkungen in Python

Funktionsanmerkungen sind Ausdrücke, die darauf abzielen, Details zu Datentypen von Funktionsparametern und Datentypen von Rückgabewerten von Funktionen in Python bereitzustellen. Funktionsanmerkungen haben die folgende Syntax.

def function( < parameter > : < expression > , < parameter > : < expression > = < default value > ) -> <expression > :

Anmerkungsausdrücke werden neben Parametern platziert, die durch einen Doppelpunkt oder : getrennt sind.

Wenn es einen Standardwert gibt, werden sie nach Anmerkungsausdrücken platziert. Bei Rückgabetypen von Funktionen folgt auf die Funktionssignatur ein -> oder Pfeil und der Annotationsausdruck.

Beachten Sie, dass der Doppelpunkt ganz am Ende steht. Lassen Sie uns Funktionsanmerkungen anhand einiger relevanter Beispiele verstehen.

Siehe dazu den folgenden Python-Code.

from typing import List, Tuple


def create_user(name: str, age: int, hobbies: List[str] = []) -> dict:
    return {"name": name, "age": age, "hobbies": hobbies}


def create_users(users: List[Tuple]) -> List[dict]:
    result = []

    for user in users:
        result.append(create_user(name=user[0], age=user[1], hobbies=user[2]))

    return result


u1: dict = create_user("Vaibhav", 20, ["Football", "Video Games"])
data = [
    ("Rick", 40, ["Shooting"]),
    ("Derly", 38, ["Archery", "Tracking"]),
    ("Maggie", 25, []),
    ("Carol", 32, ["Cooking"]),
]
users: List[dict] = create_users(data)
print(u1)
print(users)
print(__annotations__)

Ausgabe:

{'name': 'Vaibhav', 'age': 20, 'hobbies': ['Football', 'Video Games']}
[{'name': 'Rick', 'age': 40, 'hobbies': ['Shooting']}, {'name': 'Derly', 'age': 38, 'hobbies': ['Archery', 'Tracking']}, {'name': 'Maggie', 'age': 25, 'hobbies': []}, {'name': 'Carol', 'age': 32, 'hobbies': ['Cooking']}]
{'u1': <class 'dict'>, 'users': typing.List[dict]}

Wie wir sehen können, akzeptiert die Funktion create_user() drei Werte, nämlich name, age und hobbies, und gibt ein Dictionary oder dict zurück.

Die Methode create_users() akzeptiert eine Liste von Tupeln, die eine Liste von Benutzern darstellen. Diese Methode gibt eine Liste von Wörterbüchern zurück.

Das Ergebnis des Methodenaufrufs der Methode create_user() wird in einer Variablen u1 gespeichert, die vom Typ dict ist. Und das Ergebnis des Funktionsaufrufs der Methode create_users() wird in einer Variablen users gespeichert, die vom Typ List[dict] ist.

Das Attribut __annotations__ liefert nur Details zu den Variablen. Um Anmerkungsdetails zu den Funktionen abzurufen, können wir das Attribut __annotations__ verwenden.

Der folgende Python-Code veranschaulicht dies.

from typing import List, Tuple


def create_user(name: str, age: int, hobbies: List[str] = []) -> dict:
    return {"name": name, "age": age, "hobbies": hobbies}


def create_users(users: List[Tuple]) -> List[dict]:
    result = []

    for user in users:
        result.append(create_user(name=user[0], age=user[1], hobbies=user[2]))

    return result


print(create_user.__annotations__)
print(create_users.__annotations__)

Ausgabe:

{'name': <class 'str'>, 'age': <class 'int'>, 'hobbies': typing.List[str], 'return': <class 'dict'>}
{'users': typing.List[typing.Tuple], 'return': typing.List[dict]}

Das Ausgabewörterbuch enthält alle Anmerkungsdetails. Beachten Sie, dass für den Rückgabetyp return der Schlüssel im Dictionary ist. Bei Parametern sind die Parameternamen die Schlüssel.