Python Language
einstellen

Syntax

• empty_set = set () # initialisiert eine leere Menge
• literal_set = {'foo', 'bar', 'baz'} # Konstruiere einen Satz mit 3 Strings darin
• set_from_list = set (['foo', 'bar', 'baz']) # ruft die Set-Funktion für ein neues Set auf
• set_from_iter = set (x für x im Bereich (30)) # verwendet beliebige iterierbare Elemente, um eine Menge zu erstellen
• set_from_iter = {x für x in [random.randint (0,10) für i im Bereich (10)]} # alternative Schreibweise

Bemerkungen

Holen Sie sich die einzigartigen Elemente einer Liste

Nehmen wir an, Sie haben eine Liste von Restaurants - vielleicht lesen Sie sie aus einer Datei. Sie interessieren sich für die einzigartigen Restaurants in der Liste. Der beste Weg, die eindeutigen Elemente aus einer Liste zu erhalten, besteht darin, sie in einen Satz umzuwandeln:

restaurants = ["McDonald's", "Burger King", "McDonald's", "Chicken Chicken"]
unique_restaurants = set(restaurants)
print(unique_restaurants)
# prints {'Chicken Chicken', "McDonald's", 'Burger King'}

Beachten Sie, dass sich das Set nicht in der gleichen Reihenfolge wie die ursprüngliche Liste befindet. Das ist, weil Mengen ungeordnet sind , genau wie dict .

Dies kann leicht wieder in eine umgewandelt werden List mit Pythons eingebaute list Funktion, eine weitere Liste geben , die die gleiche Liste wie das Original , aber ohne Duplikate:

list(unique_restaurants)
# ['Chicken Chicken', "McDonald's", 'Burger King']

Es ist auch üblich, dies als eine Zeile zu sehen:

# Removes all duplicates and returns another list
list(set(restaurants))

Jetzt können alle Operationen, die in der ursprünglichen Liste ausgeführt werden könnten, erneut ausgeführt werden.

Operationen an Sets

mit anderen Sets

# Intersection    
{1, 2, 3, 4, 5}.intersection({3, 4, 5, 6})  # {3, 4, 5}
{1, 2, 3, 4, 5} & {3, 4, 5, 6}              # {3, 4, 5}

# Union
{1, 2, 3, 4, 5}.union({3, 4, 5, 6})  # {1, 2, 3, 4, 5, 6}
{1, 2, 3, 4, 5} | {3, 4, 5, 6}       # {1, 2, 3, 4, 5, 6}

# Difference
{1, 2, 3, 4}.difference({2, 3, 5})  # {1, 4}
{1, 2, 3, 4} - {2, 3, 5}            # {1, 4}

# Symmetric difference with
{1, 2, 3, 4}.symmetric_difference({2, 3, 5})  # {1, 4, 5}
{1, 2, 3, 4} ^ {2, 3, 5}                      # {1, 4, 5}

# Superset check
{1, 2}.issuperset({1, 2, 3})  # False
{1, 2} >= {1, 2, 3}           # False

# Subset check
{1, 2}.issubset({1, 2, 3})  # True
{1, 2} <= {1, 2, 3}         # True

# Disjoint check
{1, 2}.isdisjoint({3, 4})  # True
{1, 2}.isdisjoint({1, 4})  # False

mit einzelnen Elementen

# Existence check
2 in {1,2,3}      # True
4 in {1,2,3}      # False
4 not in {1,2,3}  # True

# Add and Remove
s = {1,2,3}
s.add(4)        # s == {1,2,3,4}

s.discard(3)    # s == {1,2,4}
s.discard(5)    # s == {1,2,4}

s.remove(2)     # s == {1,4}
s.remove(2)     # KeyError!

Setoperationen geben neue Sets zurück, verfügen jedoch über die entsprechenden In-Place-Versionen:

Zum Beispiel:

s = {1, 2}
s.update({3, 4})   # s == {1, 2, 3, 4}

Sets im Vergleich zu Multisets

