Sets in Python
In today’s article we will explore sets in Python. You must have learnt in your Math class about sets and if you remember a set is a collection of elements but today we will dig into the details of sets in Python which is close to, but not the same as, mathematical sets. Set is one of the four built-in data types in Python along with List, Tuple, and Dictionary, all with different qualities and usage. It is used to store collections of data and are written with curly brackets.
In Python, sets store unordered values and cannot have multiple occurrences of the same element. It makes sets highly useful to efficiently remove duplicate values from a list or tuple and to perform common math operations like unions and intersections. For example, let S be a set of even numbers less than or equal to 10.
As I said, sets can neither have any order nor have repeated values.
You can see in the above code each element can appear in the set only once. Now, Let W be a set
In the example above, the order of the set W is not preserved.
Initialize a Set
In order to create a new empty set, you use set()
Add and Delete Values from a Set
We can use update() to add new elements to a set. It adds elements from a set (passed as an argument) to the set. In the example below, I have used update() to add new elements to the empty set S.
To delete an element from a set. We can use remove() and it only works if the element to be deleted is present in the set.
Whereas discard() works whether the element to be deleted is present in the set or not.
We can use pop() to remove a random element from the set.
In order to get a sorted list from a set, we use sorted() function.
Immutable Elements
Although a set is mutable i.e. we can add or remove elements from it, the elements of a set are immutable (cannot be changed). Immutable objects include numbers, strings and tuples. In the example below you can see that the elements of a set can be tuples.
but they cannot be lists.
Operations on sets
Python defines many operations on sets. Most operations come in two forms, as a method and as an overload of mathematical operators.
Element of or belongs to: To check if an element is in a set or not we use “in” and “not in” operators.
Subset (A⊆B ): A is a subset of B if set A is included in set B. In other words, all the elements in set A are also elements of set B. You can see in the diagram below. To investigate in Python, whether a set A is a subset of another set B or not, we use issubset() or <=.
Superset (B⊇A): B is a superset of A is another way of saying that A is a subset of B. To examine it in Python, we use issuperset() or >=.
Union (A⋃B): A⋃B has all the elements that belong either to set A or to set B. To find union in Python, we use union() or |.
Intersection (A⋂B): A⋂B has all the elements that belong to both set A and set B. To determine intersection in Python, we use intersection() or &.
Difference (B-A): B-A contains all elements that are in B and not in A. To evaluate difference in Python, we use difference() or -.
Symmetric Difference (A △ B): A △ B comprises all elements that belong to A or B but not to their intersection or contains all elements that are in one of the two sets, but not in both. We use the method symmetric_difference() or ^, to find symmetric difference in Python.
Computing the cartesian Product
The Cartesian product of two sets A and B, denoted A × B, is the set of all possible ordered pairs where the elements of A are first and the elements of B are second. In set-builder notation, A × B = <(a, b) : a ∈ A and b ∈ B>. The code snippet below computes the cartesian product of two sets A and B in Python.
Conclusion
In this article, we have learnt about sets in Python, how to create a set, how to add and remove elements from a set. We went over the operations that can be applied on sets. We also saw that sets themselves are mutable but their elements are immutable. Thank you for reading. I hope you found this article useful. If you have any questions, feel free to reach out in the comments below or through Twitter. Happy Pythoning!
13. Методы¶
Не так просто дать определение, что же такое объектно-ориентированное программирование, но мы уже видели некоторые его свойства:
- Программы строятся из определений объектов и определений функций, и большинство вычислений выражается в терминах операций над объектами.
- Каждое определение объекта соответствует некоторому объекту или понятию реального мира, а функции, работающие с объектом, соответствуют тому, как взаимодействуют реальные объекты.
Например, класс Time , определенный в предыдущей главе, соответствует тому, как люди привыкли записывать время. А определенные нами функции соответствуют действиям, которые люди выполняют над временем. Подобным же образом, классы Point и Rectangle соответствуют математическим понятиям точки и прямоугольника.
До сих пор мы не пользовались средствами, которые Python предоставляет для объектно-ориентированного программирования. Строго говоря, эти средства не являются необходимыми для создания программ. По большей части, они предоставляют альтернативный синтаксис для тех вещей, которые мы уже делали. Однако, часто этот синтаксис оказывается более кратким и выразительным.
Например, в программе Time нет очевидной связи между определением класса и следующими за ним определениями функций. Если присмотреться, то оказывается, что каждая из функций принимает в качестве параметра, по крайней мере, один объект Time .
Это наблюдение мотивирует нас перейти к методам. Мы уже встречали некоторые методы, например, keys и values , которые вызываются на словарных объектах. Каждый метод связан с классом и предназначен для использования с объектами этого класса.
Методы похожи на функции, но есть два отличия:
- Методы определяются внутри определения класса, чтобы сделать отношения между классом и методом явными.
- Синтаксис для вызова метода отличается от синтаксиса для вызова функции.
В следующих разделах мы превратим функции из предыдущей главы в методы. Это преобразование почти механическое. Мы сделаем это, выполнив определенную последовательность шагов.
13.2. Метод increment ¶
Для начала давайте превратим в метод функцию increment .
Для этого достаточно поместить определение функции внутрь определения класса. Хорошим тоном будет также переименование параметра time в self (хоть делать это и не обязательно). Как вы, должно быть, помните, в сообществе программистов Python существует соглашение, согласно которому первому параметру метода дают имя self (англ.: сам).
Обратите внимание на сдвиг кода метода относительно заголовка класса:
Преобразование чисто механическое — мы переместили определение метода в определение класса, и изменили имя первого параметра.
Теперь можно вызвать increment как метод, используя точечную нотацию:
Объект, на котором вызывается метод, присваивается первому параметру метода. Таким образом, в данном случае my_time присваивается параметру self . Второй параметр, seconds , получает значение 600 .
В процедурном программировании предполагается, что функции выполняют необходимые действия. Синтаксис для вызова функции , increment(my_time, 600) , говорит: Эй, increment ! Вот тебе объект Time и 600 секунд, сделай с ними все необходимое.
Синтаксис объектно-ориентированном программировании предполагает, что необходимые действия выполняет объект. Вызов, подобный my_time.increment(600) говорит: Эй, my_time ! Пожалуйста, увеличь себя на 600 секунд!
Является ли полезным такое изменение взгляда на вещи? Дело в том, что иногда, передавая ответственность от функций объектам, мы можем писать более гибкий код. Также становится проще поддерживать и повторно использовать такой код.
13.3. Более сложный пример¶
Функция after немного более сложная, поскольку она имеет дело с двумя объектами Time . Первый из параметров переименуем в self , второй оставим без изменений:
Мы вызываем этот метод на одном объекте Time , и передаем второй объект Time в качестве аргумента:
Программа состоит из предложений на почти естественном английском языке: Если время готовности (done_time) позднее, чем текущее время (current_time), то.
13.4. Инициализирующий метод¶
Как мы уже знаем, инициализирующий метод — это специальный метод, который вызывается при создании объекта. Этот метод имеет имя __init__ (два символа подчеркивания, init , и еще два символа подчеркивания). Инициализирующий метод класса Time выглядит так:
Заметьте, что между атрибутом self.hours и параметром hours не возникает конфликта имен. Точечная нотация устраняет конфликт.
Метод, вызываемый при создании объекта и инициализирующий состояние объекта, также называют конструктором. В Python метод __init__ является конструктором.
Когда мы создаем объект Time , указанные нами аргументы передаются конструктору:
Поскольку параметры метода __init__ имеют значения по умолчанию, мы можем и не передавать аргументы при создании объекта:
Или передать только первый аргумент:
Или только первые два аргумента:
Мы также можем передать часть аргументов, явно поименовав их:
13.5. Метод __str__ ¶
Метод __str__ имеет специальное назначение в Python, он возвращает строковое представление объекта. Определим метод __str__ для класса Time , позаимствовав решение из функции print_time из предыдущей главы:
Если класс предоставляет метод с именем __str__ , то тем самым переопределяет поведение встроенной функции Python str .
При выводе объекта Time с помощью print неявно вызывается __str__ на этом объекте. Поэтому добавление метода __str__ также меняет поведение print :
Как видите, добавление метода __str__ к классу Time сделало ненужным написанную ранее функцию print_time .
Когда мы пишем новый класс, мы почти всегда начинаем с написания метода __init__ , который облегчает создание объектов, и метода __str__ , который часто полезен для отладки.
13.6. Снова Points ¶
Теперь, для закрепления изученного материала, давайте перепишем класс Point в стиле ООП:
Инициализирующий метод принимает x и y как опциональные параметры, значение по умолчанию для каждого из них 0.
Метод __str__ возвращает строковое представление объекта Point :
13.7. Перегрузка операторов¶
Некоторые языки программирования позволяют изменять определения встроенных операторов для использования этих операторов с типами, определенными пользователем. Это свойство называется перегрузкой операторов.
Например, для перегрузки оператора + , класс должен предоставить метод __add__ :
Как обычно, первый параметр метода представляет объект, на котором вызывается метод. Второй параметр удачно назван other (англ.: другой) чтобы противопоставить его первому, self . Для того, чтобы сложить два объекта Point , мы создаем и возвращаем новый объект Point , содержащий сумму координат x и сумму координат y двух объектов.
Теперь, когда мы применяем оператор + к объектам Point , Python вызывает метод __add__ :
Выражение p1 + p2 равнозначно выражению p1.__add__(p2) , только более изящно.
В качестве упражнения вам будет предложено самостоятельно написать метод __sub__(self, other) , который перегрузит оператор вычитания.
Перегрузить оператор умножения можно, определив метод __mul__ , или __rmul__ , или оба эти метода. Если левый операнд оператора * является объектом Point , то Python вызовет метод __mul__ , который ожидает, что второй операнд также является объектом Point . Этот метод рассчитает произведение точек согласно известной из математики формуле (сумма квадратов катетов равна квадрату гипотенузы):
Если левый операнд оператора * является примитивным числовым типом, а правый операнд — объект Point , то Python вызовет метод __rmul__ , который выполнит умножение объекта Point на число:
Результатом будет новый объект Point , чьи координаты кратны первоначальным координатам. Если other окажется типом, который нельзя умножить на число с плавающей точкой, то __rmul__ сгенерирует ошибку.
Следующий пример демонстрирует оба вида умножения:
А что случится, если мы попробуем вычислить p2 * 2 ? Так как первый аргумент является объектом Point , то Python вызовет __mul__ и передаст 2 в качестве второго аргумента. Внутри метода, __mul__ попытается получить атрибут x объекта other , что закончится неудачей, поскольку целое число не имеет атрибутов:
13.8. Полиморфизм¶
Большинство написанных нами методов работают только с определенными типами данных. Когда создается новый класс, то пишутся методы, которые работают с объектами этого класса.
Но есть некоторые операции, которые хотелось бы уметь выполнять с разными типами данных, например, арифметические операции из предыдущего раздела. Если разные типы поддерживают одни и те же операции, значит, можно писать функции, работающие с любым из этих типов.
Например, операция multadd (обычная в линейной алгебре) имеет три параметра; первые два перемножаются, и к полученному произведению прибавляется третий. Можем записать это на языке Python таким образом:
Этот метод будет работать с любыми значениями x и y , которые можно перемножить, и с любым значением z , которое можно прибавить к полученному произведению.
Можно вызвать этот метод с числовыми значениями:
Или с объектами Point :
В первом случае, Point умножается на число и складывается с другим Point . Во втором случае, произведение двух Point дает числовое значение, и третий аргумент также является числом.
Функции, подобные этой, которые могут принимать аргументы различных типов, называются полиморфными.
В качестве еще одного примера, рассмотрим метод front_and_back , который печатает список дважды, сначала — в прямом, а затем и в обратном порядке:
Поскольку метод reverse модифицирующий, мы делаем копию списка, прежде чем расставить его элементы в обратном порядке. Таким образом, метод reverse не изменяет список, который он получает в качестве параметра.
Вот пример использования метода front_and_back со списком:
Поскольку мы предназначили эту функцию для работы со списками, неудивительно, что она работает, как ожидалось. Было бы удивительно, если бы мы смогли применить эту функцию к объекту Point .
Для того, чтобы определить, может ли функция быть применена к новому типу, мы воспользуемся основным правилом полиморфизма: Если все операции внутри функции могут быть применены к данному типу, то вся функция может быть применена к данному типу.
Операции внутри функции включают copy , reverse и print .
copy работает с любым объектом. Мы уже написали метод __str__ для Point . Нам остается написать метод reverse для класса Point :
Теперь можно передать объект Point функции front_and_back :
Замечательное свойство языка Python — это непреднамеренный полиморфизм, когда вы обнаруживаете, что написанная вами функция может работать с типами, для которых вы ее не предназначали.
13.9. Глоссарий¶
13.10. Упражнения¶
Переделайте функцию convert_to_seconds в метод класса Time :
Добавьте в класс Point метод __sub__(self, other) , который перегрузит оператор вычитания, и попробуйте с ним поработать.
Перепишите класс Rectangle в объектно-ориентированном стиле, определив методы __init__ и __str__ .
Добавьте в класс Rectangle методы move_rect и grow_rect , созданные на основе одноименных функций из предыдущей главы.
Определите класс Pet (англ.: любимое животное) с атрибутами имя и возраст, инициализируемыми в методе __init__ значениями параметров метода. Метод __str__ должен возвращать строку с именем и возрастом животного. Поэкспериментируйте, создавая объекты класса Pet и выводя их на печать.
Исчерпывающее руководство по множествам в Python
Класс set (множество) — это одна из ключевых структур данных в Python. Она представляет собой неупорядоченную коллекцию уникальных элементов. Класс set , в некоторой степени, соответствует математическому множеству. Многие широко используемые математические операции, применимые к множествам, существуют и в Python. Часто вычисления, производимые над множествами, оказываются гораздо быстрее, чем альтернативные операции со списками. В результате, для того чтобы писать эффективный код, Python-программисту просто необходимо уметь пользоваться множествами. В этой статье я расскажу об особенностях работы с классом set в Python.
Инициализация множеств
Существует два способа создания объекта set : с использованием конструкции set(iterable) и путём помещения элементов, разделённых запятыми, в фигурные скобки — < . >. Если же при инициализации множества попытаться воспользоваться пустыми фигурными скобками — <> — тогда будет создан словарь, а не пустое множество. Для создания пустых множеств используется команда set() . Обратите внимание на то, что при инициализации множеств порядок элементов неважен, и на то, что дублирующиеся элементы в множество добавить не получится.
Какие элементы можно включить в состав множества? Это могут быть только элементы иммутабельных типов. Сюда входят такие типы, как float , int , string , bool и прочие подобные. А вот мутабельные типы — списки, словари, да и сами множества, в состав множеств включать нельзя. Если вас интересуют подробности о типах данных в Python — рекомендую почитать эту статью. Учитывая вышесказанное — следующая конструкция вызовет ошибку:
Но что если случается так, что в множествах надо хранить некие уникальные последовательности значений? Подробнее об этом мы поговорим в конце статьи.
Примечание об иммутабельности
Иммутабельность — это ограничение, касающееся лишь встроенных типов. На практике, чтобы объект можно было добавить в множество, или чтобы его можно было использовать в качестве ключа в словаре, этот объект всего лишь должен быть хешируемым. По умолчанию объекты пользовательских классов обладают хешем, основанным на их идентификаторах. Равенство объектов определяется по их идентификаторам. Это значит, что два объекта, идентичные в плане атрибутов, будут равны друг другу только тогда, когда они представляют один и тот же объект, или в том случае, если для них определён пользовательский оператор eq .
Если для некоего класса определён пользовательский оператор eq , то объекты этого класса перестают быть хешируемыми, если только для них не будет определён пользовательский оператор hash . Тут важно то, что если два объекта равны, то их хеши тоже должны быть равны. В противном случае при добавлении подобных объектов в словарь или в множество возникнут проблемы. Дело в том, что при проверке наличия значения в составе ключей словаря или в составе множества, проверяются и хеши и равенство объектов.
Единственный случай, когда в множестве имеет смысл хранить мутабельный объект, или когда такой объект может играть роль ключа словаря, это когда оператор проверки равенства объекта не использует его мутабельные атрибуты. Предположим, у некоего объекта имеется оператор равенства и соответствующая хеш-функция, основанные на атрибутах этого объекта. Если такой объект сначала добавить в множество, а потом поменять его, тогда хеш-значение, использованное при его сохранении, будет отличаться от текущего хеш-значения. Это — плохая практика.
Добавление элементов в множества
Существует множество способов добавления элементов в множество. Для того чтобы осуществить изменение (мутацию) множества, отдельный элемент в него можно добавить командой .add() . Итерируемый объект добавляют командой .update() , или, что то же самое, используя оператор |= :
Под «мутацией» я понимаю изменение исходного объекта. Есть ещё команды, которые не изменяют исходное множество. Например — метод . union() , или его эквивалент — оператор | :
Явное различие поведения методов .update() и .union() можно продемонстрировать, разобрав следующий пример:
И наконец — два множества можно конкатенировать, использовав деструктурирование:
Этот приём будет работать аналогично методу .union() , но я рекомендую пользоваться именно .union() .
Обратите внимание на то, что в предыдущих примерах я пользовался методом .update() , но в них можно было бы применить и оператор |= . Это значит, что a |= b ( .update() ) — это НЕ то же самое, что a = a | b (.union()) . Дело в том, что в первом фрагменте кода осуществляется изменение объекта, хранящегося в a , а во втором примере a назначается новое значение.
Удаление элементов множеств
Мы рассмотрели команды для добавления элементов в множества. Существуют похожие на них команды, применяемые при удалении элементов. Вот как эти команды можно соотнести с уже известными вам командами:
Аналог .add() — .remove() .
Аналог .update() — .difference_update() или -= .
Аналог .union() — .difference() или — .
Снова хочу обратить ваше внимание на то, что надо помнить о разнице между конструкциями вида a -= b (исходное множество изменяется) и a = a — b (исходное множество не изменяется).
Имеется и ещё несколько методов, которые могут пригодиться для удаления объектов:
.clear() — очищает множество.
.remove() — удаляет элемент лишь в том случае, если он существует (в противном случае выдаёт ошибку); .discard() — работает похожим образом, но, если элемента не существует, ошибку не возвращает.
.pop() — удалит случайный элемент из множества и вернёт этот элемент.
Другие операции для работы с множествами
Одна из сильных сторон Python-множеств заключается в наличии большого количества стандартных операций, предназначенных для работы с ними. Мы обсудили команды для модификации множеств путём добавления и удаления элементов, но это — далеко не всё, что можно делать с множествами.
Пересечение множеств
Пересечением двух множеств является множество элементов, входящих в состав обоих множеств. Для выполнения этой операции используются следующие методы и операторы:
Команды, при выполнении которых множество не меняется: .intersection() или & . Например — a.intersection(b) или a & b .
Команды, при выполнении которых множество меняется: .intersection_update() или &= .
Симметрическая разность множеств или дизъюнктивное объединение
Симметрическая разность множеств — это противоположность их пересечению. Она даёт все элементы, которые не принадлежат одновременно обоим исходным множествам. Для нахождения симметрической разности множеств используются следующие методы и операторы:
Команды, при выполнении которых множество не меняется: . symmetric_difference() или ^ . Например — a.symmmetric_difference(b) или a ^ b .
Команды, при выполнении которых множество меняется: .symmetric_difference_update() или ^= .
Методы проверки наличия элементов в множествах, сравнение множеств
Я рассказал о том, как модифицировать множества, но они, в основном, используются для того, чтобы быстро проверять, имеются ли в них некие элементы, или нет. Подобные операции, выполняемые на списках, будут медленнее. Посмотрим на конструкции, используемые для проверки наличия элементов в множествах, и на некоторые другие полезные команды.
Проверка принадлежности элемента множеству
Вероятно, это — та операция, к которой вы будете прибегать чаще, чем к другим. Проверка наличия элемента в множестве выполняется с помощью оператора in . А проверка отсутствия элемента — с помощью оператора not in . Для таких операций над множествами, в отличие от подобных проверок, выполняемых в применении к спискам, характерна константная временная сложность — O(1). В результате, по мере роста размеров множества, не будет страдать скорость проверки наличия или отсутствия в нём неких элементов.
Проверка того, является ли одно множество подмножеством другого
Множество является подмножеством другого множества в том случае, если все элементы первого множества входят в состав второго. Например, (A, B, C) — это подмножество (A, B, C, D) . В Python подобную проверку можно провести, воспользовавшись методом .issubset() или оператором <= . Чтобы проверить, является ли одно множество истинным подмножеством другого, то есть — что одно множество — это подмножество другого, и что эти множества не равны, можно воспользоваться оператором < . Но учитывайте, что ещё можно пользоваться операторами >= и > .
Проверка того, что в двух множествах нет общих элементов
Если в множествах нет общих элементов, их называют непересекающимися множествами. В Python соответствующая проверка выполняется с помощью метода .isdisjoint() .
Абстракция множеств
Так же, как и в случае со списками и словарями, при работе с множествами можно воспользоваться так называемой абстракцией множеств (set comprehension). Делается это путём добавления обрабатываемого выражения в фигурные скобки и через возврат единственного мутабельного элемента на каждом проходе цикла: < <element> for . in . >.
Хранение в множествах данных более сложных типов
Представьте, что у нас имеется цикл, на каждой итерации которого мы обходим некоторое количество узлов графа. Предположим, мы обошли граф два раза, у нас получились следующие пути:
Потом надо быстро проверить, прошлись ли мы по определённому пути. Нужно, чтобы такая проверка проводилась бы быстро, поэтому совершенно естественным будет использовать для её реализации множество. Как это сделать, если список, из-за его мутабельности, нельзя добавить в множество? К нашему счастью, в подобных обстоятельствах можно воспользоваться кортежем, классом tuple , который, по сути, представляет собой иммутабельную версию списка. Рассмотрим пример.
Сначала создадим граф, используя словарь. Ключи словаря будут представлять узлы графа, а значения — списки узлов, в которые можно перейти из текущего узла.
Визуализировав это описание, я получил такой граф.
Граф
Если вы задаётесь вопросом о том, как я создал такой граф — знайте, что сделал я это, прибегнув к graphviz и написав следующий код:
Теперь я займусь случайным блужданием по графу, проходя от 1 до 10 узлов, после чего сохраню результирующие пути в объекте set в виде кортежей. Посмотрим, сколько уникальных путей мы сможем сгенерировать за 100 проходов по графу:
Из 100 случайных проходов по графу 83 оказались уникальными.
А что если нас не волнует порядок узлов, а нужно лишь сохранить сведения о посещённых узлах? Тогда будет смысл хранить отдельные пути в множествах, но, как уже было сказано, множества мутабельны, помещать их в другие множества нельзя. В такой ситуации, вместо обычных множеств, описываемых классом set , можно прибегнуть к неизменяемым множествам, представленным классом frozenset . Чтобы это сделать — поработаем с кодом цикла из предыдущего примера:
Итоги
Множества — это полезный инструмент Python-разработчика. Они позволяют очень быстро выполнять определённые операции, что способно значительно повысить эффективность кода. Кроме того, в Python имеется немало простых и полезных методов для работы с множествами, применение которых способствует упрощению кода.
О, а приходите к нам работать? �� ��
Мы в wunderfund.io занимаемся высокочастотной алготорговлей с 2014 года. Высокочастотная торговля — это непрерывное соревнование лучших программистов и математиков всего мира. Присоединившись к нам, вы станете частью этой увлекательной схватки.
Мы предлагаем интересные и сложные задачи по анализу данных и low latency разработке для увлеченных исследователей и программистов. Гибкий график и никакой бюрократии, решения быстро принимаются и воплощаются в жизнь.
Множество (set) в Python
Множество (set) в Python — это набор уникальных данных. Элементы множества не могут дублироваться. Множество может содержать любое количество элементов, и они могут быть разных типов (int, float, кортеж, строки и т.д.). Но множество не может иметь изменяемые элементы, такие как списки, словари или другие множества. Для создания множества все элементы помещают внутри фигурных скобок <> , разделенных запятыми.
Создание множества в Python
В Python для создания множества все элементы помещают внутри фигурных скобок <> , разделенных запятыми.
Множество может содержать любое количество элементов, и они могут быть разных типов (int, float, кортеж, строки и т.д.). Но множество не может иметь изменяемые элементы, такие как списки, словари или другие множества.
Здесь мы создали различные типы множеств, поместив все элементы внутри фигурных скобок <> .
Примечание: При выполнении этого кода вы можете получить результат с элементами в другом порядке. Это происходит потому, что множество не имеет определенного порядка.
Создание пустого множества — дело нехитрое. Пустые фигурные скобки <> создадут пустой словарь в Python. А для создания пустого множества нужно использовать функцию set() без каких-либо аргументов. Например:
Data type of empty_set: <class ‘set’>
Data type of empty_dictionary <class ‘dict’>
empty_set — пустое множество, созданное с помощью set();
empty_dictionary — пустой словарь, созданный с помощью <> .
Наконец, мы использовали функцию type() для определения типа данных empty_set и empty_dictionary .
Дублирование элементов в множестве
Давайте посмотрим, что произойдет, если мы попытаемся включить в набор дублирующиеся элементы.
Здесь мы видим, что в множестве нет одинаковых элементов, так как оно не может содержать дубли.
Добавление, обновление и удаление элементов множества в Python
Множества изменяемые. Однако, поскольку они неупорядочены, индексирование не имеет смысла. Мы не можем получить доступ или изменить элемент множества с помощью индексации или среза. Тип данных set не поддерживает этого.
Добавление элемента в множество
В Python метод add() используется для добавления элемента в множество. Например:
Initial Set: <34, 12, 21, 54>
Updated Set:
Здесь мы создали множество с именем numbers . Обратите внимание на строку:
Здесь add() добавляет значение 32 к нашему множеству.
Обновление множества
В Python метод update() используется для обновления множества элементами других типов данных (списки, кортежи и т.д.). Например:
Здесь все уникальные элементы tech_companies добавляются в множество companies .
Удаление элемента из множества
В Python метод discard() используется для удаления указанного элемента из множества. Например:
Здесь мы использовали метод discard(), чтобы удалить ‘Java’ из множества language .
Итерация по множеству в Python
Определение количества элементов множества
В Python метод len() используется для определения количества элементов, присутствующих в множестве. Например:
Операции с множествами в Python
Python предоставляет различные встроенные методы для выполнения математических операций с множествами, таких как объединение, пересечение, разность и симметрическая разность.
Объединение множеств
Объединение двух множеств A и B включает в себя все элементы множеств A и B. 
Для выполнения операции объединения множеств используется оператор | или метод union() . Например:
Union using |: <0, 1, 2, 3, 4, 5>
Union using union():
Примечание: A | B и union() эквивалентны операции множества A ⋃ B .
Пересечение множеств
Пересечение двух множеств A и B включает в себя общие элементы между множествами A и B. 
В Python для выполнения операции пересечения множеств используется оператор & или метод intersection() . Например:
Intersection using &: <1, 3>
Intersection using intersection():
Примечание: A & B и intersection() эквивалентны операции множества A ⋂ B .
Разность множеств
Разница между двумя множествами A и B включает в себя элементы множества A, которых нет в множестве B. 
В Python для выполнения операции разности между двумя множествами используется оператор — или метод difference() . Например:
Difference using -: <3, 5>
Difference using difference():
Примечание: A — B и A.difference(B) эквивалентны операции множества A — B .
Симметрическая разность множеств
Симметрическая разность двух множеств A и B включает в себя все элементы A и B без общих элементов. 
В Python для выполнения операции симметрической разности между двумя множествами используется оператор ^ или метод symmetric_difference() . Например:
Проверка, являются ли два множества равными
В Python оператор == используется, чтобы проверить, равны ли два множества. Например:
Set A and Set B are equal
Здесь A и B имеют одинаковые элементы, поэтому условие
вычисляется в True . Следовательно, выполняется print(‘Set A and Set B are equal’) внутри if.