Python 3. Множества
Свойства множеств
Я уже писал про последовательности и множества
в Python 3. Множество (set) — это неупорядоченная совокупность уникальных объектов. Это значит, что:
- в множестве не может быть дубликатов;
- у элементов нет порядка и индексов;
- множество можно изменять: добавлять в него объекты и удалять их.
Создать множество можно с помощью фигурных скобок. От словаря оно отличается тем, что внутри перечисляются только значения, без ключей. Ниже показано, как создать множество и получить его тип и длину:
my_set = {1, 2, 3, 4, 5} # создание множества
print(type(my_set)) # тип
print(len(my_set)) # количество элементов
print(my_set)
Исполнение:
<class 'set'>
5
{1, 2, 3, 4, 5}
Так как множество неупорядоченное, то обращение по индексу, срезы, конкатенация и повторoение с ним не работают. Порядок элементов при выводе тоже нельзя считать гарантированным: в разных версиях Python и при разных запусках он может отличаться.
Множества чаще всего используют для двух задач:
- удаление дубликатов;
- проверка, входит ли элемент в набор (поиск в множестве выполняется очень быстро, даже если в нём миллионы элементов).
Создание множества
Непустое множество создаётся с помощью фигурных скобок, как мы уже видели. А вот пустое множество так создать нельзя, потому что {} в Python — это пустой словарь:
Код:
a = {}
print(type(a))
b = set()
print(type(b))
Исполнение:
<class 'dict'>
<class 'set'>
Поэтому пустое множество создаётся только с помощью функции set().
Функция set() умеет создавать множество из любого итерируемого объекта: списка, кортежа, строки и т. д. При этом все повторяющиеся значения сразу пропадут:
Код:
nums = [1, 2, 2, 3, 3, 3]
print(set(nums))
Исполнение:
{1, 2, 3}
Добавление элементов
Добавить один элемент в множество можно с помощью метода add(). Если такой элемент уже есть, то ничего не произойдёт и ошибки не будет:
Код:
my_set = {1, 2, 3}
my_set.add(4)
my_set.add(4) # такой элемент уже есть, множество не изменится
print(my_set)
Исполнение:
{1, 2, 3, 4}
Одно множество можно соединить с другим с помощью метода update():
Код:
my_set1 = {1, 2, 3, 4, 5}
my_set2 = {3, 4, 5, 6, 7}
my_set1.update(my_set2)
print(my_set1)
Исполнение:
{1, 2, 3, 4, 5, 6, 7}
Метод update() принимает не только множества, но и любые итерируемые объекты: списки, кортежи и т. д. Причём можно передать сразу несколько:
Код:
my_set = {1, 2, 3}
my_set.update([3, 4], (5, 6))
print(my_set)
Исполнение:
{1, 2, 3, 4, 5, 6}
Как видно из результата, повторяющиеся значения, которые мы добавляем в множество, игнорируются.
Удаление элементов
Удалить конкретный элемент можно с помощью методов remove() и discard(). Они отличаются тем, что происходит при удалении несуществующего элемента:
remove()— выдаст ошибкуKeyError;discard()— ничего не удалит, но и ошибки не будет.
Сначала удалим существующие элементы:
Код:
my_set = {1, 2, 3, 4, 5}
my_set.remove(1)
my_set.discard(3)
print(my_set)
Исполнение:
{2, 4, 5}
Теперь попробуем удалить несуществующий элемент методом remove():
Код:
my_set = {1, 2, 3, 4, 5}
my_set.remove(6)
print(my_set)
Исполнение:
KeyError: 6
И тот же пример с методом discard():
Код:
my_set = {1, 2, 3, 4, 5}
my_set.discard(6)
print(my_set)
Исполнение:
{1, 2, 3, 4, 5}
Если вам не важно, что именно удалить, то можно воспользоваться методом pop(). Он удаляет из множества произвольный элемент и возвращает его. Так как порядка в множестве нет, предсказать, какой элемент будет удалён, нельзя. Если множество пустое, то pop() выдаст ошибку KeyError.
Чтобы удалить все элементы сразу, используйте метод clear():
Код:
my_set = {'a', 'x', 'y'}
x = my_set.pop() # какой именно элемент удалится — заранее неизвестно
print(x, my_set)
my_set.clear()
print(my_set)
Исполнение:
x {'y', 'a'}
set()
У вас результат pop() может отличаться, и это нормально.
Операции над множествами
Над множествами можно выполнять операции из теории множеств: пересечение, объединение, разность и симметричную разность. Они показаны на следующем рисунке:

