So prüfen Sie, ob ein Tupel in Python nur Zahlen enthält

Einführung

In diesem Lab lernen Sie, wie Sie in Python prüfen können, ob ein Tupel nur Zahlen (Ganzzahlen und Fließkommazahlen) enthält. Sie beginnen damit, numerische Tupel zu definieren und zu untersuchen, wie Sie Tupel erstellen können, die Ganzzahlen, Fließkommazahlen oder eine Mischung aus beiden enthalten. Dazu erstellen Sie eine Datei namens numeric_tuple.py, fügen Tupeldefinitionen hinzu und führen das Skript aus, um die Ausgabe zu beobachten.

Anschließend werden Sie im Lab durch die Verwendung der all()-Funktion in Verbindung mit isinstance() geführt, um zu überprüfen, ob alle Elemente in einem Tupel tatsächlich numerisch sind. Abschließend lernen Sie, wie Sie leere Tupel bei dieser Prüfung elegant behandeln können.

Numerische Tupel definieren

In diesem Schritt lernen Sie, wie Sie in Python Tupel definieren können, die nur numerische Daten (Ganzzahlen und Fließkommazahlen) enthalten. Tupel sind eine grundlegende Datenstruktur in Python, ähnlich wie Listen, aber mit einem wesentlichen Unterschied: Sie sind unveränderlich (immutable), was bedeutet, dass ihre Elemente nach der Erstellung nicht geändert werden können. Diese Unveränderlichkeit macht sie nützlich für die Darstellung von festen Datensammlungen.

Beginnen wir damit, ein einfaches Tupel mit Ganzzahlen zu erstellen:

Öffnen Sie Ihren VS Code-Editor.
Erstellen Sie eine neue Datei namens numeric_tuple.py im Verzeichnis ~/project.
```
## ~/project/numeric_tuple.py
my_tuple = (1, 2, 3, 4, 5)
print(my_tuple)
```
Speichern Sie die Datei.
Öffnen Sie Ihr Terminal.
Führen Sie das Skript mit dem Befehl python aus:
```
python ~/project/numeric_tuple.py
```
Sie sollten die folgende Ausgabe sehen:
```
(1, 2, 3, 4, 5)
```

Jetzt erstellen wir ein Tupel mit Fließkommazahlen:

Ändern Sie die Datei numeric_tuple.py, um Fließkommawerte einzubeziehen:

## ~/project/numeric_tuple.py
my_tuple = (1.0, 2.5, 3.7, 4.2, 5.9)
print(my_tuple)

Speichern Sie die Datei.
Führen Sie das Skript erneut aus:
```
python ~/project/numeric_tuple.py
```
Sie sollten die folgende Ausgabe sehen:
```
(1.0, 2.5, 3.7, 4.2, 5.9)
```

Tupel können auch eine Mischung aus Ganzzahlen und Fließkommazahlen enthalten:

Ändern Sie die Datei numeric_tuple.py, um sowohl Ganzzahl- als auch Fließkommawerte einzubeziehen:
```
## ~/project/numeric_tuple.py
my_tuple = (1, 2.5, 3, 4.2, 5)
print(my_tuple)
```
Speichern Sie die Datei.
Führen Sie das Skript aus:
```
python ~/project/numeric_tuple.py
```
Sie sollten die folgende Ausgabe sehen:
```
(1, 2.5, 3, 4.2, 5)
```

Zusammenfassend können Sie Tupel mit numerischen Daten definieren, indem Sie die Zahlen (Ganzzahlen und Fließkommazahlen) in Klammern () einschließen und sie mit Kommas trennen.

Verwenden von all() mit isinstance()

In diesem Schritt lernen Sie, wie Sie die all()-Funktion in Kombination mit der isinstance()-Funktion verwenden, um zu prüfen, ob alle Elemente in einem Tupel numerisch sind. Dies ist eine nützliche Technik zur Validierung von Daten und zur Sicherstellung, dass Ihr Code mit den richtigen Wertetypen arbeitet.

Zunächst verstehen wir, was all() und isinstance() tun:

all(iterable): Diese Funktion gibt True zurück, wenn alle Elemente des Iterierbaren (z. B. eines Tupels) wahr sind (oder wenn das Iterierbare leer ist). Sie gibt False zurück, wenn irgendein Element falsch ist.
isinstance(object, classinfo): Diese Funktion gibt True zurück, wenn das object eine Instanz von classinfo (z. B. int, float) ist. Andernfalls gibt sie False zurück.

Jetzt erstellen wir ein Python-Skript, um zu prüfen, ob alle Elemente in einem Tupel entweder Ganzzahlen oder Fließkommazahlen sind:

