Wie man prüft, ob eine Menge in Python einzigartige Elemente enthält

Einführung

In diesem Lab lernen Sie, wie Sie prüfen können, ob eine Menge (Set) in Python einzigartige Elemente enthält. Mengen sind ein eingebauter Datentyp, der ungeordnete Sammlungen einzigartiger Elemente speichert und automatisch Duplikate entfernt. Sie beginnen damit, Mengen zu erstellen und auszugeben und zu beobachten, wie Duplikate behandelt werden.

Anschließend wird das Lab tiefer in die Eigenschaften von Mengen eintauchen und untersuchen, wie Sie ihre einzigartigen Merkmale für Aufgaben wie das Entfernen von doppelten Einträgen oder das Prüfen auf das Vorhandensein von Elementen nutzen können. Sie lernen, die Eindeutigkeit mithilfe der Funktionen len() und der Elementzählung zu überprüfen.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL python(("Python")) -.-> python/PythonStandardLibraryGroup(["Python Standard Library"]) python(("Python")) -.-> python/DataStructuresGroup(["Data Structures"]) python(("Python")) -.-> python/FunctionsGroup(["Functions"]) python/DataStructuresGroup -.-> python/sets("Sets") python/FunctionsGroup -.-> python/build_in_functions("Build-in Functions") python/PythonStandardLibraryGroup -.-> python/data_collections("Data Collections") subgraph Lab Skills python/sets -.-> lab-559561{{"Wie man prüft, ob eine Menge in Python einzigartige Elemente enthält"}} python/build_in_functions -.-> lab-559561{{"Wie man prüft, ob eine Menge in Python einzigartige Elemente enthält"}} python/data_collections -.-> lab-559561{{"Wie man prüft, ob eine Menge in Python einzigartige Elemente enthält"}} end

Lernen Sie die Eindeutigkeit von Mengen kennen

In diesem Schritt lernen Sie das grundlegende Konzept der Eindeutigkeit von Mengen (Sets) in Python kennen. Mengen sind ein eingebauter Datentyp in Python, der eine ungeordnete Sammlung von einzigartigen Elementen speichert. Das bedeutet, dass eine Menge keine doppelten Werte enthalten kann. Das Verständnis dieser Eigenschaft ist entscheidend für die effiziente Verwaltung und Manipulation von Daten, bei denen Eindeutigkeit wichtig ist.

Beginnen wir damit, eine einfache Menge zu erstellen:

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

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

## Create a set of numbers
my_set = {1, 2, 3, 4, 5}

## Print the set
print(my_set)

Speichern Sie die Datei.
Führen Sie das Skript im Terminal mit dem Befehl python aus:
```
python set_example.py
```
Sie sollten die folgende Ausgabe sehen:
```
{1, 2, 3, 4, 5}
```

Nun sehen wir uns an, was passiert, wenn wir versuchen, doppelte Elemente zu einer Menge hinzuzufügen:

Ändern Sie die Datei set_example.py, um doppelte Werte einzufügen:

## Create a set with duplicate numbers
my_set = {1, 2, 2, 3, 4, 4, 5}

## Print the set
print(my_set)

Speichern Sie die Datei.
Führen Sie das Skript erneut aus:
```
python set_example.py
```
Sie sollten die folgende Ausgabe sehen:
```
{1, 2, 3, 4, 5}
```

Beachten Sie, dass die Menge nur einzigartige Elemente enthält, obwohl wir versucht haben, doppelte Werte (2 und 4) hinzuzufügen. Dies zeigt die Kern-Eigenschaft von Mengen: Sie eliminieren automatisch Duplikate.

Diese Eindeutigkeitseigenschaft macht Mengen sehr nützlich für Aufgaben wie das Entfernen von doppelten Einträgen aus einer Liste oder das Prüfen, ob ein Element bereits in einer Sammlung vorhanden ist. In den folgenden Schritten werden wir weitere Anwendungen von Mengen untersuchen und lernen, wie wir ihre einzigartigen Eigenschaften nutzen können.

Eigenschaften von Mengen verstehen

In diesem Schritt werden wir tiefer in die Eigenschaften von Mengen (Sets) in Python eintauchen. Mengen sind nicht nur Sammlungen einzigartiger Elemente; sie unterstützen auch verschiedene Operationen, die sie zu einem leistungsstarken Werkzeug für die Datenmanipulation machen. Wir werden untersuchen, wie man Elemente hinzufügt, Elemente entfernt und gängige Mengenoperationen wie Vereinigung, Schnittmenge und Differenz durchführt.

Beginnen wir damit, Elemente zu einer Menge hinzuzufügen:

Öffnen Sie die Datei set_example.py im Verzeichnis ~/project mit dem VS Code-Editor.

Ändern Sie die Datei, um Elemente mit der Methode add() zur Menge hinzuzufügen:

## Create a set
my_set = {1, 2, 3}

## Add elements to the set
my_set.add(4)
my_set.add(5)

## Print the set
print(my_set)

Speichern Sie die Datei.
Führen Sie das Skript im Terminal mit dem Befehl python aus:
```
python set_example.py
```
Sie sollten die folgende Ausgabe sehen:
```
{1, 2, 3, 4, 5}
```

Nun sehen wir uns an, wie man Elemente aus einer Menge entfernt:

