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

Множества и словари в Python

Содержание

• Ссылки на контесты
• Множества Python
  • Создание и изменение множества
  • Математические операции
    • Проверки
  • Сводная таблица по множествам (cheatsheet)
  • Неизменяемые множества
• Словари Python
  • Создание и изменение словаря
    • Примечание о числовых ключах
  • Использование DictView: циклы и множественные операции
  • Словарь с упорядоченными ключами OrderedDict

• Начинающие (участвовать)
• Основные (участвовать)
• Продвинутые (участвовать)

Множество (set) — встроенная структура данных языка Python, имеющая следующие свойства:

• множество — это коллекция

  Множество содержит элементы

• множество неупорядоченно

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

• элементы множества уникальны

  Множество не может содержать два одинаковых элемента.

• элементы множества — хешируемые объекты (hashable objects)

  В Python множество set реализовано с использованием хеш-таблицы. Это приводит к тому, что элементы множества должны быть неизменяемыми объектами. Например, элементом множества может быть строка, число, кортеж tuple, но не может быть список list, другое множество set…

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

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

Запустите в терминале Python в интерпретируемом режиме и проработайте примеры ниже.

Пустое множество создаётся с помощью функции set

>>> A = set()
>>> type(A)
<class 'set'>
>>> len(A)
0
>>> A
set()

Обратите внимание, что размер множества множества можно получить с помощью функции len.

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

>>> A.add(1)
>>> A
{1}
>>> A.add(2)
>>> A
{1, 2}
>>> A.add(2)
>>> A
{1, 2}

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

Также, из вывода видно, что литералом множества являются фигурные скобки {}, в которых через запятую указаны элементы. Так, ещё один способ создать непустое множество — воспользоваться литералом

>>> B = {1, 2}
>>> B
{1, 2}

При попытке добавления изменяемого объекта возникнет ошибка

>>> B.add([3,4,5])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

Здесь произошла попытка добавить массив в множество B.

У операции добавления set.add существует обратная — операция удаления set.remove

