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

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

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

Видеоурок

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

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

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

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

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

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

Frozenset

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

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

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

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

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

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

Исчерпывающее руководство по множествам в Python

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

Инициализация множеств

Существует два способа создания объекта set : с использованием конструкции set(iterable) и путём помещения элементов, разделённых запятыми, в фигурные скобки — < . >. Если же при инициализации множества попытаться воспользоваться пустыми фигурными скобками — <> — тогда будет создан словарь, а не пустое множество. Для создания пустых множеств используется команда set() . Обратите внимание на то, что при инициализации множеств порядок элементов неважен, и на то, что дублирующиеся элементы в множество добавить не получится.

a = < "a", "b", "c", "d", "e", "f", "f" ># конструктору set можно передать любой итерируемый объект b = set(["a", "b", "c", "d", "e", "f"]) c = set(("a", "b", "c", "d", "e", "e", "f", "f")) # порядок элементов неважен d = set(["d", "e", "f", "a", "b", "c"]) # деструктурирование списка e = < *["a", "b", "c", "d", "e", "f"] >assert a == b == c == d == e # в одном множестве могут храниться значения разных типов f = set(["a", True, 123]) g = < "a", True, 123, True, 123 >assert f == g # set() - это множество, а <> - это словарь assert set() != <>

Какие элементы можно включить в состав множества? Это могут быть только элементы иммутабельных типов. Сюда входят такие типы, как float , int , string , bool и прочие подобные. А вот мутабельные типы — списки, словари, да и сами множества, в состав множеств включать нельзя. Если вас интересуют подробности о типах данных в Python — рекомендую почитать эту статью. Учитывая вышесказанное — следующая конструкция вызовет ошибку:

 < ["a", "b", "c"], True ># => TypeError: unhashable type: 'list'

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

Примечание об иммутабельности

Иммутабельность — это ограничение, касающееся лишь встроенных типов. На практике, чтобы объект можно было добавить в множество, или чтобы его можно было использовать в качестве ключа в словаре, этот объект всего лишь должен быть хешируемым. По умолчанию объекты пользовательских классов обладают хешем, основанным на их идентификаторах. Равенство объектов определяется по их идентификаторам. Это значит, что два объекта, идентичные в плане атрибутов, будут равны друг другу только тогда, когда они представляют один и тот же объект, или в том случае, если для них определён пользовательский оператор eq .

Если для некоего класса определён пользовательский оператор eq , то объекты этого класса перестают быть хешируемыми, если только для них не будет определён пользовательский оператор hash . Тут важно то, что если два объекта равны, то их хеши тоже должны быть равны. В противном случае при добавлении подобных объектов в словарь или в множество возникнут проблемы. Дело в том, что при проверке наличия значения в составе ключей словаря или в составе множества, проверяются и хеши и равенство объектов.

Единственный случай, когда в множестве имеет смысл хранить мутабельный объект, или когда такой объект может играть роль ключа словаря, это когда оператор проверки равенства объекта не использует его мутабельные атрибуты. Предположим, у некоего объекта имеется оператор равенства и соответствующая хеш-функция, основанные на атрибутах этого объекта. Если такой объект сначала добавить в множество, а потом поменять его, тогда хеш-значение, использованное при его сохранении, будет отличаться от текущего хеш-значения. Это — плохая практика.

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

Существует множество способов добавления элементов в множество. Для того чтобы осуществить изменение (мутацию) множества, отдельный элемент в него можно добавить командой .add() . Итерируемый объект добавляют командой .update() , или, что то же самое, используя оператор |= :

a = set() # добавление строкового элемента a.add("hello") # Следующий код НЕ эквивалентен предыдущему. # Метод update ожидает поступления итерируемого объекта, поэтому # строка рассматривается как итерируемый объект, содержащий символы # которые и добавляются в множество a.update("hello") assert a == < 'hello', 'h', 'e', 'l', 'o' ># А тут в множество добавляются две строки, так как они размещены в списке a.update(["hi", "world"]) assert a ==

Под «мутацией» я понимаю изменение исходного объекта. Есть ещё команды, которые не изменяют исходное множество. Например — метод . union() , или его эквивалент — оператор | :

a = < "a", "b" , "c" >b = < "a", "c", "d" >assert a | b == a.union(b) == < "a", "b", "c", "d" ># исходные объекты не изменились assert a == < "a", "b" , "c" >and b ==

Явное различие поведения методов .update() и .union() можно продемонстрировать, разобрав следующий пример:

