Чем отличаются set и frozenset python

Python: Set/Frozenset (Множество)

Множество (класс set) — это контейнер, который содержит уникальные не повторяющиеся элементы в случайном порядке (неупорядоченная коллекция).

Что значит неупорядоченная? Это значит, что два множества эквивалентны, если содержат одинаковые элементы.

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

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

 mySet = # выводится в любом случайном порядке print(mySet) #

Но таким способом нельзя создать пустое множество, вместо него будет создан пустой словарь.

 wrong_empty_set = <> print(type(wrong_empty_set)) #

Для создания пустого множества нужно непосредственно использовать set():

 correct_empty_set = set() print(type(correct_empty_set)) #

Также в set() можно передать какой-либо объект, по которому можно пройтись (Iterable):

 color_list = ["red", "green", "green", "blue", "purple", "purple"] color_set = set(color_list) print(color_set) # порядок может быть другим #

Число элементов вычисляется через len().

Существует ограничение, что элементами множества (как и ключами словарей) в Python могут быть только так называемые хешируемые (Hashable) объекты. Это обусловлено тем фактом, что внутренняя реализация set основана на хеш-таблицах. Например, списки и словари – это изменяемые объекты, которые не могут быть элементами множеств. Большинство неизменяемых типов в Python (int, float, str, bool, и т.д.) – хешируемые. Неизменяемые коллекции, например tuple, являются хешируемыми, если хешируемы все их элементы.

Проверить принадлежит ли какой-либо объект множеству можно с помощью оператора in.

 tremendously_huge_set = if "green" in tremendously_huge_set: print("Green is there!") else: print("Unfortunately, there is no green. ") 

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

 words = ['a', 'a', 'b', 'b', 'c', 'd', 'e'] mySet = set(words) print(str(mySet)) 

 colors = for color in colors: print(color) 

Два множества называются равными, если они состоят из одних и тех же элементов, порядок этих элементов не важен. Обратите внимание, что состав множеств отличается, но тем не менее они одинаковы (см. начало статьи).

 my_cats = your_cats = print(my_cats == your_cats) # True 

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

 even_numbers = odd_numbers = # Очевидно, что множества чётных и нечётных чисел не пересекаются if even_numbers.isdisjoint(odd_numbers): print("Множества не пересекаются!") # Множества не пересекаются! 

Подмножество множества S – это такое множество, каждый элемент которого является также и элементом множества S. Множество S в свою очередь является надмножеством исходного множества.

 # Множество чисел Фибоначчи меньших 100 fibonacci_numbers = # Множество натуральных чисел меньших 100 natural_numbers = set(range(100)) # Множество чисел Фибоначчи является подмножеством множества # натуральных чисел if fibonacci_numbers.issubset(natural_numbers): print("Подмножество!") # Вывод: Подмножество! # В свою очередь множество натуральных чисел является # надмножеством множества чисел Фибоначчи if natural_numbers.issuperset(fibonacci_numbers): print("Надмножество!") # Вывод: Надмножество! 

Пустое множество является подмножеством абсолютно любого множества. Само множество является подмножеством самого себя.

Другие методы: ‘clear’ (очистка множества), ‘copy’, ‘pop’ (удаляет первый элемент из множества. Так как множества не упорядочены, нельзя точно сказать, какой элемент будет первым), ‘remove’, ‘update’, ‘__bases__’, ‘__contains__’, ‘add’, ‘difference’, ‘difference_update’, ‘discard’, ‘intersection’ (пересечение), ‘intersection_update’, ‘isdisjoint’ (истина, если set и other не имеют общих элементов), ‘issubset’, ‘issuperset’, ‘symmetric_difference’, ‘symmetric_difference_update’, ‘union’ (объединение нескольких множеств).

У множеств можно находить объединение или пересечение элементов.

