Wie man prüft, ob eine Liste in Python eine Zeichenkette enthält

Einführung

In diesem Lab lernen Sie, wie Sie prüfen können, ob eine Liste in Python eine Zeichenkette (string) enthält. Das Lab beginnt mit der Einführung des grundlegenden Konzepts von Zeichenketten, wobei gezeigt wird, wie Sie einzelne Zeichen mithilfe von Indizierung zugreifen, Teilzeichenketten mithilfe von Slicing extrahieren und die Länge einer Zeichenkette bestimmen können.

Sie beginnen damit, ein Python-Skript namens string_elements.py zu erstellen, um Zeichenkettenelemente zu untersuchen. In diesem Skript wird einer Variablen eine Zeichenkette zugewiesen, einzelne Zeichen werden zugegriffen, Teilzeichenketten extrahiert und die Länge der Zeichenkette berechnet. Dies bildet die Grundlage für das Verständnis der Zeichenkettenmanipulation in Python.

Lernen Sie über Zeichenkettenelemente

In diesem Schritt lernen Sie das grundlegende Konzept von Zeichenketten (strings) in Python kennen. Zeichenketten sind Sequenzen von Zeichen und gehören zu den am häufigsten verwendeten Datentypen in der Programmierung. Das Verständnis, wie man mit Zeichenketten arbeitet, ist für Aufgaben wie Datenmanipulation, Textverarbeitung und Benutzer-Eingabe von entscheidender Bedeutung.

Zunächst erstellen wir ein einfaches Python-Skript, um Zeichenkettenelemente zu untersuchen.

Öffnen Sie den VS Code-Editor in der LabEx-Umgebung.
Erstellen Sie eine neue Datei namens string_elements.py im Verzeichnis ~/project.
```
~/project/string_elements.py
```
Fügen Sie den folgenden Code zur Datei string_elements.py hinzu:
```
## Assign a string to a variable
my_string = "Hello, LabEx!"

## Accessing individual characters using indexing
first_character = my_string[0]
print("First character:", first_character)

## String slicing to extract a substring
substring = my_string[7:12]
print("Substring:", substring)

## String length
string_length = len(my_string)
print("String length:", string_length)
```
Dieses Skript zeigt, wie man einzelne Zeichen in einer Zeichenkette mithilfe von Indizierung (indexing) zugreift, Teilzeichenketten mithilfe von Slicing extrahiert und die Länge einer Zeichenkette mithilfe der Funktion len() bestimmt.
- my_string = "Hello, LabEx!": Diese Zeile weist der Variablen my_string die Zeichenkette "Hello, LabEx!" zu.
- first_character = my_string[0]: Diese Zeile greift auf das Zeichen an Index 0 (das erste Zeichen) von my_string zu und weist es der Variablen first_character zu. In Python beginnt die Indizierung bei 0.
- substring = my_string[7:12]: Diese Zeile extrahiert eine Teilzeichenkette aus my_string, die bei Index 7 beginnt und bei Index 12 endet (exklusiv). Die Teilzeichenkette wird "LabEx" sein.
- string_length = len(my_string): Diese Zeile berechnet die Länge von my_string mithilfe der Funktion len() und weist sie der Variablen string_length zu.
Speichern Sie die Datei string_elements.py.
Führen Sie das Skript in der Terminal mit dem folgenden Befehl aus:
```
python string_elements.py
```
Sie sollten die folgende Ausgabe sehen:
```
First character: H
Substring: LabEx
String length: 13
```
Diese Ausgabe bestätigt, dass Sie erfolgreich einzelne Zeichen zugegriffen, Teilzeichenketten extrahiert und die Länge der Zeichenkette bestimmt haben.

Verwenden Sie any() mit isinstance()

In diesem Schritt lernen Sie, wie Sie die Funktion any() in Kombination mit der Funktion isinstance() verwenden, um zu prüfen, ob irgendein Element in einer Liste eine Instanz eines bestimmten Datentyps, wie z. B. einer Zeichenkette (string), ist. Dies ist eine leistungsstarke Technik zur Validierung von Daten und zur Sicherstellung, dass Ihr Code verschiedene Datentypen korrekt verarbeitet.

Erstellen wir ein Python-Skript, um dieses Konzept zu demonstrieren.