def add_to_set1(a, b): a.update(b) return a def add_to_set2(a, b): a = a.union(b) return a a = < "a", "b" , "c" >b = < "a", "c", "d" ># Исходный объект был модифицирован # и будет равен возвращённому объекту assert a == add_to_set1(a, b) a = < "a", "b" , "c" >b = < "a", "c", "d" ># Исходный объект НЕ был модифицирован # и не будет равен возвращённому объекту assert a != add_to_set2(a, b)

И наконец — два множества можно конкатенировать, использовав деструктурирование:

a = < "a", "b" , "c" >b = < "a", "c", "d" >assert < *a, *b >==

Этот приём будет работать аналогично методу .union() , но я рекомендую пользоваться именно .union() .

Обратите внимание на то, что в предыдущих примерах я пользовался методом .update() , но в них можно было бы применить и оператор |= . Это значит, что a |= b ( .update() ) — это НЕ то же самое, что a = a | b (.union()) . Дело в том, что в первом фрагменте кода осуществляется изменение объекта, хранящегося в a , а во втором примере a назначается новое значение.

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

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

• Аналог .add() — .remove() .
• Аналог .update() — .difference_update() или -= .
• Аналог .union() — .difference() или — .

a = < "a", "b" , "c" >a.remove("b") assert a == < "a", "c" >a = < "a", "b" , "c" ># Так же, как .update(), эта команда ожидает итерируемый объект # В результате здесь удаляются "a" и "b", # а не целая строка "ab" a.difference_update("ab") assert a == < "c" >a = < "a", "b" , "c" >a.difference_update(["ab"]) # "ab" нет в составе элементов множества, поэтому ничего не удаляется assert a == < "a", "b", "c" ># Оператор -, эквивалент метода .difference(), # не модифицирует исходный объект a = < "a", "b" , "c" >b = a - < "b", "c" >assert a != b and b ==

Снова хочу обратить ваше внимание на то, что надо помнить о разнице между конструкциями вида a -= b (исходное множество изменяется) и a = a — b (исходное множество не изменяется).

Имеется и ещё несколько методов, которые могут пригодиться для удаления объектов:

• .clear() — очищает множество.
• .remove() — удаляет элемент лишь в том случае, если он существует (в противном случае выдаёт ошибку); .discard() — работает похожим образом, но, если элемента не существует, ошибку не возвращает.
• .pop() — удалит случайный элемент из множества и вернёт этот элемент.

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

Одна из сильных сторон Python-множеств заключается в наличии большого количества стандартных операций, предназначенных для работы с ними. Мы обсудили команды для модификации множеств путём добавления и удаления элементов, но это — далеко не всё, что можно делать с множествами.

Пересечение множеств

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

• Команды, при выполнении которых множество не меняется: .intersection() или & . Например — a.intersection(b) или a & b .
• Команды, при выполнении которых множество меняется: .intersection_update() или &= .

a = < "a", "b", "c" >b = < "b", "c", "d" >assert a & b ==

Симметрическая разность множеств или дизъюнктивное объединение

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

• Команды, при выполнении которых множество не меняется: . symmetric_difference() или ^ . Например — a.symmmetric_difference(b) или a ^ b .
• Команды, при выполнении которых множество меняется: .symmetric_difference_update() или ^= .

a = < "a", "b", "c" >b = < "b", "c", "d" >assert a ^ b ==

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

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

Проверка принадлежности элемента множеству

Вероятно, это — та операция, к которой вы будете прибегать чаще, чем к другим. Проверка наличия элемента в множестве выполняется с помощью оператора in . А проверка отсутствия элемента — с помощью оператора not in . Для таких операций над множествами, в отличие от подобных проверок, выполняемых в применении к спискам, характерна константная временная сложность — O(1). В результате, по мере роста размеров множества, не будет страдать скорость проверки наличия или отсутствия в нём неких элементов.

a = < "a", "b", "c" >assert "a" in a assert "d" not in a

Проверка того, является ли одно множество подмножеством другого

Множество является подмножеством другого множества в том случае, если все элементы первого множества входят в состав второго. Например, (A, B, C) — это подмножество (A, B, C, D) . В Python подобную проверку можно провести, воспользовавшись методом .issubset() или оператором = и > .