Объединение множеств – это множество, которое содержит все элементы исходных множеств. В Python есть несколько способов объединить множества.

 my_fruits = your_fruits = # Для объединения множеств можно использовать оператор `|`, # оба операнда должны быть объектами типа set our_fruits = my_fruits | your_fruits print(our_fruits) # Вывод (порядок может быть другим): # Также можно использовать метод union. # Отличие состоит в том, что метод union принимает не только # объект типа set, а любой iterable-объект you_fruit_list: list = list(your_fruits) our_fruits: set = my_fruits.union(you_fruit_list) print(our_fruits) # Вывод (порядок может быть другим):

Добавление элементов в множество можно рассматривать как частный случай объединения множеств за тем исключением, что добавление элементов изменяет исходное множество, а не создаёт новый объект.

 colors = # Метод add добавляет новый элемент в множество colors.add("purple") # Добавление элемента, который уже есть в множестве, не изменяет # это множество colors.add("red") print(colors) # Вывод (порядок может быть другим): # Метод update принимает iterable-объект (список, словарь, генератор и т.п.) # и добавляет все элементы в множество numbers = numbers.update(i**2 for i in [1, 2, 3]) print(numbers) # Вывод (порядок может быть другим):

Пересечение множеств – это множество, в котором находятся только те элементы, которые принадлежат исходным множествам одновременно.

 def is_prime(number: int) -> bool: """ Возвращает True, если number - это простое число """ assert number > 1 return all(number % i for i in range(2, int(number**0.5) + 1)) def is_fibonacci(number: int) -> bool: """ Возвращает True, если number - это число Фибоначчи """ assert number > 1 a, b = 0, 1 while a + b

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

 i_know: set = you_know: dict = < "Go": 0.4, "C++": 0.6, "Rust": 0.2, "Java": 0.9 ># Обратите внимание, что оператор `-` работает только # для объектов типа set you_know_but_i_dont = set(you_know) - i_know print(you_know_but_i_dont) # Вывод (порядок может быть другим): # Метод difference может работать с любым iterable-объектом, # каким является dict, например i_know_but_you_dont = i_know.difference(you_know) print(i_know_but_you_dont) # Вывод:

Удаление элемента из множества можно рассматривать как частный случай разности, где удаляемый элемент – это одноэлементное множество. Следует отметить, что удаление элемента, как и в аналогичном случае с добавлением элементов, изменяет исходное множество.

 fruits = # Удаление элемента из множества. Если удаляемого элемента # нет в множестве, то ничего не происходит fruits.discard("orange") fruits.discard("pineapple") print(fruits) # Вывод (порядок может быть другим): # Метод remove работает аналогично discard, но генерирует исключение, # если удаляемого элемента нет в множестве fruits.remove("pineapple") # KeyError: "pineapple" 

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

 non_positive = non_negative = # Обратите внимание, что оператор `^` может применяться # только для объектов типа set non_zero = non_positive ^ non_negative print(non_zero) # Вывод (порядок может быть другим):

Как видно из примера выше, число 0 принадлежит обоим исходным множествам, и поэтому оно не входит в результирующее множество. Для операции симметрической разности, помимо оператора ^, также существует два специальных метода – symmetric_difference и symmetric_difference_update. Оба этих метода принимают iterable-объект в качестве аргумента, отличие же состоит в том, что symmetric_difference возвращает новый объект-множество, в то время как symmetric_difference_update изменяет исходное множество.

 non_positive = non_negative = range(4) non_zero = non_positive.symmetric_difference(non_negative) print(non_zero) # Вывод (порядок может быть другим): # Метод symmetric_difference_update изменяет исходное множество colors = colors.symmetric_difference_update(["green", "blue", "yellow"]) print(colors) # Вывод (порядок может быть другим):

frozenset

frozenset — это неизменяемое множество.

Методы: ‘__name__’, ‘copy’, ‘__bases__’, ‘__contains__’, ‘difference’, ‘intersection’, ‘isdisjoint’, ‘issubset’, ‘issuperset’, ‘symmetric_difference’, ‘union’.

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

 setCat = set('кот') frozenCat = frozenset('кот') print(setCat == frozenCat) print(type(setCat)) # set print(type(frozenCat)) #frozenset setCat.add('э') # можем добавить print(setCat) frozenCat.add('e') # эта строка вызовет ошибку при компиляции 

