Множества в Python

В этом руководстве вы узнаете всё о множествах в Python: как их создавать, как добавлять и удалять элементы и т. д. 

Множество — неупорядоченный набор элементов. Каждый элемент в множестве уникален (т. е. повторяющихся элементов нет) и неизменяем. 

Само по себе множество можно изменять, то есть удалять или добавлять элементы. 

Множества удобно использовать для выполнения математических операций: объединение, пересечение, симметрическая разность и т. д. 

Как создать множество

Множество объявляется так: элементы помещаются в фигурные скобки {} и разделяются запятыми. Сделать это можно и с помощью встроенной функции set().

Внутри множества может быть любое количество элементов любого типа (целые числа, числа с плавающей точкой, кортежи, строки и т. д.). Внутрь множества нельзя помещать элементы изменяемых типов: списки, другие множества или словари

# Разные виды множеств
# Множество с целыми числами
my_set = {1, 2, 3}
print(my_set)

# Множество с разными типами данных
my_set = {1.0, "Привет", (1, 2, 3)}
print(my_set)

Вывод:

{1, 2, 3}
{1.0, (1, 2, 3), 'Привет'}
# Внутри множества не может быть одинаковых элементов
# Вывод: {1, 2, 3, 4}
my_set = {1, 2, 3, 4, 3, 2}
print(my_set)

# Аргументом функции set() может быть список
# Вывод: {1, 2, 3}
my_set = set([1, 2, 3, 2])
print(my_set)

# Внутри множества не может быть изменяемых объектов
# В этом множестве [3, 4] — изменяемый список
# Поэтому следующая строка вызовет ошибку

my_set = {1, 2, [3, 4]}

Вывод:

{1, 2, 3, 4}
{1, 2, 3}
Traceback (most recent call last):
 File "<string>", line 15, in <module>
   my_set = {1, 2, [3, 4]}
TypeError: unhashable type: 'list'

Создание пустого множество — дело хитрое. 

Пустые фигурные скобки {} — это словарь. Чтобы объявить пустое множество, нужно использовать функцию set() без аргументов

# Обратим внимание на объявление пустого множества

# Объявление с помощью {}
a = {}

# Проверка типа a
print(type(a))

# Объявление с помощью set()
a = set()

# Проверка типа a
print(type(a))

Вывод:

<class 'dict'>
<class 'set'>

Как изменять множество

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

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

Чтобы добавить один элемент, нужно использовать метод add(). Если нужно добавить несколько элементов — метод update(). Метод update() принимает в качестве аргументов кортежи, списки или другие множества. Во всех случаях следует избегать одинаковых элементов. 

# создаем my_set
my_set = {1, 3}
print(my_set)

# вызов my_set[0] приведет к ошибке
# TypeError: 'set' object does not support indexing

# добавляем элемент
# Вывод: {1, 2, 3}
my_set.add(2)
print(my_set)

# добавляем несколько элементов
# Вывод: {1, 2, 3, 4}
my_set.update([2, 3, 4])
print(my_set)

# добавляем список и множество
# Вывод: {1, 2, 3, 4, 5, 6, 8}
my_set.update([4, 5], {1, 6, 8})
print(my_set)

Вывод:

{1, 3}
{1, 2, 3}
{1, 2, 3, 4}
{1, 2, 3, 4, 5, 6, 8}

Как удалять элементы из множества 

Определенный элемент множества можно удалить с помощью методов discard() и remove().

Разница между ними вот в чем. Если элемент, который вы хотите удалить с помощью discard(), отсутствует в множестве — оно не изменится. А вот remove() вызовет ошибку, если элемента нет в множестве.

# разница между discard() и remove()

# создаем my_set
my_set = {1, 3, 4, 5, 6}
print(my_set)

# удаление элемента
# с помощью discard
# Вывод: {1, 3, 5, 6}
my_set.discard(4)
print(my_set)

# удаление элемента
# с помощью remove

