Setzt in Python

Vielleicht erinnern Sie sich daran, dass Sie irgendwann in Ihrer mathematischen Ausbildung etwas übersets undset theory gelernt haben. Vielleicht erinnern Sie sich sogar an Venn-Diagramme:

Wenn dies nicht klingelt, mach dir keine Sorgen! Dieses Tutorial sollte für Sie weiterhin leicht zugänglich sein.

In der Mathematik kann eine strenge Definition einer Menge abstrakt und schwer zu verstehen sein. In der Praxis kann eine Menge einfach als eine genau definierte Sammlung verschiedener Objekte betrachtet werden, die typischerweise alselements odermembers bezeichnet werden.

Das Gruppieren von Objekten in einem Satz kann auch beim Programmieren hilfreich sein, und Python bietet hierfür einen integrierten Satztyp. Sets unterscheiden sich von anderen Objekttypen durch die eindeutigen Operationen, die an ihnen ausgeführt werden können.

Here’s what you’ll learn in this tutorial: Sie werden sehen, wie Sieset Objekte in Python definieren und die von ihnen unterstützten Vorgänge ermitteln. Wie bei den früheren Tutorials zu Listen und Wörterbüchern sollten Sie nach Abschluss dieses Tutorials ein gutes Gefühl dafür haben, wann ein Satz die richtige Wahl ist. Sie erfahren auch mehr überfrozen sets, die bis auf ein wichtiges Detail den Mengen ähnlich sind.

__ Take the Quiz: Testen Sie Ihr Wissen mit unserem interaktiven Quiz „Python-Sets“. Nach Abschluss erhalten Sie eine Punktzahl, mit der Sie Ihren Lernfortschritt im Laufe der Zeit verfolgen können:

Das Quiz machen "

Set definieren

Der in Python integrierteset-Typ weist die folgenden Merkmale auf:

Sets sind ungeordnet.
Set-Elemente sind einzigartig. Doppelte Elemente sind nicht zulässig.
Eine Menge selbst kann geändert werden, aber die in der Menge enthaltenen Elemente müssen von einem unveränderlichen Typ sein.

Mal sehen, was das alles bedeutet und wie Sie mit Sets in Python arbeiten können.

Ein Set kann auf zwei Arten erstellt werden. Zunächst können Sie eine Menge mit der eingebautenset()-Funktion definieren:

x = set()

In diesem Fall ist das Argument<iter> iterierbar - im Moment wiederum Think List oder Tuple - und generiert die Liste der Objekte, die in die Menge aufgenommen werden sollen. Dies ist analog zu dem Argument<iter>, das für die Listenmethode.extend()angegeben wurde:

>>>

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

Strings sind auch iterierbar, sodass ein String auch anset() übergeben werden kann. Sie haben bereits gesehen, dasslist(s) eine Liste der Zeichen in der Zeichenfolges generiert. In ähnlicher Weise generiertset(s) einen Satz von Zeichen ins:

>>>

>>> s = 'quux'

>>> list(s)
['q', 'u', 'u', 'x']
>>> set(s)
{'x', 'u', 'q'}

Sie können sehen, dass die resultierenden Mengen ungeordnet sind: Die ursprüngliche Reihenfolge, wie in der Definition angegeben, bleibt nicht unbedingt erhalten. Außerdem werden doppelte Werte in der Menge nur einmal dargestellt, wie bei der Zeichenfolge'foo' in den ersten beiden Beispielen und dem Buchstaben'u' in der dritten.

Alternativ kann eine Menge mit geschweiften Klammern ({}) definiert werden:

x = {, , ..., }

Wenn eine Menge auf diese Weise definiert wird, wird jedes<obj> zu einem bestimmten Element der Menge, selbst wenn es iterierbar ist. Dieses Verhalten ähnelt dem der Listenmethode.append().

Somit können die oben gezeigten Sätze auch wie folgt definiert werden:

>>>

>>> x = {'foo', 'bar', 'baz', 'foo', 'qux'}
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = {'q', 'u', 'u', 'x'}
>>> x
{'x', 'q', 'u'}

Um es zusammenzufassen:

Das Argument zuset() ist iterierbar. Es wird eine Liste von Elementen generiert, die in die Menge eingefügt werden sollen.
Die Objekte in geschweiften Klammern werden intakt in das Set eingefügt, auch wenn sie iterierbar sind.