#11 – Множества (set и frozenset)

Python содержит еще один формат списка, что позволяет хранить набор данных. Таким списком являются множества. В ходе урока мы научимся использовать множество «set», а также множество «frozenset».

Видеоурок

Множества схожи со списками, но имеют ряд отличий.

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

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

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

some_list = [12, 56, 91, 12] set(some_list) # Результат: 12, 56, 91

Также для множеств существует огромное количество операций, которые приведены ниже:

Frozenset

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

Весь код будет доступен после подписки на проект!

Задание к уроку

Необходимо оформить подписку на проект, чтобы получить доступ ко всем домашним заданиям

Большое задание по курсу

Вам необходимо оформить подписку на сайте, чтобы иметь доступ ко всем большим заданиям. В задание входит методика решения, а также готовый проект с ответом к заданию.
PS: подобные задания доступны при подписке от 1 месяца

Чем отличаются set и frozenset python

[Коллекции] Множества set и frozenset в Python: примеры и использование

21 марта 2023
Оценки статьи
Еще никто не оценил статью

Множества (Set) в Python — это неупорядоченные коллекции уникальных элементов, которые могут быть любого типа данных. В этой статье мы рассмотрим основные аспекты множеств set() и frozenset() в Python.

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

В Python множества создаются с помощью фигурных скобок <> , содержащих уникальные элементы, разделенные запятыми. Например:

# Создание множества my_set = 1, 2, 3, 4, 5> print(my_set) # 

Если вы хотите создать пустое множество, вы можете использовать функцию set() без аргументов:

# Создание пустого множества empty_set = set() print(empty_set) # set() 

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

В Python множества поддерживают множество операций, таких как объединение, пересечение, разность и симметрическая разность.

Ниже показаны часто используемые из методов:

Объединение множеств: оператор | или метод union() .

A = 1, 2, 3> B = 3, 4, 5> C = A | B print(C) # выведет 

Пересечение множеств: оператор & или метод intersection() .

A = 1, 2, 3> B = 3, 4, 5> C = A & B print(C) # выведет 

Разность множеств: оператор — или метод difference() .

A = 1, 2, 3> B = 3, 4, 5> C = A - B print(C) # выведет 

Симметрическая разность множеств: оператор ^ или метод symmetric_difference() .

A = 1, 2, 3> B = 3, 4, 5> C = A ^ B print(C) # выведет 

Примеры использования set в Python

Пример 1: Создание множества из списка

numbers = [1, 2, 3, 3, 4, 5, 5, 6] unique_numbers = set(numbers) print(unique_numbers) # 

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

set1 = 1, 2, 3, 4, 5> set2 = 4, 5, 6, 7, 8>  # Объединение множеств print(set1.union(set2)) # # Пересечение множеств print(set1.intersection(set2)) # # Разность множеств print(set1.difference(set2)) # # Симметрическая разность множеств print(set1.symmetric_difference(set2)) # 

Пример 3: Добавление и удаление элементов

fruits = "apple", "banana", "orange">  # Добавление элемента fruits.add("grape") print(fruits) # # Удаление элемента fruits.remove("banana") print(fruits) # 

Создание неизменяемого множества (frozenset) в Python

Синтаксис создания frozenset такой же, как и обычного set, только используется функция frozenset() вместо set() :

fruits = frozenset(["apple", "banana", "cherry"]) 

Основные отличия frozenset от set заключаются в том, что frozenset не может быть изменен после создания, включая добавление, удаление и изменение элементов. Поэтому, frozenset может быть использован в качестве ключа словаря, а set нет.

Примеры использования frozenset в Python

Пример 1: Создание и доступ к элементам frozenset

fruits = frozenset(["apple", "banana", "cherry"]) print(fruits) # Output: frozenset()  # Доступ к элементам frozenset for fruit in fruits:  print(fruit) # Output: # apple # banana # cherry 