Öffnen Sie den VS Code-Editor in der LabEx-Umgebung.
Erstellen Sie eine neue Datei namens any_isinstance.py im Verzeichnis ~/project.
```
~/project/any_isinstance.py
```
Fügen Sie den folgenden Code zur Datei any_isinstance.py hinzu:
```
## List containing different data types
my_list = [1, 2, "hello", 4, 5, "world"]

## Check if any element in the list is a string
has_string = any(isinstance(item, str) for item in my_list)

## Print the result
print("List contains a string:", has_string)
```
Dieses Skript prüft, ob die Liste my_list irgendeine Zeichenkette enthält, indem es any() und isinstance() verwendet.
- my_list = [1, 2, "hello", 4, 5, "world"]: Diese Zeile erstellt eine Liste namens my_list, die ganze Zahlen (Integers) und Zeichenketten enthält.
- has_string = any(isinstance(item, str) for item in my_list): Diese Zeile verwendet einen Generatorausdruck (isinstance(item, str) for item in my_list), um zu prüfen, ob jedes item in my_list eine Instanz des Typs str (d. h. eine Zeichenkette) ist. Die Funktion any() gibt True zurück, wenn mindestens ein Element im Generatorausdruck True ist, und False sonst.
- print("List contains a string:", has_string): Diese Zeile gibt das Ergebnis der Prüfung aus.
Speichern Sie die Datei any_isinstance.py.
Führen Sie das Skript in der Terminal mit dem folgenden Befehl aus:
```
python any_isinstance.py
```
Sie sollten die folgende Ausgabe sehen:
```
List contains a string: True
```
Diese Ausgabe bestätigt, dass das Skript korrekt erkannt hat, dass die Liste mindestens ein Zeichenkettenelement enthält.

Zeichenkettenpositionen finden

In diesem Schritt lernen Sie, wie Sie die Position einer Teilzeichenkette (substring) innerhalb einer größeren Zeichenkette mithilfe der Methoden find() und index() bestimmen können. Diese Methoden sind für Aufgaben wie die Suche nach bestimmten Mustern in Texten und die Extraktion relevanter Informationen unerlässlich.

Erstellen wir ein Python-Skript, um zu zeigen, wie man Zeichenkettenpositionen findet.

Öffnen Sie den VS Code-Editor in der LabEx-Umgebung.
Erstellen Sie eine neue Datei namens string_positions.py im Verzeichnis ~/project.
```
~/project/string_positions.py
```
Fügen Sie den folgenden Code zur Datei string_positions.py hinzu:
```
## String to search within
my_string = "This is a sample string for demonstration."

## Find the index of the first occurrence of "sample"
index_of_sample = my_string.find("sample")
print("Index of 'sample':", index_of_sample)

## Find the index of the first occurrence of "string"
index_of_string = my_string.find("string")
print("Index of 'string':", index_of_string)

## Find the index of a non-existent substring
index_of_nonexistent = my_string.find("xyz")
print("Index of 'xyz':", index_of_nonexistent)

## Using index() method
try:
    index_of_demo = my_string.index("demo")
    print("Index of 'demo':", index_of_demo)
except ValueError:
    print("'demo' not found")
```
Dieses Skript zeigt, wie man die Methoden find() und index() verwendet, um Teilzeichenketten innerhalb einer Zeichenkette zu finden.
- my_string = "This is a sample string for demonstration.": Diese Zeile weist der Variablen my_string die Zeichenkette "This is a sample string for demonstration." zu.
- index_of_sample = my_string.find("sample"): Diese Zeile verwendet die Methode find(), um den Index der ersten Vorkommnis der Teilzeichenkette "sample" in my_string zu finden. Die Methode find() gibt den Index der ersten Vorkommnis zurück oder -1, wenn die Teilzeichenkette nicht gefunden wird.
- index_of_nonexistent = my_string.find("xyz"): Diese Zeile zeigt, was passiert, wenn die Teilzeichenkette nicht gefunden wird. find() gibt -1 zurück.
- Die Methode index() ist ähnlich wie find(), aber sie löst eine ValueError-Ausnahme aus, wenn die Teilzeichenkette nicht gefunden wird. Der try...except-Block behandelt diese Ausnahme.
Speichern Sie die Datei string_positions.py.
Führen Sie das Skript in der Terminal mit dem folgenden Befehl aus:
```
python string_positions.py
```
Sie sollten die folgende Ausgabe sehen:
```
Index of 'sample': 10
Index of 'string': 17
Index of 'xyz': -1
Index of 'demo': 27
```
Diese Ausgabe bestätigt, dass das Skript die Positionen der Teilzeichenketten "sample", "string" und "demo" innerhalb der Hauptzeichenkette korrekt gefunden hat und dass es den Fall behandelt hat, dass eine Teilzeichenkette nicht gefunden wird.

Zusammenfassung

In diesem Labo (Laborübung) konzentriert sich der erste Schritt auf das Verständnis von Zeichenketten (strings) in Python. Dabei wird eine Datei namens string_elements.py im Verzeichnis ~/project im VS Code-Editor erstellt.

Das Skript zeigt, wie man einer Variablen eine Zeichenkette zuweist, einzelne Zeichen mithilfe von Indizierung (beginnend bei 0) zugreift, Teilzeichenketten mithilfe von Slicing extrahiert und die Länge einer Zeichenkette mithilfe der Funktion len() bestimmt. Das Beispiel verwendet die Zeichenkette "Hello, LabEx!", um diese Konzepte zu veranschaulichen.