Beachten Sie den Unterschied zwischen diesen beiden Satzdefinitionen:

>>>

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

Ein Satz kann leer sein. Denken Sie jedoch daran, dass Python leere geschweifte Klammern ({}) als leeres Wörterbuch interpretiert. Die einzige Möglichkeit, eine leere Menge zu definieren, besteht in der Funktionset():

>>>

>>> x = set()
>>> type(x)

>>> x
set()

>>> x = {}
>>> type(x)

Eine leere Menge ist im booleschen Kontext falsch:

>>>

>>> x = set()
>>> bool(x)
False
>>> x or 1
1
>>> x and 1
set()

Sie könnten denken, die intuitivsten Mengen würden ähnliche Objekte enthalten - zum Beispiel gerade Zahlen oder Nachnamen:

>>>

>>> s1 = {2, 4, 6, 8, 10}
>>> s2 = {'Smith', 'McArthur', 'Wilson', 'Johansson'}

Python benötigt dies jedoch nicht. Die Elemente in einer Menge können Objekte unterschiedlichen Typs sein:

>>>

>>> x = {42, 'foo', 3.14159, None}
>>> x
{None, 'foo', 42, 3.14159}

Vergessen Sie nicht, dass Set-Elemente unveränderlich sein müssen. Zum Beispiel kann ein Tupel in einem Satz enthalten sein:

>>>

>>> x = {42, 'foo', (1, 2, 3), 3.14159}
>>> x
{42, 'foo', 3.14159, (1, 2, 3)}

Listen und Wörterbücher sind jedoch veränderbar, sodass sie nicht als Elemente festgelegt werden können:

>>>

>>> a = [1, 2, 3]
>>> {a}
Traceback (most recent call last):
  File "", line 1, in 
    {a}
TypeError: unhashable type: 'list'

>>> d = {'a': 1, 'b': 2}
>>> {d}
Traceback (most recent call last):
  File "", line 1, in 
    {d}
TypeError: unhashable type: 'dict'

Größe und Mitgliedschaft einstellen

Die Funktionlen() gibt die Anzahl der Elemente in einer Menge zurück, und die Operatorenin undnot in können zum Testen der Mitgliedschaft verwendet werden:

>>>

>>> x = {'foo', 'bar', 'baz'}

>>> len(x)
3

>>> 'bar' in x
True
>>> 'qux' in x
False

Betrieb an einem Set

Viele der Operationen, die für die anderen zusammengesetzten Datentypen von Python verwendet werden können, sind für Mengen nicht sinnvoll. Beispielsweise können Sets nicht indiziert oder in Scheiben geschnitten werden. Python bietet jedoch eine ganze Reihe von Operationen für Mengenobjekte, die im Allgemeinen dieoperations imitieren, die für mathematische Mengen definiert sind.

Operatoren vs. Methoden

Die meisten, wenn auch nicht alle Set-Operationen in Python können auf zwei verschiedene Arten ausgeführt werden: nach Operator oder nach Methode. Schauen wir uns am Beispiel von set union an, wie diese Operatoren und Methoden funktionieren.

Bei zwei Mengen,x1 undx2, ist die Vereinigung vonx1 undx2 eine Menge, die aus allen Elementen in jeder Menge besteht.

Betrachten Sie diese beiden Sätze:

x1 = {'foo', 'bar', 'baz'}
x2 = {'baz', 'qux', 'quux'}

Die Vereinigung vonx1 undx2 ist{'foo', 'bar', 'baz', 'qux', 'quux'}.

Note: Beachten Sie, dass das Element'baz', das sowohl inx1 als auch inx2 vorkommt, nur einmal in der Union vorkommt. Sets enthalten niemals doppelte Werte.

In Python kann die Set Union mit dem Operator|ausgeführt werden:

>>>

>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'baz', 'qux', 'quux'}
>>> x1 | x2
{'baz', 'quux', 'qux', 'bar', 'foo'}

Die eingestellte Vereinigung kann auch mit der Methode.union() erhalten werden. Die Methode wird für eine der Mengen aufgerufen und die andere als Argument übergeben:

>>>

>>> x1.union(x2)
{'baz', 'quux', 'qux', 'bar', 'foo'}

So wie sie in den obigen Beispielen verwendet werden, verhalten sich Operator und Methode identisch. Aber es gibt einen subtilen Unterschied zwischen ihnen. Wenn Sie den Operator| verwenden, müssen beide Operanden gesetzt sein. Die.union()-Methode nimmt dagegen jedes iterable als Argument, konvertiert es in eine Menge und führt dann die Vereinigung durch.