>>> B
{1, 2}
>>> B.remove(1)
>>> B
{2}
>>> B.remove(3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 3

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

Однако, существует метод set.discard, который удаляет элемент из множества, только в том случае, если этот элемент присутствовал в нём.

Математические операции

Множества Python поддерживают привычные математические операции

Проверки

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

in

>>> B = {1, 2}
>>> B
{1, 2}
>>> 3 in B
False

Асимптотика x in set — O(1).

Стоит отметить, что оператор in работает и с другими коллекциями. Например, можно проверять вхождение подстроки в строку 'AA' in 'bbAAcc' или вхождение элемента в массив 5 in [1, 2, 5, 6]. Асимптотики в данном случае нужно уточнять в документации.

Одинаковые множества

>>> A = {1, 2, 3}
>>> B = {1, 2, 3}
>>> A == B
True
>>> B.add(4)
>>> A
{1, 2, 3}
>>> B
{1, 2, 3, 4}
>>> A == B
False

Проверка на нестрогое подмножество set.issubset

>>> A
{1, 2, 3}
>>> B
{1, 2, 3, 4}
>>> A.issubset(B)
True
>>> B.issubset(A)
False
>>> A.issubset(A)
True

Проверка на нестрогое надмножество set.issuperset

>>> A
{1, 2, 3}
>>> B
{1, 2, 3, 4}
>>> A.issuperset(B)
False
>>> B.issuperset(A)
True
>>> B.issuperset(B)
True

Операции получения новых множеств

>>> A = {1, 2, 4}
>>> B = {1, 2, 3}
>>> A. union(B)  # union - объединение множеств
{1, 2, 3, 4}
>>> A.intersection(B)  # intersection - пересечение
{1, 2}
>>> A.difference(B)  # difference - разность множеств
{4}
>>> B.difference(A)
{3}
>>> A.symmetric_difference(B)  # symmetric_difference - симметрическая разность
{3, 4}
>>> B.symmetric_difference(A)
{3, 4}

Сводная таблица по множествам (cheatsheet)

Обозначения

• elem — Python-объект

• A — множество set

• B, C,..

  1. В случае использования в методах A.method_name(B, C,..): B, C,.. являются любыми итерируемыми объектами. Методы допускают такие аргументы, например, {-1}.union(range(2)) == {-1, 0, 1} вернёт True.

  2. В случае использования c операторами, например, A > B или A & B & C & …: B, C,.. являются множествами. Дело в том, что эти операторы определены для операндов типа set (и также frozenset, о которых речь позже).

Операция	Синтаксис	Тип результата
Вхождение элемента	elem in A	bool
Равенство	A == B	bool
Является нестрогим подмножеством	A.issubset(B) или A <= B	bool
Является строгим подмножеством	A < B	bool
Является нестрогим надмножеством	A.issuperset(B) или A >= B	bool
Явяляется строгим надмножеством	A > B	bool
Объединение множеств	A.union(B, C,..)	set
	A | B | C | …	set
Пересечение множеств	A.intersection(B, C,..)	set
	A & B & C & …	set
Разность множеств	A. …	set

Кроме того, у операций, порождающих новые множества, существует inplace варианты. Для методов это те же названия, только с префиксом _update, а для соответствующих операторов добавляется знак равенства =. Ниже показан вариант для операции разности множеств

>>> A = {1, 2, 3, 4}
>>> B = {2, 4}
>>> A.difference_update(B)
>>> A
{1, 3}
>>> A = {1, 2, 3, 4}
>>> B = {2, 4}
>>> A -= B
>>> A
{1, 3}

Неизменяемые множества

В Python существует неизменяемая версия множества — frozenset. Этот тип объектов поддерживает все операции обычного множества set, за исключением тех, которые его меняют.

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

Для создания frozenset используется функция frozenset(iterable), в качестве аргумента принимающая итерирумый объект.

>>> FS = frozenset({1, 2, 3})
>>> FS
frozenset({1, 2, 3})
>>> A = {1, 2, 4}
>>> FS & A
frozenset({1, 2})
>>> A & FS
{1, 2}

В этом примере показано создание frozenset из обычного множества {1, 2, 3}. Обратите внимание на тип возвращаемого объекта для операции пересечения &. Возвращаемый объект имеет тип, соответствующий типу первого аргумента. Такое же поведение будет и с другими операциями над множествами.

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

В Python есть встроенный ассоциативный массив —

dict. Его реализация основана на хеш-таблицах. Поэтому

• ключом может быть только хешируемый объект
• значением может быть любой объект

Создание и изменение словаря

Пустой словарь можно создать двумя способами:

>>> d1 = dict()
>>> d2 = {}
>>> d1
{}
>>> d2
{}
>>> type(d1)
<class 'dict'>
>>> type(d2)
<class 'dict'>

Добавить элемент в словарь можно с помощью квадратных скобок:

>>> domains = {}
>>> domains['ru'] = 'Russia'
>>> domains['com'] = 'commercial'
>>> domains['org'] = 'organizations'
>>> domains
{'ru': 'Russia', 'com': 'commercial', 'org': 'organizations'}

Из этого примера видно, что литералом словаря являются фигурные скобки, в которых через запятую перечислены пары в формате ключ:значение

. Например, словарь domains можно было создать так domains = {'ru': 'Russia', 'com': 'commercial', 'org': 'organizations'}.

Доступ к элементу осуществляется по ключу:

>>> domains['com']
'commercial'
>>> domains['de']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'de'

Удалить элемент можно с помощью оператора del. Если ключа в словаре нет, произойдет ошибка KeyError

>>> domains
{'ru': 'Russia', 'com': 'commercial', 'org': 'organizations'}
>>> del domains['de']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'de'
>>> del domains['ru']
>>> domains
{'com': 'commercial', 'org': 'organizations'}

Кроме того, для добавления, получения и удаления элементов есть методы dict.setdefault, dict.get, dict.pop, которые задействует дополнительный аргумент на случай, если ключа в словаре нет

>>> d1 = {}
>>> d1.setdefault('a', 10)
10
>>> d1. setdefault('b', 20)
20
>>> d1
{'a': 10, 'b': 20}
>>> d1.setdefault('c')
>>> d1
{'a': 10, 'b': 20, 'c': None}
>>> d1.setdefault('a', 123)
10
>>> d1
{'a': 10, 'b': 20, 'c': None}
>>> d1.get('a')
10
>>> d1.get('d')  # вернул None
>>> d1.get('d', 'NoKey')
'NoKey'
>>> d1.pop('d')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'd'
>>> d1.pop('d', 255)
255
>>> d1
{'a': 10, 'b': 20, 'c': None}
>>> d1.pop('a', 255)
10
>>> d1
{'b': 20, 'c': None}

Примечание о числовых ключах

Ключом может являться и число: int или float. Однако при работе со словарями в Python помните, что два ключа разные, если для них верно k1 != k2 # True.

Вот пример:

>>> d = {0: 10}
>>> d
{0: 10}
>>> d[0] = 22
>>> d
{0: 22}
>>> d[0.0] = 33
>>> d
{0: 33}
>>> 0. 0 != 0
False

Поэтому при возможности избегайте в качестве ключей float-объектов.

Использование DictView: циклы и множественные операции

Если попробовать пройтись в цикле по словарю, то это будет проход по ключам

>>> d = {'a': 10, 'c': 30, 'b': 20}
>>> for k in d:
...     print(k)
...
a
c
b

Зачастую необходимо пройтись в цикле по ключам, значениям или парам ключ:значение, содержащиеся в словаре. Для этого существуют методы dict.keys(), dict.values(), dict.items(). Они возвращают специальные DictView объекты, которые можно использовать в циклах:

>>> d = {'a': 10, 'c': 30, 'b': 20}
>>> for k in d.keys():
...     print(k)
...
a
c
b
>>> for v in d.values():
...     print(v)
...
10
30
20
>>> for k, v in d.items():
...     print(k, v)
...
a 10
c 30
b 20

Объекты DictView, содержащие только ключи, ведут себя подобно множествам. Кроме того, если DictView объекты для значений или пар содержат неизменяемые объекты, тогда они тоже ведут себя подобно множествам. Это означает, что привычные для множеств операции пересечения, вхождения и другие также работают с DictView.

>>> d
{'a': 10, 'c': 30, 'b': 20}
>>> dkeys = d.keys()
>>> 'abc' in dkeys
False
>>> 'c' in dkeys
True
>>> {'a', 'b', 'c'} == dkeys
True
>>> dkeys & {'b', 'c', 'd'}
{'b', 'c'}

Словарь с упорядоченными ключами OrderedDict

Это может понадобится для отправки задач на ejudge.

Если внимательно просмотреть примеры на циклы выше, то видно, что порядок итерирования в циклах совпадает с порядком добавления элементов в словарь.

Однако, такое поведение у стандартных словарей dict гарантируется, начиная с версии 3.7 (лабораторные примеры были сделаны из-под версии 3.7.4). Узнать свою версию Python можно, например, из терминала python3 —version или зайдя в интерпретируемый режим (версия будет написана сверху).

Если для вашей программы важно упорядочивание элементов, но вы не знаете, какой версии интерпретатор будет исполнять ваш скрипт, то вам нужно воспользоваться упорядоченной версией словарей OrderedDict.

Она находится в стандартной библиотеке collections.

Упорядоченный словарь поддерживает все операции, что и обычный словарь.

>>> import collections
>>> od = collections.OrderedDict()
>>> od
OrderedDict()
>>> od['a'] = 10
>>> od['c'] = 30
>>> od['b'] = 20
>>> od
OrderedDict([('a', 10), ('c', 30), ('b', 20)])

пересечение и сортировка — Методы и операции над множествами

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

Создание

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

a = {1, 2, 0, 1, 3, 2}
print(a)

{0, 1, 2, 3}

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

a = set('data')
print(a)

{'d', 'a', 't'}

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

Использование

Обычно используется для следующих операций:

• Проверка, есть ли данное значение в множестве. Для этого используется in.

  a = {0, 1, 2, 3}
  print(2 in a)
  
  True

• Наоборот, проверка отсутствия. Используется not in.

  a = {0, 1, 2, 3}
  print(2 not in a)
  
  False

• Перебор всех элементов.

  for a in {0, 1, 2}:
      print(a)
  
  0
  1
  2

Генератор

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

Следующий код демонстрирует генерацию множества a с циклом for для нескольких чисел.

a = {i for i in [1, 2, 0, 1, 3, 2]}
print(a)

{0, 1, 2, 3}

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

Изменение множеств

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

Получение размера

Узнать точное количество элементов, входящих в состав множества, поможет метод len, принимающий в качестве аргумента набор данных. Функция print выводит результат.

a = {0, 1, 2, 3}
print(len(a))

4

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

Чтобы внести новые значения, потребуется вызывать метод add. Аргументом в данном случае будет добавляемый элемент последовательности. В примере кода на Python добавим в множество элемент со значением 4.

a = {0, 1, 2, 3}
a.add(4)
print(a)

{0, 1, 2, 3, 4}

Удаление элемента

Для удаления элементов из множества используются следующие функции в Python (кроме очистки, которая будет рассмотрена ниже):

• remove — удаление элемента с генерацией исключения в случае, если такого элемента нет;
• discard — удаление элемента без генерации исключения, если элемент отсутствует;
• pop — удаление первого элемента, генерируется исключение при попытке удаления из пустого множества.

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

a = {0, 1, 2, 3}
a.remove(3)
print(a)

{0, 1, 2}

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

Полная очистка

Иногда необходимо полностью убрать все элементы. Чтобы не удалять каждый элемент отдельно, используется метод clear, не принимающий аргументов. Если вывести содержимое после этой операции, на экране появится только его название.

a = {0, 1, 2, 3}
a.clear()
print(a)

set()

В результате получили пустое множество.

Сортировка

Порядок следования элементов не учитывается. Поэтому нет смысла говорить о сортировке множеств в Python 3.

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

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

a = {0, 1, 12, 'b', 'ab', 3, 2, 'a'}
print(a)

{0, 1, 'b', 3, 2, 12, 'ab', 'a'}

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

Посмотрим, что будет, если попытаемся вывести только числа:

a = {0, 1, 12, 3, 2}
print(a)

{0, 1, 2, 3, 12}

Все элементы выведены упорядоченно. Теперь посмотрим что будет если преобразовать в список:

a = {0, 1, 12, 3, 2}
b = list(a)
print(b)

[0, 1, 2, 3, 12]

Аналогично, в список значения записались отсортированными по возрастанию.

Получается, что элементы хранятся в памяти в упорядоченном виде, если они одного типа. Но лучше не стоит на это расчитывать, алгоритмы Python могут поменяться.

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

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

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

Рассмотрим операции с множествами доступные в Python 3.

Объединение

Чтобы объединить все элементы двух разных множеств, стоит воспользоваться методом union на одном из объектов. Следующий пример демонстрирует работу данной функции, где создается последовательность чисел под именем c.

a = {0, 1, 2, 3}
b = {4, 3, 2, 1}
c = a.union(b)
print(c)

{0, 1, 2, 3, 4}

Добавление

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

a = {0, 1, 2, 3}
b = {4, 3, 2, 1}
a.update(b)
print(a)

{0, 1, 2, 3, 4}

Пересечение

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

a = {0, 1, 2, 3}
b = {4, 3, 2, 1}
c = a.intersection(b)
print(c)

{1, 2, 3}

Разность

Чтобы вычислить разность для двух разных множеств, необходимо воспользоваться методом difference. Функция позволяет найти элементы, уникальные для второго набора данных, которых в нем нет. Следующий код демонстрирует эту операцию.

a = {0, 1, 2, 3}
b = {4, 3, 2, 1}
c = a.difference(b)
print(c)

{0}

Отношения между множествами

Для определения подмножеств и надмножеств существуют специальные функции, возвращающие True или False в зависимости от результата выполнения.

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

Чтобы выяснить, является ли множество a подмножествомb, стоит попробовать вывести на экран результат выполнения метода issubset, как в следующем примере. Так как не все элементы набора чисел a присутствуют в b, функция вернет False.

a = {0, 1, 2, 3, 4}
b = {3, 2, 1}
print(a.issubset(b))

False

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

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

a = {0, 1, 2, 3, 4}
b = {3, 2, 1}
print(a.issuperset(b))

True

Тип frozenset

Множество, содержимое которого не поддается изменению имеет тип frozenset. Значения из этого набора нельзя удалить, как и добавить новые. В следующем примере демонстрируется создание при помощи стандартной функции.

a = frozenset({"hello", "world"})
print(a)

frozenset({'hello', 'world'})

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

Преобразование множеств

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

Строка

Для преобразования множества в строку используется конкатенация текстовых значений, которую обеспечивает функция join. В этом случае ее аргументом является набор данных в виде нескольких строк. Запятая в кавычках выступает в качестве символа, разделяющего значения. Метод type возвращает тип данных объекта в конце приведенного кода.

a = {'set', 'str', 'dict', 'list'}
b = ','.join(a)
print(b)
print(type(b))

set,dict,list,str
<class 'str'>

Словарь

Чтобы получить из множества словарь, следует передать функции dict набор из нескольких пар значений, в каждом из которых будет находиться ключ. Метод print демонстрирует на экране содержимое полученного объекта, а type отображает его тип.

a = {('a', 2), ('b', 4)}
b = dict(a)
print(b)
print(type(b))

{'b': 4, 'a': 2}
<class 'dict'>

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

1. ключ будущего словаря;
2. значение, соответствующее ключу.

Список

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

a = {1, 2, 0, 1, 3, 2}
b = list(a)
print(b)
print(type(b))

[0, 1, 2, 3]
<class 'list'>

Резюме

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

Название	Назначение
len	Получение размера
add	Добавление элемента
remove	Удаление элемента
clear	Очистка
union	Объединение
update	Добавление всех элементов одного множества в другое
intersection	Нахождение множества, элементы которого находятся на пересечении двух множеств
difference	Нахождение множества, элементы которого входят в первое, но не входят во второе множество
issubset	Проверка, является ли множество подмножеством
issuperset	Проверка, является ли множество надмножеством

Заключение

Таким образом, были рассмотрены базовые возможности множеств стандартной библиотеки языка программирования Python. Использование этой совокупности уникальных значений, позволяет не только манипулировать различными видами данных, производя объединение, пересечение и вычитание определенных элементов. Благодаря стандартным функциям по работе с множествами, программист получает возможность конвертировать их в другие типы данных, обладающие упорядоченностью, такие как строка, список и словарь.

Python Sets — GeeksforGeeks

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

Создание набора

Наборы можно создавать с помощью встроенного set() функция с итерируемым объектом или последовательностью, помещая последовательность в фигурные скобки, разделенные «запятой».

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

Python3

SET1 = SET () PRINT () PRINT () PRINT () PRINT () .0005 print (set1)   set1 = set ( "GeeksForGeeks" ) print ( "\nSet with the use of String: " ) print (set1)   String = 'GeeksForGeeks' set1 = set (String) print ( "\nSet with the use of an Object: " ) print (set1)   set1 = Set ([ "Geeks" , "для" , "Geeks" ]) . Печать ( 7 70028 " 7 70028" 70028 " . of - " ) печать (набор1)

Вывод

 Начальный пустой набор:
установлен()
Установить с использованием String:
{'e', 'r', 'G', 's', 'F', 'k', 'o'}
Установить с использованием объекта:
{'e', 'r', 'G', 's', 'F', 'k', 'o'}
Установить с использованием списка:
{'Geeks', 'For'} 

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

Python3

set1 = set ([ 1 , 2 , 4 , 4 , 3 , 3 , 3 , 6 , 5 ]) Print ( Print ( ». Neply ( " neply : "neply of ( " neply ( "neply ( " neply ( .0027 ) print (set1)   set1 = set ([ 1 , 2 , 'Geeks' , 4 , 'для' , 6 , 'Geeks' ]) Печать ( Печать ( Print. ) печать (набор1)

Вывод

 Набор с использованием цифр:
{1, 2, 3, 4, 5, 6}
Установить с использованием смешанных значений
{1, 2, 'For', 4, 6, 'Geeks'} 

Creating a set with another method

Python3

my_set = { 1 , 2 , 3 } Печать (MY_SET)

Выход

 {1, 2, 3} 

Добавление

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

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

Python3

set1 = set () print ( "Initial blank Set: " ) print (набор1)   set1. add( 8 ) set1.add( 9 ) set1.add(( 6 , 7 )) print ( "\nSet after Addition of Three elements: " ) print (set1)   for i in range ( 1 , 6 ): SET1.ADD (I) ПРИНАНИЕ ( . ) печать (набор1)

Выход

 Исходный бланк Набор:
установлен()
Установить после добавления трех элементов:
{8, 9, (6, 7)}
Установите после добавления элементов с 1 по 5:
{1, 2, 3, (6, 7), 4, 5, 8, 9} 

Использование метода update()

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

Python3

set1 = set ([ 4 , 5 , ( 6 , 7 )]) SET1.Update ([ 10 , 11 ]) Print ( Print ( Print ( 9005 9005 . ) печать (набор1)

Вывод

 Обновление с использованием добавления элементов
{4, 5, (6, 7), 10, 11} 

Доступ к набору

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

Python3

SET1 = SET ( " , " " , " " , " " , " " , " " , " . Печать ( "\ Ninitial Set" ) Печать (SET1) PRINT ( Print ( . 0028 for i in set1:      print (i, end = " " )   print ( "Geeks" в набор1)

Выход

 Исходный набор
{'Для', 'Вундеркиндов'}
Элементы набора:
For Geeks True 

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

Использование метода remove() или метода discard():

Элементы могут быть удалены из набора с помощью встроенной функции remove(), но возникает KeyError, если элемент не существует в наборе. Чтобы удалить элементы из набора без KeyError, используйте discard(), если элемент не существует в наборе, он остается неизменным.

Python3

набор1 = набор ([ 9, 10028 2 , 3 , 4 , 5 , 6 ,              7 , 8 , 9 , 10 , 11 , 12 ]) .0028 (set1)   set1.remove( 5 ) set1.remove( 6 ) print ( "\nSet after Removal of two elements: " ) print (set1)   set1. discard( 8 ) set1.discard( 9 ) print ( "\nSet after Discarding two elements: " ) print (set1)   for i in range ( 1 , 5 ): SET1.Remove (I) Печать ( "\ Nete0028 ) печать (комплект1)

Выход

 Исходный набор:
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}
Установить после удаления двух элементов:
{1, 2, 3, 4, 7, 8, 9, 10, 11, 12}
Установить после удаления двух элементов:
{1, 2, 3, 4, 7, 10, 11, 12}
Установить после удаления диапазона элементов:
{7, 10, 11, 12} 

Использование метода pop():

Функцию Pop() также можно использовать для удаления и возврата элемента из набора, но она удаляет только последний элемент набора.

Примечание: Если набор неупорядочен, то нет способа определить, какой элемент выталкивается с помощью функции pop().

Python3

set1 = set ([ 1 , 2 , 3 , 4 , 5 , 6 ,              7 , 8 , 9 , 10 , 11 , 12 ]) print ( "Initial Набор: « ) Печать (SET1) SET1. POP () PRINT ( " \ NSET.0028 ) печать (комплект1)

Выход

 Исходный набор:
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}
Установить после извлечения элемента:
{2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12} 

Использование метода clear():

Для удаления всех элементов из набора используется функция clear().

Python3

набор1 = набор ([ 1 , 2 , 3 , 4 , 5 ]) print ( "\n Initial set: " ) print (set1)     set1. clear() print ( "\nSet after clearing all the elements: " ) печать (набор1)

Выход

 Исходный набор:
{1, 2, 3, 4, 5}
Установить после очистки всех элементов:
set() 

Замороженные наборы в Python — это неизменяемые объекты, которые поддерживают только методы и операторы, которые производят результат, не затрагивая застывший набор или наборы, к которым они применяются. Хотя элементы набора можно изменить в любое время, элементы фиксированного набора остаются неизменными после создания.

Если никакие параметры не переданы, возвращается пустой замороженный набор.

Python3

String = ( 'G' , 'e' , 'e' , 'k' , 'S' , 'F' , 'O' , 'R' ) )0028 = Замороженное замороженное. "\nEmpty FrozenSet: " ) print ( frozenset ())

Output

 The FrozenSet is:
замороженный набор ({'o', 'G', 'e', ​​'s', 'r', 'F', 'k'})
Пустой замороженный набор:
замороженный набор () 

Typecasting Objects into sets

Python3

my_list = [ 1 , 2 , 3 , 3 , 4 , 5 , 5 , 6 , 2 ] my_set = SET (MY_LIST) Печать ( "MY_LIST AS AS AS:" , MY_SET) MY_STR . = SET (MY_STR) Печать ( "MY_STR AS AS:" , MY_SET1) MY_SET1) MY_SET1) MY_SET1) .0028 1 : "One" , 2 : "Two" , 3 : "Three" } my_set2 = set (my_dict) print ( "my_dict as a set: " , my_set2)

Output

 my_list as a set:  { 1, 2, 3, 4, 5, 6}
my_str как набор: {'f', 'G', 'r', 'o', 's', 'k', 'e'}
my_dict в виде набора: {1, 2, 3} 

Методы установки

99

Функция	Описание
ADD ()	Добавить элемент
. ADDES ALEMELES	ALEMPERES	. Если элемент отсутствует в наборе, вызовите KeyError
clear()	Удаляет все элементы из набора
copy()	Возвращает поверхностную копию набора
pop( )	Удаляет и возвращает произвольный элемент множества. Поднять KeyError, если набор пуст
update()	Обновляет набор с объединением самого себя и других
union()	Возвращает объединение наборов в новом наборе
2 разность( )	Возвращает разницу двух или более наборов в виде нового набора
Different_update()	Удаляет все элементы другого набора из этого набора
discard()	Удаляет элемент из набора, если он является членом. (Ничего не делать, если элемент не находится в наборе)
пересечение()	Возвращает пересечение двух множеств как новый набор
isdisjoint()	Возвращает True, если два множества имеют нулевое пересечение
issubset()	Возвращает True, если это множество содержится в другом наборе
issuperset()	Возвращает True, если этот набор содержит другой набор symmetric_difference_update()	Обновляет набор с помощью симметричной разницы самого себя и другого

Последние статьи о наборах Python

Набор программ

• Программа для приема строк, содержащих все гласные
• Программа на Python для поиска общих элементов в трех списках с использованием наборов
• Поиск отсутствующих и дополнительных значений в двух списках
• Пары полных строк в двух наборах
• Проверка правильности заданной строки является гетерограммой или нет
• Максимум и минимум в наборе
• Удаление элементов из набора
• Разность Python Set для поиска потерянного элемента из дублированного массива
• Минимальное количество подмножеств с различными элементами с использованием счетчика
• Проверка наличия в двух списках хотя бы одного общего элемента
• Программа для подсчета количества гласных с использованием наборов в заданной строке
• Различие между двумя списками пересечение, разность и симметричная разность)
• Составная строка с необычными символами в Python
• Словарь Python, набор и счетчик для проверки, могут ли частоты совпадать
• Использование Set() в Python Pangram Checking
• Set update() в Python для объединения n массивов

Полезные ссылки

• Вывод программ Python — наборы
• Последние статьи о наборах Python
• Вопросы с множественным выбором — Python

Все, что вам нужно знать о наборах Python (2022) — Dataquest

21 января 2022 г.

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

Что такое множество в Python?

Набор — это встроенная структура данных Python, используемая для хранения коллекции уникальных элементов, потенциально смешанных типов данных, в одной переменной. Наборы Python:

• Неупорядоченный – элементы набора не имеют определенного порядка
• Unindexed — мы не можем получить доступ к элементам с [i] как со списками
• Изменяемый — набор может быть изменен на целые числа или кортежи
• Iterable — мы можем перебирать элементы набора

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

Основные области применения наборов Python включают следующее:

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

Создание набора Python

Мы можем создать набор Python двумя способами:

1. С помощью встроенной функции set() с переданным итерируемым объектом (например, списком, кортежем или строкой)
2. Поместив все элементы, разделенные запятой, внутри пары фигурных скобок {}

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

Давайте посмотрим, как это все работает:

 # Первый способ: использование функции set() для итерируемого объекта
set1 = set([1, 1, 1, 2, 2, 3]) # из списка
set2 = set(('a', 'a', 'b', 'b', 'c')) # из кортежа
set3 = set('anaconda') # из строки
# Второй способ: с помощью фигурных скобок
set4 = {1, 1, 'анаконда', 'анаконда', 8. 6, (1, 2, 3), нет}
печать('Набор1:', набор1)
печать('Набор2:', набор2)
печать('Набор3:', набор3)
печать('Набор4:', набор4)
# Неверный способ: пытаться создать набор с изменяемыми элементами (список и набор)
set5 = {1, 1, 'анаконда', 'анаконда', 8.6, [1, 2, 3], {1, 2, 3}}
print('Set5:', set5) 

 Набор 1: {1, 2, 3}
Set2: {'б', 'с', 'а'}
Set3: {'n', 'o', 'd', 'c', 'a'}
Set4: {1, 8.6, 'анаконда', (1, 2, 3), нет}
-------------------------------------------------- -------------------------
TypeError Traceback (последний последний вызов)
~\AppData\Local\Temp/ipykernel_6832/1057027593.py в
     13
     14 # Неправильный способ: пытаемся создать набор с изменяемыми элементами (список и набор)
---> 15 set5 = {1, 1, 'анаконда', 'анаконда', 8.6, [1, 2, 3], {1, 2, 3}}
     16 print('Set5:', set5)
TypeError: unhashable type: 'list' 

Здесь мы можем сделать следующие наблюдения:

• Дубликаты были удалены из последовательности в каждом случае
• Изначальный порядок предметов изменился
• set4 содержит элементы разных типов данных
• Попытка создать набор Python с изменяемыми элементами (список и набор) привела к ошибке TypeError

Особый случай возникает, когда нам нужно создать пустой набор Python. Поскольку пустые фигурные скобки {} создать пустой словарь Python, мы не можем использовать этот подход для создания пустого набора в Python. Использование функции set() все еще действует в этом случае:

 пустой1 = {}
пустой2 = установить()
печать (тип (пусто1))
печать (тип (пусто2)) 

Проверка членства в наборе

Чтобы проверить, присутствует ли определенный элемент в наборе Python, мы используем ключевые слова оператора в или комбинацию ключевых слов не в :

 набор = {1, 2, 3}
печать (1 в моем наборе)
печать (1 не в моем наборе) 

 Правда
Ложь 

Доступ к значениям в наборе Python

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

.

 myset = {'а', 'б', 'с', 'г'}
для элемента в myset:
    печать (элемент) 

 б
г
а
с 

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

Изменение набора Python

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

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

 # Исходный набор
моя установка = установка ()
# Добавление одного неизменяемого элемента
мой набор.добавить('а')
печать (мой набор)
# Добавление нескольких элементов
myset.update({'b', 'c'}) # набор неизменяемых элементов
печать (мой набор)
myset.update(['d', 'd', 'd']) # список неизменяемых элементов
печать (мой набор)
myset.update(['e'], ['f']) # несколько списков неизменяемых элементов
печать (мой набор)
myset.update('fgh') # строка
печать (мой набор)
myset. update([[1, 2], [3, 4]]) # попытка добавить список изменяемых элементов (списков)
печать (мой набор) 

 {'а'}
{'б', 'в', 'а'}
{'б', 'г', 'в', 'а'}
{'е', 'е', 'б', 'г', 'в', 'а'}
{'e', 'f', 'b', 'h', 'd', 'c', 'a', 'g'}
-------------------------------------------------- -------------------------
TypeError Traceback (последний последний вызов)
~\AppData\Local\Temp/ipykernel_6832/2286239840.py в
     15 myset.update('fgh') # строка
     16 принтов (мой комплект)
---> 17 myset.update([[1, 2], [3, 4]]) # попытка добавить список изменяемых элементов (списков)
     18 принт(мой набор)
TypeError: unhashable type: 'list' 

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

Чтобы удалить элемент/элементы из набора Python, мы можем выбрать один из четырех методов:

1. discard() — удаляет определенный элемент или ничего не делает, если этот элемент отсутствует в наборе
2. remove() — удаляет определенный элемент или вызывает KeyError , если этот элемент отсутствует в наборе
3. pop() — удаляет и возвращает случайный элемент или вызывает KeyError , если набор пуст
4. clear() — очищает набор (удаляет все элементы)

Рассмотрим несколько примеров:

 # Исходный набор
набор = {1, 2, 3, 4}
печать (мой набор)
# Удаление определенного элемента с помощью метода discard()
myset. discard(1) # элемент присутствовал в наборе
печать (мой набор)
myset.discard(5) # элемент отсутствовал в наборе
печать (мой набор)
# Удаление определенного элемента с помощью метода remove()
myset.remove(4) # элемент присутствовал в наборе
печать (мой набор)
myset.remove(5) # элемент отсутствовал в наборе
печать (мой набор) 

 {1, 2, 3, 4}
{2, 3, 4}
{2, 3, 4}
{2, 3}
-------------------------------------------------- -------------------------
KeyError Traceback (последний последний вызов)
~\AppData\Local\Temp/ipykernel_6832/2462592674.py в
     12 myset.remove(4) # предмет присутствовал в наборе
     13 принт(мой набор)
---> 14 myset.remove(5) # элемент отсутствовал в наборе
     15 принтов (набор)
KeyError: 5 

 # Берем набор из кода выше
набор = {2, 3}
# Удаление и возврат случайного предмета
print(myset.pop()) # удаленный и возвращенный элемент
print(myset) # обновленный набор
# Удаление всех элементов
мой набор.очистить()
печать (мой набор)
# Попытка удалить и вернуть случайный элемент из пустого набора
мой набор. поп()
печать (мой набор) 

 2
{3}
установлен()
-------------------------------------------------- -------------------------
KeyError Traceback (последний последний вызов)
~\AppData\Local\Temp/ipykernel_6832/0087.py в
     11
     12 # Попытка удалить и вернуть случайный предмет из пустого набора
---> 13 myset.pop()
     14 принтов (набор)
KeyError: «извлечь из пустого набора» 

Встроенные функции Python для наборов

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

 # Набор с числовыми элементами
мой набор = {5, 10, 15}
print('Установить:', мой набор)
print('Размер:', len(myset))
print('Мин.:', мин.(набор))
print('Макс.:', макс.(мой набор))
print('Сумма:', сумма(myset))
печать('\п')
# Набор со строковыми элементами
myset = {'а', 'А', 'б', 'Бб'}
print('Установить:', мой набор)
print('Мин. :', мин.(набор))
print('Макс.:', макс.(мой набор))
печать('\п')
# Набор с элементами кортежа
myset = {(1, 2), (1, 0), (2, 3)}
print('Установить:', мой набор)
print('Мин.:', мин.(набор))
print('Макс.:', max(myset)) 

 Комплект: {10, 5, 15}
3 Размер
Мин: 5
Макс: 15
Сумма: 30
Установить: {'A', 'b', 'a', 'Bb'}
Мин: А
Макс: б
Установить: {(1, 0), (1, 2), (2, 3)}
Мин: (1, 0)
Макс: (2, 3) 

Обратите внимание, что в наборе {'b', 'a', 'A', 'Bb'} минимальное значение равно A , а не a . Это происходит потому, что лексикографически все прописные буквы ниже всех мизерных.

 печать (все ({1, 2}))
распечатать (все ({1, Ложь}))
печать (любой ({1, ложь}))
печать (любой ({Ложь, Ложь})) 

 Правда
ЛОЖЬ
Истинный
Ложь 

• sorted() — возвращает отсортированный список элементов набора

 набор = {4, 2, 5, 1, 3}
печать (отсортировано (myset))
myset = {'c', 'b', 'e', ​​'a', 'd'}
печать (отсортировано (myset)) 

 [1, 2, 3, 4, 5]
['а', 'б', 'с', 'г', 'е'] 

Выполнение математических операций над наборами Python

Эта группа операций включает объединение, пересечение, разность и симметричную разность. Каждое из них может осуществляться оператором или методом.

Давайте попрактикуемся в математических операциях с наборами на следующих двух наборах Python:

 а = {1, 2, 3, 4, 5}
б = {4, 5, 6, 7} 

Установить соединение

Объединение двух (или более) наборов Python возвращает новый набор всех уникальных элементов из обоих (всех) наборов. Это можно сделать с помощью | Оператор или метод union() :

 печать (а | б)
печать (б | а)
печать (а.союз (б))
печать (б.союз (а)) 

 {1, 2, 3, 4, 5, 6, 7}
{1, 2, 3, 4, 5, 6, 7}
{1, 2, 3, 4, 5, 6, 7}
{1, 2, 3, 4, 5, 6, 7} 

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

Синтаксис операции объединения для более чем двух наборов Python следующий: а | б | c или a.соединение(b, c) .

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

Установить пересечение

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

 печать (а и б)
печать (б и а)
печать (а. пересечение (б))
печать (b.intersection (а)) 

 {4, 5}
{4, 5}
{4, 5}
{4, 5} 

Опять же, в этом случае порядок наборов не имеет значения: a & b или b & a дадут один и тот же результат, и то же самое верно и при использовании метода.

Синтаксис операции пересечения для более чем двух наборов Python следующий: a & b & c или a.intersection(b, c) .

Установить разницу

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

 печать (а - б)
печать (б - а)
печать (a.difference (b))
печать (b.difference (а)) 

 {1, 2, 3}
{6, 7}
{1, 2, 3}
{6, 7} 

Здесь порядок наборов имеет значение: a - b (или a.difference(b) ) возвращает все элементы, которые есть в a , но не в b , а b - a (или b.difference(a) ) возвращает все элементы, которые есть в b , но не в и .

Синтаксис операции разности для более чем двух наборов Python следующий: a - b - c или a.difference(b, c) . В таких случаях мы сначала вычисляем a - b , затем находим разницу между результирующим набором и следующим справа, то есть c , и так далее.

Установить симметричную разность

Симметричная разница двух наборов Python возвращает новый набор элементов, присутствующих либо в первом, либо во втором наборе, но не в обоих одновременно. Другими словами, симметричная разность двух множеств — это разница между объединением множеств и пересечением множеств, и это имеет смысл и для симметричной разности множественных множеств. Мы можем выполнить эту операцию, используя 9с . Однако на этот раз мы не можем использовать метод symmetric_difference() , так как он принимает ровно один аргумент и в противном случае вызывает TypeError :

.

 а = {1, 2, 3, 4, 5}
б = {4, 5, 6, 7}
с = {7, 8, 9}
а.симметричная_разница(б, в) 

 -------------------------------------------------- --------------------------
TypeError Traceback (последний последний вызов)
~\AppData\Local\Temp/ipykernel_6832/4105073859.py в
      3 с = {7, 8, 9}
      4
----> 5 a.symmetric_difference(b, c)
TypeError: set.symmetric_difference() принимает ровно один аргумент (2 задано) 

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

Есть несколько других полезных методов и операторов для работы с двумя или более наборами Python:

• traffic_update() (или оператор &= ) — перезаписывает текущий набор с пересечением этого набора с другим (или несколькими наборами)
• разность_обновление() 9= оператор) — перезаписывает текущий набор с симметричной разностью этого набора с другим (или несколькими наборами)
• isdisjoint() (нет соответствующего оператора) — возвращает True , если два множества не имеют общих элементов, что означает, что пересечение этих множеств является пустым множеством
• issubset() (или оператор <= ) — возвращает True , если другой набор содержит каждый элемент текущего набора, включая случай, когда оба набора идентичны. Если мы хотим исключить последний случай, мы не можем использовать этот метод; вместо этого нам нужно использовать < (строго меньше) оператор
• issuperset() (или оператор >= ) — возвращает True , если текущий набор содержит каждый элемент другого набора, включая случай, когда оба набора идентичны. Если мы хотим исключить последний случай, мы не можем использовать этот метод; вместо этого нам нужно использовать оператор > (строго больше)

Заключение

В заключение давайте повторим, что мы узнали о наборах Python в этом руководстве:

• Основные характеристики набора Python
• Основные области применения наборов Python
• Два способа создания набора Python
• Как создать пустой набор Python
• Как проверить, присутствует ли определенный элемент в наборе Python
• Как получить доступ к значениям в наборе Python
• Два метода добавления новых элементов в набор Python
• Четыре метода удаления элементов из набора Python
• Какие встроенные функции Python применимы к наборам Python
• Как выполнять основные математические операции над двумя или более наборами Python с помощью метода или оператора
• Какие еще операции мы можем выполнять с двумя или более наборами Python

Теперь вы должны быть знакомы со всеми нюансами создания, изменения и использования наборов в Python.