Множества (set) в Python: основные методы, операции и функции

• 21.03.2022
• 1526
• Основы Python
• Типы данных
• Множества

Множество — это неупорядоченная коллекция уникальных и неизменяемых элементов.

Особенности множества:

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

Создание множества

Создание множества с помощью фигурных скобок

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

my_set = {'один', 'два', 'три', 'четыре', 'пять'}
print(my_set)
#{'пять', 'три', 'два', 'четыре', 'один'}

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

my_set = {2, 'три', (4, 5, 6)}
print(my_set)
#{2, 'три', (4, 5, 6)}

Создание множества с помощью функции set()

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

my_str = 'строка'
my_set = set(my_str)
print(my_set)
#{'к', 'о', 'р', 'с', 'а', 'т'}

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

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

my_str = 'математика'
my_set = set(my_str)
print(my_set)
#{'т', 'м', 'е', 'и', 'а', 'к'}

Создание множества из списка с помощью функции set():

my_list = [1, 2, 3, 4, 5, 2]
my_set = set(my_list)
print(my_set)
#{1, 2, 3, 4, 5}

Если нужно создать пустое множество, то нужно пользоваться функцией set():

my_set = {}
my_set_2 = set()
print(type(my_set))
print(type(my_set_2))
#<class 'dict'>
#<class 'set'>

Доступ к элементам множества через цикл

Так как множество — неиндексируемо, значит получить элемент по индексу нет возможности.
Но мы можем получить доступ к элементам, например через цикл:

my_set = {'один', 'два', 'три', 'четыре', 'пять'}
for item in my_set:
    print(item)
#пять
#четыре
#два
#один
#три

Проверка наличия элемента в множестве

Есть нужный элемент в множестве или нет можно проверить с помощью in:

my_set = {'один', 'два', 'три', 'четыре', 'пять'}
print('один' in my_set)
#True

Если элемента в множестве нет, получаем False:

my_set = {'один', 'два', 'три', 'четыре', 'пять'}
print('шесть' in my_set)
#False

Основные методы множества

Добавление элементов в множество: set.add(elem)

my_set = {'один', 'два', 'три', 'четыре', 'пять'}
my_set.add('шесть')
print(my_set)
#{'четыре', 'шесть', 'три', 'один', 'два', 'пять'}

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

Для этого есть несколько методов, рассмотрим каждый из них.

1) Удаление элемента из множества: set.remove(elem)
Если элемент есть в множестве, он будет удален, если его нет, то будет возвращена ошибка «KeyError»:

my_set = {'один', 'два', 'три', 'четыре', 'пять'}
my_set.remove('пять')
print(my_set)
#{'два', 'три', 'четыре', 'один'}

my_set = {'один', 'два', 'три', 'четыре', 'пять'}
my_set.remove('шесть')
print(my_set)
#builtins.KeyError: 'шесть'

2) Удаление элемента из множества: set.discard(elem)
Этот метод удобен когда вам не нужен возврат ошибки, в случае отсутствия элемента в множестве:

my_set = {'один', 'два', 'три', 'четыре', 'пять'}
my_set.discard('пять')
print(my_set)
#{'четыре', 'один', 'три', 'два'}

my_set = {'один', 'два', 'три', 'четыре', 'пять'}
my_set.discard('шесть')
print(my_set)
#{'один', 'пять', 'четыре', 'три', 'два'}

3) Удаление первого элемента из множества: set.pop()
Множества неупорядоченная коллекция, так что нельзя предугадать какой элемент будет удален:

my_set = {'один', 'два', 'три', 'четыре', 'пять'}
my_set.pop()
print(my_set)
#{'один', 'три', 'четыре', 'пять'}

Также метод set.pop() вместе с удалением возвращает элемент, который был удален:

my_set = {'один', 'два', 'три', 'четыре', 'пять'}
print(my_set.pop())
print(my_set)
#один
#{'четыре', 'три', 'два', 'пять'}

Удалить все элементы множества: set.clear()