Beachten Sie den Unterschied zwischen diesen beiden Aussagen:

>>>

>>> x1 | ('baz', 'qux', 'quux')
Traceback (most recent call last):
  File "", line 1, in 
    x1 | ('baz', 'qux', 'quux')
TypeError: unsupported operand type(s) for |: 'set' and 'tuple'

>>> x1.union(('baz', 'qux', 'quux'))
{'baz', 'quux', 'qux', 'bar', 'foo'}

Beide versuchen, die Vereinigung vonx1 und dem Tupel('baz', 'qux', 'quux') zu berechnen. Dies schlägt mit dem Operator| fehl, ist jedoch mit der Methode.union()erfolgreich.

Verfügbare Operatoren und Methoden

Unten finden Sie eine Liste der in Python verfügbaren Set-Operationen. Einige werden vom Operator ausgeführt, andere von der Methode und andere von beiden. Das oben beschriebene Prinzip gilt im Allgemeinen: Wenn eine Menge erwartet wird, akzeptieren Methoden normalerweise jedes iterierbare Argument, aber Operatoren benötigen tatsächliche Mengen als Operanden.

x1.union(x2[, x3 ...])

x1 | x2 [| x3 ...]

Berechnen Sie die Vereinigung von zwei oder mehr Mengen.

x1.union(x2) undx1 | x2 geben beide die Menge aller Elemente entweder inx1 oder inx2 zurück:

>>>

>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'baz', 'qux', 'quux'}

>>> x1.union(x2)
{'foo', 'qux', 'quux', 'baz', 'bar'}

>>> x1 | x2
{'foo', 'qux', 'quux', 'baz', 'bar'}

Mit dem Operator oder der Methode können mehr als zwei Sätze angegeben werden:

>>>

>>> a = {1, 2, 3, 4}
>>> b = {2, 3, 4, 5}
>>> c = {3, 4, 5, 6}
>>> d = {4, 5, 6, 7}

>>> a.union(b, c, d)
{1, 2, 3, 4, 5, 6, 7}

>>> a | b | c | d
{1, 2, 3, 4, 5, 6, 7}

Die resultierende Menge enthält alle Elemente, die in einer der angegebenen Mengen vorhanden sind.

x1.intersection(x2[, x3 ...])

x1 & x2 [& x3 ...]

Berechnen Sie den Schnittpunkt von zwei oder mehr Mengen.

x1.intersection(x2) undx1 & x2 geben die Menge der Elemente zurück, die sowohlx1 als auchx2 gemeinsam sind:

>>>

>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'baz', 'qux', 'quux'}

>>> x1.intersection(x2)
{'baz'}

>>> x1 & x2
{'baz'}

Sie können mit der Schnittmethode und dem Operator mehrere Mengen angeben, genau wie mit der Mengenvereinigung:

>>>

>>> a = {1, 2, 3, 4}
>>> b = {2, 3, 4, 5}
>>> c = {3, 4, 5, 6}
>>> d = {4, 5, 6, 7}

>>> a.intersection(b, c, d)
{4}

>>> a & b & c & d
{4}

Die resultierende Menge enthält nur Elemente, die in allen angegebenen Mengen vorhanden sind.

x1.difference(x2[, x3 ...])

x1 - x2 [- x3 ...]

Berechnen Sie die Differenz zwischen zwei oder mehr Sätzen.

x1.difference(x2) undx1 - x2 geben die Menge aller Elemente zurück, die inx1, aber nicht inx2 angegeben sind:

>>>

>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'baz', 'qux', 'quux'}

>>> x1.difference(x2)
{'foo', 'bar'}

>>> x1 - x2
{'foo', 'bar'}

Eine andere Möglichkeit ist, dassx1.difference(x2) undx1 - x2 die Menge zurückgeben, die sich ergibt, wenn Elemente inx2 entfernt oder vonx1 subtrahiert werden.

Sie können erneut mehr als zwei Sätze angeben:

>>>

>>> a = {1, 2, 3, 30, 300}
>>> b = {10, 20, 30, 40}
>>> c = {100, 200, 300, 400}

>>> a.difference(b, c)
{1, 2, 3}

>>> a - b - c
{1, 2, 3}

