Mit Mengen (Sets) in Python arbeiten

Einleitung

In diesem Lab erhalten Sie praktische Erfahrung mit Mengen (Sets) in Python. Mengen sind leistungsstarke Datenstrukturen zum Speichern eindeutiger Elemente und zur Durchführung effizienter Mitgliedschaftstests.

Sie lernen, wie Sie Mengen mit verschiedenen Methoden erstellen, Elemente hinzufügen und entfernen sowie gängige Mengenoperationen wie Schnittmenge (intersection), Vereinigungsmenge (union) und Differenz (difference) durchführen. Abschließend wenden Sie Ihr Wissen auf einen praktischen Anwendungsfall an: das Entfernen doppelter Elemente aus einer Liste mithilfe von Mengen.

Erstellen und Hinzufügen von Elementen zu Mengen

In diesem Schritt lernen Sie, wie Sie Mengen (Sets) in Python erstellen und Elemente zu ihnen hinzufügen. Mengen sind ungeordnete Sammlungen eindeutiger Elemente. Sie sind nützlich für Mitgliedschaftstests und das Eliminieren von Duplikaten.

Erstellen Sie zunächst eine neue Python-Datei in Ihrem Verzeichnis ~/project mit dem VS Code-Editor. Nennen Sie die Datei set_creation.py.

Öffnen Sie die Datei und fügen Sie den folgenden Code hinzu, um verschiedene Möglichkeiten zur Erstellung von Mengen zu demonstrieren:

## Verwendung von geschweiften Klammern
a = {'jack', 'sjoerd'}
print(a)
print(type(a))

## Verwendung einer Set Comprehension
a = {c for c in 'abracadabra'}  ## Mengen entfernen automatisch Duplikate
print(a)
print(type(a))

## Verwendung des set() Konstruktors
a = set()  ## Erstellt eine leere Menge. {} kann nicht für eine leere Menge verwendet werden.
print(a)
print(type(a))

b = {}  ## Dies erstellt ein Dictionary, das wir später behandeln werden.
print(type(b))

c = set('foobar')  ## Erstellt eine Menge aus einem iterierbaren Objekt und entfernt automatisch Duplikate
print(c)
print(type(c))

Speichern Sie die Datei. Öffnen Sie nun das Terminal in VS Code (Terminal -> Neues Terminal) und führen Sie das Skript mit dem Befehl python aus:

python ~/project/set_creation.py

Sie sollten eine Ausgabe ähnlich der folgenden sehen, die die verschiedenen erstellten Mengen und ihre Typen anzeigt:

{'sjoerd', 'jack'}
<class 'set'>
{'a', 'r', 'b', 'c', 'd'}
<class 'set'>
set()
<class 'set'>
<class 'dict'>
{'r', 'b', 'a', 'f', 'o'}
<class 'set'>

Als Nächstes untersuchen wir, wie Elemente zu einer vorhandenen Menge hinzugefügt werden. Wir verwenden die Methode add(), um ein einzelnes Element hinzuzufügen, und die Methode update(), um mehrere Elemente aus einem iterierbaren Objekt hinzuzufügen.

Erstellen Sie eine weitere neue Python-Datei namens set_add.py in Ihrem Verzeichnis ~/project.

Fügen Sie den folgenden Code in die Datei ein:

## Verwendung von add() zum Hinzufügen eines einzelnen Elements
letters = {'a', 'b', 'c'}
print("Original set:", letters)
letters.add('d')  ## Fügt das einzelne Element 'd' hinzu
print("After adding 'd':", letters)

## Verwendung von update() zum Hinzufügen von Elementen aus einem iterierbaren Objekt
letters = {'a', 'b', 'c'}
print("\nOriginal set for update:", letters)
letters.update('defg')  ## Fügt Elemente aus einem String hinzu
print("After updating with 'defg':", letters)

letters.update(['x', 'y', 'z'])  ## Fügt Elemente aus einer Liste hinzu
print("After updating with ['x', 'y', 'z']:", letters)

Speichern Sie die Datei und führen Sie sie vom Terminal aus:

python ~/project/set_add.py

Beobachten Sie die Ausgabe. Aufgrund der ungeordneten Natur von Mengen kann die Reihenfolge der Elemente nach dem Hinzufügen variieren, aber alle hinzugefügten Elemente sollten vorhanden sein.

Original set: {'c', 'a', 'b'}
After adding 'd': {'d', 'c', 'a', 'b'}

Original set for update: {'c', 'a', 'b'}
After updating with 'defg': {'g', 'f', 'd', 'e', 'c', 'a', 'b'}
After updating with ['x', 'y', 'z']: {'g', 'f', 'd', 'e', 'c', 'a', 'b', 'z', 'y', 'x'}

Sie haben erfolgreich Mengen mit verschiedenen Methoden erstellt und Elemente zu ihnen hinzugefügt.

Elemente aus Mengen entfernen

