Mengenoperationen (z. B. das Bestimmen von Vereinigungsmengen, Produktmengen und Teilmengen) mit Pythons Mengentyp

Geschäft

Python bietet einen eingebauten Datentyp, set, der Mengen verarbeitet.

Der Typ Set ist eine Sammlung nicht-duplizierter Elemente (Elemente, die nicht denselben Wert haben, eindeutige Elemente) und kann Set-Operationen wie Union-Set, Produkt-Set und Differenz-Set durchführen.

In diesem Abschnitt werden die grundlegenden Operationen der mengenartigen Mengenoperationen anhand von Beispielcode erläutert.

  • Erstellung von Set-Objekten: {},set()
  • Mengeneinschlussnotation
  • Anzahl der Elemente in der Menge:len()
  • Hinzufügen eines Elements zu einer Menge:add()
  • Ein Element aus einer Menge entfernen: discard(),remove(),pop(),clear()
  • Wasset (Zusammenschluss, Gewerkschaft):|operator,union()
  • Produktsets (gemeinsame Teile, Schnittpunkte, Kreuzungen):& Betreiber,intersection()
  • relative Ergänzung:-Operator,difference()
  • Symmetrie-Differenzmenge:^ Betreiber,symmetric_difference()
  • Teilmenge oder nicht:<= Betreiber,issubset()
  • Oberer Satz oder nicht:>= Operator,issuperset()
  • Bestimmung, ob sie sich gegenseitig primär sind oder nicht:isdisjoint()

Der Typ set ist ein veränderlicher Typ, der Elemente hinzufügen und löschen kann, und es gibt auch einen Typ frozenset, der dieselbe Set-Operation und andere Methoden wie der Typ set hat, aber unveränderlich ist (nicht durch Hinzufügen, Löschen oder anderweitiges Ändern von Elementen verändert werden kann).

Erstellung eines Set-Objekts:: {}, set()

Erzeugt durch Wellenklammern {}

Objekte vom Typ set können erstellt werden, indem Elemente in geschweifte Klammern {} eingeschlossen werden.

Wenn es doppelte Werte gibt, werden diese ignoriert und nur eindeutige Werte bleiben als Elemente erhalten.

s = {1, 2, 2, 3, 1, 4}

print(s)
print(type(s))
# {1, 2, 3, 4}
# <class 'set'>

Es ist möglich, verschiedene Typen als Elemente zu verwenden. Allerdings können aktualisierbare Objekte, wie z. B. Listen, nicht registriert werden. Tupel sind erlaubt.

Da die Mengentypen nicht geordnet sind, wird auch die Reihenfolge, in der sie erzeugt werden, nicht gespeichert.

s = {1.23, 'abc', (0, 1, 2), 'abc'}

print(s)
# {(0, 1, 2), 1.23, 'abc'}

# s = {[0, 1, 2]}
# TypeError: unhashable type: 'list'

Verschiedene Typen, wie int und float, werden als Duplikate betrachtet, wenn ihre Werte gleichwertig sind.

s = {100, 100.0}

print(s)
# {100}

Da eine leere Klammer {} als Wörterbuchtyp betrachtet wird, kann ein Objekt vom Typ leere Menge (empty set) mit dem nachfolgend beschriebenen Konstruktor erstellt werden.

s = {}

print(s)
print(type(s))
# {}
# <class 'dict'>

Erzeugt durch den Konstruktor set()

Objekte des Typs set können auch mit dem Konstruktor set() erstellt werden.

Die Angabe eines iterierbaren Objekts wie einer Liste oder eines Tupels als Argument erzeugt ein Mengenobjekt, dessen Elemente nur eindeutige Werte sind, wobei doppelte Elemente ausgeschlossen sind.

l = [1, 2, 2, 3, 1, 4]

print(l)
print(type(l))
# [1, 2, 2, 3, 1, 4]
# <class 'list'>

s_l = set(l)

print(s_l)
print(type(s_l))
# {1, 2, 3, 4}
# <class 'set'>

Unveränderliche frozenset-Typen werden mit dem Konstruktor frozenset() erstellt.