Sets sind ungeordnete Sammlungen verschiedener Elemente. Manchmal möchten wir jedoch mit ungeordneten Sammlungen von Elementen arbeiten, die nicht notwendigerweise verschieden sind, und die Multiplizitäten der Elemente verfolgen.

Betrachten Sie dieses Beispiel:

>>> setA = {'a','b','b','c'}
>>> setA
set(['a', 'c', 'b'])

Durch das Speichern der Zeichenfolgen 'a' , 'b' , 'b' , 'c' in einer festgelegten Datenstruktur haben wir die Information verloren, dass 'b' zweimal vorkommt. Wenn Sie die Elemente in einer Liste speichern, bleiben diese Informationen natürlich erhalten

>>> listA = ['a','b','b','c']
>>> listA
['a', 'b', 'b', 'c']

Eine Listendatenstruktur führt jedoch eine zusätzliche nicht benötigte Reihenfolge ein, die unsere Berechnungen verlangsamt.

Zur Implementierung von Multisets stellt Python die Counter Klasse aus dem collections Modul (ab Version 2.7) bereit:

>>> from collections import Counter
>>> counterA = Counter(['a','b','b','c'])
>>> counterA
Counter({'b': 2, 'a': 1, 'c': 1})

Counter ist ein Wörterbuch, in dem Elemente als Wörterbuchschlüssel und ihre Zählwerte als Wörterbuchwerte gespeichert werden. Und wie alle Wörterbücher ist es eine ungeordnete Sammlung.

Festlegen von Operationen mit Methoden und eingebauten Elementen

Wir definieren zwei Mengen a und b

>>> a = {1, 2, 2, 3, 4}
>>> b = {3, 3, 4, 4, 5}

HINWEIS: {1} erstellt einen Satz eines Elements, {} erstellt jedoch ein leeres dict . Die korrekte Methode zum Erstellen eines leeren Sets ist set() .

Überschneidung

a.intersection(b) gibt eine neue Menge mit Elementen zurück, die in a und b

>>> a.intersection(b)
{3, 4}

Union

a.union(b) gibt eine neue Menge mit Elementen zurück, die in a und b

>>> a.union(b)
{1, 2, 3, 4, 5}

Unterschied

a.difference(b) gibt eine neue Menge mit Elementen zurück, die in a aber nicht in b

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

Symmetrischer Unterschied

a.symmetric_difference(b) gibt eine neue Menge mit Elementen zurück, die entweder in a oder b jedoch nicht in beiden

>>> a.symmetric_difference(b)
{1, 2, 5}
>>> b.symmetric_difference(a)
{1, 2, 5}

HINWEIS: a.symmetric_difference(b) == b.symmetric_difference(a)

Teilmenge und Obermenge

c.issubset(a) prüft, ob sich jedes Element von c in a .

a.issuperset(c) prüft, ob sich jedes Element von c in a .

>>> c = {1, 2}
>>> c.issubset(a)
True
>>> a.issuperset(c)
True

Die letzteren Operationen haben gleichwertige Operatoren, wie unten gezeigt:

Disjunkte Sätze

Die Sätze a und d sind nicht zusammenhängend, wenn kein Element in a auch in d und umgekehrt.

>>> d = {5, 6}
>>> a.isdisjoint(b) # {2, 3, 4} are in both sets
False
>>> a.isdisjoint(d)
True

# This is an equivalent check, but less efficient
>>> len(a & d) == 0
True

# This is even less efficient
>>> a & d == set()
True

Mitgliedschaft testen

Die eingebaute in Keyword sucht nach Vorkommen

>>> 1 in a
True
>>> 6 in a
False

Länge

Die eingebaute len() Funktion gibt die Anzahl der Elemente im Satz zurück

>>> len(a)
4
>>> len(b)
3

Satz von Sets

{{1,2}, {3,4}}

führt zu:

TypeError: unhashable type: 'set'

Verwenden frozenset stattdessen frozenset :

{frozenset({1, 2}), frozenset({3, 4})}