Пример 2: Сравнение frozenset с set

fruits1 = frozenset(["apple", "banana", "cherry"]) fruits2 = set(["banana", "cherry", "orange"])  # Проверяем, содержится ли fruits1 в fruits2 print(fruits1.issubset(fruits2)) # Output: False  # Объединяем два множества fruits3 = fruits1.union(fruits2) print(fruits3) # Output: frozenset() 

Пример 3: Ключи словаря

fruit_counts = frozenset(["apple", "banana"]): 2, frozenset(["cherry"]): 3> print(fruit_counts) # Output: ): 2, frozenset(): 3> 

Таким образом, frozenset является неизменяемым аналогом set. Это может быть полезно, когда нужно использовать множество в качестве ключа словаря или когда необходимо сохранить множество в неизменяемом состоянии.

Заключение

В заключение, множества set() и frozenset() являются важным инструментом в Python для работы с уникальными и неупорядоченными коллекциями данных.

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

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

Оба типа множеств имеют свои особенности и применяются в разных ситуациях. Важно выбирать правильный тип множества для конкретной задачи.

Меню категорий

Загрузка категорий.

Множества в Python (set, frozenset)

Не слишком строгое определение множества, однако, с ним возникали проблемы даже у великих математиков.

В широком смысле, элементами множеств могут быть даже нематериальные вещи: чётные числа, несданные задачи по термодинамике, алгоритмы сортировки, любимые фильмы Юлии и Алексея и даже мысли об эклерах.

�� Возьмите в руки кота. Взяли? Хорошо. Теперь множество котов в ваших руках насчитывает ровно один мурлыкающий элемент. Если же пушистику вдруг не понравится, что вы его тискаете, и он выскочит из рук, то элементов внутри множества не останется. Множество, в котором нет ни одного элемента, называется пустым. Но что же там в Python?

Назначение в Python

Множества (set) в питоне появились не сразу, и здесь они представлены как неупорядоченные коллекции уникальных и неизменяемых объектов. Коллекции, которые не являются ни последовательностями (как списки), ни отображениями (как словари). Хотя с последними у множеств много общего.

Можно сказать, что set напоминает словарь, в котором ключи не имеют соответствующих им значений

• Дают возможность быстро удалять дубликаты, поскольку, по определению, могут содержать только уникальные элементы;
• Позволяют, в отличие от других коллекций, выполнять над собой ряд математических операций, таких как объединение, пересечение и разность множеств;

Пример set-ов в Python:

# множество натуральных чисел от 1 до 10 natural_num_set = # множество персонажей Братства Кольца the_fellowship_of_the_ring_set = # множество приближений math.sqrt(2) sqrt_approximation_set = # множество результатов какого-то голосования vote_result_set =

Особенности set

Одно из основных свойств множеств заключается в уникальности каждого из их элементов. Посмотрим, что получится, если сформировать set из строчки с заведомо повторяющимися символами:

strange_app = set(‘TikTok’) print(strange_app) >

Из результата были удалены дублирующиеся в слове ‘TikTok’ символы. Так множества в очередной раз доказали, что содержат в себе только уникальные элементы.

�� Немаловажным является и тот факт, что при литеральном объявлении, итерируемые объекты сохраняют свою структуру.

pangram_second = set(‘съешь же ещё этих мягких французских булок, да выпей чаю’) print(pangram_ second) # попить чаю с функцией set(), к сожалению, не выйдет >

Отдельное python множество может включать в себя объекты разных типов:

Здесь нет никакого противоречия с математической дефиницией, так как все составляющие we_are_the_py_objects имеют вполне конкретное общее свойство, являясь объектами языка Питон.

Но не стоит забывать и внутреннее определение set-ов. Важно помнить, что list-ы и dict-ы не подходят на роль элементов множества, из-за своей изменяемой природы.

glados = <['Great cake']>print(glados) > Traceback (most recent call last): glados = <['Great cake']>TypeError: unhashable type: ‘list’

