Set Python. Множества в Python

В языке Python есть тип данных, который может быть очень полезен для работы с множествами – это set. В данном уроке будет рассказано о том, как работать с множествами (set python) и об операциях над ними.

Что это

Set в Python — это тип данных, встроенный в язык и предназначенный для работы с последовательностями, которые имеют свойства математических множеств. В качестве элементов набора данных выступают различные неизменяемые объекты. В python множество может состоять из не ограниченного количества элементов и они могут быть любых неизменяемых типов, таких как кортежи, числа, строки и т. д. Однако, множество не поддерживает mutable элементы, к примеру списки, словари, и прочие. Python множества — это изменяемые коллекции элементов, обладающие некоторыми особенностями:

— их элементы не упорядочены;

— их элементы не повторяются.

Таким образом, множеством в языке Python является неупорядоченная совокупность элементов, при том уникальных. Порядок расстановки элементов не учитывается при работе с его содержимым. Над одним или несколькими множествами можно выполнять разные операции, используя функции, содержащиеся в стандартной библиотеке Python.

Как создать множество python

Перед тем как выполнять операции с множеством, необходимо его создать. Существует несколько способов создавать множества в Python. Можно это сделать, присвоив любой переменной коллекцию значений, окружив их фигурными скобками {}, а так же разделить все элементы запятыми.

Создание множества в Python выглядит следующим образом:

my_set = {1, 2, 3, 4, 5}  
print(my_set)
 

Вывод:

{1, 2, 3, 4, 5}
 

Это пример создания множества чисел. Также можно создать множество из строк:

my_set = {"Ivan", "Rinat", "Olga", "Kira"}  
print(my_set)
 

Вывод:

{‘Ivan’, ‘Olga’, ‘Kira’, ‘Rinat’}
 

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

Также можно создать множество с элементами различных типов:

my_set = {1, 2.0, «Ivan», True, (1, 2, 3)}
print(my_set)

Вывод:

{1, 2.0, (1, 2, 3), ‘Ivan’}

Все элементы данного множества имеют различные типы данных. Обратите внимание, что в данном выводе нет элемента True. Скоро мы разберёмся в том, почему это произошло.

Существует другой путь, в котором также необходимо создавать множество из других коллекций. Это можно сделать, используя встроенную в Python3 функцию set(). Аргументом такой функции должна быть коллекция неких данных или строка с текстом.

Из списка:

my_set = set([1, 26, 4, 5, 6])
print(my_set)

Вывод:

{1, 26, 4, 5, 6}

Из кортежа:

my_set = set((1, 26, 4, 5, 6))
print(my_set)

Вывод:

{1, 26, 4, 5, 6}

Из словаря:

my_set = set({‘q’:1, ‘w’:2, ‘e’:3, ‘r’:4, ‘t’:5, ‘y’:6})
print(my_set)

Вывод:

{‘q’, ‘t’, ‘y’, ‘w’, ‘e’, ‘r’}

Как уже говорилось, множества не содержат повторяющиеся элементы. Если последовательность включает дубликаты элементов, то из множества эти элементы будут автоматически удалены:

my_set = set([1, 3, 9, 27, 9, 3])

print(my_set)

Вывод:

{1, 3, 9, 27}

Именно по этой причине в приведённом выше примере

my_set = {1, 2.0, «Ivan»,  True, (1, 2, 3)}

в итоговом множестве отсутствует элемент True. Так как True и единица равны, Python справедливо посчитал эти элементы дубликатами и удалил один из них.

Создать пустое множество используя пустые фигурные скобки {} не получится, поскольку Python, встретив такую строку, создаст словарь, а не множество:

example_dict = {}
print(type(example_dict))

Вывод:

<class ‘dict’>

Как показано в выводе, переменная — это словарь.

Для того, чтобы создать пустое множество, надо применить встроенную в язык и стандартную для этих случаев функцию set() без параметров:

my_set = set()
print(type(my_set))

Вывод:

<class ‘set’>

Вывод показывает, что переменная example имеет тип множество (‘set’).

Для создания множества можно воспользоваться генератором. Генератор позволяет заполнять кортежи, списки, а также другие наборы с учетом указанных условий. Заполнение проводится так же, как происходит генерация списков.

Следующий пример иллюстрирует генерацию множества с использованием цикла for для нескольких чисел:

my_set = { _ for _ in [102, 21, 30, 51, 34, 72]}
print(my_set)

Вывод:

{34, 72, 102, 51, 21, 30}

Добавляем элемент в множества python

Для изменения содержимого множеств в языке Пайтон присутствуют специальные методы, позволяющие добавлять и удалять различные элементы, а так же производить другие операции. Как и для создания set множества, существует несколько различных способов для добавления очередного элемента.

Добавление одного элемента в множество python

Добавить новый объект в уже существующее множество можно используя метод множества add(). Аргументом функции в данном случае является добавляемый элемент последовательности. Не стоит забывать, что добавлять можно только те данные, которые имеют неизменяемый тип.

my_set = set([1, 2, 9])

my_set.add(4) # добавляем элемент 4

print(my_set)

Вывод:

{1, 2, 4, 9}