# Вывод: {1, 3, 5}
my_set.remove(6)
print(my_set)

# удаление элемента,
# отсутствующего в my_set,
# с помощью discard
# Вывод: {1, 3, 5}
my_set.discard(2)
print(my_set)

# При удалении элемента,
# отсутствующего в my_set,
# с помощью remove
# вы получите ошибку.

# Вывод: KeyError

my_set.remove(2)

Вывод:

{1, 3, 4, 5, 6}
{1, 3, 5, 6}
{1, 3, 5}
{1, 3, 5}
Traceback (most recent call last):
 File "<string>", line 28, in <module>
KeyError: 2

Удалить и вернуть элемент мы можем с помощью метода pop().

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

Удалить все элементы из множества можно с помощью метода clear().

# cоздаем my_set
# Вывод: множество уникальных элементов
my_set = set("Приветмир")
print(my_set)

# pop элемента
# Вывод: случайный элемент
print(my_set.pop())

# pop еще одного элемента
my_set.pop()
print(my_set)

# очищаем my_set
# Вывод: set()
my_set.clear()
print(my_set)

Вывод:

{'П', 'и', 'р', 'т', 'е', 'м', 'в'}
П
{'р', 'т', 'е', 'м', 'в'}
set()

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

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

Рассмотрим два множества и проведем с ними разные операции.

A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}

Объединение

Результат бъединения A и B — множество, содержащее в себе все элементы множеств A и B.

Операцию объединения можно произвести двумя способами: с помощью оператора | и метода union()

# Операция объединения двух множеств
# Создаем множества A и B
A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}

# Используем оператор | 
# Вывод: {1, 2, 3, 4, 5, 6, 7, 8}
print(A | B)

Вывод: 

{1, 2, 3, 4, 5, 6, 7, 8}

Попробуйте ввести следующие примеры в консоль:

# используем функцию union
>>> A.union(B)
{1, 2, 3, 4, 5, 6, 7, 8}

# используем функцию union с B
>>> B.union(A)
{1, 2, 3, 4, 5, 6, 7, 8}

Пересечение

Результат пересечения A и B — множество, которому принадлежат те и только те элементы, которые одновременно принадлежат всем данным множествам

Операцию объединения можно произвести двумя способами: с помощью оператора & и метода intersection().

# Пересечение множеств
# Создаем множества A и B
A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}

# Используем оператор & 
# Вывод: {4, 5}
print(A & B)

Вывод:

{4, 5}

Попробуйте ввести следующие примеры в консоль:

# использование метода intersection с A
>>> A.intersection(B)
{4, 5}

# использование метода intersection с B
>>> B.intersection(A)
{4, 5}

Разность

Результат разности множеств B и A — множество элементов, содержащихся только в A. Следовательно, B-A = множество элементов, содержащихся только в B. 

Операцию объединения можно произвести двумя способами: с помощью оператора - и метода difference().

# Разность двух множеств
# Создаем множества A и B
A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}

# Используем оператор - с A
# Вывод: {1, 2, 3}
print(A - B)

Вывод:

{1, 2, 3}

Попробуйте ввести следующие примеры в консоль:

# Использование функции difference с A
>>> A.difference(B)
{1, 2, 3}

# Использование оператора - с B
>>> B - A
{8, 6, 7}

# Использование функции difference с  B
>>> B.difference(A)
{8, 6, 7}

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

Результат симметрической разности множеств A и B — множество элементов, содержащихся и в A, и в B, но не в обоих сразу. Иначе говоря, исключается только пересечение множеств. 

Операцию объединения можно произвести двумя способами: с помощью оператора ^ и метода symmetric_difference().

# Симметрическая разность множеств A и B
# Создаем множества A и B
A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}

# Используем оператор ^ 
# Вывод: {1, 2, 3, 6, 7, 8}
print(A ^ B)

Вывод:

{1, 2, 3, 6, 7, 8}

Попробуйте ввести следующие примеры в консоль:

# Использование функции symmetric_difference с A
>>> A.symmetric_difference(B)
{1, 2, 3, 6, 7, 8}

# Использование функции symmetric_difference с B
>>> B.symmetric_difference(A)
{1, 2, 3, 6, 7, 8}

Методы множеств

У множеств много методов, некоторые мы уже обсудили выше. Вот полный список методов объекта set

Метод

Описание

add()

Добавляет элемент в множество

clear()

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

copy()

Возвращает копию множества

difference()

Возвращает новое множество — разность двух или более множеств

difference_update()

Удаляет все элементы одного набора из другого

discard()

Удаляет элемент, если он содержится в множестве (если элемента в множестве нет, то ничего не происходит)

intersection()

Возвращает новое множество — пересечение двух множеств

intersection_update()

Добавляет в множество пересечение с другим множеством или с самим собой

isdisjoint()

Возвращает True, если два множества не имеют пересечения

issubset()

Возвращает True, если определенное множество содержится в другом множестве

issuperset()

Возвращает True, если в множестве есть другое множество 

pop()

Удаляет и возвращает случайный элемент множества. Если множество пусто, то возвращает ошибку KeyError

remove()

Удаляет определенный элемент множества. Если элемент отсутствует в множестве, то возвращает ошибку KeyError

symmetric_difference()

Возвращает новое множество — симметрическую разность двух множеств

symmetric_difference_update()

Добавляет в множество симметрическую разницу с другим множеством или с самим собой

union()

Возвращает новое множество — объединение множеств

update()

Добавляет в множество объединение с другим множеством или с самим собой

Несколько операций со множествами

Проверка на вхождение 

Мы можем проверить, есть ли элемент в множестве. Сделать это можно с помощью ключевого слова in.

# Использование ключевого слова in 
# Создаем множество my_set
my_set = set("яблоко")

# Проверяем, есть ли 'о' в множестве
# Вывод: True
print('о' in my_set)

# Проверяем, отсутствует ли 'к' в множестве
# Output: False
print('к' not in my_set)

Вывод:

True
False

Итерирование по множеству

Множество можно перебрать с помощью цикла for.

for letter in set("яблоко"):
    print(letter) 

Вывод:

я
о
л
к
б

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

Функция

Описание

all()

Возвращает True, если все элементы множества истинны или множество пустое

any()

Возвращает True, если хоть один элемент множества истинен. Если множество пустое, возвращает False

enumerate()

Возвращает перечисляемый объект. В нем в виде пар содержатся значения и индексы всех элементов множества

len()

Возвращает длину (количество элементов) множества 

max()

Возвращает наибольший элемент множества

min()

Возвращает наименьший элемент множества

sorted()

Возвращает отсортированный список, в котором находятся элементы множества (само множество не сортируется)

sum()

Возвращает сумму всех элементов множества

Frozenset

Frozenset — класс, имеющий характеристики множества. Отличие состоит в том, что frozenset после объявления неизменяем.

Кортеж — неизменяемый список, frozenset — неизменяемое множество.

Множества изменяемы, поэтому не могут использоваться в качестве ключей словаря. Frozenset же неизменяемы — их можно использовать в качестве ключей словаря. 

Этот тип данных поддерживает следующие методы: copy(), difference(), intersection(), isdisjoint(), issubset(), issuperset(), symmetric_difference() и union(). Так как он неизменяем, методы add() и remove() с ним не работают. 

# Frozenset
# Создаем множества A и B
A = frozenset([1, 2, 3, 4])
B = frozenset([3, 4, 5, 6])

Попробуйте ввести следующие примеры в консоль:

>>> A.isdisjoint(B)
False

>>> A.difference(B)
frozenset({1, 2})

>>> A | B
frozenset({1, 2, 3, 4, 5, 6})

>>> A.add(3)
...
AttributeError: 'frozenset' object has no attribute 'add'
```

 

codechick

СodeСhick.io - простой и эффективный способ изучения программирования.

2024 ©