Ändern Sie die Datei set_example.py, um ein Element mit der Methode remove() zu entfernen:

## Create a set
my_set = {1, 2, 3, 4, 5}

## Remove an element from the set
my_set.remove(3)

## Print the set
print(my_set)

Speichern Sie die Datei.
Führen Sie das Skript erneut aus:
```
python set_example.py
```
Sie sollten die folgende Ausgabe sehen:
```
{1, 2, 4, 5}
```

Beachten Sie, dass wenn Sie versuchen, ein Element zu entfernen, das nicht in der Menge enthalten ist, ein KeyError ausgelöst wird. Um dies zu vermeiden, können Sie die Methode discard() verwenden, die keinen Fehler auslöst, wenn das Element nicht vorhanden ist.

```python
## Create a set
my_set = {1, 2, 3, 4, 5}

## Discard an element from the set
my_set.discard(6) ## No error raised

## Print the set
print(my_set)
```

Schließlich werden wir einige gängige Mengenoperationen untersuchen:

Ändern Sie die Datei set_example.py, um Vereinigungs-, Schnitt- und Differenzoperationen durchzuführen:

## Create two sets
set1 = {1, 2, 3, 4, 5}
set2 = {3, 4, 5, 6, 7}

## Union of the sets
union_set = set1.union(set2)
print("Union:", union_set)

## Intersection of the sets
intersection_set = set1.intersection(set2)
print("Intersection:", intersection_set)

## Difference of the sets (elements in set1 but not in set2)
difference_set = set1.difference(set2)
print("Difference:", difference_set)

Speichern Sie die Datei.

Führen Sie das Skript erneut aus:

python set_example.py

Sie sollten die folgende Ausgabe sehen:

Union: {1, 2, 3, 4, 5, 6, 7}
Intersection: {3, 4, 5}
Difference: {1, 2}

Das Verständnis dieser Mengeneigenschaften und -operationen ermöglicht es Ihnen, Mengen effektiv für verschiedene Datenmanipulationstasks in Python zu nutzen.

Mit len() und Elementzählung überprüfen

In diesem Schritt lernen wir, wie man die Eigenschaften einer Menge (Set) mit der Funktion len() überprüft und ob bestimmte Elemente in der Menge vorhanden sind. Die Funktion len() gibt die Anzahl der Elemente in einer Menge zurück, und wir können den Operator in verwenden, um zu prüfen, ob ein Element in einer Menge enthalten ist. Diese Techniken sind nützlich, um den Zustand einer Menge nach der Ausführung von Operationen zu validieren.

Beginnen wir damit, die Funktion len() zu verwenden, um die Größe einer Menge zu bestimmen:

Öffnen Sie die Datei set_example.py im Verzeichnis ~/project mit dem VS Code-Editor.

Ändern Sie die Datei, um die Funktion len() zu verwenden, um die Anzahl der Elemente in der Menge auszugeben:

## Create a set
my_set = {1, 2, 3, 4, 5}

## Get the number of elements in the set
set_length = len(my_set)

## Print the length of the set
print("Length of the set:", set_length)

Speichern Sie die Datei.
Führen Sie das Skript im Terminal mit dem Befehl python aus:
```
python set_example.py
```
Sie sollten die folgende Ausgabe sehen:
```
Length of the set: 5
```

Nun sehen wir uns an, wie man mit dem Operator in prüft, ob ein Element in einer Menge enthalten ist:

Ändern Sie die Datei set_example.py, um die Anwesenheit bestimmter Elemente zu prüfen:

## Create a set
my_set = {1, 2, 3, 4, 5}

## Check if an element is in the set
if 3 in my_set:
    print("3 is in the set")
else:
    print("3 is not in the set")

## Check if an element is not in the set
if 6 in my_set:
    print("6 is in the set")
else:
    print("6 is not in the set")

Speichern Sie die Datei.
Führen Sie das Skript erneut aus:
```
python set_example.py
```
Sie sollten die folgende Ausgabe sehen:
```
3 is in the set
6 is not in the set
```

Durch die Kombination der Funktion len() und des Operators in können Sie effektiv die Eigenschaften einer Menge überprüfen und sicherstellen, dass sie die erwarteten Elemente enthält. Dies ist besonders nützlich, wenn Sie in komplexeren Programmen mit Mengen arbeiten und den Zustand Ihrer Daten validieren müssen.

Zusammenfassung

In diesem Lab beginnen Sie damit, das grundlegende Konzept der Eindeutigkeit von Mengen (Sets) in Python kennenzulernen. Mengen werden als ein eingebauter Datentyp vorgestellt, der ungeordnete Sammlungen einzigartiger Elemente speichert und automatisch Duplikate entfernt. Sie erstellen ein Python-Skript, um diese Eigenschaft zu demonstrieren, und beobachten, dass das Hinzufügen von doppelten Werten zu einer Menge nicht dazu führt, dass diese Duplikate gespeichert werden.

Das Lab geht dann weiter, um tiefer in die Eigenschaften von Mengen einzutauchen und hebt hervor, dass sie mehr sind als nur Sammlungen einzigartiger Elemente. (Der bereitgestellte Inhalt ist abgeschnitten, daher basiert dies auf der Annahme, dass der nächste Schritt auf dem ersten Verständnis der Eindeutigkeit von Mengen aufbaut.)