In diesem Schritt lernen Sie, wie Sie Elemente aus Mengen (Sets) in Python entfernen. Da Mengen ungeordnet sind, können Sie Elemente nicht wie bei Listen mithilfe von Indizierung oder Slicing entfernen. Stattdessen verwenden Sie spezifische Methoden.

Wir werden die Methoden/Anweisungen remove(), discard(), pop(), clear() und del zum Entfernen von Elementen untersuchen.

Erstellen Sie eine neue Python-Datei namens set_removal.py in Ihrem Verzeichnis ~/project mit dem VS Code-Editor.

Fügen Sie den folgenden Code in die Datei ein, um diese Entfernungsmethoden zu demonstrieren:

## Verwendung von remove() - entfernt ein angegebenes Element, löst einen Fehler aus, wenn das Element nicht gefunden wird
letters = {'a', 'b', 'c'}
print("Original set for remove():", letters)
letters.remove('a')  ## Entfernt Element 'a'
print("After removing 'a':", letters)

## Kommentieren Sie die nächste Zeile aus, um den Fehler beim Entfernen eines nicht vorhandenen Elements zu sehen
## letters.remove('d')

## Verwendung von discard() - entfernt ein angegebenes Element, löst KEINEN Fehler aus, wenn das Element nicht gefunden wird
letters = {'a', 'b', 'c'}
print("\nOriginal set for discard():", letters)
letters.discard('a')  ## Entfernt Element 'a'
print("After discarding 'a':", letters)
letters.discard('d')  ## Element 'd' existiert nicht, kein Fehler
print("After discarding 'd' (non-existent):", letters)

## Verwendung von pop() - entfernt und gibt ein zufälliges Element zurück
letters = {'a', 'b', 'c', 'd', 'e', 'f'}
print("\nOriginal set for pop():", letters)
removed_element = letters.pop()  ## Entfernt zufällig ein Element
print("Removed element with pop():", removed_element)
print("Set after first pop():", letters)
removed_element = letters.pop()  ## Entfernt zufällig ein weiteres Element
print("Removed element with pop():", removed_element)
print("Set after second pop():", letters)

## Verwendung von clear() - entfernt alle Elemente aus der Menge
letters = {'a', 'b', 'c', 'd', 'e', 'f'}
print("\nOriginal set for clear():", letters)
letters.clear()  ## Entfernt alle Elemente
print("Set after clear():", letters)

## Verwendung von del - löscht die gesamte Menge
letters = {'a', 'b', 'c', 'd', 'e', 'f'}
print("\nSet before del:", letters)
del letters
## Kommentieren Sie die nächste Zeile aus, um den Fehler nach dem Löschen der Menge zu sehen
## print(letters)

Speichern Sie die Datei und führen Sie sie vom Terminal aus:

python ~/project/set_removal.py

Beobachten Sie die Ausgabe für jede Entfernungsmethode. Beachten Sie, wie remove() einen Fehler verursacht, wenn das Element nicht vorhanden ist, während discard() dies nicht tut. Sehen Sie auch, wie pop() jedes Mal ein zufälliges Element entfernt.

Original set for remove(): {'c', 'a', 'b'}
After removing 'a': {'c', 'b'}

Original set for discard(): {'c', 'a', 'b'}
After discarding 'a': {'c', 'b'}
After discarding 'd' (non-existent): {'c', 'b'}

Original set for pop(): {'f', 'd', 'e', 'c', 'a', 'b'}
Removed element with pop(): f
Set after first pop(): {'d', 'e', 'c', 'a', 'b'}
Removed element with pop(): d
Set after second pop(): {'e', 'c', 'a', 'b'}

Original set for clear(): {'f', 'd', 'e', 'c', 'a', 'b'}
Set after clear(): set()

Set before del: {'f', 'd', 'e', 'c', 'a', 'b'}

Sie haben erfolgreich verschiedene Möglichkeiten zum Entfernen von Elementen aus Mengen geübt.

Ausführen von Mengenoperationen (Schnittmenge, Vereinigung, Differenz)

In diesem Schritt lernen Sie, wie Sie gängige mathematische Mengenoperationen wie Schnittmenge, Vereinigung und Differenz mit Python-Mengen durchführen. Diese Operationen sind grundlegend für die Arbeit mit Sammlungen eindeutiger Elemente.

Wir verwenden zwei Beispielmengen, um diese Operationen zu demonstrieren.

Erstellen Sie eine neue Python-Datei namens set_operations.py in Ihrem Verzeichnis ~/project mit dem VS Code-Editor.

Fügen Sie den folgenden Code in die Datei ein:

a = {'a', 'r', 'b', 'c', 'd'}
b = {'a', 'l', 'c', 'm', 'z'}

## Schnittmenge (Intersection): Elemente, die in beiden Mengen gemeinsam vorkommen
print("Set A:", a)
print("Set B:", b)
print("\nIntersection using intersection():", a.intersection(b))
print("Intersection using & operator:", a & b)

## Vereinigung (Union): Alle eindeutigen Elemente aus beiden Mengen
print("\nUnion using union():", a.union(b))
print("Union using | operator:", a | b)

