Множества — один из базовых и в то же время мощных типов данных в языке программирования Python. Они позволяют хранить уникальные элементы без определенного порядка и выполнять различные операции: от объединения и пересечения до вычитания и проверки подмножеств. В этой статье мы подробно рассмотрим, что такое множества, как их создавать, изменять и использовать на практике.
Что такое множество в Python и как его создать
Множество в языке программирования Python — это неупорядоченная коллекция неизменяемых элементов. Сами элементы изменять нельзя, но можно изменять само множество, в которое эти элементы входят, добавляя новые элементы или удаляя ненужные. Создадим, к примеру, множество, состоящее из названий марок автомобилей. Это можно сделать так:
cars = {"Волга", "LADA", "Mercedes-Benz", "LADA"}
Или использовать для создания множества конструктор set:
cars = set(("Волга", "LADA", "Mercedes-Benz", "LADA"))
Как видно, одна из марок авто упоминается два раза. Выведем это множество в консоль и посмотрим, что получится. Вывод делаем при помощи функции print:
print(cars)
В консоли получим следующее:
{'Волга', 'Mercedes-Benz', 'LADA'}
Теперь все марки авто входят во множество только в единственном экземпляре. Это потому, что множество — коллекция не только неизменяемых, но и уникальных элементов. Дубликаты здесь невозможны. Неупорядоченность элементов можно заметить, если вызвать функцию print несколько раз: при каждом вызове порядок элементов может отличаться. Например, один из результатов может выглядеть так:
{'LADA', 'Mercedes-Benz', 'Волга'}
Или так:
{'Mercedes-Benz', 'LADA', 'Волга'}
Далее разберем вопрос о доступе к элементам множества.
Доступ к элементам
Так как элементы во множестве не упорядочены и не имеют индекса, то получить доступ к какому-то отдельному элементу не получится. Но зато можно перебрать все элементы множества при помощи цикла for:
cars = set(("Волга", "LADA", "Mercedes-Benz"))
for car in cars:
print(car)
Результат будет примерно такой:
LADA Волга Mercedes-Benz
Или же можно проверить наличие какого-либо элемента во множестве. Сделать это очень просто. Проверим наличие марки LADA во множестве cars:
print("LADA" in cars)
В консоли получим:
True
Это значит, что марка входит во множество. А если мы попытаемся проверить наличие, например, Оки во множестве cars:
print("Ока" in cars)
То получим такой ответ:
False
То есть, такой марки автомобилей в этом множестве нет.
Добавление элементов
Для добавления одного элемента во множество можно использовать метод add. Добавим в наше множество автомобилей марку Ока:
cars.add("Ока")
print(cars)
В консоли получим такой вывод:
{'Волга', 'Mercedes-Benz', 'LADA', 'Ока'}
А что делать, если нужно добавить сразу несколько элементов? Здесь на помощь придет метод update. Добавим с его помощью во множество cars еще две марки авто. Применим этот метод сразу после добавления Оки:
cars.add("Ока")
cars.update(["Volkswagen", "Renault"])
print(cars)
Результат:
{'Mercedes-Benz', 'Renault', 'Волга', 'LADA', 'Ока', 'Volkswagen'}
Как видим, все довольно просто.
Удаление элементов
Для удаления элементов из множества можно использовать метод discard. Удалим, например, Волгу из нашего множества cars:
cars = {"Волга", "LADA", "Mercedes-Benz"}
cars.discard("Волга")
print(cars)
Получим такой вывод:
{'Mercedes-Benz', 'LADA'}
Также для удаления элементов можно использовать метод remove:
cars = {"Волга", "LADA", "Mercedes-Benz"}
cars.remove("Волга")
print(cars)
Вывод в консоли будет такой же, как и в предыдущем случае. А в чем тогда разница между этими двумя методами? А разница в том, что, если удаляемый элемент не существует, то remove выдаст ошибку, тогда как discard просто выведет множество без изменений. Попробуем удалить несуществующую Оку из множества cars. Сначала применим метод remove:
cars.remove("Ока")
print(cars)
В консоли увидим примерно следующее:
Traceback (most recent call last):
File "/home/alex/OpenideProjects/sets/sets.py", line 3, in <module>
cars.remove("Ока")
KeyError: 'Ока'
Теперь применим метод discard:
cars.discard("Ока")
print(cars)
Получим:
{'LADA', 'Волга', 'Mercedes-Benz'}
Есть еще метод pop, который удаляет последний элемент множества. Но тут следует вспомнить, что множества в Python неупорядоченные и, следовательно, удаляться будет случайный элемент. Вот так можно применить этот метод к нашему множеству из трех авто:
car = cars.pop() print(car) print(cars)
В переменную car записывается удаляемый элемент. В консоль сначала выводится удаляемый элемент, а потом множество без этого элемента. Результат:
LADA
{'Волга', 'Mercedes-Benz'}
Еще один вариант результата:
Mercedes-Benz
{'LADA', 'Волга'}
Чтобы очистить множество, то есть удалить все его элементы, можно использовать метод clear:
cars.clear() print(cars)
Вывод будет таким:
set()
А чтобы полностью удалить множество можно воспользоваться ключевым словом del:
del cars print(cars)
Понятно, что в результате будет показано сообщение об ошибке, так как мы пытаемся вывести в консоль множество, которого уже не существует:
Traceback (most recent call last):
File "/home/alex/OpenideProjects/sets/sets.py", line 5, in <module>
print(cars)
^^^^
NameError: name 'cars' is not defined. Did you mean: 'vars'?
Идем дальше.
Операции над множествами
Множества в Python очень похожи на таковые из области дискретной математики. Их также можно объединять, пересекать, вычислять разность и тому подобное. Далее рассмотрим некоторые основные операции, которые можно производить над множествами в Python.
Объединение множеств
Допустим нам даны два числовых множества:
numbers1 = {1, 2, 3, 4}
numbers2 = {5, 6, 7, 8}
И стоит задача объединить эти множества. Это значит, что необходимо получить новое множество, в которое будут входить все элементы данных множеств. Сделать это можно при помощи метода union:
numbers = numbers1.union(numbers2) print(numbers)
Результат:
{1, 2, 3, 4, 5, 6, 7, 8}
Также для объединения множеств можно использовать оператор | :
numbers = numbers1 | numbers2 print(numbers)
Результат будет такой же. А что будет, если попытаться объединить два одинаковых множества? Давайте посмотрим:
numbers1 = {1, 2, 3, 4}
numbers2 = {1, 2, 3, 4}
numbers = numbers1 | numbers2
print(numbers)
В консоли получим следующее:
{1, 2, 3, 4}
Такой вывод мы получили потому, что элементы, входящие во множество, как уже говорилось, должны быть уникальными.
Пересечение множеств
Возьмем вот такие два множества:
numbers1 = {1, 2, 3, 4}
numbers2 = {3, 4, 7, 8}
И попробуем получить их пересечение. Нам снова нужно получить новое множество, но такое, в которое будут входить только общие для данных множеств элементы. Для этого можно применить метод intersection:
numbers = numbers1.intersection(numbers2) print(numbers)
В результате получим:
{3, 4}
Также вместо метода можно использовать оператор &:
numbers = numbers1 & numbers2 print(numbers)
Результат будет точно такой же. Теперь давайте посмотрим какой вывод мы получим, если попытаемся получить пересечение множеств, у которых нет общих элементов:
numbers1 = {1, 2, 3, 4}
numbers2 = {5, 6, 7, 8}
numbers = numbers1 & numbers2
print(numbers)
Получим следующее:
set()
Получили пустое множество.
Разность множеств
Даны два множества:
numbers1 = {1, 2, 3, 4}
numbers2 = {4, 5, 6, 7}
Требуется получить их разность. Разность множеств — это новое множество, которое содержит элементы присутствующие в одном множестве, но отсутствующие в другом. Эту разность можно получить с помощью метода difference:
umbers = numbers1.difference(numbers2) print(numbers)
Результат:
{1, 2, 3}
Этот же результат мы получим, если применим оператор – (минус) вместо указанного метода:
numbers = numbers1 - numbers2 print(numbers)
А что получится, если поменять множества местами? Мы должны получить множество состоящее из чисел 5, 6 и 7. Проверим, так ли это:
numbers = numbers2 - numbers1 print(numbers)
Результат:
{5, 6, 7}
Все верно! Получили в итоге, то, что ожидали.
Симметрическая разность множеств
Симметрическая разность двух множеств — это такое новое множество, которое содержит элементы присутствующие в одном из множеств, но не в обоих одновременно. Пусть даны такие два множества:
numbers1 = {1, 2, 3, 4}
numbers2 = {4, 5, 6, 7}
Получить их симметрическую разность можно при помощи метода symmetric_difference:
numbers = numbers1.symmetric_difference(numbers2) print(numbers)
В консоли получим следующий вывод:
{1, 2, 3, 5, 6, 7}
Этот же результат мы получим, если применим оператор ^ вместо приведенного выше метода:
numbers = numbers1 ^ numbers2 print(numbers)
В предыдущем подразделе мы для этих же множеств получили сначала разность {1, 2, 3}, а потом поменяли множества местами и получили разность {5, 6, 7}. То есть, симметрическую разность {1, 2, 3, 5, 6, 7} можно представить как объединение двух разностей с разным порядком исходных множеств. Понятно, что перемена множеств местами при получении симметрической разности результат не изменит. Проверим:
numbers = numbers2 ^ numbers1 print(numbers)
Результат:
{1, 2, 3, 5, 6, 7}
Вывод в консоли тот же, что и в прошлых примерах.
Проверка множеств
Пусть нам даны два таких множества:
numbers1 = {1, 2, 3, 4}
numbers2 = {1, 2, 3}
И требуется проверить является ли множество numbers2 подмножеством numbers1, то есть входит ли в его состав. Сделать это можно при помощи метода issubset:
is_subset = numbers2.issubset(numbers1) print(is_subset)
Получим такой вывод:
True
Это значит, что множество numbers2 является подмножеством numbers1. Еще есть метод issuperset. С его помощью можно проверить является ли одно множество НАДмножеством другого. Применим этот метод к вышеприведенным множествам:
is_superset = numbers1.issuperset(numbers2) print(is_superset)
Получим:
True
Также можно проверять множества на пересечение. Для примера возьмем пару таких множеств:
numbers1 = {1, 2, 3, 4}
numbers2 = {4, 5, 6}
Видим, что у этих множеств имеется один общий элемент (число 4), то есть они пересекаются. Проверить это можно при помощи метода isdisjoint:
is_disjoint = numbers1.isdisjoint(numbers2) print(is_disjoint)
В консоли получим:
False
Метод вернул нам значение False. Это значит, что множества пересекаются.
Замороженное множество
В языке Python также есть множества, которые нельзя изменять. Если в ранее рассмотренных множествах можно было добавлять или удалять элементы, то здесь такие операции невозможны. Создаются такие множества при помощи конструктора frozenset. Имя конструктора буквально означает «замороженное множество» (frozen переводится как «замороженный»). Возьмем для примера множество, состоящее из имен трех людей:
people = {"Юрий", "Мария", "Анна"}
И создадим из него неизменяемое множество:
fs_people = frozenset(people)
Теперь после такой заморозки мы даже не сможем добавить что-либо в это множество. Проверим это. Попробуем, например, добавить еще одного человека:
fs_people.add("Антон")
print(fs_people)
Получим такое сообщение об ошибке:
Traceback (most recent call last):
File "/home/alex/OpenideProjects/sets/sets.py", line 6, in <module>
fs_people.add("Антон")
^^^^^^^^^^^^^
AttributeError: 'frozenset' object has no attribute 'add'
Примерно такое же сообщение мы получим и при попытке удаления элементов из множества. Далее предлагаем выполнить небольшое задание.
Задание для самостоятельного выполнения
В университете проводится исследование о совмещении учебы и работы среди студентов. Для анализа собраны две группы людей:
- Студенты университета: Антон, Дмитрий и Сергей.
- Работающие специалисты: Антон, Дмитрий, Николай и Максим.
Как видно из списков, некоторые участники исследования совмещают учебу с работой.
Необходимо разработать программу, которая позволит:
- Определить полный список всех участников исследования.
- Выявить людей, которые одновременно являются и студентами, и работающими специалистами.
- Составить перечень студентов, которые не имеют официальной работы.
- Получить список людей, которые находятся только в одной из групп (либо студенты, либо работающие, но не оба статуса одновременно).
Решение
Для решения этой задачи нам потребуется создать два множества и произвести над ними основные операции:
# Создаем множества
students = {"Антон", "Дмитрий", "Сергей"}
employees = {"Антон", "Дмитрий", "Николай", "Максим"}
# 1. Находим всех людей в обеих группах (объединение множеств)
all_people = students.union(employees)
print("Все участники исследования:", all_people)
# 2. Находим людей, которые одновременно учатся и работают (пересечение множеств)
both_groups = students.intersection(employees)
print("\nЛюди, совмещающие учебу и работу:", both_groups)
# 3. Находим только студентов (разность множеств)
only_students = students.difference(employees)
print("\nТолько студенты:", only_students)
# 4. Находим людей, которые находятся только в одной группе (симметричная разность)
only_one_group = students.symmetric_difference(employees)
print("\nЛюди только в одной группе:", only_one_group)
Результат выполнения программы:
Все участники исследования: {'Сергей', 'Николай', 'Дмитрий', 'Максим', 'Антон'}
Люди, совмещающие учебу и работу: {'Антон', 'Дмитрий'}
Только студенты: {'Сергей'}
Люди только в одной группе: {'Сергей', 'Николай', 'Максим'}