Wenn mehrere Sätze angegeben sind, wird der Vorgang von links nach rechts ausgeführt. Im obigen Beispiel wird zuersta - b berechnet, was zu{1, 2, 3, 300} führt. Dann wirdc von dieser Menge subtrahiert, wobei{1, 2, 3} übrig bleibt:

x1.symmetric_difference(x2)

x1 ^ x2 [^ x3 ...]

Berechnen Sie diesymmetric difference zwischen den Sätzen.

x1.symmetric_difference(x2) undx1 ^ x2 geben die Menge aller Elemente entweder inx1 oderx2 zurück, aber nicht in beiden:

>>>

>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'baz', 'qux', 'quux'}

>>> x1.symmetric_difference(x2)
{'foo', 'qux', 'quux', 'bar'}

>>> x1 ^ x2
{'foo', 'qux', 'quux', 'bar'}

Der Operator^erlaubt auch mehr als zwei Sätze:

>>>

>>> a = {1, 2, 3, 4, 5}
>>> b = {10, 2, 3, 4, 50}
>>> c = {1, 50, 100}

>>> a ^ b ^ c
{100, 5, 10}

Wie beim Differenzoperator wird die Operation von links nach rechts ausgeführt, wenn mehrere Sätze angegeben werden.

Obwohl der Operator^mehrere Sätze zulässt, funktioniert die Methode.symmetric_difference()eltsamerweise nicht:

>>>

>>> a = {1, 2, 3, 4, 5}
>>> b = {10, 2, 3, 4, 50}
>>> c = {1, 50, 100}

>>> a.symmetric_difference(b, c)
Traceback (most recent call last):
  File "", line 1, in 
    a.symmetric_difference(b, c)
TypeError: symmetric_difference() takes exactly one argument (2 given)

x1.isdisjoint(x2)

Legt fest, ob zwei Sätze Elemente gemeinsam haben.

x1.isdisjoint(x2) gibtTrue zurück, wennx1 undx2 keine gemeinsamen Elemente haben:

>>>

>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'baz', 'qux', 'quux'}

>>> x1.isdisjoint(x2)
False

>>> x2 - {'baz'}
{'quux', 'qux'}
>>> x1.isdisjoint(x2 - {'baz'})
True

Wennx1.isdisjoint(x2)True ist, dann istx1 & x2 die leere Menge:

>>>

>>> x1 = {1, 3, 5}
>>> x2 = {2, 4, 6}

>>> x1.isdisjoint(x2)
True
>>> x1 & x2
set()

Note: Es gibt keinen Operator, der der Methode.isdisjoint() entspricht.

x1.issubset(x2)

x1 <= x2

Bestimmen Sie, ob eine Menge eine Teilmenge der anderen ist.

In der Mengenlehre wird eine Mengex1 als Teilmenge einer anderen Mengex2 betrachtet, wenn jedes Element vonx1 inx2 vorliegt.

x1.issubset(x2) undx1 <= x2 gebenTrue zurück, wennx1 eine Teilmenge vonx2 ist:

>>>

>>> x1 = {'foo', 'bar', 'baz'}
>>> x1.issubset({'foo', 'bar', 'baz', 'qux', 'quux'})
True

>>> x2 = {'baz', 'qux', 'quux'}
>>> x1 <= x2
False

Eine Menge wird als Teilmenge ihrer selbst betrachtet:

>>>

>>> x = {1, 2, 3, 4, 5}
>>> x.issubset(x)
True
>>> x <= x
True

Es scheint vielleicht seltsam. Aber es passt zur Definition - jedes Element vonx ist inx.

x1 < x2

Bestimmt, ob eine Menge eine richtige Teilmenge der anderen ist.

Eine richtige Teilmenge ist dieselbe wie eine Teilmenge, außer dass die Mengen nicht identisch sein können. Eine Mengex1 wird als geeignete Teilmenge einer anderen Mengex2 angesehen, wenn jedes Element vonx1 inx2 undx1 undx2 sind nicht gleich.

x1 < x2 gibtTrue zurück, wennx1 eine richtige Teilmenge vonx2 ist:

>>>

>>> x1 = {'foo', 'bar'}
>>> x2 = {'foo', 'bar', 'baz'}
>>> x1 < x2
True

>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'foo', 'bar', 'baz'}
>>> x1 < x2
False

Während eine Menge als Teilmenge von sich selbst betrachtet wird, ist sie keine richtige Teilmenge von sich selbst:

>>>

>>> x = {1, 2, 3, 4, 5}
>>> x <= x
True
>>> x < x
False

Note: Der Operator< ist die einzige Möglichkeit, um zu testen, ob eine Menge eine richtige Teilmenge ist. Es gibt keine entsprechende Methode.

x1.issuperset(x2)

x1 >= x2

Bestimmen Sie, ob eine Menge eine Obermenge der anderen ist.

Eine Obermenge ist die Umkehrung einer Teilmenge. Eine Mengex1 wird als Obermenge einer anderen Mengex2 betrachtet, wennx1 jedes Element vonx2 enthält.

x1.issuperset(x2) undx1 >= x2 gebenTrue zurück, wennx1 eine Obermenge vonx2 ist:

>>>

>>> x1 = {'foo', 'bar', 'baz'}

>>> x1.issuperset({'foo', 'bar'})
True

>>> x2 = {'baz', 'qux', 'quux'}
>>> x1 >= x2
False

Sie haben bereits gesehen, dass eine Menge als Teilmenge von sich selbst betrachtet wird. Eine Menge wird auch als Obermenge von sich selbst betrachtet:

>>>

>>> x = {1, 2, 3, 4, 5}
>>> x.issuperset(x)
True
>>> x >= x
True

x1 > x2

Bestimmt, ob eine Menge eine richtige Obermenge der anderen ist.

Eine richtige Obermenge ist dieselbe wie eine Obermenge, außer dass die Mengen nicht identisch sein können. Eine Mengex1 wird als richtige Obermenge einer anderen Mengex2 angesehen, wennx1 jedes Element vonx2 enthält undx1 undx2 nicht gleich.

x1 > x2 gibtTrue zurück, wennx1 eine richtige Obermenge vonx2 ist:

>>>

>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'foo', 'bar'}
>>> x1 > x2
True

>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'foo', 'bar', 'baz'}
>>> x1 > x2
False

Eine Menge ist keine richtige Obermenge von sich selbst:

>>>

>>> x = {1, 2, 3, 4, 5}
>>> x > x
False

Note: Der Operator> ist die einzige Möglichkeit, um zu testen, ob eine Menge eine richtige Obermenge ist. Es gibt keine entsprechende Methode.

Einen Satz ändern

Obwohl die in einer Menge enthaltenen Elemente vom unveränderlichen Typ sein müssen, können die Mengen selbst geändert werden. Wie bei den obigen Operationen gibt es eine Mischung aus Operatoren und Methoden, mit denen der Inhalt eines Satzes geändert werden kann.

Erweiterte Zuweisungsoperatoren und -methoden

Jeder der oben aufgeführten Operatoren für Vereinigung, Schnittmenge, Differenz und symmetrische Differenz verfügt über ein erweitertes Zuweisungsformular, mit dem eine Menge geändert werden kann. Für jede gibt es auch eine entsprechende Methode.

x1.update(x2[, x3 ...])

x1 |= x2 [| x3 ...]

Ändern Sie einen Satz nach Union.

x1.update(x2) undx1 |= x2 addieren zux1 alle Elemente inx2, diex1 noch nicht hat:

>>>

>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'foo', 'baz', 'qux'}

>>> x1 |= x2
>>> x1
{'qux', 'foo', 'bar', 'baz'}

>>> x1.update(['corge', 'garply'])
>>> x1
{'qux', 'corge', 'garply', 'foo', 'bar', 'baz'}

x1.intersection_update(x2[, x3 ...])

x1 &= x2 [& x3 ...]

Ändern Sie eine Menge nach Schnittmenge.

x1.intersection_update(x2) undx1 &= x2 aktualisierenx1, wobei nur Elemente beibehalten werden, die sowohl inx1 als auch inx2 enthalten sind:

>>>

>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'foo', 'baz', 'qux'}

>>> x1 &= x2
>>> x1
{'foo', 'baz'}

>>> x1.intersection_update(['baz', 'qux'])
>>> x1
{'baz'}

x1.difference_update(x2[, x3 ...])

x1 -= x2 [| x3 ...]

Ändern Sie einen Satz durch Differenz.

x1.difference_update(x2) undx1 -= x2 aktualisierenx1 und entfernen Elemente, die inx2 gefunden wurden:

>>>

>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'foo', 'baz', 'qux'}