## Differenz (Difference): Elemente in der ersten Menge, aber nicht in der zweiten Menge
print("\nDifference A - B using difference():", a.difference(b))
print("Difference A - B using - operator:", a - b)
print("\nDifference B - A using difference():", b.difference(a))
print("Difference B - A using - operator:", b - a)

Speichern Sie die Datei und führen Sie sie vom Terminal aus:

python ~/project/set_operations.py

Beobachten Sie die Ausgabe. Sie sehen die Ergebnisse der Schnittmengen-, Vereinigungs- und Differenzoperationen, sowohl mit Methodenaufrufen als auch mit Operator-Symbolen.

Set A: {'a', 'r', 'b', 'c', 'd'}
Set B: {'c', 'a', 'l', 'm', 'z'}

Intersection using intersection(): {'a', 'c'}
Intersection using & operator: {'a', 'c'}

Union using union(): {'r', 'b', 'd', 'c', 'a', 'l', 'm', 'z'}
Union using | operator: {'r', 'b', 'd', 'c', 'a', 'l', 'm', 'z'}

Difference A - B using difference(): {'r', 'b', 'd'}
Difference A - B using - operator: {'r', 'b', 'd'}

Difference B - A using difference(): {'l', 'm', 'z'}
Difference B - A using - operator: {'l', 'm', 'z'}

Sie haben erfolgreich Mengenoperationen durchgeführt, um gemeinsame Elemente zu finden, Mengen zu kombinieren und Elemente zu finden, die nur in einer Menge vorhanden sind.

Sets zur Entfernung von Duplikaten aus Listen verwenden

In diesem letzten Schritt lernen Sie eine praktische Anwendung von Mengen (Sets): das Entfernen von doppelten Elementen aus einer Liste. Da Mengen von Natur aus nur eindeutige Elemente enthalten, ist die Konvertierung einer Liste in eine Menge und dann zurück in eine Liste eine einfache und effiziente Methode, um dies zu erreichen.

Erstellen Sie eine neue Python-Datei namens remove_duplicates.py in Ihrem Verzeichnis ~/project mit dem VS Code-Editor.

Fügen Sie den folgenden Code in die Datei ein:

## Eine Liste mit doppelten Elementen
a = [1, 2, 3, 2, 5, 3, 2, 1]
print("Original list:", a)

## Konvertieren Sie die Liste in eine Menge, um Duplikate zu entfernen
b = set(a)
print("List converted to set:", b)

## Konvertieren Sie die Menge zurück in eine Liste
c = list(b)
print("Set converted back to list (duplicates removed):", c)

Speichern Sie die Datei und führen Sie sie vom Terminal aus:

python ~/project/remove_duplicates.py

Beobachten Sie die Ausgabe. Sie sehen die ursprüngliche Liste mit Duplikaten, die Menge mit eindeutigen Elementen und schließlich die Liste, aus der Duplikate entfernt wurden. Beachten Sie, dass die Reihenfolge der Elemente in der endgültigen Liste möglicherweise nicht mit der ursprünglichen Liste übereinstimmt, da Mengen ungeordnet sind.

Original list: [1, 2, 3, 2, 5, 3, 2, 1]
List converted to set: {1, 2, 3, 5}
Set converted back to list (duplicates removed): [1, 2, 3, 5]

Sie haben erfolgreich Mengen verwendet, um doppelte Elemente aus einer Liste zu entfernen. Dies ist eine gängige und nützliche Technik in der Python-Programmierung.

Zusammenfassung

In diesem Lab haben Sie die Grundlagen der Arbeit mit Mengen (Sets) in Python gelernt. Sie haben zunächst verschiedene Methoden zur Erstellung von Mengen erkundet, darunter die Verwendung von geschweiften Klammern, Set-Comprehensions und dem set()-Konstruktor. Dabei haben Sie verstanden, dass Mengen automatisch doppelte Elemente verarbeiten und dass {} ein Dictionary und keine leere Menge erstellt. Anschließend haben Sie das Hinzufügen von Elementen zu bestehenden Mengen geübt, indem Sie die add()-Methode für einzelne Elemente und die update()-Methode für mehrere Elemente aus einem Iterable verwendet haben.

Aufbauend auf Erstellung und Hinzufügung haben Sie gelernt, wie Elemente aus Mengen entfernt werden, indem Sie die remove()-Methode (die einen Fehler auslöst, wenn das Element nicht gefunden wird) und die discard()-Methode (die keinen Fehler auslöst) verwenden. Sie haben auch Mengenoperationen erkundet und Schnittmengen (& oder intersection()), Vereinigungen (| oder union()) und Differenzen (- oder difference()) durchgeführt, um Mengen basierend auf ihren Elementen zu kombinieren oder zu vergleichen. Schließlich haben Sie Ihr Wissen über Mengen auf einen praktischen Anwendungsfall angewendet: das effiziente Entfernen von doppelten Elementen aus einer Liste, indem die Liste in eine Menge und dann zurück in eine Liste konvertiert wird.