Skip to content

Mengenoperationen in Python (Vereinigung, Schnittmenge, symmetrische Differenz, etc.)

Python

In Python ist eine Sammlung von nicht überlappenden Elementen (eindeutige Elemente) eingestellt. Es kann Mengenoperationen wie Vereinigung, Schnittmenge, Differenz, symmetrische Differenz usw. ausführen.

Dieser Artikel hat folgenden Inhalt.

Grundoperationen:

  • Erstellen Sie ein Set-Objekt:{}, set()
  • Verständnis festlegen
  • Holen Sie sich die Anzahl der Elemente in der Menge:len()
  • Fügen Sie der Menge ein Element hinzu:add()
  • Ein Element aus der Menge entfernen:discard(), remove(), pop(), clear()

Mathematische Operationen:

  • Union:| operator, union()
  • Überschneidung:& operator, intersection()
  • Unterschied:- operator, difference()
  • Symmetrischer Unterschied:^ operator, symmetric_difference()
  • Testen Sie, ob A eine Teilmenge von B ist:<= operator, issubset()
  • Testen Sie, ob A eine Obermenge von B ist:>= operator, issuperset()
  • Testen Sie, ob A und B disjunkt sind:isdisjoint()

Der Set-Typ ist ein veränderlicher Typ, der Elemente hinzufügen und entfernen kann. Python bietet auch den Typ frozenset, der Methoden für Set-Operationen wie set hat, aber unveränderlich ist. Frozenset kann nicht durch Hinzufügen oder Entfernen von Elementen geändert werden.

Erstellen Sie ein Set-Objekt:{}, set()

Erstellen Sie ein Set-Objekt mit geschweiften Klammern {}

Set-Objekte can erstellt Werden, Indem Elemente in geschweiften Klammern {} Eingeschlossen Werden.

Wenn doppelte Werte vorhanden sind, werden sie ignoriert, und nur die eindeutigen Werte bleiben als Elemente erhalten.

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

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

set can Elemente unterschiedlichen Typs haben, aber keine veränderlichen Objekte wie list.

Der Satztyp IST ungeordnet, weshalb die Reihenfolge, in der er erstellt wurde, nicht beibehalten WIRD.

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

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

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

Auch wenn die Typen unterschiedlich sind, wie z. B. int und float, werden sie als Duplikat betrachtet, wenn die Werte gleich sind.

s = {100, 100.0}

print(s)
# {100}

Da ein leeres {} als ein Wörterbuch-Diktat betrachtet WIRD, can ein leerer Satz unter Verwendung von set(), das als nächstes beschrieben WIRD, erstellt Werden.

s = {}

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

Erstellen Sie ein Set-Objekt mit set()

Set-Objekte können auch mit set() erstellt werden.

Durch die Angabe eines iterierbaren Objekts wie einer Liste oder eines Tupels als Argument wird ein Mengenobjekt erstellt, in dem doppelte Elemente ausgeschlossen werden und nur eindeutige Werte enthalten 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'>

Use you for a unveränderliches FrozenSet FrozenSet().

fs_l = frozenset(l)

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

Wenn das Argument weggelassen WIRD, WIRD Eine leere Menge generiert.

s = set()

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

SIE can set() verwenden, um doppelte Elemente aus einer Liste oder einem Tupel zu entfernen, aber die ursprüngliche Reihenfolge wird nicht beibehalten.

Verwenden Sie list() und tuple(), um eine Menge in eine Liste oder ein Tupel umzuwandeln.

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

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

Im following Artikel erfahren SIE, wie SIE doppelte Elemente in der ursprünglichen Reihenfolge entfernen oder nur doppelte Elemente extrahieren.

Verständnis festlegen

Python bietet sowohl Set Comprehensions als auch List Comprehensions. Verwenden Sie geschweifte Klammern {} anstelle von eckigen Klammern [].

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

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

Weitere Informationen zu Hörverständnissen finden Sie im following Artikel.

Holen Sie sich die Anzahl der Elemente in der Menge:len()

Die Anzahl der Elemente der 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 Vorkommen in Einer Liste mit doppelten Elementen umfassen möchten, lesen Sie den following Artikel.

Fügen Sie der Menge ein Element hinzu:add()

Verwenden Sie die add()-Methode, um der Menge ein Element hinzuzufügen.

s = {0, 1, 2}

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

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

Verwenden Sie die Methoden discard(), remove(), pop() und clear(), um ein Element aus der Menge zu entfernen.

Die Methode discard() löscht das durch das Argument angegebene Element. Wenn ein Wert angegeben WIRD, DER NICHT IM SATZ VORHANDEN IST, WIRD KEINE AKTION AUSGEFÜHRT.

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 auch das durch das Argument angegebene Element, löst aber einen Fehler KeyError aus, wenn ein Wert angegeben wird, der nicht in der Menge 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 ein Element aus der Menge und gibt seinen Wert zurück. Sie können nicht auswählen, welche Werte entfernt werden sollen. Es löst einen Fehler KeyError aus, wenn die Menge leer ist.

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() entfernt alle Elemente aus der Menge und leert sie.

s = {0, 1, 2}

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

Union:| operator, union()

Sie können die Vereinigung mit dem | erhalten -Operator oder die Methode union().

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 union() können mehrere Argumente angegeben werden.

Außerdem can als Argumente nicht nur set, sondern auch Listen und Tupel angegeben Werden, sterben per set() in set converted Werden can. Dasselbe gilt für die following 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}

Überschneidung:& operator, intersection()

Sie können die Schnittmenge mit dem &-Operator oder der Methode crossing() erhalten.

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}

Unterschied:- operator, difference()

Sie können die Differenz mit dem Operator – oder der Methode difference() erhalten.

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}

Symmetrischer Unterschied:^ operator, symmetric_difference()

Sie können die symmetrische Differenz mit dem ^-Operator oder symmetric_difference() erhalten.

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

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

Testen Sie, ob A eine Teilmenge von B ist:<= operator, issubset()

Um zu testen, ob A eine Teilmenge von B ist, dh ob alle Elemente von A in B enthalten sind, 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 True für äquivalente Mengen zurück.

Um zu testen, ob eine Menge eine echte Teilmenge ist, verwenden SIE den <-Operator, der False für äquivalente Mengen zurückgibt.

print(s1 <= s1)
# True

print(s1.issubset(s1))
# True

print(s1 < s1)
# False

Testen Sie, ob A eine Obermenge von B ist:>= operator, issuperset()

Um zu testen, ob A eine Obermenge von B ist, dh ob alle Elemente von B in A enthalten sind, 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 True für äquivalente Mengen zurück.

Um zu testen, ob eine Menge eine echte Obermenge ist, verwenden SIE den Operator >, der False für äquivalente Mengen zurückgibt.

print(s1 >= s1)
# True

print(s1.issuperset(s1))
# True

print(s1 > s1)
# False

Testen Sie, ob A und B disjunkt sind:isdisjoint()

Um zu testen, ob A und B disjunkt sind, dh ob A und B keine gemeinsamen Elemente haben, verwenden Sie die Methode isdisjoint().

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

print(s1.isdisjoint(s2))
# False

print(s1.isdisjoint(s3))
# True