Öffnen Sie Ihren VS Code-Editor.
Erstellen Sie eine neue Datei namens check_numeric_tuple.py im Verzeichnis ~/project.
```
## ~/project/check_numeric_tuple.py
def is_numeric_tuple(my_tuple):
    return all(isinstance(item, (int, float)) for item in my_tuple)

tuple1 = (1, 2.5, 3, 4.2, 5)
tuple2 = (1, 2, 'a', 4, 5)
tuple3 = (1.0, 2.0, 3.0)

print(f"Tuple 1 is numeric: {is_numeric_tuple(tuple1)}")
print(f"Tuple 2 is numeric: {is_numeric_tuple(tuple2)}")
print(f"Tuple 3 is numeric: {is_numeric_tuple(tuple3)}")
```
In diesem Skript:
- Wir definieren eine Funktion is_numeric_tuple, die ein Tupel als Eingabe nimmt.
- Innerhalb der Funktion verwenden wir all() mit einem Generatorausdruck (isinstance(item, (int, float)) for item in my_tuple), um zu prüfen, ob jedes item im Tupel eine Instanz von entweder int oder float ist.
- Wir testen dann die Funktion mit drei verschiedenen Tupeln.
Speichern Sie die Datei.
Öffnen Sie Ihr Terminal.
Führen Sie das Skript mit dem Befehl python aus:
```
python ~/project/check_numeric_tuple.py
```
Sie sollten die folgende Ausgabe sehen:
```
Tuple 1 is numeric: True
Tuple 2 is numeric: False
Tuple 3 is numeric: True
```
Diese Ausgabe zeigt, dass tuple1 und tuple3 nur numerische Werte enthalten, während tuple2 einen String enthält und daher nicht als numerisches Tupel angesehen wird.

Dieses Beispiel zeigt, wie Sie all() und isinstance() effektiv nutzen können, um den Inhalt eines Tupels zu validieren und sicherzustellen, dass alle Elemente einem bestimmten Datentyp entsprechen.

Leere Tupel behandeln

In diesem Schritt lernen Sie, wie Sie leere Tupel behandeln können, wenn Sie auf numerische Werte prüfen. Ein leeres Tupel ist ein Tupel ohne Elemente, dargestellt als (). Es ist wichtig, leere Tupel in Ihrem Code zu berücksichtigen, um potenzielle Fehler zu vermeiden und sicherzustellen, dass Ihr Programm wie erwartet funktioniert.

Ändern wir das Skript aus dem vorherigen Schritt, um leere Tupel zu behandeln:

Öffnen Sie Ihren VS Code-Editor.

Öffnen Sie die Datei check_numeric_tuple.py im Verzeichnis ~/project.

## ~/project/check_numeric_tuple.py
def is_numeric_tuple(my_tuple):
    if not my_tuple:
        return True  ## Ein leeres Tupel wird als numerisch angesehen
    return all(isinstance(item, (int, float)) for item in my_tuple)

tuple1 = (1, 2.5, 3, 4.2, 5)
tuple2 = (1, 2, 'a', 4, 5)
tuple3 = (1.0, 2.0, 3.0)
tuple4 = () ## Leeres Tupel

print(f"Tuple 1 is numeric: {is_numeric_tuple(tuple1)}")
print(f"Tuple 2 is numeric: {is_numeric_tuple(tuple2)}")
print(f"Tuple 3 is numeric: {is_numeric_tuple(tuple3)}")
print(f"Tuple 4 is numeric: {is_numeric_tuple(tuple4)}")

In diesem geänderten Skript:

Wir haben am Anfang der Funktion is_numeric_tuple eine Prüfung hinzugefügt: if not my_tuple: return True. Diese prüft, ob das Tupel leer ist. Wenn ja, gibt die Funktion True zurück und betrachtet das leere Tupel als numerisch.
Wir haben ein leeres Tupel tuple4 = () hinzugefügt, um die Funktion zu testen.

Speichern Sie die Datei.
Öffnen Sie Ihr Terminal.
Führen Sie das Skript mit dem Befehl python aus:
```
python ~/project/check_numeric_tuple.py
```
Sie sollten die folgende Ausgabe sehen:
```
Tuple 1 is numeric: True
Tuple 2 is numeric: False
Tuple 3 is numeric: True
Tuple 4 is numeric: True
```
Diese Ausgabe zeigt, dass das leere Tupel tuple4 jetzt richtig behandelt wird und als numerisches Tupel angesehen wird.

Das Behandeln von leeren Tupeln ist eine gute Praxis, um Ihren Code robuster zu machen und unerwartetes Verhalten zu vermeiden. In diesem Fall haben wir beschlossen, ein leeres Tupel als numerisch zu betrachten, aber Sie können die Logik entsprechend Ihren spezifischen Anforderungen anpassen.

Zusammenfassung

In diesem Labo (Lab) konzentriert sich der erste Schritt auf die Definition von numerischen Tupeln in Python. Sie haben gelernt, dass Tupel unveränderliche (immutable) Datenstrukturen sind, ähnlich wie Listen, und mit Klammern () definiert werden. Sie können Tupel erstellen, die Ganzzahlen, Fließkommazahlen oder eine Mischung aus beiden enthalten, wobei die Elemente durch Kommas getrennt werden.

Das Labo zeigt dann, wie Sie prüfen können, ob ein Tupel nur Zahlen enthält, indem Sie die all()-Funktion in Verbindung mit isinstance() verwenden. (Der Inhalt ist in der ursprünglichen Labo-Beschreibung abgeschnitten.)