Set python что это

Исчерпывающее руководство по множествам в 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 — это последовательность элементов, которые разделены между собой запятой и заключены в фигурные скобки.

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

In [1]: vlans = [10, 20, 30, 40, 100, 10] In [2]: set(vlans) Out[2]: 10, 20, 30, 40, 100> In [3]: set1 = set(vlans) In [4]: print(set1) 40, 100, 10, 20, 30> 

Чем отличаются list, tuple и set? Зачем они нужны?

List (список), tuple (кортеж), set (множество) — это встроенные структуры данных языка python. Каждая из них имеет свои возможности и ограничения. Это позволяет выбрать наиболее подходящий способ хранения информации в программе.

List (список)

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

Создание списка

>>> my_list = [] # Создание пустого списка с помощью литерала списка >>> my_list = list() # Создание пустого списка с помощью встроенной функции >>> >>> my_list = [1,2,['a','b'],4,5] # Инициализация списка >>> >>> my_list = list('hello world') # Создание списка из итерируемого объекта >>> my_list ['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd'] >>> >>> my_list = [x for x in range(10)] # Генератор списков в действии >>> my_list [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 

Доступные методы

• my_list.append(x) — добавляет x в конец списка
• my_list.clear() — очищает список
• my_list.copy() — возвращает копию списка my_list
• my_list.count(x) — возвращает кол-во элементов со значением x
• my_list.extend(x) — добавляет элементы списка x к концу списка my_list
• my_list.index(x,start,end) — возвращает индекс первого найденного x, можно задать промежуток для поиска (опционально)
• my_list.insert(index, x) — вставляет x на заданную позицию
• my_list.pop(index) — возвращает элемент с указанным индексом и удаляет его, если индекс не указан — возвращается и удаляется последний элемент
• my_list.remove(x) — удаляет первый элемент со значением x
• my_list.reverse() — инвертирует порядок элементов в списке
• my_list.sort(key=x) сортирует список на основе функции x

В каких случаях использовать?

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

Tuple (кортёж)

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

Создание кортежа.

>>> my_tuple = () # Создание кортежа с помощью литерала >>> my_tuple = tuple() # Создание кортежа с помощью встроенной функции >>> >>> my_tuple = (1,2,['a','b'],4,5) # Инициализация кортежа >>> >>> my_tuple = tuple('hello world') # Создание кортежа из итерируемого объекта >>> my_tuple ('h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd') >>> >>> my_tuple = tuple(2**x for x in [0, 1, 2, 3]) # Генератор кортежей >>> my_tuple (1, 2, 4, 8) 

Доступные методы

• my_tuple.count(x) — возвращает кол-во элементов со значением x
• my_tuple.index(x,start,end) — возвращает индекс первого найденного x, можно задать промежуток для поиска (опционально)

В каких случаях использовать?

Для хранения данных вместо списка (если они не предполагают изменений).

Set (множество)

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

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

>>> my_something = > # . Попытка создать множество при помощи литерала даст нам словарь >>> type(my_something) class 'dict'> >>> >>> my_set = set() # Создание при помощи встроенной функции >>> >>> my_set = 1,2,3,4,5> # Инициализация множества >>> >>> my_set = set('hello world') # Создания множества из итерируемого объекта >>> my_set 'r', 'o', 'e', 'h', 'd', 'w', 'l', ' '> >>> >>> my_set = x for x in range(10)> # Генератор множеств >>> my_set 0, 1, 2, 3, 4, 5, 6, 7, 8, 9> 

Доступные методы

• my_set.add(x) — добавляет x во множество
• my_set.difference(x) — возвращает множество элементов my_set, которые не входят во множество x
• my_set.difference_update(x) — удаляет из множества my_set все элементы, которые входят во множество x
• my_set.discard(x) — удаляет элемент x из my_set
• my_set.intersection(x) — возвращает элементы общие для множеств my_set и x
• my_set.intersection_update(x) — удаляет из множества my_set элементы, которых нет во множестве x
• my_set.isdisjoint(x) — возвращает true если my_set и x не содержат одинаковых значений
• my_set.issubset(x) — возвращает true если все элементы my_set входят во множество x
• my_set.issuperset(x) — возвращает true если все элементы x входят во множество my_set
• my_set.pop() — возвращает и удаляет первый (на данный момент) элемент множества
• my_set.remove(x) — удаляет x из множества
• my_set.symmetric_difference(x) — возвращает все элементы из x и my_set, которые встречаются только в одном из множеств
• my_set.symmetric_difference_update(x) — обновляет исходное множество таким образом, что оно будет состоять из всех элементов x и my_set, которые встречаются только в одном из множеств
• my_set.union(x) — возвращает новое множество, состоящее из всех элементов x и my_set
• my_set.update(x) — добавляет в my_set все элементы x

