Python Language
Impostato

Sintassi

• empty_set = set () # inizializza un set vuoto
• literal_set = {'foo', 'bar', 'baz'} # costruisce un set con 3 stringhe al suo interno
• set_from_list = set (['foo', 'bar', 'baz']) # chiama la funzione set per un nuovo set
• set_from_iter = set (x per x in range (30)) # usa iterables arbitrari per creare un set
• set_from_iter = {x per x in [random.randint (0,10) per i in range (10)]} # notazione alternativa

Osservazioni

Ottieni gli elementi unici di una lista

Supponiamo che tu abbia un elenco di ristoranti, forse lo leggi da un file. Ti interessano i ristoranti unici nella lista. Il modo migliore per ottenere gli elementi unici da un elenco è trasformarlo in un set:

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

Si noti che il set non è nello stesso ordine della lista originale; questo perché gli insiemi sono non ordinati , proprio come dict s.

Questo può essere facilmente trasformato in una List con la funzione di list incorporata di Python, dando un altro elenco che è lo stesso elenco dell'originale ma senza duplicati:

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

È anche comune vederlo come una riga:

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

Ora qualsiasi operazione che potrebbe essere eseguita nell'elenco originale può essere eseguita di nuovo.

Operazioni sui set

con altri set

# 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

con singoli elementi

# 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!

Imposta le operazioni restituiscono nuovi set, ma hanno le corrispondenti versioni sul posto:

Per esempio:

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

Imposta contro multiset

Gli insiemi sono raccolte non ordinate di elementi distinti. Ma a volte vogliamo lavorare con collezioni non ordinate di elementi che non sono necessariamente distinti e tenere traccia delle molteplicità degli elementi.

Considera questo esempio:

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

Salvando le stringhe 'a' , 'b' , 'b' , 'c' in una struttura dati impostata abbiamo perso le informazioni sul fatto che 'b' verifica due volte. Naturalmente il salvataggio degli elementi in una lista manterrebbe queste informazioni

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

ma una struttura di dati di lista introduce un ordine extra non necessario che rallenterà i nostri calcoli.

Per implementare i multiset Python fornisce la classe Counter dal modulo collections (a partire dalla versione 2.7):

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

Counter è un dizionario in cui gli elementi vengono memorizzati come chiavi del dizionario e i loro conteggi sono memorizzati come valori del dizionario. E come tutti i dizionari, è una collezione non ordinata.

Imposta le operazioni usando Methods e Builtins

Definiamo due serie a e b

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

NOTA: {1} crea un set di un elemento, ma {} crea un dict vuoto. Il modo corretto per creare un set vuoto è set() .

Intersezione

a.intersection(b) restituisce un nuovo set con elementi presenti sia in a che in b

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

Unione

a.union(b) restituisce un nuovo set con elementi presenti in a e b

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

Differenza

a.difference(b) restituisce un nuovo set con elementi presenti in a ma non in b

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

Differenza simmetrica

a.symmetric_difference(b) restituisce un nuovo set con elementi presenti in a o b ma non in entrambi

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

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

Sottoinsieme e superset

c.issubset(a) verifica se ogni elemento di c è in a .

a.issuperset(c) verifica se ogni elemento di c è in a .

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

Queste ultime operazioni hanno operatori equivalenti come mostrato di seguito:

Set disgiunti

Imposta a e d sono disgiunti se nessun elemento in a è anche in d e viceversa.

>>> 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

Test dell'appartenenza

Il built-in in ricerche di parole chiave per occorrenze

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

Lunghezza

La funzione built-in len() restituisce il numero di elementi nel set

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

Set di Set

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

porta a:

TypeError: unhashable type: 'set'

Invece, usa frozenset :

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