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

В этой статье я разбираю множества (set) в 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 .