В каких случаях использовать?

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

Попробуйте бесплатные уроки по Python

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

Переходите на страницу учебных модулей «Девмана» и выбирайте тему.

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

Множество (set) в Python — это набор уникальных данных. Элементы множества не могут дублироваться. Множество может содержать любое количество элементов, и они могут быть разных типов (int, float, кортеж, строки и т.д.). Но множество не может иметь изменяемые элементы, такие как списки, словари или другие множества. Для создания множества все элементы помещают внутри фигурных скобок <> , разделенных запятыми.

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

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

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

# Множество целочисленного типа
student_id = < 112 , 114 , 116 , 118 , 115 >
print ( ‘Student ID:’ , student_id )
# Множество строчного типа
vowel_letters = < 'a' , 'e' , 'i' , 'o' , 'u' >
print ( ‘Vowel Letters:’ , vowel_letters )
# Множество смешанного типа
print ( ‘Set of mixed data types:’ , mixed_set )

Здесь мы создали различные типы множеств, поместив все элементы внутри фигурных скобок <> .

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

Создание пустого множества — дело нехитрое. Пустые фигурные скобки <> создадут пустой словарь в Python. А для создания пустого множества нужно использовать функцию set() без каких-либо аргументов. Например:

# Создание пустого множество
empty_set = set ( )
# Создание пустого словаря
empty_dictionary = < >
# Проверка типа данных empty_set
print ( ‘Data type of empty_set:’ , type ( empty_set ) )
# Проверка типа данных dictionary_set
print ( ‘Data type of empty_dictionary’ , type ( empty_dictionary ) )

Data type of empty_set:
Data type of empty_dictionary

empty_set — пустое множество, созданное с помощью set();

empty_dictionary — пустой словарь, созданный с помощью <> .

Наконец, мы использовали функцию type() для определения типа данных empty_set и empty_dictionary .

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

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

print ( numbers )

Здесь мы видим, что в множестве нет одинаковых элементов, так как оно не может содержать дубли.

Добавление, обновление и удаление элементов множества в Python

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

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

В Python метод add() используется для добавления элемента в множество. Например:

print ( ‘Initial Set:’ , numbers )
# Использование метода add()
numbers . add ( 32 )
print ( ‘Updated Set:’ , numbers )

Initial Set:
Updated Set:

Здесь мы создали множество с именем numbers . Обратите внимание на строку:

numbers . add ( 32 )

Здесь add() добавляет значение 32 к нашему множеству.

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

В Python метод update() используется для обновления множества элементами других типов данных (списки, кортежи и т.д.). Например:

tech_companies = [ ‘apple’ , ‘google’ , ‘apple’ ]
companies . update ( tech_companies )
print ( companies )

Здесь все уникальные элементы tech_companies добавляются в множество companies .

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

В Python метод discard() используется для удаления указанного элемента из множества. Например:

print ( ‘Initial Set:’ , languages )
# Удаление ‘Java’ из множества
removedValue = languages . discard ( ‘Java’ )
print ( ‘Set after remove():’ , languages )

Здесь мы использовали метод discard(), чтобы удалить ‘Java’ из множества language .

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

# Используем цикл for для доступа к каждому элементу
for fruit in fruits :
print ( fruit )

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

В Python метод len() используется для определения количества элементов, присутствующих в множестве. Например:

even_numbers = < 2 , 4 , 6 , 8 >
print ( ‘Set:’ , even_numbers )
print ( ‘Total Elements:’ , len ( even_numbers ) )

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

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

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

Объединение двух множеств A и B включает в себя все элементы множеств A и B.

Для выполнения операции объединения множеств используется оператор | или метод union() . Например:

# Первое множество
# Второе множество
# Выполнение операции объединения с помощью |
print ( ‘Union using |:’ , A | B )
# Выполнение операции объединения с помощью union()
print ( ‘Union using union():’ , A . union ( B ) )

Union using |:
Union using union():

Примечание: A | B и union() эквивалентны операции множества A ⋃ B .

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

Пересечение двух множеств A и B включает в себя общие элементы между множествами A и B.

В Python для выполнения операции пересечения множеств используется оператор & или метод intersection() . Например:

# Первое множество
# Второе множество
# Выполнение операции пересечения с помощью &
print ( ‘Intersection using &:’ , A & B )
# Выполнение операции пересечения с помощью intersection()
print ( ‘Intersection using intersection():’ , A . intersection ( B ) )

Intersection using &:
Intersection using intersection():

Примечание: A & B и intersection() эквивалентны операции множества A ⋂ B .

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

Разница между двумя множествами A и B включает в себя элементы множества A, которых нет в множестве B.

В Python для выполнения операции разности между двумя множествами используется оператор — или метод difference() . Например:

# Первое множество
# Второе множество
# Выполнение операции разности с помощью —
print ( ‘Difference using -:’ , A — B )
# Выполнение операции разности с помощью difference()
print ( ‘Difference using difference():’ , A . difference ( B ) )

Difference using -:
Difference using difference():

Примечание: A — B и A.difference(B) эквивалентны операции множества A — B .

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

Симметрическая разность двух множеств A и B включает в себя все элементы A и B без общих элементов.

В Python для выполнения операции симметрической разности между двумя множествами используется оператор ^ или метод symmetric_difference() . Например:

# Первое множество
# Второе множество
# Выполнение операции симметрической разности с помощью &
print ( ‘using ^:’ , A ^ B )
# Выполнение операции симметрической разности с помощью symmetric_difference()
print ( ‘using symmetric_difference():’ , A . symmetric_difference ( B ) )

Проверка, являются ли два множества равными

В Python оператор == используется, чтобы проверить, равны ли два множества. Например:

# Первое множество
# Второе множество
# Проверяем, равны ли два множества
print ( ‘Set A and Set B are equal’ )
print ( ‘Set A and Set B are not equal’ )

Set A and Set B are equal

Здесь A и B имеют одинаковые элементы, поэтому условие

вычисляется в True . Следовательно, выполняется print(‘Set A and Set B are equal’) внутри if.

Методы для работы с множествами в Python

Функции	Описание
add()	Добавляет элемент к множеству.
all()	Возвращает True, если все элементы множества True (или если множество пустое).
any()	Возвращает True, если хоть один из элементов множества True. Если множество пустое, возвращается False.
clear()	Удаляет все элементы из множества.
copy()	Возвращает копию множества.
difference()	Возвращает разность двух или более множеств в виде нового множества.
difference_update()	Удаляет все элементы другого множества из текущего множества.
discard()	Удаляет элемент из множества, если он является его частью. (Ничего не делает, если элемент не находится в множестве)
enumerate()	Возвращает объект перечисления, который содержит индекс и значение для всех элементов множества в виде пары.
intersection()	Возвращает пересечение двух множеств в виде нового множества.
intersection_update()	Обновляет множество пересечением себя и другого множества.
isdisjoint()	Возвращает True, если два множества не имеют пересечение.
issubset()	Возвращает True, если другое множество содержит текущее множество.
issuperset()	Возвращает True, если текущее множество содержит другое множество.
len()	Возвращает длину (количество элементов) в множестве.
max()	Возвращает самый большой элемент в множестве.
min()	Возвращает наименьший элемент в множестве.
pop()	Удаляет и возвращает произвольный элемент множества. Вызывает ошибку KeyError, если множество пустое.
remove()	Удаляет элемент из множества. Если элемент не является членом множества, возникает ошибка KeyError.
sorted()	Возвращает новый отсортированный список из элементов множества (но не выполняет сортировку).
sum()	Возвращает сумму всех элементов множества.
symmetric_difference()	Возвращает симметрическую разность двух множеств в виде нового множества.
symmetric_difference_update()	Обновляет множество с симметрической разностью себя и другого.
union()	Возвращает объединение множеств в новом множестве.
update()	Обновляет множество с объединением себя и других.