In dieser Anleitung tauchen wir in die Welt der Python-Sets ein und erforschen, wie sie funktionieren. Wir werden uns verschiedene Methoden ansehen, um Sets zu manipulieren und zu verändern.
Sets sind ein fundamentaler Bestandteil der eingebauten Datenstrukturen in Python. Wenn Sie mit einer Sammlung von Elementen arbeiten müssen, bei der keine Duplikate vorkommen dürfen, ist ein Set die richtige Wahl.
Wir werden die Grundlagen von Python-Sets und die Methoden, die Sie zur Bearbeitung benötigen, kennenlernen. Außerdem werden wir uns ansehen, wie man grundlegende Mengenoperationen in Python durchführt.
Beginnen wir gleich!
Grundlagen von Python-Sets
Ein Set in Python ist eine ungeordnete Sammlung von Elementen, die jeweils einzigartig sind. Das bedeutet, dass jedes Element in einem Set nur einmal vorkommen darf.
Sie können Elemente zu einem Set hinzufügen oder daraus entfernen. Daher ist ein Set eine veränderbare Sammlung. Sets können Elemente unterschiedlicher Datentypen enthalten, aber jedes dieser Elemente muss hashbar sein.
In Python wird ein Objekt als hashbar bezeichnet, wenn sein Hashwert sich nicht ändert. Die meisten unveränderlichen Objekte, wie zum Beispiel Strings, Tupel und Wörterbücher in Python, sind hashbar.
Wir lernen nun im Detail, wie man Sets erstellt. Betrachten Sie die folgenden zwei Beispiele:
py_set = {0,1,2,(2,3,4),'Cool!'}
py_set = {0,1,2,[2,3,4],'Oops!'}
# Ausgabe
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-40-2d3716c7fe01> in <module>()
----> 1 py_set = {0,1,2,[2,3,4],'Oops!'}
TypeError: unhashable type: 'list'
Das erste Set beinhaltet drei Zahlen, ein Tupel und einen String. Die Erstellung des Sets funktioniert hier ohne Probleme. Im zweiten Beispiel enthält das Set anstelle eines Tupels eine Liste. Eine Liste ist eine veränderbare Sammlung und kann nicht gehasht werden. Die Initialisierung führt zu einem `TypeError`.
Zusammenfassend lässt sich sagen: Ein Python-Set ist eine veränderbare Sammlung von eindeutigen und hashbaren Elementen.
So erstellen Sie ein Python-Set
Wir beginnen mit der Erstellung eines Sets in Python.
#1. Explizite Initialisierung
Sie können ein Set in Python erstellen, indem Sie die Elemente des Sets innerhalb geschweifter Klammern `{}` angeben und sie durch Kommas `,` trennen.
py_set1 = {'Python','C','C++','JavaScript'}
type(py_set1)
# Ausgabe
set
Wenn Sie schon einmal mit Python-Listen gearbeitet haben, wissen Sie, dass `[]` eine leere Liste initialisiert. Obwohl ein Python-Set in geschweifte Klammern `{}` eingeschlossen wird, können Sie nicht einfach `{}` verwenden, um ein leeres Set zu erstellen. Dies liegt daran, dass `{}` ein Python-Wörterbuch und kein Set initialisiert.
py_set2 = {}
type(py_set2)
# Ausgabe
dict
Sie können die Funktion `type()` verwenden, um zu überprüfen, ob `py_set` tatsächlich ein Wörterbuch (dict) ist.
#2. Die set()-Funktion
Um ein leeres Set zu initialisieren und ihm später Elemente hinzuzufügen, können Sie die Funktion `set()` nutzen.
py_set3 = set()
type(py_set3)
# Ausgabe
set
#3. Konvertieren anderer Iterables in ein Set
Eine weitere Möglichkeit, Sets zu erstellen, ist die Umwandlung anderer iterierbarer Objekte, wie z.B. Listen und Tupel, in Sets, indem man die Funktion `set(iterable)` verwendet.
py_list = ['Python','C','C++','JavaScript','C']
py_set4 = set(py_list)
print(py_set4)
# {'C++', 'C', 'JavaScript', 'Python'} # Doppeltes Element 'C' entfernt
type(py_set4)
# set
Im obigen Beispiel kommt ‚C‘ in `py_list` zweimal vor. In `py_set4` erscheint es jedoch nur einmal, da ein Set nur eindeutige Elemente beinhaltet. Diese Methode wird oft verwendet, um Duplikate aus Python-Listen zu entfernen.
Elemente zu einem Python-Set hinzufügen
Wir beginnen damit, ein leeres Set `py_set` zu erstellen, mit dem wir für den Rest dieser Anleitung arbeiten werden.
py_set = set()
len(py_set) # gibt die Länge eines Sets zurück
# Ausgabe
0
#1. Die .add()-Methode
Um einem Set Elemente hinzuzufügen, können Sie die Methode `.add()` verwenden. `set.add(element)` fügt dem Set ein neues Element hinzu.
Zur Verdeutlichung fügen wir dem `py_set` Elemente hinzu und geben das Set bei jedem Schritt aus.
▶️ Fügen wir den String „Python“ als Element zu `py_set` hinzu.
py_set.add('Python')
print(py_set)
# Ausgabe
{'Python'}
Als Nächstes fügen wir ein weiteres Element hinzu.
py_set.add('C++')
print(py_set)
# Ausgabe
{'Python', 'C++'}
Es ist wichtig zu verstehen, dass die Methode `.add()` ein Element nur dann zu dem Set hinzufügt, wenn es noch nicht vorhanden ist. Wenn das Set das Element, das Sie hinzufügen möchten, bereits enthält, hat die Hinzufügungsoperation keine Auswirkung.
Um dies zu überprüfen, versuchen wir, „C++“ zu `py_set` hinzuzufügen.
py_set.add('C++')
print(py_set)
# Ausgabe
{'Python', 'C++'}
Das Set enthält bereits `C++`, daher hat die Additionsoperation keine Auswirkung.
▶️ Fügen wir dem Set noch ein paar weitere Elemente hinzu.
py_set.add('C')
print(py_set)
py_set.add('JavaScript')
print(py_set)
py_set.add('Rust')
print(py_set)
# Ausgabe
{'Python', 'C++', 'C'}
{'JavaScript', 'Python', 'C++', 'C'}
{'Rust', 'JavaScript', 'Python', 'C++', 'C'}
#2. Die .update()-Methode
Bisher haben wir gesehen, wie man einzelne Elemente zu einem bestehenden Set hinzufügt.
Was aber, wenn Sie mehrere Elemente auf einmal hinzufügen möchten?
Hierfür können Sie die Methode `.update()` verwenden: `set.update(collection)`, um Elemente einer Sammlung zu einem Set hinzuzufügen. Die Sammlung kann eine Liste, ein Tupel, ein Dictionary usw. sein.
py_set.update(['Julia','Ruby','Scala','Java'])
print(py_set)
# Ausgabe
{'C', 'C++', 'Java', 'JavaScript', 'Julia', 'Python', 'Ruby', 'Rust', 'Scala'}
Diese Methode ist besonders nützlich, wenn Sie einer Menge eine ganze Sammlung von Elementen hinzufügen wollen, ohne ein zusätzliches Objekt im Speicher zu erzeugen.
Im nächsten Abschnitt werden wir sehen, wie man Elemente aus einem Set entfernt.
Elemente aus einem Python-Set entfernen
Betrachten wir folgendes Set (den Zustand von `py_set` vor der Update-Operation).
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
#1. Die .pop()-Methode
`set.pop()` entfernt ein zufälliges Element aus dem Set und gibt es zurück. Rufen wir die pop-Methode auf `py_set` auf und sehen, was zurückgegeben wird.
py_set.pop()
# Ausgabe
'Rust'
In diesem Fall hat der Aufruf von `.pop()` den String ‚Rust‘ zurückgegeben.
Wichtig: Da `.pop()` ein zufälliges Element zurückgibt, können Sie beim Ausführen des Codes bei Ihnen auch ein anderes Ergebnis erhalten.
Wenn wir das Set untersuchen, sehen wir, dass ‚Rust‘ nicht mehr im Set vorhanden ist.
print(py_set)
# Ausgabe
{'JavaScript', 'Python', 'C++', 'C'}
#2. Die Methoden .remove() und .discard()
In der Praxis möchten Sie vielleicht bestimmte Elemente aus dem Set entfernen. Hierfür können Sie die Methoden `.remove()` und `.discard()` verwenden.
`set.remove(element)` entfernt das angegebene Element aus dem Set.
py_set.remove('C')
print(py_set)
# Ausgabe
{'JavaScript', 'Python', 'C++'}
Wenn wir versuchen, ein Element zu entfernen, das nicht im Set vorhanden ist, erhalten wir einen `KeyError`.
py_set.remove('Scala')
# Ausgabe
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
<ipython-input-58-a1abab3a8892> in <module>()
----> 1 py_set.remove('Scala')
KeyError: 'Scala'
Sehen wir uns `py_set` noch einmal an. Wir haben nun drei Elemente.
print(py_set)
# Ausgabe
{'JavaScript', 'Python', 'C++'}
Mit der Syntax `set.discard(element)` entfernt die Methode `.discard()` Elemente aus dem Set.
py_set.discard('C++')
print(py_set)
# Ausgabe
{'JavaScript', 'Python'}
Sie unterscheidet sich jedoch von der Methode `.remove()` dadurch, dass sie keinen `KeyError` auslöst, wenn wir versuchen, ein nicht vorhandenes Element zu entfernen.
Wenn wir versuchen, ‚Scala‘ (das nicht existiert) mit der Methode `.discard()` aus der Liste zu entfernen, bekommen wir keinen Fehler.
py_set.discard('Scala') #kein Fehler!
print(py_set)
# Ausgabe
{'JavaScript', 'Python'}
Auf Elemente eines Python-Sets zugreifen
Bisher haben wir gelernt, wie man Elemente zu Python-Sets hinzufügt und entfernt. Wir haben jedoch noch nicht gesehen, wie man auf einzelne Elemente in einem Set zugreift.
Da ein Set eine ungeordnete Sammlung ist, kann es nicht indiziert werden. Wenn Sie versuchen, über einen Index auf die Elemente eines Sets zuzugreifen, erhalten Sie wie gezeigt einen Fehler.
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
print(py_set[0])
# Ausgabe
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-27-0329274f4580> in <module>()
----> 1 print(py_set[0])
TypeError: 'set' object is not subscriptable
Wie können Sie also auf die Elemente in einem Set zugreifen?
Hierfür gibt es zwei gängige Methoden:
- Durchlaufen Sie das Set und greifen Sie auf jedes Element zu
- Überprüfen Sie, ob ein bestimmtes Element im Set enthalten ist
▶️ Durchlaufen Sie das Set und greifen Sie mit einer `for`-Schleife auf die Elemente zu.
for elt in py_set:
print(elt)
# Ausgabe
C++
JavaScript
Python
Rust
C
In der Praxis möchten Sie vielleicht mit dem `in`-Operator prüfen, ob ein bestimmtes Element im Set vorhanden ist.
Wichtig: `element in set` gibt `True` zurück, wenn `element` in `set` vorhanden ist, sonst `False`.
In diesem Beispiel enthält `py_set` „C++“, aber nicht „Julia“. Der `in`-Operator gibt daher `True` bzw. `False` zurück.
'C++' in py_set
# True
'Julia' in py_set
# False
So finden Sie die Länge eines Python-Sets
Wie bereits erwähnt, können Sie die Funktion `len()` verwenden, um die Anzahl der Elemente in einem Set zu erhalten.
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
len(py_set)
# Ausgabe: 5
So löschen Sie ein Python-Set
Um ein Set zu löschen, indem Sie alle Elemente daraus entfernen, können Sie die Methode `.clear()` verwenden.
Rufen wir die Methode `.clear()` für `py_set` auf.
py_set.clear()
Wenn Sie versuchen, es auszugeben, erhalten Sie `set()`, was anzeigt, dass das Set leer ist. Sie können auch die Funktion `len()` aufrufen, um zu überprüfen, ob die Länge des Sets Null ist.
print(py_set)
# set()
print(len(py_set))
# 0
Bisher haben wir die grundlegenden CRUD-Operationen für Python-Sets gelernt:
- **Erstellen:** Verwenden Sie die Funktion `set()`, die Typumwandlung und Initialisierung
- **Lesen:** Greifen Sie auf Elemente des Sets zu, indem Sie Schleifen und den `in`-Operator verwenden, um die Zugehörigkeit zu testen
- **Aktualisieren:** Fügen Sie Elemente zu Sets hinzu oder entfernen Sie sie daraus und aktualisieren Sie Sets
- **Löschen:** Löschen Sie ein Set, indem Sie alle Elemente daraus entfernen
Häufige Set-Operationen mit Python-Code erklärt
Mit Python-Sets können wir auch die grundlegenden Mengenoperationen durchführen. Wir werden sie in diesem Abschnitt kennenlernen.
#1. Vereinigung von Sets in Python
In der Mengenlehre ist die Vereinigung zweier Mengen die Menge aller Elemente, die in mindestens einer der beiden Mengen vorhanden sind. Wenn es zwei Mengen A und B gibt, enthält die Vereinigung die Elemente, die nur in A, nur in B und die Elemente, die sowohl in A als auch in B vorkommen.
Um die Vereinigung von Mengen zu finden, können Sie den Operator `|` oder die Methode `.union()` mit der Syntax `setA.union(setB)` verwenden.
setA = {1,3,5,7,9}
setB = {2,4,6,8,9}
print(setA | setB)
# Ausgabe
{1, 2, 3, 4, 5, 6, 7, 8, 9}
setA.union(setB)
# Ausgabe
{1, 2, 3, 4, 5, 6, 7, 8, 9}
Die Mengenvereinigung ist eine kommutative Operation, d.h. A ∪ B ist dasselbe wie B ∪ A. Überprüfen wir dies, indem wir die Positionen von `setA` und `setB` im Methodenaufruf `.union()` vertauschen.
setB.union(setA)
# Ausgabe
{1, 2, 3, 4, 5, 6, 7, 8, 9}
#2. Schnittmenge von Sets in Python
Eine weitere gängige Set-Operation ist die Schnittmenge von zwei Sets A und B. Die Set-Schnittmengenoperation gibt ein Set zurück, das alle Elemente enthält, die sowohl in A als auch in B vorhanden sind.
Um die Schnittmenge zu berechnen, können Sie den Operator `&` oder die Methode `.intersection()` verwenden, wie im folgenden Code-Snippet gezeigt.
print(setA & setB)
# Ausgabe
{9}
setA.intersection(setB)
# Ausgabe
{9}
In diesem Beispiel kommt das Element 9 sowohl in `setA` als auch in `setB` vor, die Schnittmenge enthält also nur dieses Element.
Wie die Mengenvereinigung ist auch die Mengenschnittmenge eine kommutative Operation.
setB.intersection(setA)
# Ausgabe
{9}
#3. Mengendifferenz in Python
Bei zwei beliebigen Mengen helfen uns die Vereinigung und Schnittmenge dabei, die Elemente zu finden, die in beiden bzw. mindestens einer der Mengen vorhanden sind. Die Mengendifferenz hingegen hilft uns, die Elemente zu finden, die in einer Menge vorhanden sind, aber nicht in der anderen.
`setA.difference(setB)` gibt die Menge der Elemente an, die nur in `setA` und nicht in `setB` vorhanden sind.
`setB.difference(setA)` gibt die Menge der Elemente an, die nur in `setB` und nicht in `setA` vorhanden sind.
print(setA - setB)
print(setB - setA)
# Ausgabe
{1, 3, 5, 7}
{8, 2, 4, 6}
Offensichtlich ist A \ B nicht dasselbe wie B \ A, daher ist die Mengendifferenz keine kommutative Operation.
setA.difference(setB)
# {1, 3, 5, 7}
setB.difference(setA)
# {2, 4, 6, 8}
#4. Symmetrische Mengendifferenz in Python
Während uns die Mengenüberschneidung Elemente gibt, die in beiden Mengen vorhanden sind, gibt uns die symmetrische Mengendifferenz die Menge der Elemente zurück, die in genau einer der Mengen vorhanden sind.
Betrachten Sie das folgende Beispiel.
setA = {1,3,5,7,10,12}
setB = {2,4,6,8,10,12}
Um die symmetrische Differenzmenge zu berechnen, können Sie den Operator `^` oder die Methode `.symmetric_difference()` verwenden.
print(setA ^ setB)
# Ausgabe
{1, 2, 3, 4, 5, 6, 7, 8}
Die Elemente 10 und 12 sind sowohl in `setA` als auch in `setB` vorhanden. Sie sind also nicht in der symmetrischen Differenzmenge enthalten.
setA.symmetric_difference(setB)
# Ausgabe
{1, 2, 3, 4, 5, 6, 7, 8}
Da die symmetrische Mengenoperationsdifferenz alle Elemente sammelt, die in genau einer der beiden Mengen vorkommen, ist die resultierende Menge dieselbe, unabhängig von der Reihenfolge, in der die Elemente gesammelt werden. Die symmetrische Mengendifferenz ist also eine kommutative Operation.
setB.symmetric_difference(setA)
# Ausgabe
{1, 2, 3, 4, 5, 6, 7, 8}
#5. Teilmengen und Obermengen in Python
In der Mengenlehre helfen Teilmengen und Obermengen, die Beziehung zwischen zwei Mengen zu verstehen.
Bei zwei gegebenen Mengen A und B ist Menge B eine Teilmenge von Menge A, wenn alle Elemente in Menge B auch in Menge A vorhanden sind. Und Menge A ist die Obermenge von Menge B.
Betrachten Sie das Beispiel mit zwei Sets: `languages` und `languages_extended`.
languages = {'Python', 'JavaScript','C','C++'}
languages_extended = {'Python', 'JavaScript','C','C++','Rust','Go','Scala'}
In Python können Sie die Methode `.issubset()` verwenden, um zu überprüfen, ob ein bestimmtes Set eine Teilmenge eines anderen Sets ist.
`setA.issubset(setB)` gibt `True` zurück, wenn `setA` eine Teilmenge von `setB` ist, andernfalls `False`.
In diesem Beispiel ist `languages` eine Teilmenge von `languages_extended`.
languages.issubset(languages_extended)
# Ausgabe
True
Ähnlich können Sie die Methode `.issuperset()` verwenden, um zu überprüfen, ob ein bestimmtes Set eine Obermenge eines anderen Sets ist.
`setA.issuperset(setB)` gibt `True` zurück, wenn `setA` eine Obermenge von `setB` ist, andernfalls `False`.
languages_extended.issuperset(languages)
# Ausgabe
True
Da `languages_extended` eine Obermenge von `languages` ist, gibt `languages_extended.issuperset(languages)` `True` zurück, wie oben gezeigt.
Fazit
Ich hoffe, diese Anleitung hat Ihnen geholfen, die Funktionsweise von Python-Sets, ihre CRUD-Methoden und grundlegenden Mengenoperationen zu verstehen. Als Nächstes können Sie versuchen, sie in Ihren Python-Projekten einzusetzen.
Sie können sich auch andere detaillierte Python-Anleitungen ansehen. Viel Spaß beim Lernen!