Если среди объектов, изначально составляющих set, данный элемент уже был, то ничего не произойдёт, и начальное множество останется неизменным.

my_set = set([1, 2, 9])

my_set.add(9) # пытаемся добавить элемент 9

print(my_set)

Вывод:

{1, 2, 9}

Добавление нескольких элементов в множество python

Добавление группы элементов в множество — это частный случай операции объединения множеств. Его отличие от стандартного объединения заключается в том, что добавление группы элементов изменяет первоначальное множество, а не создает новое.

Для добавления нескольких элементов необходимо использовать метод update, который принимает итерабельный объект (список, кортеж, генератор и т.п.) и добавляет все входящие в него элементы в исходное множество.

Добавление списка:

my_set = {1, 2, 3}
example_list = [‘q’, ‘w’, ‘e’]
my_set.update(example_list)
print(my_set)

Вывод:

{1, 2, 3, ‘q’, ‘e’, ‘w’}

Добавление генератора:

my_set = {1, 2, 3}
my_set.update(i//2 for i in [15, 32, 43])

print(my_set)

Вывод:

{1, 2, 3, 7, 16, 21}

Данный метод (update) можно использовать как альтернативу методу add и добавлять в множество всего один элемент с его помощью.

Удаляем элементы из множеств python

remove

Метод remove удаляет элемент из коллекции set. В случае отсутствия такого элемента в наборе возникает исключение «KeyError «. В качестве входного параметра метода выступает элемент, который необходимо удалить.

# Объявляем множество
my_set = {1, 2, 3}

print(my_set)

Вывод:

{1, 2, 3}

# Удаляем элемент «1»
my_set.remove(1)

print(my_set)

Вывод:

{2, 3}

# Удаляем элемент «5»
my_set.remove(5)

print(my_set)

Вывод:

…
KeyError: 5

discard

Работает так же, как и remove(), но, в том случае если элемент отсутствует в коллекции, не выбрасывает исключение:

# Объявляем множество
my_set = {1, 2, 3}

print(my_set)

Вывод:

{1, 2, 3}

# Удаляем элемент «1»
my_set.discard(1)
print(my_set)

Вывод:

{2, 3}

# Удаляем элемент «5»
my_set.discard (5)

print(my_set)

Вывод:

{1, 2, 3}

pop

Метод pop удаляет тот элемент, который будет находиться в памяти первым

Хотелось бы отметить, что так как множества не упорядочены, то выглядит работа этого метода, как удаление случайного элемента.

Этот метод не только удаляет один из элементов множества, но и возвращает его значение:

my_set = {«Ivan», «Rinat», «Olga», «Kira»}
print(my_set)

Вывод:

{‘Olga’, ‘Rinat’, ‘Kira’, ‘Ivan’}

print(my_set.pop())

Вывод:

Olga

print(my_set)

Вывод:

{‘Rinat’, ‘Kira’, ‘Ivan’}

Методы множеств python

Часто используемые функции множеств python

Только несколько из всех методов, перечисленных в dir(), используются постоянно. Выше уже были рассмотрены add, update, а также remove, discard и pop.

Функция принадлежности членства

Оператор in используется для проверки принадлежности элемента набору:

my_set = {«Ivan», «Rinat», «Olga», «Kira»}
print({«Ivan» in my_set)

Вывод:

True

my_set = {«Ivan», «Rinat», «Olga», «Kira»}
print({«Anna» in my_set)

Вывод:

False

Есть и другие способы проверить принадлежность:

set_a.isdisjoint(set_b) — True, если set_a и set_b не имеют совместных элементов.

set_a == set_b — True, если все элементы set_a принадлежат set_b, все элементы set_b принадлежат set_a.

set_a.issubset(set_b) или set_a <= set_b — True, если все элементы set_a принадлежат set_b.

set_a.issuperset(set_b) или set_a >= set_b — True, если все элементы set_b принадлежат set_a.

Разные функции

Кратко перечислим ещё несколько методов и функций, которыми можно пользоваться для работы с объектами множеств.

Когда необходимо полностью удалить все элементы, на помощь приходит метод clear(). Данный метод не принимает никаких аргументов. Он позволяет не удалять каждый элемент «вручную», а выполнить очистку всего множества одной командой.

my_set = {102, 21, 330, 51, 34, 72}

my_set.clear() # Удаляем элементы множества my_set

print(my_set)

Вывод:

set()

В множествах порядок следования элементов не учитывается. Поэтому бессмысленно говорить об их сортировке.

Но, с другой стороны, дело обстоит немного иначе. Для быстрого поиска элементов, предпочтительно их записывать в память в упорядоченном виде. Это, естественно, понимали и создатели Пайтона.

А что будет с элементами различных типов данных в одном множестве? Эти элементы, на сколько мы знаем, не должны сортироваться.

my_set = {1, 2.0, «Ivan», True, (1, 2, 3)}
print(my_set)

Вывод:

{1, 2.0, (1, 2, 3), ‘Ivan’}

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

Рассмотрим, что будет, если попытаться ввести только числа:

my_set = {6, 5, 4, 3, 2, 1}

print(my_set)

Вывод:

{1, 2, 3, 4, 5, 6}

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

my_set = {i for i in range(300, 0, -77)}

print(my_set)

Вывод:

{146, 300, 69, 223}

Если вам нужно получить отсортированную коллекцию из множества, лучше воспользоваться функцией sorted или встроенным методом списка sort. Элементы будут отсортированы и код будет понятен для других.

my_set = {i for i in range(3000, 0, -770)}

print(my_set)

my_list = list(my_set)

my_list.sort()

print(my_list)

Вывод:

{3000, 690, 1460, 2230} # Множество
[690, 1460, 2230, 3000] # Отсортированный список

copy() — Возвращает не глубокую копию множества.

difference_update() — Удаляет из заданного множества все элементы второго множества.

intersection_update() — Множество обновляется пересечением со вторым множеством.

symmetric_difference_update() — Обновляет set разницей между первым и вторым множеством и при этом разница симметричная.

Узнать количество элементов, из которых состоит set, можно при помощи функции len(), принимающей набор значений в качестве аргумента

Так же стоит отметить, что существует такой тип данных, как неизменяемое множество. Следовательно, в Python frozenset поддерживает все методы обычных множеств кроме тех, которые его изменяют.

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

Объединение множеств

При использовании объединения множеств создаётся ещё одно множество, которое содержит все элементы, входящие в первоначальные два (без дубликатов). Операция объединения в языке Python выполняется несколькими способами: используя символ «|» или встроенный метод union().

# используя символьный метод
set_a = {1, 9, 22, 4}
set_b = {3, 4, 5, 6}
set_c = set_a | set_b
print(set_c)

Вывод:

{1, 3, 4, 5, 6, 9, 22}

# используя метод union
set_a = {1, 9, 22, 4}
set_b = {3, 4, 5, 6}
set_c = set_a.union(set_b)
print(set_c)

Вывод:

{1, 3, 4, 5, 6, 9, 22}

Как можно увидеть из листинга, приведённого выше, эти методы идентичны.

Пересечение множеств

При использовании пересечения множеств создаётся новый объект-множество, содержащий все элементы, общие для обоих (без дубликатов). Операция пересечения выполняется несколькими способами: используя символ & или метод intersection().

# используя символьный метод
set_a = {1, 9, 22, 4}
set_b = {3, 4, 5, 6}
set_c = set_a & set_b
print(set_c)

Вывод:

{4}

# используя метод intersection
set_a = {1, 9, 22, 4}
set_b = {3, 4, 5, 6}
set_c = set_a.intersection(set_b)
print(set_c)

Вывод:

{4}

Методы дают одинаковый результат.

Разность множеств

При использовании разности множеств Питон создаёт новый объект, включающий элементы, которые есть в первом, но не входят во второй (в данном случае — в множестве set_a). Операция разности выполняется несколькими способами: с помощью символа, а так же метода python set — difference().

# используя символьный метод
set_a = {1, 9, 22, 4}
set_b = {3, 4, 5, 6}
set_c = set_a — set_b
print(set_c)

Вывод:

{1, 9, 22}

# используя метод difference
set_a = {1, 9, 22, 4}
set_b = {3, 4, 5, 6}
set_c = set_a.difference(set_b)
print(set_c)

Вывод:

{1, 9, 22}

Симметричная разность множеств

При применении симметричной разности на двух set-объектах создаётся новый объект, включающий все элементы, за исключением тех, которые есть в обоих. Выполняется симметричная разность несколькими способами: используя символ ^, или метод symmetric_difference().

# используя символьный метод
set_a = {1, 9, 22, 4}
set_b = {3, 4, 5, 6}
set_c = set_a ^ set_b
print(set_c)

Вывод:

{1, 3, 5, 6, 9, 22}

# используя метод symmetric_difference
set_a = {1, 9, 22, 4}
set_b = {3, 4, 5, 6}
set_c = set_a.symmetric_difference(set_b)
print(set_c)

Вывод:

{1, 3, 5, 6, 9, 22}

Подмножество и надмножество в python

Множество set_b называется подмножеством set_a, если все элементы set_b принадлежат set_a. Проверить, является ли множество set_b подмножеством set_a можно несколькими способами: с помощью символа <= или метод issubset(). Оба способа возвращают True/False исходя из результата проверки.

# используя символьный метод
set_a = {1, 9, 22, 4, 5}
set_b = {4, 1}
set_b <= set_a

Вывод:

True

# используя метод issubset
set_a = {1, 9, 22, 4, 5}
set_b = {4, 1}
set_b.issubset(set_a)

Вывод:

True

Множество set_a называется надмножество set_b, если все элементы set_b входят в set_a. Проверить на надмножество в Python можно следующими способами: используя символ >= или метод issuperset(). Оба способа возвращают True/False исходя из результата проверки.

# используя символьный метод
set_a = {1, 9, 22, 4, 5}
set_b = {22, 4}
set_a >= set_b

Вывод:

True

# используя метод issubset
set_a = {1, 9, 22, 4, 5}
set_b = {22, 4}
set_a.issuperset(set_b)

Вывод:

True