So überprüfen Sie, ob eine Liste in Python Elemente eines bestimmten Typs enthält

Einführung

In diesem Lab lernen Sie, wie Sie prüfen können, ob eine Liste Elemente eines bestimmten Typs in Python enthält. Dies beinhaltet das Verständnis des Konzepts der Typüberprüfung (type checking), das für das Schreiben von robustem und wartbarem Code in Python's dynamisch typisierter Umgebung von entscheidender Bedeutung ist.

Sie werden die grundlegenden Datentypen von Python erkunden und die type()-Funktion verwenden, um den Typ von Variablen zu bestimmen. Das Lab wird Sie durch das Erstellen eines Python-Skripts führen, um die Typüberprüfung zu demonstrieren, und dann die isinstance()-Funktion zusammen mit all() einführen, um zu überprüfen, ob alle Elemente in einer Liste vom gewünschten Typ sind.

Skills Graph

Lernen Sie über Typüberprüfung (Type Checking)

In diesem Schritt werden wir das Konzept der Typüberprüfung in Python untersuchen. Typüberprüfung ist der Prozess, bei dem überprüft wird, ob die Typen der Werte, die in einem Programm verwendet werden, mit den erwarteten Typen übereinstimmen. Python ist eine dynamisch typisierte Sprache, was bedeutet, dass die Typüberprüfung hauptsächlich zur Laufzeit erfolgt. Das Verständnis, wie man Typen überprüft und sicherstellt, dass sie korrekt sind, ist jedoch für das Schreiben von robustem und wartbarem Code von entscheidender Bedeutung.

Beginnen wir damit, die grundlegenden Datentypen in Python zu verstehen:

• int: Repräsentiert Ganzzahlen (z.B. 1, 2, -5).
• float: Repräsentiert Fließkommazahlen (z.B. 3.14, 2.0).
• str: Repräsentiert Zeichenketten (Text) (z.B. "hello", "world").
• bool: Repräsentiert boolesche Werte (True oder False).
• list: Repräsentiert eine geordnete Sammlung von Elementen (z.B. [1, 2, 3]).
• tuple: Repräsentiert eine geordnete, unveränderliche Sammlung von Elementen (z.B. (1, 2, 3)).
• dict: Repräsentiert eine Sammlung von Schlüssel-Wert-Paaren (z.B. {"name": "Alice", "age": 30}).

Um den Typ einer Variablen zu überprüfen, können Sie die type()-Funktion verwenden. Erstellen wir ein Python-Skript, um dies zu demonstrieren.

1. Öffnen Sie den VS Code-Editor in der LabEx-Umgebung.

2. Erstellen Sie eine neue Datei mit dem Namen type_checking.py im Verzeichnis ~/project.

   ~/project/type_checking.py

3. Fügen Sie den folgenden Code in die Datei type_checking.py ein:

   ## Assign values to different variables
   x = 10
   y = 3.14
   name = "Bob"
   is_valid = True
   my_list = [1, 2, 3]
   my_tuple = (4, 5, 6)
   my_dict = {"key": "value"}
   
   ## Print the type of each variable
   print(f"Type of x: {type(x)}")
   print(f"Type of y: {type(y)}")
   print(f"Type of name: {type(name)}")
   print(f"Type of is_valid: {type(is_valid)}")
   print(f"Type of my_list: {type(my_list)}")
   print(f"Type of my_tuple: {type(my_tuple)}")
   print(f"Type of my_dict: {type(my_dict)}")

   Dieses Skript weist Variablen Werte unterschiedlicher Typen zu und verwendet dann die type()-Funktion, um den Typ jeder Variablen auszugeben.

4. Führen Sie das Skript im Terminal mit dem Befehl python aus:

   python ~/project/type_checking.py

   Sie sollten eine Ausgabe ähnlich der folgenden sehen:

   Type of x: <class 'int'>
   Type of y: <class 'float'>
   Type of name: <class 'str'>
   Type of is_valid: <class 'bool'>
   Type of my_list: <class 'list'>
   Type of my_tuple: <class 'tuple'>
   Type of my_dict: <class 'dict'>

   Diese Ausgabe zeigt den Typ jeder Variablen und bestätigt, dass Python den Typ jedes Werts korrekt erkennt.

Das Verständnis der Typen Ihrer Variablen ist für die korrekte Ausführung von Operationen unerlässlich. Beispielsweise können Sie nicht direkt eine Zeichenkette zu einer Ganzzahl hinzufügen, ohne die Zeichenkette zunächst in eine Ganzzahl umzuwandeln.

## Example of type error
x = 10
name = "Bob"

