Объект set {множество} в Python

[Кирилл]

Продолжение знакомства с объектами Python.

Перед прочтением рекомендую ознакомиться с темой Объект list [Список] в Pyton

В этой теме пойдет речь о множествах
Множество в Python - это структура данных, похожая множества в математике (произвольная совокупность определенных и различимых объектов, объединенных мысленно в единое целое), что подтверждено в справке Python:

Build an unordered collection of unique elements.
Построить неупорядоченную коллекцию уникальных элементов

Множество может состоять из различных элементов, порядок элементов в множестве не определен. Тип объекта - класс.

Пример множества: {множество}

Введите в интерпретаторе:

y = set('Множество')
print(y)

Вывод будет следующим :

{'ж', 'в', 'е', 'н', 'с', 'т', 'М', 'о'}

Что произошло?


1) Функция set создает объект 'set' {} , а текст внутри итерирует и разбивает по элементам.

2) Внутри объекта set создаются ссылки на полученные таким образом элементы, размещенные внутри множества.

3) Переменная y ссылается на объект set в целом (хотя в Python это называется несколько иначе, но так проще воспринимать)

* множество автоматически удаляет повторяющиеся элементы, оставляя только уникальные

Давайте посмотрим, как это выглядит визуально:

set_object = set('abc')

Теперь посмотрим, какова будет разница между списком и множеством:

set_object = set('abc')
list_object = list('abc')

Теперь мы видим, что список (list) имеет индексированные вложенные контейнеры, упорядоченные в определенном порядке (0, 1, 2....)
Список позволяет обращаться к объекту по индексу, а множество такую возможность не предоставляет.

Теперь посмотрим, как будет обстоять дело, если мы будем ссылаться на переменную:

a = 'str_a'
b = 'str_b'
set_object = {a, b, 'c'}
list_object = [a, b, 'c']

Как видно, ни список, ни множество не ссылаются на ссылки, а сразу обращаются к объекту в памяти.


Итак, вернемся к пункту №2 - функции set, с помощью которой было создано множество.

Множество можно создать несколькими способами:

1) Функция set()

#set()
set_object = set('abc')
print(y)

Консоль нам введет следующее:

{'c', 'a', 'b'}

На вход принимает пустое значение или итерируемый объект и преобразует его посимвольно.

Фигурные скобки - один из признаков того, что мы наблюдаем множество.
Обратите внимание - коллекция значений не упорядочена, строка 'abc' на входе преобразована в 'c', 'a', 'b' на выходе.

2) При помощи литерала с фигурными скобками {}:

set_object = {a, b, 'c'}
print(set_object)

Принимает на вход любое количество аргументов и не меняет их.

3) Как и в случае со списком (list) через генератор:

set_object = {i for i in range(5)}
print(set_object)

Вывод:

{0, 1, 2, 3, 4}

Разберем методы множества с примерами.

1) add() - добавляет новый элемент в множество:

#set.add()
set_object = {1, 2, 3, 4}
print(set_object)

set_object.add(5)
print(set_object)

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

2) clear() - очищает содержимое множества:

#set.clear()
set_object = {1, 2, 3, 4}
set_object.clear()
print(set_object)

Вывод:

set()

3) copy() - создает копию множества:

#set.copy()
set_object = {1, 2, 3, 4}
set_obj2 = {}
set_obj2 = set_object.copy()
print(set_obj2)

Вывод:

{1, 2, 3, 4}

4) difference() - возвращает разность двух или более множеств в качестве нового множества.

#set.difference()
set_object_1 = {1, 2, 3, 4}
set_object_2 = {3, 4, 5, 6, 7}
set_object_3 = {6, 7, 8, 9}


tmp = set_object_1.difference(set_object_2)
tmp2 = set_object_1.difference(set_object_3 )
tmp3 = set_object_1.difference(set_object_2, set_object_3 )

print(tmp) # {1, 2} в set_object_2 нет 1 и 2
print(tmp2) # {1, 2, 3, 4} в set_object_3 нет {1, 2, 3, 4}
print(tmp3) # {1, 2}  в set_object_3 нет {1, 2, 3, 4}, а в set_object_2 нет 1 и 2

Вывод:

#в set_object_2 нет 1 и 2
{1, 2}
# в set_object_3 нет {1, 2, 3, 4}
{1, 2, 3, 4}
# в set_object_3 нет {1, 2, 3, 4}, а в set_object_2 нет 1 и 2
{1, 2}

5) difference_update(...) - удаляет элементы одного множества из другого, если есть совпадения:

#set.difference_update()
set_object_1 = {1, 2, 3, 4, 9}
set_object_2 = {3, 4, 5, 6, 7}
set_object_3 = {6, 7, 8, 9}

set_object_1.difference_update(set_object_2, set_object_3)

print(set_object_1)

Вывод:

{1, 2}

6) discard() - удалить элемент из множества, если он там есть.
* если искомый объект в множетсве отсутствует - не вызывается ошибка исключения

#set.discard()
set_object_1 = {1, 2, 3, 4, 9}
set_object_1.discard(3)

print(set_object_1)

Вывод:

{1, 2, 4, 9}

7) intersection() - возвращает пересекающиеся значения двух множеств в виде нового множества:

#set.intersection()
set_object_1 = {1, 2, 3, 4, 9}
set_object_2 = {3, 4, 5, 6, 7}

tmp = set_object_1.intersection(set_object_2)

print(tmp)

Вывод:

{3, 4}

8) intersection_update() - перезаписать множество, поместив туда пересекающиеся значения с другим множеством:

#set.intersection_update()
set_object_1 = {1, 2, 3, 4, 9}
set_object_2 = {3, 4, 5, 6, 7}

set_object_1.intersection_update(set_object_2)

print(set_object_1)

Вывод:

{3, 4}

9) isdisjoint() - возвращает True или False в зависимости от того, нулевое и ли нет пересечение у двух множеств:

#set.isdisjoint()
set_object_1 = {1, 2, 3, 4, 9}
set_object_2 = {3, 4, 5, 6, 7}

print(set_object_1.isdisjoint(set_object_2))

Вывод:
False

10) issubset() - возвращает True, если одно множество полностью идентично второму:

#set.issubset()
set_object_1 = {1, 2, 3, 4, 9}
set_object_2 = {1, 2, 3, 4, 9}

print(set_object_1.issubset(set_object_2))

Вывод:

True

11) issuperset(iterable) - возвращает True, если часть множества и итерируемый объект iterable имеют полное пересечение с iterable:

#set.issuperset(iterable)
set_object_1 = {1, 2, 3, 4, 9}
set_object_2 = {1, 2}
list_object = [2, 3]
print(set_object_1.issuperset(set_object_2))
print(set_object_1.issuperset(list_object))

Вывод:

True
True

12) pop() - итерирует множество, удаляет элемент и возвращает его значение:

Вывод:

#set.pop()
set_object_1 = {1, 2, 3, 4, 9}
print(set_object_1.pop())
print(set_object_1.pop())
print(set_object_1.pop())
print(set_object_1.pop())
print(set_object_1.pop())

Вывод:

1
2
3
4
9

13) remove() - удаляет указанный элемент из множества, если таковой отсутствует - вызывает ошибку исключения:

#set.remove()
set_object_1 = {1, 2, 3, 4, 9}
set_object_1.remove(9)
print(set_object_1)
set_object_1.remove(4)
print(set_object_1)

Вывод:

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

14) symmetric_difference() - возвращает симметричную разницу между итерируемыми объектами в виде нового множества:

#set.symmetric_difference()
set_object_1 = {1, 6, 2, 3, 4, 9}
set_object_2 = {1, 2, 8}

print(set_object_1.symmetric_difference(set_object_2))
print(set_object_1.symmetric_difference([4,7, 99]))

Вывод:

{3, 4, 6, 8, 9}
{1, 2, 99, 3, 6, 7, 9}

15) symmetric_difference_update() - перезаписывает множество значением симметричной разницы между множеством и итериремым объектом:

#set.symmetric_difference_update()
set_object_1 = {1, 6, 2, 3, 4, 9}
set_object_2 = {1, 2, 8}

set_object_1.symmetric_difference_update(set_object_2)
print(set_object_1)
set_object_1.symmetric_difference_update([4,7, 99])
print(set_object_1)

Вывод:

{3, 4, 6, 8, 9}
{3, 99, 6, 7, 8, 9}

16) union() - возвращает объеденные в новое множество значения vмножества и итерируемого объета:

#set.union()
set_object_1 = {1, 6, 2, 3, 4, 9}
set_object_2 = {1, 2, 8}

tmp =  set_object_1.union(set_object_2)
print(tmp)

Вывод:

{1, 2, 3, 4, 6, 8, 9}


17) update() - объединяет множество и итерируемый объект:

#set.update()
set_object_1 = {1, 6, 2, 3, 4, 9}
set_object_1.update([77,88])
print(set_object_1)

{1, 2, 3, 4, 6, 9, 77, 88}