Функция set() , тем не менее, корректно обрабатывает случаи, когда ей на вход подаются списки или словари.

# словарь будет преобразован во множество его ключей, значения отбрасываются some_dict = some_set = set(some_dict) print(some_set) > # элементы списка преобразуются в элементы множества, дубликаты удаляются card_suit = [‘heart’, ‘diamond’, ‘club’, ‘spade’, ‘spade’] suit_set = set(card_suit) print(suit_set) >

Однако в списках не должно быть вложенных изменяемых элементов.

tricky_list = [, ] sad_set = set(tricky_list) print(sad_set) > Traceback (most recent call last): sad_set = set(tricky_list) TypeError: unhashable type: ‘dict’

Работа с set-ами

Создание

Объявим Python-множество S . Существует два способа это сделать:

Способ №1 . Воспользовавшись литералом:

Способ №2 . Применив встроенную функцию set() :

Чтобы получить аналогичный результат, необходимо передать итерируемый объект (список, строку или кортеж) в качестве аргумента:

# объявим список L L = [‘1’, ‘2’, ‘3’] # и предоставим его в set() S_2 = set(L) print(S_2) # так как set — коллекция неупорядоченная, то результат вывода может отличаться > print(type(S_2)) >

�� Замечание: пустое множество создаётся исключительно через set()

empty_set = set() print(empty_set) > set() print(type(empty_set)) >

Если же сделать так:

another_empty_set = <> print(another_empty_set) > <> print(type(another_empty_set)) >

То получим пустой словарь. А если внутри фигурных скобок поместить пустую строку:

maybe_empty_set = print(maybe_empty_set) > print(type(maybe_empty_set)) >

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

# количество элементов множества print(len(maybe_empty_set)) > 1

Вполне естественно, что пустое множество, при приведении его к логическому типу, тождественно ложно:

true_or_false = set() print(bool(true_or_false)) > False

Пересечение

В программировании нередки задачи, в которых требуется найти совпадающие элементы двух коллекций. Классическое решение основано на цикле for , но нас интересует другое — то, что строится на использовании set-ов.

# пусть есть два списка, и нужно отыскать и вывести их одинаковые компоненты unbreakable_diamond = [‘Jotaro’, ‘Josuke’, ‘Koichi’] golden_wind = [‘Jotaro’, ‘Koichi’, ‘Giorno’] # & — здесь оператор пересечения overlap = set(unbreakable_diamond) & set(golden_wind) print(overlap) >

Добавление элемента

Для добавления нового элемента в существующий набор используем метод add(x) .

stats = stats.add(14.7) print(stats) >

Если среди исходных объектов, составляющих set, «x» уже был, то ничего не произойдёт, и начальное множество не изменится.

big_cats = big_cats.add(‘cheetah’) # это жестоко, но второго гепарда не появится print(big_cats) >

Удаление и очистка

Очистить и свести уже существующий сет к пустому не составит никаких проблем благодаря методу сlear() :

set_with_elements = print(set_with_elements) > set_with_elements.clear() print(set_with_elements) > set()

Для удаления одного единственного компонента из набора в Питоне определены аж три способа.

Способ №1 . Метод remove() . Метод удаляет элемент elem из set -а. В случае отсутствия elem в наборе интерпретатор выбрасывает исключение.

point_coord = <('x', 52.4), ('y', -5), ('z', 0.3)>print(point_coord) > <('y', -5), ('z', 0.3), ('x', 52.4)>point_coord.remove((‘x’, 52.4)) print(point_coord) > <('y', -5), ('z', 0.3)>point_coord.remove((‘z’, 11.8)) print(point_coord) > Traceback (most recent call last): point_coord.remove((‘z’, 11.8)) KeyError: (‘z’, 11.8)

Способ №2 . Метод discard() . Производит предельно схожую с remove() операцию с той лишь разницей, что, в случае отсутствия элемента в коллекции, исключение не возникает:

triangle_coord = <(0, 4), (3, 0), (-3, 0)>print(triangle_coord) > <(3, 0), (-3, 0), (0, 4)>triangle_coord.discard((0, 4)) print(triangle_coord) > <(3, 0), (-3, 0)>triangle_coord.discard((54, 55)) print(triangle_coord) >

Способ №3 . Метод pop() .

Удаляет и возвращает случайный элемент множества:

Перебор элементов

Множество, как и любую другую коллекцию, итерируем циклом for :

iterate_me = for num in iterate_me: print(num) > 1.1 1.4 1.3 1.2 1.5

Принадлежность объекта set-у

Оператор in даёт возможность проверить наличие элемента в наборе:

berry_club = print(‘Tomato’ in berry_club) > True print(‘Strawberry’ in berry_club) > False

Сортировка множеств

Операция сортировки отсутствует для множеств Python по определению. Множество — неупорядоченный набор. Но не нужно расстраиваться. С помощью функции sorted() , вы всегда можете получить отсортированный список:

some_digits = print(sorted(some_digits)) > [-4, 1, 2, 12, 14, 34, 55] cities = print(sorted(cities)) > [‘Архангельск’, ‘Белгород’, ‘Калининград’, ‘Москва’, ‘Новосибирск’, ‘Хабаровск’]

Длина множества

Размеры определенного set -а получаем функцией len() :

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

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

Объединение

(оператор | , логическое ИЛИ )

Объединением двух множеств «X» и «Y» является такое третье множество «Z», каждый элемент которого принадлежит либо множеству «X», либо «Y».

lang_X = <'C++', 'Perl', 'PHP'>lang_Y = lang_Z = lang_X.union(lang_Y) # или так lang_Z = lang_X | lang_Y print(lang_Z) >

Пересечение

(оператор & , логическое И )

Пересечением двух множеств «A» и «B» является такое третье множество «C», каждый элемент которого принадлежит и множеству «A», и множеству «B».

bats_enemies = sups_enemies = JL_enemies = bats_enemies.intersection(sups_enemies) # или так JL_enemies = bats_enemies & sups_enemies print(JL_enemies) >

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

Разностью двух множеств «O» и «P» является такое третье множество «S», каждый элемент которого принадлежит множеству «O» и не принадлежит множеству «P».

minuend = subtrahend = total = minuend.difference(subtrahend) # или так total = minuend — subtrahend print(total) >

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

Симметрической разностью двух множеств «M» и «N» является такое третье множество «L», каждый элемент которого принадлежит либо множеству «M», либо «N», но не их пересечению.

f_set = s_set = t_set = f_set.symmetric_difference(s_set) # или так t_set = f_set ^ s_set print(t_set) >

Помимо теоретико-множественных операций, в питоне существуют и сугубо утилитарные производные методы.

isdisjoint()

Метод определяет, есть ли у двух set-ов общие элементы:

it = ru = ukr = # вернет False, если множества пересекаются print(ukr.isdisjoint(it)) > True # и True, в противном случае print(ru.isdisjoint(it)) > False

В Python нет оператора, который бы соответствовал этому методу.

issubset()

Показывает, является ли «I» подмножеством «J» (Метод вернет True, если все элементы «I» принадлежат «J»):

solar_system = first_three_planets = poor_small_guy = emptyness = set() print(first_three_planets.issubset(solar_system)) # или так first_three_planets True print(poor_small_guy.issubset(solar_system)) # poor_small_guy False # как и в математике, пустое множество есть подмножество любого множества print(emptyness.issubset(solar_system)) # emptyness True # также любое множество является подмножеством самого себя print(poor_small_guy.issubset(poor_small_guy)) # poor_small_guy True

print(poor_small_guy.issubset(poor_small_guy)) # poor_small_guy < poor_small_guy >False

issuperset()

Показывает, является ли «F» надмножеством «G»:

print(solar_system.issuperset(first_three_planets)) # solar_system >= first_three_planets > True print(poor_small_guy.issuperset(solar_system)) # poor_small_guy >= solar_system > False # в сердечке Плутона лишь пустота… print(poor_small_guy.issuperset(emptyness)) # poor_small_guy >= emptyness > True

