Python Language
Zestaw

Składnia

• empty_set = set () # zainicjuj pusty zestaw
• literal_set = {'foo', 'bar', 'baz'} # zbuduj zestaw z 3 ciągami znaków
• set_from_list = set (['foo', 'bar', 'baz']) # wywołaj funkcję set dla nowego zestawu
• set_from_iter = set (x dla xw zakresie (30)) # użyj dowolnej iteracji, aby utworzyć zestaw
• set_from_iter = {x dla x w [random.randint (0,10) dla i w zakresie (10)]} # alternatywna notacja

Uwagi

Uzyskaj unikalne elementy listy

Załóżmy, że masz listę restauracji - być może czytasz ją z pliku. Dbasz o wyjątkowe restauracje na liście. Najlepszym sposobem na uzyskanie unikatowych elementów z listy jest przekształcenie ich w zestaw:

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

Zauważ, że zestaw nie jest w tej samej kolejności, co oryginalna lista; to dlatego, że zbiory są nieuporządkowane , tak jak dict .

Można to łatwo przekształcić z powrotem w List pomocą wbudowanej funkcji list Pythona, co daje kolejną listę, która jest taka sama jak w oryginale, ale bez duplikatów:

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

Często jest to postrzegane jako jedna linia:

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

Teraz wszelkie operacje, które można wykonać na oryginalnej liście, można wykonać ponownie.

Operacje na zbiorach

z innymi zestawami

# 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

z pojedynczymi elementami

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

Operacje na zestawach zwracają nowe zestawy, ale mają odpowiednie wersje na miejscu:

Na przykład:

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

Zestawy kontra multisety

Zestawy to nieuporządkowane kolekcje różnych elementów. Ale czasami chcemy pracować z nieuporządkowanymi zbiorami elementów, które niekoniecznie są odrębne i śledzą mnogość elementów.

Rozważ ten przykład:

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

Zapisując ciągi 'a' , 'b' , 'b' , 'c' w ustalonej strukturze danych, utraciliśmy informacje o tym, że 'b' występuje dwa razy. Oczywiście zapisanie elementów na liście zachowałoby tę informację

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

ale struktura danych listy wprowadza dodatkowe niepotrzebne porządkowanie, które spowolni nasze obliczenia.

Do implementacji multisetów Python udostępnia klasę Counter z modułu collections (od wersji 2.7):

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

Counter to słownik, w którym elementy są przechowywane jako klucze słownika, a ich liczby są przechowywane jako wartości słownika. I jak wszystkie słowniki, jest to kolekcja nieuporządkowana.

Ustaw operacje za pomocą metod i wbudowanych funkcji

Definiujemy dwa zestawy a i b

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

UWAGA: {1} tworzy zestaw jednego elementu, ale {} tworzy pusty dict . Prawidłowym sposobem utworzenia pustego zestawu jest set() .

Skrzyżowanie

a.intersection(b) zwraca nowy zestaw z elementami obecnymi zarówno w a jak i b

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

Unia

a.union(b) zwraca nowy zestaw z elementami obecnymi w a.union(b) a i b

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

Różnica

a.difference(b) zwraca nowy zestaw z elementami obecnymi w a ale nie w b

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

Różnica symetryczna

a.symmetric_difference(b) zwraca nowy zestaw z elementami obecnymi w a lub b ale nie w obu

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

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

Podzbiór i nadzbiór

c.issubset(a) sprawdza, czy każdy element c jest . a

a.issuperset(c) sprawdza, czy każdy element c jest . a

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

Te ostatnie operacje mają równoważne operatory, jak pokazano poniżej:

Zestawy rozłączne

Zestawy a i d są rozłączne, jeśli żaden element w a także nie znajduje się w d i odwrotnie.

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

Testowanie członkostwa

Polecenie wbudowane in wyszukiwań słów kluczowych dla wystąpień

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

Długość

Wbudowana funkcja len() zwraca liczbę elementów w zestawie

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

Zestaw zestawów

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

prowadzi do:

TypeError: unhashable type: 'set'

Zamiast tego użyj frozenset :

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