a = < "a", "b", "c" >b = < "a", "b" >assert a.issubset(b) == (a = b and a > b

Проверка того, что в двух множествах нет общих элементов

Если в множествах нет общих элементов, их называют непересекающимися множествами. В Python соответствующая проверка выполняется с помощью метода .isdisjoint() .

a = < "a", "b", "c" >b = < "a", "b" >c = < "d" ># без isdisjoint() assert len(a & c) == 0 and len(a & b) != 0 # с этим методом assert a.isdisjoint(c) and not a.isdisjoint(b)

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

Так же, как и в случае со списками и словарями, при работе с множествами можно воспользоваться так называемой абстракцией множеств (set comprehension). Делается это путём добавления обрабатываемого выражения в фигурные скобки и через возврат единственного мутабельного элемента на каждом проходе цикла: < for . in . > .

# преобразование списка в множество с добавлением 1 к каждому элементу assert < i+1 for i in [1, 2, 3, 4] >== < 2, 3, 4, 5 ># только чётные числа a = < i for i in range(10) if i % 2 == 0 >a.update(< -3, 100 >) # Преобразование множества в список с добавлением 1 к каждому элементу # ВНИМАНИЕ: перебирая множество, не рассчитывайте на то, что сохранится тот # порядок следования элементов, в котором они были в него добавлены print([i+1 for i in a]) # => [1, 3, 5, 101, 7, 9, -2]

Хранение в множествах данных более сложных типов

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

A -> B -> D D -> C -> E -> B

Потом надо быстро проверить, прошлись ли мы по определённому пути. Нужно, чтобы такая проверка проводилась бы быстро, поэтому совершенно естественным будет использовать для её реализации множество. Как это сделать, если список, из-за его мутабельности, нельзя добавить в множество? К нашему счастью, в подобных обстоятельствах можно воспользоваться кортежем, классом tuple , который, по сути, представляет собой иммутабельную версию списка. Рассмотрим пример.

Сначала создадим граф, используя словарь. Ключи словаря будут представлять узлы графа, а значения — списки узлов, в которые можно перейти из текущего узла.

# можно перейти от ключа к значениям graph =

Визуализировав это описание, я получил такой граф.

Если вы задаётесь вопросом о том, как я создал такой граф — знайте, что сделал я это, прибегнув к graphviz и написав следующий код:

from graphviz import Digraph dot = Digraph() for k in graph.keys(): dot.node(k, k) edges = [] for k, v in graph.items(): edges += [f"" for to in v] dot.edges(edges) dot.render(view=True)

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

import random def perform_random_walk(graph, n_steps): node = random.sample(list(graph), 1)[0] path = [node] for _ in range(n_steps): node = random.sample(graph[node], 1)[0] path.append(node) return tuple(path) paths = set() lengths = list(range(1, 10+1)) for _ in range(100): paths.add(perform_random_walk(graph, random.choice(lengths))) len(paths) # => 83

Из 100 случайных проходов по графу 83 оказались уникальными.

А что если нас не волнует порядок узлов, а нужно лишь сохранить сведения о посещённых узлах? Тогда будет смысл хранить отдельные пути в множествах, но, как уже было сказано, множества мутабельны, помещать их в другие множества нельзя. В такой ситуации, вместо обычных множеств, описываемых классом set , можно прибегнуть к неизменяемым множествам, представленным классом frozenset . Чтобы это сделать — поработаем с кодом цикла из предыдущего примера:

paths = set() lengths = list(range(1, 10+1)) for _ in range(100): path = perform_random_walk(graph, random.choice(lengths)) paths.add(frozenset(path)) len(paths) # => 21

Итоги

Множества — это полезный инструмент Python-разработчика. Они позволяют очень быстро выполнять определённые операции, что способно значительно повысить эффективность кода. Кроме того, в Python имеется немало простых и полезных методов для работы с множествами, применение которых способствует упрощению кода.

О, а приходите к нам работать? �� ��

Мы в wunderfund.io занимаемся высокочастотной алготорговлей с 2014 года. Высокочастотная торговля — это непрерывное соревнование лучших программистов и математиков всего мира. Присоединившись к нам, вы станете частью этой увлекательной схватки.

Мы предлагаем интересные и сложные задачи по анализу данных и low latency разработке для увлеченных исследователей и программистов. Гибкий график и никакой бюрократии, решения быстро принимаются и воплощаются в жизнь.

Сейчас мы ищем плюсовиков, питонистов, дата-инженеров и мл-рисерчеров.

Множества (Set)

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

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

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

Множество можно создать, заключив разделенные запятыми неизменяемые элементы в фигурные скобки <> . Python также предоставляет метод set() , который можно использовать для создания множества по переданной последовательности.

Пример 1: Использование фигурных скобок

Days = print(Days) print(type(Days)) print("looping through the set elements . ") for i in Days: print(i) 

  looping through the set elements . Friday Tuesday Monday Saturday Thursday Sunday Wednesday 

Пример 2: Использование метода set()

Days = set(["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]) print(Days) print(type(Days)) print("looping through the set elements . ") for i in Days: print(i) 

  looping through the set elements . Friday Wednesday Thursday Saturday Monday Tuesday Sunday 

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

# Creating a set which have immutable elements set1 = print(type(set1)) #Creating a set which have mutable element set2 = print(type(set2)) 

 Traceback (most recent call last) in 4 5 #Creating a set which holds mutable elements ----> 6 set2 = 7 print(type(set2)) TypeError: unhashable type: 'list' 

В приведенном выше коде мы создали два множества, множество set1 содержит неизменяемые элементы, а set2 — один изменяемый элемент в виде списка. При проверке типа set2 возникла ошибка, что означает, что set может содержать только неизменяемые элементы.

Создание пустого множества немного отличается, потому что пустые фигурные скобки <> также используются для создания словаря. Поэтому Python предоставляет метод set() , используемый без аргумента для создания пустого множества.

# Empty curly braces will create dictionary set3 = <> print(type(set3)) # Empty set using set() function set4 = set() print(type(set4)) 

Давайте посмотрим, что произойдет, если мы предоставим дублирующий элемент в множество.

set5 = print("Return set with unique elements:",set5) 

Return set with unique elements:

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

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

Python предоставляет методы add() и update() , которые можно использовать для добавления определенного элемента в набор. Метод add() используется для добавления одного элемента, а метод update() — для добавления нескольких элементов в множество. Рассмотрим следующий пример.

Пример: 1 — Использование метода add()

Months = set(["January","February", "March", "April", "May", "June"]) print("\nprinting the original set . ") print(months) print("\nAdding other months to the set. "); Months.add("July"); Months.add ("August"); print("\nPrinting the modified set. "); print(Months) print("\nlooping through the set elements . ") for i in Months: print(i) 

printing the original set . Adding other months to the set. Printing the modified set. looping through the set elements . February July May April March August June January 

Чтобы добавить более одного элемента в набор, Python предоставляет метод update() . В качестве аргумента он принимает iterable .

Рассмотрим следующий пример.

Пример — 2 Использование функции update()

Months = set(["January","February", "March", "April", "May", "June"]) print("\nprinting the original set . ") print(Months) print("\nupdating the original set . ") Months.update(["July","August","September","October"]); print("\nprinting the modified set . ") print(Months); 

printing the original set . updating the original set . printing the modified set .

Удаление элементов из набора

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

Рассмотрим следующий пример.

Пример-1 Использование метода discard()

months = set(["January","February", "March", "April", "May", "June"]) print("\nprinting the original set . ") print(months) print("\nRemoving some months from the set. "); months.discard("January"); months.discard("May"); print("\nPrinting the modified set. "); print(months) print("\nlooping through the set elements . ") for i in months: print(i) 

printing the original set . Removing some months from the set. Printing the modified set. looping through the set elements . February March April June 

Python также предоставляет метод remove() для удаления элемента из набора. Рассмотрим следующий пример удаления элементов с помощью метода remove() .

Пример-2 Использование функции remove()

months = set(["January","February", "March", "April", "May", "June"]) print("\nprinting the original set . ") print(months) print("\nRemoving some months from the set. "); months.remove("January"); months.remove("May"); print("\nPrinting the modified set. "); print(months) 

printing the original set . Removing some months from the set. Printing the modified set.

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

Рассмотрим следующий пример удаления элемента из множества с помощью метода pop() .

Months = set(["January","February", "March", "April", "May", "June"]) print("\nprinting the original set . ") print(Months) print("\nRemoving some months from the set. "); Months.pop(); Months.pop(); print("\nPrinting the modified set. "); print(Months) 

printing the original set . Removing some months from the set. Printing the modified set.

В приведенном выше коде последним элементом множества Month является March , но метод pop() удалил June и January , потому что набор неупорядочен и метод pop() не смог определить последний элемент набора.

Python предоставляет метод clear() для удаления всех элементов из набора.

Рассмотрим следующий пример.

Months = set(["January","February", "March", "April", "May", "June"]) print("\nprinting the original set . ") print(Months) print("\nRemoving all the items from the set. "); Months.clear() print("\nPrinting the modified set. ") print(Months) 

printing the original set . Removing all the items from the set. Printing the modified set. set() 

Разница между методами discard() и remove()

Несмотря на то, что метод discard() и remove() выполняют одну и ту же задачу, между discard() и remove() есть одно основное различие.

Если ключ, который нужно удалить из множества с помощью метода discard() , не существует в множестве, Python не выдаст ошибку. Программа сохраняет свой поток управления.

С другой стороны, если элемент, который нужно удалить из множества с помощью remove() , не существует в наборе, Python выдаст ошибку.

Рассмотрим следующий пример.

Months = set(["January","February", "March", "April", "May", "June"]) print("\nprinting the original set . ") print(Months) print("\nRemoving items through discard() method. "); Months.discard("Feb"); #will not give an error although the key feb is not available in the set print("\nprinting the modified set. ") print(Months) print("\nRemoving items through remove() method. "); Months.remove("Jan") #will give an error as the key jan is not available in the set. print("\nPrinting the modified set. ") print(Months) 

printing the original set . Removing items through discard() method. printing the modified set. Removing items through remove() method. Traceback (most recent call last): File "set.py", line 9, in Months.remove("Jan") KeyError: 'Jan' 

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

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

Объединение двух множеств в Python

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

Рассмотрим следующий пример для вычисления объединения двух множеств.

Пример 1: использование оператора union |

Days1 = Days2 = print(Days1|Days2) #printing the union of the sets 

Python также предоставляет метод union() , который также можно использовать для вычисления объединения двух множеств. Рассмотрим следующий пример.

Пример 2: использование метода union()

Days1 = Days2 = print(Days1.union(Days2)) #printing the union of the sets 

Пересечение двух множеств в Python

Пересечение двух множеств может быть выполнено с помощью оператора & или функции intersection() . Пересечение двух множеств задается как набор элементов, общих для обоих множеств.

Пример 1: Использование оператора &

Days1 = Days2 = print(Days1&Days2) #prints the intersection of the two sets 

Пример 2: Использование метода intersection()

set1 = set2 = print(set1.intersection(set2)) #prints the intersection of the two sets 

set1 = set2 = set3 = set1.intersection(set2) print(set3) 

Метод intersection_update()

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

Метод intersection_update() отличается от метода intersection() , поскольку он изменяет исходное множество, удаляя ненужные элементы, с другой стороны, метод intersection() возвращает новое множество.

Рассмотрим следующий пример.

a = b = c = a.intersection_update(b, c) print(a) 

Нахождение разности двух множеств в Python

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

Пример 1: Использование оператора вычитания ( — )

Days1 = Days2 = print(Days1-Days2) #

Пример 2 : Использование метода difference()

Симметричная разность двух множеств в Python

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

Пример — 1: Использование оператора ^

a = b = c = a^b print(c) 

Пример — 2: Использование метода symmetric_difference()

a = b = c = a.symmetric_difference(b) print(c) 

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

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

Рассмотрим следующий пример.

Days1 = Days2 = Days3 = #Days1 is the superset of Days2 hence it will print true. print (Days1>Days2) #prints false since Days1 is not the subset of Days2 print (Days1 

True False False 

Frozenset = frozenset([1,2,3,4,5]) print(type(Frozenset)) print("\nprinting the content of frozen set. ") for i in Frozenset: print(i); Frozenset.add(6) #gives an error since we cannot change the content of Frozenset after c 

 printing the content of frozen set. 1 2 3 4 5 Traceback (most recent call last): File "set.py", line 6, in Frozenset.add(6) #gives an error since we can change the content of Frozenset after creation AttributeError: 'frozenset' object has no attribute 'add' 

Dictionary = print(type(Dictionary)) Frozenset = frozenset(Dictionary); #Frozenset will contain the keys of the dictionary print(type(Frozenset)) for i in Frozenset: print(i) 

  Name Country ID 

my_set = n = int(input("Enter the number you want to remove")) my_set.discard(n) print("After Removing:",my_set) 

Enter the number you want to remove:12 After Removing:

set1 = set([1,2,4,"John","CS"]) set1.update(["Apple","Mango","Grapes"]) print(set1) 

set1 = set(["Peter","Joseph", 65,59,96]) set2 = set(["Peter",1,2,"Joseph"]) set3 = set1.union(set2) print(set3) 

set1 = set2 = set3 = set1.intersection(set2) print(set3) 

set1 = set2 = set3 = set1.intersection(set2) print(set3) 

TypeError: 'frozenset' object does not support item assignment 

set1 = set(["Peter","James","Camroon","Ricky","Donald"]) set2 = set(["Camroon","Washington","Peter"]) set3 = set(["Peter"]) issubset = set1 >= set2 print(issubset) issuperset = set1 = set3 print(issuperset) 

False False True True 

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

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

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

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

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

 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("Множества не пересекаются!") # Множества не пересекаются! 

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

 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) # Вывод (порядок может быть другим):

 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) # Вывод (порядок может быть другим):

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