## This will raise a TypeError
## result = x + name

Wenn Sie die letzte Zeile im Skript einkommentieren, treten Sie auf einen TypeError auf, da Python nicht weiß, wie es eine Ganzzahl und eine Zeichenkette addieren soll.

Um dies zu beheben, müssten Sie die Ganzzahl in eine Zeichenkette umwandeln oder umgekehrt, je nachdem, welches Ergebnis gewünscht ist.

## Convert integer to string
x = 10
name = "Bob"
result = str(x) + name
print(result)  ## Output: 10Bob

In den nächsten Schritten werden wir fortgeschrittene Techniken für die Typüberprüfung und die Sicherstellung der Typkonsistenz in Ihrem Python-Code untersuchen.

Verwenden von all() mit isinstance()

In diesem Schritt lernen wir, wie wir die all()-Funktion in Kombination mit der isinstance()-Funktion verwenden können, um eine ausgefeiltere Typüberprüfung für Datenkollektionen durchzuführen. Dies ist besonders nützlich, wenn Sie sicherstellen müssen, dass alle Elemente in einer Liste, einem Tupel oder einem anderen iterierbaren Objekt einen bestimmten Typ haben.

Die isinstance()-Funktion wird verwendet, um zu prüfen, ob ein Objekt eine Instanz einer bestimmten Klasse oder eines bestimmten Typs ist. Sie nimmt zwei Argumente entgegen: das zu prüfende Objekt und den Typ, gegen den geprüft werden soll. Sie gibt True zurück, wenn das Objekt eine Instanz des Typs ist, und False sonst.

Die all()-Funktion wird verwendet, um zu prüfen, ob alle Elemente in einem iterierbaren Objekt wahr sind. Sie nimmt ein Argument entgegen: ein iterierbares Objekt (z.B. eine Liste, ein Tupel oder ein Set). Sie gibt True zurück, wenn alle Elemente im iterierbaren Objekt wahr sind, und False sonst.

Indem wir diese beiden Funktionen kombinieren, können wir leicht prüfen, ob alle Elemente in einer Sammlung einen bestimmten Typ haben.

1. Öffnen Sie den VS Code-Editor in der LabEx-Umgebung.

2. Erstellen Sie eine neue Datei mit dem Namen type_checking_all.py im Verzeichnis ~/project.

   ~/project/type_checking_all.py

3. Fügen Sie den folgenden Code in die Datei type_checking_all.py ein:

   ## List of values
   values = [1, 2, 3, 4, 5]
   
   ## Check if all values are integers
   all_integers = all(isinstance(x, int) for x in values)
   
   ## Print the result
   print(f"Are all values integers? {all_integers}")
   
   ## List with mixed types
   mixed_values = [1, 2, "3", 4, 5]
   
   ## Check if all values are integers
   all_integers_mixed = all(isinstance(x, int) for x in mixed_values)
   
   ## Print the result
   print(f"Are all values integers in mixed_values? {all_integers_mixed}")
   
   ## List of strings
   string_values = ["a", "b", "c"]
   
   ## Check if all values are strings
   all_strings = all(isinstance(x, str) for x in string_values)
   
   ## Print the result
   print(f"Are all values strings? {all_strings}")

   Dieses Skript zeigt, wie man all() und isinstance() verwendet, um die Typen der Elemente in einer Liste zu prüfen.

4. Führen Sie das Skript im Terminal mit dem Befehl python aus:

   python ~/project/type_checking_all.py

   Sie sollten eine Ausgabe ähnlich der folgenden sehen:

   Are all values integers? True
   Are all values integers in mixed_values? False
   Are all values strings? True

   Diese Ausgabe zeigt, dass die all()-Funktion korrekt erkennt, ob alle Elemente in der Liste vom angegebenen Typ sind.

Lassen Sie uns analysieren, wie dies funktioniert:

• isinstance(x, int) prüft, ob das Element x eine Ganzzahl ist.
• (isinstance(x, int) for x in values) ist ein Generatorausdruck, der für jedes Element in der values-Liste True oder False liefert.
• all(...) prüft dann, ob alle von dem Generatorausdruck gelieferten Werte True sind.

Dieser Ansatz ist sehr flexibel und kann verwendet werden, um nach jedem Typ oder jeder Kombination von Typen in einer Sammlung zu suchen.

Angeben des gewünschten Typs