my_set = {'один', 'два', 'три', 'четыре', 'пять'}
my_set.clear()
print(my_set)
#set()

Копировать множество: set.copy()

my_set = {'один', 'два', 'три', 'четыре', 'пять'}
x = my_set.copy()
print(x)
#{'два', 'четыре', 'один', 'три', 'пять'}

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

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

При объединении множеств a и b — получим новое множество, которое содержит все элементы множеств a и b.

Объединение с помощью оператора |:

a = {1, 2, 3}
b = {4, 5, 6}
print(a | b)
#{1, 2, 3, 4, 5, 6}

Объединение с помощью метода set.union():

a = {1, 2, 3}
b = {4, 5, 6}
print(a.union(b))
#{1, 2, 3, 4, 5, 6}

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

При пересечении множеств a и b — получим новое множество, в котором будут элементы, которые принадлежат обоим множествам.

Пересечение с помощью оператора &:

a = {1, 2, 3, 4, 5}
b = {4, 5, 6, 7, 8}
print(a & b)
#{4, 5}

Пересечение с помощью метода set.intersection():

a = {1, 2, 3, 4, 5}
b = {4, 5, 6, 7, 8}
print(a.intersection(b))
#{4, 5}

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

При разности множеств a и b — получим новое множество, элементы которого содержатся только в множестве a.
raznost.png

Разность с помощью оператора -:

a = {1, 2, 3, 4, 5}
b = {4, 5, 6, 7, 8}
print(a - b)
#{1, 2, 3}

Разность с помощью метода set.difference():

a = {1, 2, 3, 4, 5}
b = {4, 5, 6, 7, 8}
print(a.difference(b))
#{1, 2, 3}

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

При симметрической разности множеств a и b — получим новое множество, элементов, которые есть и в a и b, но не в обоих сразу.

Симметрическая разность с помощью оператора ^:

a = {1, 2, 3, 4, 5}
b = {4, 5, 6, 7, 8}
print(a ^ b)
#{1, 2, 3, 6, 7, 8}

Симметрическая разность с помощью метода set.symmetric_difference():

a = {1, 2, 3, 4, 5}
b = {4, 5, 6, 7, 8}
print(a.symmetric_difference(b))
#{1, 2, 3, 6, 7, 8}

Не пересекающиеся множества

Определяем являются ли множества не пересекающимися, т.е. они оба не содержат общих элементов.
Проверка выполняется методом set.isdisjoint():

a = {1, 2, 3, 4, 5}
b = {4, 5, 6, 7, 8}
print(a.isdisjoint(b))
#False

a = {1, 2, 3, 4, 5}
b = {6, 7, 8}
print(a.isdisjoint(b))
#True

Основные функции множеств

Длина множества: len(set)

my_set = {1, 2, 3}
print(len(my_set))
#3

Максимальный элемент в множестве: max(set)

my_set = {1, 2, 3}
print(max(my_set))
#3

Минимальный элемент в множестве: min(set)

my_set = {1, 2, 3}
print(min(my_set))
#1

Сумма элементов множества: sum(set)

my_set = {1, 2, 3}
print(sum(my_set))
#6

Отсортированный список из элементов множества: sorted(set)

my_set = {1, 4, 2, 3}
print(sorted(my_set))
#[1, 2, 3, 4]

Frozenset

Грубо говоря, это те же множества, но с одним нюансом, в них нельзя добавлять новые элементы. Т.е. Frozenset — неизменяемый тип данных.

my_set = {1, 2, 3}
my_fset = frozenset(my_set)
print(type(my_fset))
my_fset.add(4)
#builtins.AttributeError: 'frozenset' object has no attribute 'add'

Небольшой лайфхак

Простой способ удалить не уникальные (повторяющиеся) элементы.

Превратить список в множество (т.к. в множестве только уникальные элементы) и потом обратно с конвертировать в список:

my_list = [1, 2, 3, 1, 2, 3]
my_set = set(my_list)
my_list = list(my_set)
print(my_list)
print(type(my_list))
#[1, 2, 3]
#<class 'list'>