Эти же операции в виде кода:
Код:
my_set1 = {1, 5, 9, 6, 4}
my_set2 = {6, 5, 1, 8, 2}
# Пересечение (элементы, которые есть в обоих множествах)
print(my_set1 & my_set2)
# Объединение (все элементы из обоих множеств)
print(my_set1 | my_set2)
# Симметричная разность (элементы, которые есть только в одном из множеств)
print(my_set1 ^ my_set2)
# Разность (элементы первого множества, которых нет во втором)
print(my_set1 - my_set2)
print(my_set2 - my_set1)
Исполнение:
{1, 5, 6}
{1, 2, 4, 5, 6, 8, 9}
{2, 4, 8, 9}
{9, 4}
{8, 2}
У каждой операции есть и метод-аналог:
| Операция | Оператор | Метод |
|---|---|---|
| Пересечение | & | intersection() |
| Объединение | | | union() |
| Симметричная разность | ^ | symmetric_difference() |
| Разность | - | difference() |
Код:
my_set1 = {1, 5, 9, 6, 4}
my_set2 = {6, 5, 1, 8, 2}
print(my_set1.intersection(my_set2))
print(my_set1.union(my_set2))
print(my_set1.symmetric_difference(my_set2))
print(my_set1.difference(my_set2))
Исполнение:
{1, 5, 6}
{1, 2, 4, 5, 6, 8, 9}
{2, 4, 8, 9}
{9, 4}
Результат тот же. Главное различие в том, что операторы работают только с множествами, а методы принимают любые итерируемые объекты, например список: my_set1.union([10, 11]).
Сравнение множеств
Множества можно сравнивать между собой:
<=илиissubset()— является ли множество подмножеством другого (все его элементы есть в другом множестве);>=илиissuperset()— является ли множество надмножеством другого (содержит все его элементы);isdisjoint()— проверяет, что у множеств нет общих элементов.
Код:
x = {1, 2}
y = {1, 2, 3}
z = {7, 8}
print(x <= y) # x — подмножество y
print(x.issubset(y)) # то же самое
print(y >= x) # y — надмножество x
print(y.issuperset(x)) # то же самое
print(x.isdisjoint(z)) # нет общих элементов x и z
print(x.isdisjoint(y)) # нет общих элементов x и y
Исполнение:
True
True
True
True
True
False
Проверка вхождения элемента
Проверка на то, входит ли элемент в множество, выполняется с помощью оператора in:
Код:
my_set = {15, 85, 12, 55, 95, 87, 33}
print(95 in my_set)
print(11 in my_set)
Исполнение:
True
False
Именно эта проверка в множествах работает намного быстрее, чем в списках. Для списка Python вынужден перебирать элементы по очереди, а множество находит нужный элемент почти мгновенно.
Какие элементы можно хранить в множестве
Множество вычисляет хеш-код для каждого элемента, поэтому в нём могут храниться только хешируемые объекты. В Python изменяемые объекты (список, словарь, множество) не хешируемы. То есть такое множество создать нельзя:
Код:
my_set = {[1, 2, 3], ["один", "два"]}
Исполнение:
TypeError: unhashable type: 'list'
А такое можно, потому что кортежи неизменяемые:
Код:
my_set = {(1, 2, 3), ("один", "два")}
print(my_set)
Исполнение:
{('один', 'два'), (1, 2, 3)}
Порядок элементов у вас может отличаться, о чём я говорил выше.
Из этого следует, что множество не может быть элементом другого множества. Но если очень нужно, то можно воспользоваться frozenset — это неизменяемое множество. Его нельзя изменить после создания, зато оно хешируемое:
Код:
f = frozenset([1, 2, 3])
print(f)
f.add(4)
Исполнение:
frozenset({1, 2, 3})
AttributeError: 'frozenset' object has no attribute 'add'
Теперь frozenset можно положить в обычное множество:
Код:
my_set = {frozenset({1, 2}), frozenset({3})}
print(my_set)
Исполнение:
{frozenset({3}), frozenset({1, 2})}
Удаление дубликатов из списка
Самый частый способ применения множеств — это удаление дубликатов из списка. Достаточно преобразовать список в множество, а потом обратно в список:
Код:
names = ["b", "a", "b", "c", "a"]
unique = list(set(names))
Но у этого способа есть недостаток: порядок элементов не сохраняется. Если порядок важен, то можно воспользоваться словарём. Словари в Python запоминают порядок добавления ключей, а ключи не могут повторяться:
Код:
names = ["b", "a", "b", "c", "a"]
print(list(dict.fromkeys(names)))
Исполнение:
['b', 'a', 'c']
Каждый элемент остался в единственном экземпляре, и порядок первых вхождений сохранился.
Особенности сравнения элементов
Множество считает элементы одинаковыми, если они равны (==) и у них одинаковый хеш. В Python 1, 1.0 и True равны между собой, поэтому в множестве останется только один из них:
Код:
print({1, True, 1.0})
Исполнение:
{1}
Это нужно помнить, если вы храните в одном множестве числа и логические значения.
Если понравилась статья, подпишись на мой канал в VK или Telegram .