Множество — это неупорядоченная коллекция уникальных и неизменяемых элементов.
Особенности множества:
- В множестве содержатся только уникальные элементы, никаких дубликатов.
- Элементы множества неизменяемые, но само множество изменяемо.
- Элементы множества — неиндексируемы, а значит, здесь нет срезов.
Создание множества
Создание множества с помощью фигурных скобок
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'>