Особенности оператора строгого надмножества > идентичны таковым у < .

print(poor_small_guy > poor_small_guy) > False

И для него в языке Python тоже не существует соответствующего метода.

Квартет методов, которые присваивают set -у результат его объединения с другим множеством. «Другое множество» передаётся методу в качестве аргумента.

update()

Изменяет исходное множество по объединению:

dogs_in_first_harness = dogs_in_second_harness = dogs_in_second_harness.update(dogs_in_first_harness) # или так dogs_in_second_harness |= dogs_in_first_harness print(dogs_in_second_harness) >

intersection_update()

basin_measurements_west = basin_measurements_east = basin_measurements_west.intersection_update(basin_measurements_east) # или так basin_measurements_west &= basin_measurements_east print(basin_measurements_west) >

difference_update()

prices_may = prices_june = prices_may.difference_update(prices_june) # или так prices_may -= prices_june print(prices_may) >

symmetric_difference_update()

И, наконец, по симметрической разности:

his_bag = her_bag = her_bag.symmetric_difference_update(his_bag) print(her_bag) # или так her_bag ^= his_bag >

Свойства методов и операторов

Как показано выше, данные операции, за некоторым исключением, выполнятся двумя способами: при помощи метода или соответствующего ему оператора (например union() и оператор | ). Главным и основным их различием является то, что метод может принимать в качестве аргумента не только set , но и любой итерируемый объект, в то время, как оператор требует в качестве операндов наличие фактических множеств.

list_of_years = [2019, 2018, 2017] set_of_years = print(set_of_years.union(list_of_years)) > print(set_of_years | list_of_years) > Traceback (most recent call last):> print(set_of_years | list_of_years) TypeError: unsupported operand type(s) for |: ‘set’ and ‘list’

Но есть и сходства. Например, важным является то, что некоторые операторы и методы позволяют совершать операции над несколькими сетами сразу:

one = set(‘11111’) two = set(‘22222’) three = set(‘33333’) four = set(‘44444’) five = set(‘55555’) uni_set_v1 = one.union(two, three, four, five) print(uni_set_v1) > uni_set_v2 = one | two | three | four | five print(uni_set_v2) > es1 = es2 = es3 = # порядок выполнения операций слева —> направо print(es1 — es2 — es3) > print(es1.difference(es2, es3)) >

Тем интереснее, что оператор ^ симметрической разности позволяет использовать несколько наборов, а метод symmetric_difference() — нет.

tc1 = tc2 = tc3 = print(tc1 ^ tc2 ^ tc3) # вы же помните про порядок операций (слева-направо)? > print(tc1.symmetric_difference(tc2, tc3)) > Traceback (most recent call last): print(tc1.symmetric_difference(tc2, tc3)) TypeError: symmetric_difference() takes exactly one argument (2 given)

Преобразования

Конвертация строки во множество

Чтобы перевести строку во множество, достаточно представить её в виде литерала этого множества.

my_string = ‘Lorem ipsum dolor sit amet’ sting_to_set = print(sting_to_set) >

Конвертация списка во множество

Со списком подобный трюк не пройдет, но здесь на помощь спешит функция set() :

my_list = [2, 4, 8, 16, 32] list_to_set = set(my_list) print(list_to_set) >

Frozenset

Закончим статью описанием такой структуры данных, что максимально близка Python-множествам. Она называется Frozenset .

Frozen set -ы, по сути, отличаются от обычных лишь тем, что являются неизменяемым типом данных, в то время, как простой set возможно изменять.

ordinary_set = set() frozen_set = frozenset() print(ordinary_set == frozen_set) > True # на них также определены теоретико-множественные операции print(type(ordinary_set-frozen_set)) > # отличие кроется в неизменяемости ordinary_set.add(1) print(ordinary_set) > frozen_set.add(1) > Traceback (most recent call last): frozen_set.add(1) AttributeError: ‘frozenset’ object has no attribute ‘add’