>>> x1 -= x2
>>> x1
{'bar'}

>>> x1.difference_update(['foo', 'bar', 'qux'])
>>> x1
set()

x1.symmetric_difference_update(x2)

x1 ^= x2

Ändern Sie eine Menge durch symmetrische Differenz.

x1.symmetric_difference_update(x2) undx1 ^= x2 aktualisierenx1, wobei Elemente beibehalten werden, die entweder inx1 oderx2 enthalten sind, aber nicht in beiden:

>>>

>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'foo', 'baz', 'qux'}
>>>
>>> x1 ^= x2
>>> x1
{'bar', 'qux'}
>>>
>>> x1.symmetric_difference_update(['qux', 'corge'])
>>> x1
{'bar', 'corge'}

Andere Methoden zum Ändern von Sets

Abgesehen von den oben genannten erweiterten Operatoren unterstützt Python mehrere zusätzliche Methoden zum Ändern von Mengen.

x.add()

Fügt einer Menge ein Element hinzu.

x.add(<elem>) addiert<elem>, das ein einzelnes unveränderliches Objekt sein muss, zux:

>>>

>>> x = {'foo', 'bar', 'baz'}

>>> x.add('qux')
>>> x
{'bar', 'baz', 'foo', 'qux'}

x.remove()

Entfernt ein Element aus einer Menge.

x.remove(<elem>) entfernt<elem> vonx. Python löst eine Ausnahme aus, wenn<elem> nicht inx enthalten ist:

>>>

>>> x = {'foo', 'bar', 'baz'}

>>> x.remove('baz')
>>> x
{'bar', 'foo'}

>>> x.remove('qux')
Traceback (most recent call last):
  File "", line 1, in 
    x.remove('qux')
KeyError: 'qux'

x.discard()

Entfernt ein Element aus einer Menge.

x.discard(<elem>) entfernt auch<elem> ausx. Wenn<elem> jedoch nicht inx enthalten ist, führt diese Methode im Hintergrund nichts aus, anstatt eine Ausnahme auszulösen:

>>>

>>> x = {'foo', 'bar', 'baz'}

>>> x.discard('baz')
>>> x
{'bar', 'foo'}

>>> x.discard('qux')
>>> x
{'bar', 'foo'}

x.pop()

Entfernt ein zufälliges Element aus einer Menge.

x.pop() entfernt und gibt ein beliebig ausgewähltes Element ausx zurück. Wennx leer ist, löstx.pop() eine Ausnahme aus:

>>>

>>> x = {'foo', 'bar', 'baz'}

>>> x.pop()
'bar'
>>> x
{'baz', 'foo'}

>>> x.pop()
'baz'
>>> x
{'foo'}

>>> x.pop()
'foo'
>>> x
set()

>>> x.pop()
Traceback (most recent call last):
  File "", line 1, in 
    x.pop()
KeyError: 'pop from an empty set'

x.clear()

Löscht einen Satz.

x.clear() entfernt alle Elemente ausx:

>>>

>>> x = {'foo', 'bar', 'baz'}
>>> x
{'foo', 'bar', 'baz'}
>>>
>>> x.clear()
>>> x
set()

Gefrorene Sets

Python bietet einen weiteren integrierten Typ namensfrozenset, der in jeder Hinsicht genau wie eine Menge ist, außer dass ein Frozenset unveränderlich ist. Sie können nicht ändernde Vorgänge für ein Frozenset ausführen:

>>>

>>> x = frozenset(['foo', 'bar', 'baz'])
>>> x
frozenset({'foo', 'baz', 'bar'})

>>> len(x)
3

>>> x & {'baz', 'qux', 'quux'}
frozenset({'baz'})

Methoden, die versuchen, ein Frozenset zu ändern, schlagen jedoch fehl:

>>>

>>> x = frozenset(['foo', 'bar', 'baz'])

>>> x.add('qux')
Traceback (most recent call last):
  File "", line 1, in 
    x.add('qux')
AttributeError: 'frozenset' object has no attribute 'add'

>>> x.pop()
Traceback (most recent call last):
  File "", line 1, in 
    x.pop()
AttributeError: 'frozenset' object has no attribute 'pop'

>>> x.clear()
Traceback (most recent call last):
  File "", line 1, in 
    x.clear()
AttributeError: 'frozenset' object has no attribute 'clear'

>>> x
frozenset({'foo', 'bar', 'baz'})

