Python Language
Задавать

Синтаксис

• empty_set = set () # инициализировать пустой набор
• literal_set = {'foo', 'bar', 'baz'} # построить набор из 3 строк внутри него
• set_from_list = set (['foo', 'bar', 'baz']) # вызвать функцию set для нового набора
• set_from_iter = set (x для x в диапазоне (30)) # использовать произвольные итерации для создания набора
• set_from_iter = {x для x в [random.randint (0,10) для i в диапазоне (10)]} # альтернативная нотация

замечания

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

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

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

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

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

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 = {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):

>>> from collections import 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}

ПРИМЕЧАНИЕ. {1} создает набор из одного элемента, но {} создает пустой dict . Правильный способ создания пустого набора set() .

пересечение

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

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

длина

Функция builtin len() возвращает количество элементов в наборе

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

Набор наборы

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

приводит к:

TypeError: unhashable type: 'set'

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

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