Введение

Примеры

Получить уникальные элементы списка

Допустим, у вас есть список ресторанов - может быть, вы читаете его из файла. Вы заботитесь об уникальных ресторанах в списке. Лучший способ получить уникальные элементы из списка - превратить его в набор:

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

 

Обратите внимание, что набор не в том же порядке, что и исходный список; это потому , что множества являются неупорядоченными, так же , как dict с.

Это может быть легко преобразован обратно в List с Python встроенный в list функций, что дает еще один список , который тот же список , как оригинал , но без дубликатов:

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

 

Также принято видеть это одной строкой:

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

 

Теперь любые операции, которые могут быть выполнены в исходном списке, могут быть выполнены снова.

Операции на множествах

с другими наборами

 # 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

 

с отдельными элементами

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

Операции множества возвращают новые множества, но имеют соответствующие версии на месте:

метод  операция на месте  метод на месте  союз  s | = t  Обновить  пересечение  s & = t  intersection_update  разница  s - = t  difference_update  symmetric_difference  с ^ = т  symmetric_difference_update

Например:

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

Наборы против мультимножеств

Наборы - это неупорядоченные наборы отдельных элементов. Но иногда мы хотим работать с неупорядоченными коллекциями элементов, которые не обязательно различны и отслеживают множественность элементов.

Рассмотрим этот пример:

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

 

При сохранении строки 'a' , 'b' , 'b' , 'c' в структуру набора данных , мы потеряли информацию о том , что 'b' происходит дважды. Конечно, сохранение элементов в списке сохранит эту информацию

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

 

но структура данных списка вводит дополнительный ненужный порядок, который замедляет наши вычисления.

Для реализации мультинаборы Python предоставляет Counter класса из collections модуля (начиная с версии 2.7):

>>> из коллекции импортов Counter >>> counterA = Counter (['a', 'b', 'b', 'c']) >>> CounterA Counter ({'b': 2, 'a': 1 , 'c': 1})

Counter представляет собой словарь , где где элементы хранятся в виде ключей словаря и их счетчики хранятся в виде значений словаря. И, как и все словари, это неупорядоченная коллекция.

Операции над множествами с использованием методов и встроенных функций

Определим два множества a и b

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

союз

a.union(b) возвращает новый набор с элементами , присутствующими в любом a и b

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

разница

a.difference(b) возвращает новый набор с элементами , присутствующими в , но не в a b

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

Симметричная разница

a.symmetric_difference(b) возвращает новый набор с элементами , присутствующими в любом a или b , но не в обеих

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

Примечание: a.symmetric_difference(b) == b.symmetric_difference(a)

Подмножество и суперсет

c.issubset(a) проверяет , соответствует ли каждый элемент c в . a

a.issuperset(c) проверяет , является ли каждый элемент c находится в . a

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

Последние операции имеют эквивалентные операторы, как показано ниже:

метод  оператор  a.intersection(b)   a & b    a.union(b)   | b  a.difference(b)   a - b   a.symmetric_difference(b)   a ^ b   a.issubset(b)   a <= b   a.issuperset(b)   a >= b

Несвязные множества

Наборы и a d не пересекаются , если ни один элемент в не находится также в a d , и наоборот.

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

Тестирование членства

Встроенный in поисках ключевых слов для появлений

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

длина

Встроенный len() функция возвращает количество элементов в наборе

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

Набор Наборов

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

 

приводит к:

 TypeError: unhashable type: 'set'

 

Вместо этого используйте frozenset :

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

Синтаксис

Параметры

Примечания