Deep Dive: Frozensets und Augmented Assignment

Da ein Frozenset unveränderlich ist, könnte es sein, dass es nicht das Ziel eines erweiterten Zuweisungsoperators sein kann. Aber beachten Sie:

>>>
>>> f = frozenset(['foo', 'bar', 'baz'])
>>> s = {'baz', 'qux', 'quux'}

>>> f &= s
>>> f
frozenset({'baz'})
Was gibt?

Python führt keine erweiterten Zuweisungen für vorhandene Frozensets durch. Die Aussagex &= s entspricht effektivx = x & s. Die ursprünglichenx werden nicht geändert. Es wirdx einem neuen Objekt neu zugewiesen, und das ursprünglich referenzierte Objektx ist verschwunden.

Sie können dies mit der Funktionid()überprüfen:

>>>
>>> f = frozenset(['foo', 'bar', 'baz'])
>>> id(f)
56992872
>>> s = {'baz', 'qux', 'quux'}

>>> f &= s
>>> f
frozenset({'baz'})
>>> id(f)
56992152
f hat nach der erweiterten Zuweisung eine andere Ganzzahlkennung. Es wurde neu zugewiesen und nicht geändert.

Einige Objekte in Python werden an Ort und Stelle geändert, wenn sie das Ziel eines erweiterten Zuweisungsoperators sind. Aber Frozensets sind es nicht.

Frozensets sind in Situationen nützlich, in denen Sie ein Set verwenden möchten, aber ein unveränderliches Objekt benötigen. Beispielsweise können Sie keine Menge definieren, deren Elemente auch Mengen sind, da Mengenelemente unveränderlich sein müssen:

>>>

>>> x1 = set(['foo'])
>>> x2 = set(['bar'])
>>> x3 = set(['baz'])
>>> x = {x1, x2, x3}
Traceback (most recent call last):
  File "", line 1, in 
    x = {x1, x2, x3}
TypeError: unhashable type: 'set'

Wenn Sie sich wirklich gezwungen fühlen, eine Reihe von Mengen zu definieren (hey, es könnte passieren), können Sie dies tun, wenn die Elemente frozensets sind, weil sie unveränderlich sind:

>>>

>>> x1 = frozenset(['foo'])
>>> x2 = frozenset(['bar'])
>>> x3 = frozenset(['baz'])
>>> x = {x1, x2, x3}
>>> x
{frozenset({'bar'}), frozenset({'baz'}), frozenset({'foo'})}

Erinnern Sie sich ebenfalls aus dem vorherigen Tutorial zudictionaries daran, dass ein Wörterbuchschlüssel unveränderlich sein muss. Sie können den integrierten Set-Typ nicht als Wörterbuchschlüssel verwenden:

>>>

>>> x = {1, 2, 3}
>>> y = {'a', 'b', 'c'}
>>>
>>> d = {x: 'foo', y: 'bar'}
Traceback (most recent call last):
  File "", line 1, in 
    d = {x: 'foo', y: 'bar'}
TypeError: unhashable type: 'set'

Wenn Sie Sets als Wörterbuchschlüssel verwenden müssen, können Sie frozensets verwenden:

>>>

>>> x = frozenset({1, 2, 3})
>>> y = frozenset({'a', 'b', 'c'})
>>>
>>> d = {x: 'foo', y: 'bar'}
>>> d
{frozenset({1, 2, 3}): 'foo', frozenset({'c', 'a', 'b'}): 'bar'}

Fazit

In diesem Lernprogramm haben Sie gelernt, wie Sieset-Objekte in Python definieren, und Sie haben sich mit den Funktionen, Operatoren und Methoden vertraut gemacht, die zum Arbeiten mit Mengen verwendet werden können.

Sie sollten jetzt mit den grundlegenden integrierten Datentypen vertraut sein, die Python bereitstellt.

Als Nächstes werden Sie untersuchen, wie der Code, der mit diesen Objekten arbeitet, in einem Python-Programm organisiert und strukturiert ist.

Das Quiz machen "

TOC

Setzt in Python

Setzt in Python

Set definieren

Größe und Mitgliedschaft einstellen

Betrieb an einem Set

Operatoren vs. Methoden

Verfügbare Operatoren und Methoden

Einen Satz ändern

Erweiterte Zuweisungsoperatoren und -methoden

Andere Methoden zum Ändern von Sets

Gefrorene Sets

Fazit

Related