In diesem Schritt werden wir untersuchen, wie man den gewünschten Typ für Variablen und Funktionsargumente angibt und wie man diese Typen mithilfe von Typ-Hinweisen (Type Hints) und bedingten Prüfungen (Conditional Checks) erzwingen kann. Obwohl Python dynamisch typisiert ist, ermöglichen es Ihnen Typ-Hinweise, statische Typinformationen in Ihren Code hinzuzufügen, die von Typ-Checkern wie mypy verwendet werden können, um Typfehler vor der Laufzeit aufzuspüren.

Typ-Hinweise sind Anmerkungen, die den erwarteten Typ einer Variablen, eines Funktionsarguments oder eines Funktionsrückgabewerts angeben. Sie werden für Variablen und Argumente mit der :-Syntax und für Rückgabewerte mit der ->-Syntax geschrieben.

Beginnen wir damit, Typ-Hinweise zu unserem vorherigen Beispiel hinzuzufügen.

1. Öffnen Sie den VS Code-Editor in der LabEx-Umgebung.

2. Erstellen Sie eine neue Datei mit dem Namen type_hints.py im Verzeichnis ~/project.

   ~/project/type_hints.py

3. Fügen Sie den folgenden Code in die Datei type_hints.py ein:

   def add_numbers(x: int, y: int) -> int:
       """Adds two numbers together."""
       return x + y
   
   ## Example usage
   result: int = add_numbers(5, 3)
   print(f"Result: {result}")
   
   ## Example with incorrect types
   ## This will not raise an error at runtime, but a type checker will flag it
   ## result: int = add_numbers("5", "3")
   ## print(f"Result: {result}")

   In diesem Skript:

   • x: int und y: int geben an, dass die Argumente x und y Ganzzahlen sein sollten.
   • -> int gibt an, dass die Funktion add_numbers eine Ganzzahl zurückgeben sollte.
   • result: int gibt an, dass die Variable result eine Ganzzahl sein sollte.

4. Führen Sie das Skript im Terminal mit dem Befehl python aus:

   python ~/project/type_hints.py

   Sie sollten eine Ausgabe ähnlich der folgenden sehen:

   Result: 8

   Das Skript läuft ohne Fehler, da die Typen korrekt sind. Wenn Sie jedoch die Zeilen mit den falschen Typen einkommentieren, wird das Skript weiterhin laufen, aber ein Typ-Checker wie mypy würde diese Zeilen als Typfehler markieren.

Um mypy zu installieren und auszuführen, können Sie die folgenden Befehle verwenden:

pip install mypy
mypy ~/project/type_hints.py

Da pip nicht vorkonfiguriert ist, können Sie möglicherweise auf Fehler in Bezug auf fehlende Pakete oder falsche Versionen stoßen. Zu Zwecken dieses Labs werden wir uns darauf konzentrieren, das Konzept von Typ-Hinweisen und bedingten Prüfungen zu demonstrieren.

Eine andere Möglichkeit, Typen zu erzwingen, besteht darin, bedingte Prüfungen in Ihrem Code zu verwenden. Dies ermöglicht es Ihnen, Ausnahmen auszulösen, wenn die Typen nicht den erwarteten entsprechen.

def divide_numbers(x, y):
    if not isinstance(x, (int, float)):
        raise TypeError("x must be a number")
    if not isinstance(y, (int, float)):
        raise TypeError("y must be a number")
    if y == 0:
        raise ValueError("y cannot be zero")
    return x / y

## Example usage
result = divide_numbers(10, 2)
print(f"Result: {result}")

## Example with incorrect types
## This will raise a TypeError
## result = divide_numbers("10", 2)
## print(f"Result: {result}")

In diesem Beispiel verwenden wir isinstance(), um zu prüfen, ob x und y Zahlen (entweder int oder float) sind. Wenn dies nicht der Fall ist, werfen wir einen TypeError. Wir prüfen auch, ob y Null ist, und werfen einen ValueError, wenn dies der Fall ist.

Indem Sie Typ-Hinweise und bedingte Prüfungen kombinieren, können Sie robusteren und wartbareren Python-Code schreiben, der weniger anfällig für Typfehler ist.

Zusammenfassung

In diesem Lab konzentriert sich der erste Schritt darauf, die Typüberprüfung in Python zu verstehen. Python ist eine dynamisch typisierte Sprache, bei der die Typüberprüfung hauptsächlich zur Laufzeit erfolgt. Das Lab führt die grundlegenden Python-Datentypen ein, darunter int, float, str, bool, list, tuple und dict.

Anschließend zeigt das Lab, wie man die type()-Funktion verwendet, um den Datentyp einer Variablen zu bestimmen. Es wird ein Python-Skript namens type_checking.py erstellt, um Variablen mit Werten unterschiedlicher Typen zu belegen und anschließend deren jeweilige Typen mit der type()-Funktion auszugeben.