fs_l = frozenset(l)

print(fs_l)
print(type(fs_l))
# frozenset({1, 2, 3, 4})
# <class 'frozenset'>

Wird das Argument weggelassen, wird ein leeres Objekt vom Typ Menge (leere Menge) erstellt.

s = set()

print(s)
print(type(s))
# set()
# <class 'set'>

Doppelte Elemente können mit set() aus einer Liste oder einem Tupel entfernt werden, aber die Reihenfolge der ursprünglichen Liste bleibt nicht erhalten.

Um eine Menge in eine Liste oder ein Tupel umzuwandeln, verwenden Sie list(),tuple().

l = [2, 2, 3, 1, 3, 4]

l_unique = list(set(l))
print(l_unique)
# [1, 2, 3, 4]

Im folgenden Artikel finden Sie Informationen zum Entfernen doppelter Elemente unter Beibehaltung der Reihenfolge, zum Extrahieren nur doppelter Elemente und zum Verarbeiten doppelter Elemente in einem zweidimensionalen Array (Liste von Listen).

Mengeneinschlussnotation

Neben den Listenauffassungen gibt es auch Mengenauffassungen. Ersetzen Sie einfach die eckigen Klammern [] durch geschweifte Klammern {} in Listenauffassungen.

s = {i**2 for i in range(5)}

print(s)
# {0, 1, 4, 9, 16}

Weitere Informationen zur Notation des Listenverständnisses finden Sie im folgenden Artikel.

Anzahl der Elemente in der Menge: len()

Die Anzahl der Elemente in einer Menge kann mit der eingebauten Funktion len() ermittelt werden.

s = {1, 2, 2, 3, 1, 4}

print(s)
print(len(s))
# {1, 2, 3, 4}
# 4

Wenn Sie die Anzahl der Elemente in jeder Liste zählen möchten, die Elemente mit doppelten Werten usw. enthalten, lesen Sie den folgenden Artikel.

Hinzufügen eines Elements zu einer Menge: add()

Um ein Element zu einer Menge hinzuzufügen, verwenden Sie die Methode add().

s = {0, 1, 2}

s.add(3)
print(s)
# {0, 1, 2, 3}

Ein Element aus einer Menge entfernen: discard(),remove(),pop(),clear()

Um ein Element aus einer Menge zu entfernen, verwenden Sie die Methoden discard(), remove(), pop() und clear().

Die Methode discard() löscht das im Argument angegebene Element. Wird ein Wert angegeben, der in der Menge nicht vorhanden ist, wird nichts unternommen.

s = {0, 1, 2}

s.discard(1)
print(s)
# {0, 2}

s = {0, 1, 2}

s.discard(10)
print(s)
# {0, 1, 2}

Die Methode remove() entfernt ebenfalls das im Argument angegebene Element, jedoch wird ein Fehler KeyError zurückgegeben, wenn ein Wert angegeben wird, der in der Menge nicht vorhanden ist.

s = {0, 1, 2}

s.remove(1)
print(s)
# {0, 2}

# s = {0, 1, 2}

# s.remove(10)
# KeyError: 10

Die Methode pop() entfernt Elemente aus einer Menge und gibt deren Werte zurück. Es ist nicht möglich, die zu entfernenden Werte auszuwählen. Eine leere Menge führt zu einem KeyError-Fehler.

s = {2, 1, 0}

v = s.pop()

print(s)
print(v)
# {1, 2}
# 0

s = {2, 1, 0}

print(s.pop())
# 0

print(s.pop())
# 1

print(s.pop())
# 2

# print(s.pop())
# KeyError: 'pop from an empty set'

Die Methode clear() löscht alle Elemente und macht die Menge leer.

s = {0, 1, 2}

s.clear()
print(s)
# set()

Wasset (Zusammenschluss, Gewerkschaft): |operator, union()

Die Vereinigungsmenge (merger, union) kann mit dem Operator | oder der Methode union() ermittelt werden.

s1 = {0, 1, 2}
s2 = {1, 2, 3}
s3 = {2, 3, 4}

