Python объединение множеств: Множества (set и frozenset) | Python 3 для начинающих и чайников

Интерактивный учебник языка Python

1. Множества

Множество в языке Питон — это структура данных, эквивалентная множествам в математике. Множество может состоять из различных элементов, порядок элементов в множестве неопределен. В множество можно добавлять и удалять элементы, можно перебирать элементы множества, можно выполнять операции над множествами (объединение, пересечение, разность). Можно проверять принадлежность элемента множеству.

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

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

Задание множеств

Множество задается перечислением всех его элементов в фигурных скобках. Исключением явлеется пустое множество, которое можно создать при помощи функции set(). Если функции set передать в качестве параметра список, строку или кортеж, то она вернёт множество, составленное из элементов списка, строки, кортежа. Например:

A = {1, 2, 3}
A = set('qwerty')
print(A)

выведет {'e', 'q', 'r', 't', 'w', 'y'}.

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

A = {1, 2, 3}
B = {3, 2, 3, 1}
print(A == B)

выведет True, так как A и B — равные множества.

Каждый элемент может входить в множество только один раз. set('Hello') вернет множество из четырех элементов: {'H', 'e', 'l', 'o'}.

Работа с элементами множеств

Узнать число элементов в множестве можно при помощи функции len.

Перебрать все элементы множества (в неопределенном порядке!) можно при помощи цикла for:

primes = {2, 3, 5, 7, 11}
for num in primes:
    print(num)

Проверить, принадлежит ли элемент множеству можно при помощи операции in, возвращающей значение типа bool. Аналогично есть противоположная операция not in. Для добавления элемента в множество есть метод add:

A = {1, 2, 3}
print(1 in A, 4 not in A)
A.add(4)

Для удаления элемента x из множества есть два метода: discard и remove. Их поведение различается только в случае, когда удаляемый элемент отсутствует в множестве. В этом случае метод discard не делает ничего, а метод remove генерирует исключение

Наконец, метод pop удаляет из множества один случайный элемент и возвращает его значение. Если же множество пусто, то генерируется исключение KeyError.

Из множества можно сделать список при помощи функции list.

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

С множествами в питоне можно выполнять обычные для математики операции над множествами.

Ссылки на задачи доступны в меню слева. Эталонные решения теперь доступны на странице самой задачи.

Множества в Python — CodeChick

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

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

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

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

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

Множество объявляется так: элементы помещаются в фигурные скобки

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

# Разные виды множеств
# Множество с целыми числами
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()

# создаем 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.  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: 

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

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

Мы можем проверить, есть ли элемент в множестве. Сделать это можно с помощью ключевого слова 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) 

Вывод:

я
о
л
к
б

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

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'
```

Функция Union() в Python — GeeksforGeeks

Набор Python Метод Union() возвращает новый набор, содержащий все элементы исходного набора.

Объединение двух заданных множеств — это множество, содержащее все элементы обоих множеств. Объединение двух заданных множеств A и B — это множество, состоящее из всех элементов A и всех элементов B, таких, что ни один элемент не повторяется.

Символ для обозначения объединения множеств — ‘U’

Синтаксис: SET1.UNION (SET2, SET3, SET4….)

Параметры: Зеро или больше сет

Возврат: Возвращает набор, который представляет собой объединение всех наборов (набор1, набор2, набор3…) с набором1. Он возвращает копию set1, только если параметр не передан.

 A U B: {2, 4, 5, 6, 7, 8} 

 набор1 U набор2 : {2, 4, 5, 6, 7, 8}
набор1 U набор2 U набор3 : {2, 4, 5, 6, 7, 8, 9, 10} 

 набор1 U набор2 : {2, 4, 5, 6, 7, 8}
set1 U set2 U set3 : {2, 4, 5, 6, 7, 8, 9, 10} 

 set1 U set2 : {2, 4, 5, 6, 7, 8}
набор1 U набор2 U набор3 : {2, 4, 5, 6, 7, 8, 9, 10} 

 набор1 U набор2 : {2, 4, 5, 6, 7, 8}
набор1 U набор2 U набор3 : {2, 4, 5, 6, 7, 8, 9, 10} 

 A U B: {'za', 'ab' , 'dd', 'dz', 'ba', 'cd'} 

 setA = { "a", "b", "c"}
печать (набор)
# Добавляем элемент в набор
setA.добавить ("д")
печать (набор)
 

 {'c', 'b', 'a'}
{'в', 'г', 'б', 'а'}
 

 A ∪ B = {x: x ∈ A или x ∈ B}. Здесь x — элемент, присутствующий в обоих множествах, A и B.
 

 Если A = { 23, 453, 43, 66, 21} и B = { 43, 785, 12, 35, 23, 545}

Тогда A U B = {23, 453, 43, 66, 21, 43, 785, 12, 35, 545} 

 A.union(B) # Оператор 1
B.union(A) # Заявление 2
 

 A = {1, 2, 3, 4} #Set A
B = {2, 5, 6, 7} #Набор B
С = {7, 8, 9, 10} #Набор С
D = {11, 12, 13, 14} # Установить D

# Е = А У В
E = A.union(B) # Утверждение 1

# F = А У Б У С У Д
F = A.union(B, C, D) # Утверждение 2

print("A U B: " +str(E))
print("A U B U C U D: " +str(F))
 

 A U B: {1, 2, 3, 4, 5, 6, 7}
А У Б У Ц У Д: {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}