s_union = s1 | s2
print(s_union)
# {0, 1, 2, 3}

s_union = s1.union(s2)
print(s_union)
# {0, 1, 2, 3}

Für eine Methode können mehrere Argumente angegeben werden. Neben dem Mengentyp können auch Listen und Tupel, die mit set() in den Mengentyp konvertiert werden können, als Argumente angegeben werden. Das Gleiche gilt für nachfolgende Operatoren und Methoden.

s_union = s1.union(s2, s3)
print(s_union)
# {0, 1, 2, 3, 4}

s_union = s1.union(s2, [5, 6, 5, 7, 5])
print(s_union)
# {0, 1, 2, 3, 5, 6, 7}

Produktsets (gemeinsame Teile, Schnittpunkte, Kreuzungen): & Betreiber, intersection()

Die Produktmenge (gemeinsamer Teil, Schnittmenge und Schnittmenge) kann mit dem Operator & oder der Methode intersection() ermittelt werden.

s_intersection = s1 & s2
print(s_intersection)
# {1, 2}

s_intersection = s1.intersection(s2)
print(s_intersection)
# {1, 2}

s_intersection = s1.intersection(s2, s3)
print(s_intersection)
# {2}

relative Ergänzung: -Operator, difference()

Die Differenzmenge kann mit dem Operator – oder der Methode difference() ermittelt werden.

s_difference = s1 - s2
print(s_difference)
# {0}

s_difference = s1.difference(s2)
print(s_difference)
# {0}

s_difference = s1.difference(s2, s3)
print(s_difference)
# {0}

Symmetrie-Differenzmenge: ^ Betreiber, symmetric_difference()

Die symmetrische Differenzmenge (die Menge der Elemente, die nur in einer der beiden Mengen enthalten ist) kann mit dem Operator ^ oder symmetric_difference() ermittelt werden.

Äquivalent zur exklusiven Disjunktion (XOR) bei logischen Operationen.

s_symmetric_difference = s1 ^ s2
print(s_symmetric_difference)
# {0, 3}

s_symmetric_difference = s1.symmetric_difference(s2)
print(s_symmetric_difference)
# {0, 3}

Teilmenge oder nicht: <= Betreiber, issubset()

Um festzustellen, ob eine Menge eine Teilmenge einer anderen Menge ist, verwenden Sie den Operator <= oder die Methode issubset().

s1 = {0, 1}
s2 = {0, 1, 2, 3}

print(s1 <= s2)
# True

print(s1.issubset(s2))
# True

Sowohl der Operator <= als auch die Methode issubset() geben bei gleichwertigen Mengen true zurück.

Um festzustellen, ob es sich um eine echte Teilmenge handelt, verwenden Sie den Operator <=, der bei gleichwertigen Mengen false zurückgibt.

print(s1 <= s1)
# True

print(s1.issubset(s1))
# True

print(s1 < s1)
# False

Oberer Satz oder nicht: >= Operator, issuperset()

Um festzustellen, ob eine Menge eine Obermenge einer anderen ist, verwenden Sie den Operator >= oder issuperset().

s1 = {0, 1}
s2 = {0, 1, 2, 3}

print(s2 >= s1)
# True

print(s2.issuperset(s1))
# True

Sowohl der Operator >= als auch die Methode issuperset() geben bei gleichwertigen Mengen true zurück.

Um festzustellen, ob es sich um eine echte Obermenge handelt, verwenden Sie den Operator >=, der bei äquivalenten Mengen false zurückgibt.

print(s1 >= s1)
# True

print(s1.issuperset(s1))
# True

print(s1 > s1)
# False

Bestimmung, ob sie sich gegenseitig primär sind oder nicht: isdisjoint()

Um festzustellen, ob zwei Mengen primär zueinander sind, verwenden Sie die Methode isdisjoint().

s1 = {0, 1}
s2 = {1, 2}
s3 = {2, 3}

print(s1.isdisjoint(s2))
# False

print(s1.isdisjoint(s3))
# True
Copied title and URL