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

Содержание

Интерактивный учебник языка Python

1. Множества

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

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

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

Задание множеств

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

A = {1, 2, 3}
A = set('qwerty')
print(A)

выведет {'e', 'q', 'r', 't', 'w', 'y'}.

Каждый элемент может входить в множество только один раз, порядок задания элементов
неважен. Например, программа:

A = {1, 2, 3}
B = {3, 2, 3, 1}
print(A == B)

выведет True, так как A и B — равные
множества.

Каждый элемент может входить в множество только один раз. set('Hello')
вернет множество из четырех элементов: {'H', 'e', 'l', 'o'}.

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

Узнать число элементов в множестве можно при помощи функции len.

Перебрать все элементы множества (в неопределенном порядке!) можно при помощи цикла for:

primes = {2, 3, 5, 7, 11}
for num in primes:
    print(num)

Проверить, принадлежит ли элемент множеству можно при помощи операции
in, возвращающей значение типа bool.
Аналогично есть противоположная операция not in.
Для добавления элемента в множество есть метод add:

A = {1, 2, 3}
print(1 in A, 4 not in A)
A.add(4)

Для удаления элемента x из множества есть два метода:
discard и remove. Их поведение различается
только в случае, когда удаляемый элемент отсутствует в множестве.
В этом случае метод discard не делает ничего, а метод
remove генерирует исключение KeyError.

Наконец, метод pop удаляет из множества один случайный
элемент и возвращает его значение. Если же множество пусто, то генерируется
исключение KeyError.

Из множества можно сделать список при помощи функции list.

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

С множествами в питоне можно выполнять обычные для математики операции над множествами.

A \| B A.union(B)	Возвращает множество, являющееся объединением множеств `A` и `B`.
A \|= B A.update(B)	Добавляет в множество `A` все элементы из множества `B`.
A & B A.intersection(B)	Возвращает множество, являющееся пересечением множеств `A` и `B`.
A &= B A.intersection_update(B)	Оставляет в множестве `A` только те элементы, которые есть в множестве `B`.= B A.symmetric_difference_update(B)	Записывает в `A` симметрическую разность множеств `A` и `B`.
A <= B A.issubset(B)	Возвращает `true`, если `A` является подмножеством `B`.
A >= B A.issuperset(B)	Возвращает `true`, если `B` является подмножеством `A`.
A < B	Эквивалентно `A <= B and A != B`
A > B	Эквивалентно `A >= B and A != B`

Ссылки на задачи доступны в меню слева. Эталонные решения теперь доступны на странице самой задачи.

Интерактивный учебник языка Python

Занятие 10. Множества

Задача «Угадай число»

Условие

Август и Беатриса играют в игру. Август загадал натуральное число от 1 до n. Беатриса пытается угадать это число, для этого она называет некоторые множества натуральных чисел. Август отвечает Беатрисе YES, если среди названных ей чисел есть задуманное или NO в противном случае. После нескольких заданныъх вопросов Беатриса запуталась в том, какие вопросы она задавала и какие ответы получила и просит вас помочь ей определить, какие числа мог задумать Август.

В первой строке задано n — максимальное число, которое мог загадать Август. Далее каждая строка содержит вопрос Беатрисы (множество чисел, разделенных пробелом) и ответ Августа на этот вопрос.

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

Во всех задачах считывайте входные данные через input() и выводите ответ через print().

Тесты

	Входные данные	Правильный ответ
Запустить тест 1	10 1 2 3 4 5 YES 2 4 6 8 10 NO HELP	1 3 5
Запустить тест 2	10 1 2 3 4 5 6 7 8 9 10 YES 1 NO 2 NO 3 NO 4 NO 6 NO 7 NO 8 NO 9 NO 10 NO HELP	5
Запустить тест 3	100 3 5 8 10 11 13 14 15 16 20 21 23 25 27 29 31 32 33 35 42 43 46 47 48 51 52 57 58 67 68 72 74 75 76 79 80 81 82 83 84 86 89 90 91 92 93 94 95 96 99 YES 1 4 7 9 14 16 17 19 20 23 25 27 28 29 30 31 32 33 41 42 45 46 48 50 52 54 59 60 61 63 66 67 68 69 70 71 73 74 79 81 82 83 89 90 91 92 93 94 95 100 YES 3 5 6 15 16 18 19 20 21 22 23 24 26 28 29 35 37 38 39 40 41 43 44 45 46 47 53 55 56 60 61 63 64 65 68 70 71 73 76 79 80 81 82 83 86 90 91 95 96 99 YES 1 2 3 5 11 16 17 23 25 31 32 33 34 35 38 39 41 43 44 46 47 49 51 53 58 59 62 63 68 69 70 72 73 74 76 77 78 79 80 81 82 83 85 86 93 94 95 97 99 100 YES 3 7 8 9 10 14 17 20 22 23 24 25 26 27 28 30 34 40 42 43 45 47 48 49 50 51 52 53 54 55 59 62 63 66 67 72 73 75 77 81 83 84 86 89 92 93 94 96 98 100 YES HELP	23 81 83

Входные данные

Правильный ответ

Что вывела программа

Результат

Запустить тест 1

10
1 2 3 4 5
YES
2 4 6 8 10
NO
HELP

1 3 5

Запустить тест 2

10
1 2 3 4 5 6 7 8 9 10
YES
1
NO
2
NO
3
NO
4
NO
6
NO
7
NO
8
NO
9
NO
10
NO
HELP

Запустить тест 3

100
3 5 8 10 11 13 14 15 16 20 21 23 25 27 29 31 32 33 35 42 43 46 47 48 51 52 57 58 67 68 72 74 75 76 79 80 81 82 83 84 86 89 90 91 92 93 94 95 96 99
YES
1 4 7 9 14 16 17 19 20 23 25 27 28 29 30 31 32 33 41 42 45 46 48 50 52 54 59 60 61 63 66 67 68 69 70 71 73 74 79 81 82 83 89 90 91 92 93 94 95 100
YES
3 5 6 15 16 18 19 20 21 22 23 24 26 28 29 35 37 38 39 40 41 43 44 45 46 47 53 55 56 60 61 63 64 65 68 70 71 73 76 79 80 81 82 83 86 90 91 95 96 99
YES
1 2 3 5 11 16 17 23 25 31 32 33 34 35 38 39 41 43 44 46 47 49 51 53 58 59 62 63 68 69 70 72 73 74 76 77 78 79 80 81 82 83 85 86 93 94 95 97 99 100
YES
3 7 8 9 10 14 17 20 22 23 24 25 26 27 28 30 34 40 42 43 45 47 48 49 50 51 52 53 54 55 59 62 63 66 67 72 73 75 77 81 83 84 86 89 92 93 94 96 98 100
YES
HELP

23 81 83

Интерактивный учебник языка Python

Занятие 10. Множества

Задача «Полиглоты»

Условие

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

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

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

Во всех задачах считывайте входные данные через input() и выводите ответ через print().

Тесты

	Входные данные	Правильный ответ
Запустить тест 1	3 3 Russian English Japanese 2 Russian English 1 English	1 English 3 English Japanese Russian
Запустить тест 2	5 1 German 1 German 1 German 1 German 1 German	1 German 1 German
Запустить тест 3	4 3 Russian Spanish German 3 Russian German Spanish 3 Spanish Russian German 3 German Russian Spanish	3 German Russian Spanish 3 German Russian Spanish

Входные данные

Правильный ответ

Что вывела программа

Результат

Запустить тест 1

3
3
Russian
English
Japanese
2
Russian
English
1
English

1
English
3
English
Japanese
Russian

Запустить тест 2

5
1
German
1
German
1
German
1
German
1
German

1
German
1
German

Запустить тест 3

4
3
Russian
Spanish
German
3
Russian
German
Spanish
3
Spanish
Russian
German
3
German
Russian
Spanish

3
German
Russian
Spanish
3
German
Russian
Spanish

Python и теория множеств / Хабр

В Python есть очень полезный тип данных для работы с множествами – это set. Об этом типе данных, примерах использования, и небольшой выдержке из теории множеств пойдёт речь далее.

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

Множество

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

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

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

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

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

Множества в Python

Множество в Python можно создать несколькими способами. Самый простой – это задать множество перечислением его элементов в фигурных скобках:

fruits = {"banana", "apple", "orange"}

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

wrong_empty_set = {}
print(type(wrong_empty_set))

# Вывод
<class "dict">

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

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

# Вывод
<class "set">

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

color_list = ["red", "green", "green", "blue", "purple", "purple"]
color_set = set(color_list)
print(color_set)

# Вывод (порядок может быть другим):
{"red", "purple", "blue", "green"}

Ещё одна возможность создания множества – это использование set comprehension. Это специальная синтаксическая конструкция языка, которую иногда называют абстракцией множества по аналогии с list comprehension (Списковое включение).

numbers = [1, 2, 2, 2, 3, 3, 4, 4, 5, 6]

# Единственное отличие со списковыми включениями - это
# использование фигурных скобок вместо квадратных
even_numbers = {
    number for number in numbers
    if number % 2 == 0
}
print(even_numbers)

# Вывод (порядок может быть другим):
{2, 4, 6}

Хешируемые объекты

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

# Множество кортежей (tuple)
records = {
    ("Москва", 17_200_000), 
    ("Санкт-Петербург", 5_400_000), 
    ("Новосибирск", 1_600_000),
    ("Москва", 17_200_000),
}

for city, population in records:
    print(city)

# Вывод (порядок может быть другим):
Москва
Новосибирск
Санкт-Петербург

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

class City:
    def __init__(self, name: str):
        self.name = name

    def __repr__(self) -> str:
        """ Определим метод __repr__ для наглядности следующих примеров
        """
        return f'City("{self.name}")'

print(City("Moscow") == City("Moscow"))

# Вывод:
False

cities = {City("Moscow"), City("Moscow")}
print(cities)

# Вывод
{City("Moscow"), City("Moscow")}

Скорее всего мы предполагаем, что объекты City("Moscow") должны быть равными, и следовательно в множестве cities должен находиться один объект.

Этого можно добиться, если определить семантику равенства для объектов класса City:

class City:
    def __init__(self, name: str):
        # Атрибут name не должен изменяться, пока объект существует
        # Для простоты пометим этот атрибут как внутренний
        self._name = name

    def __hash__(self) -> int:
        """ Хеш от объекта
        """
        return hash((self._name, self.__class__))

    def __eq__(self, other) -> bool:
        """ Определяем семантику равентсва (оператор ==)
        """
        if not isinstance(other, self.__class__):
            return False
        return self._name == other._name

    def __repr__(self) -> str:
        """ Определим метод __repr__ для наглядности следующих примеров
        """
        return f'City("{self._name}")'

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

Хеш объекта не должен изменяться, пока этот объект существует

Равные объекты должны возвращать одинаковый хеш

moscow = City("Moscow")
moscow_again = City("Moscow")

print(moscow == moscow_again and hash(moscow) == hash(moscow_again))
# Вывод:
True

# Теперь множество городов работает более логично и интуитивно
cities = {City("Moscow"), City("Kazan"), City("Moscow")}
print(cities)

# Вывод (порядок может быть другим):
{City("Kazan"), City("Moscow")}

Свойства множеств

Тип set в Python является подтипом Collection (про коллекции), из данного факта есть три важных следствия:

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

Можно получить количество элементов в множестве

Множества являются iterable-объектами

Принадлежность множеству

Проверить принадлежит ли какой-либо объект множеству можно с помощью оператора in. Это один из самых распространённых вариантов использования множеств. Такая операция выполняется в среднем за O(1) с теми же оговорками, которые существуют для хеш-таблиц.

tremendously_huge_set = {"red", "green", "blue"}

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

# Вывод:
Green is there!

if "purple" in tremendously_huge_set:
    print("Purple is there!")
else:
    print("Unfortunately, there is no purple...")

# Вывод:
Unfortunately, there is no purple...

Мощность множества

Мощность множества – это характеристика множества, которая для конечных множеств просто означает количество элементов в данном множестве. Для бесконечных множеств всё несколько сложнее.

even_numbers = {i for i in range(100) if i % 2 == 0}

# Мощность множества
cardinality = len(even_numbers)
print(cardinality)

# Вывод:
50

Перебор элементов множества

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

colors = {"red", "green", "blue"}

# Элементы множества можно перебрать с помощью цикла for
for color in colors:
    print(color)

# Вывод (порядок может быть другим):
red
green
blue

# Множества можно использовать там, где ожидается iterable-объект
color_counter = dict.fromkeys(colors, 1)
print(color_counter)

# Вывод (порядок может быть другим):
{"green": 1, "red": 1, "blue": 1}

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

Между множествами существуют несколько видов отношений, или другими словами взаимосвязей. Давайте рассмотрим возможные отношения между множествами в этом разделе.

Равные множества

Тут всё довольно просто – два множества называются равными, если они состоят из одних и тех же элементов. Как следует из определения множества, порядок этих элементов не важен.

my_fruits = {"banana", "apple", "orange", "orange"}
your_fruits = {"apple", "apple", "banana", "orange", "orange"}
print(my_fruits == your_fruits)

# Вывод:
True

Непересекающиеся множества

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

even_numbers = {i for i in range(10) if i % 2 == 0}
odd_numbers = {i for i in range(10) if i % 2 == 1}

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

# Вывод:
Множества не пересекаются!

Подмножество и надмножество

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

# Множество чисел Фибоначчи меньших 100
fibonacci_numbers = {0, 1, 2, 3, 34, 5, 8, 13, 21, 55, 89}

# Множество натуральных чисел меньших 100
natural_numbers = set(range(100))

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

# Вывод:
Подмножество!

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

# Вывод:
Надмножество!

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

empty = set()

# Методы issubset и issuperset могут принимать любой iterable-объект
print(
    empty.issubset(range(100))
    and empty.issubset(["red", "green", "blue"])
    and empty.issubset(set())
)

# Вывод:
True

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

natural_numbers = set(range(100))

if natural_numbers.issubset(natural_numbers):
    print("Подмножество!")

# Вывод:
Подмножество!

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

Рассмотрим основные операции, опредяляемые над множествами.

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

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

my_fruits = {"apple", "orange"}
your_fruits = {"orange", "banana", "pear"}

# Для объединения множеств можно использовать оператор `|`,
# оба операнда должны быть объектами типа set
our_fruits = my_fruits | your_fruits
print(our_fruits)

# Вывод (порядок может быть другим):
{"apple", "banana", "orange", "pear"}

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

# Вывод (порядок может быть другим):
{"apple", "banana", "orange", "pear"}

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

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

colors = {"red", "green", "blue"}

# Метод add добаляет новый элемент в множество
colors.add("purple")
# Добавление элемента, который уже есть в множестве, не изменяет
# это множество
colors.add("red")
print(colors)

# Вывод (порядок может быть другим):
{"red", "green", "blue", "purple"}

# Метод update принимает iterable-объект (список, словарь, генератор и т.п.)
# и добавляет все элементы в множество
numbers = {1, 2, 3}
numbers.update(i**2 for i in [1, 2, 3])
print(numbers)

# Вывод (порядок может быть другим):
{1, 2, 3, 4, 9}

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

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

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

def is_fibonacci(number: int) -> bool:
    """ Возвращает True, если number - это число Фибоначчи
    """
    assert number > 1
    a, b = 0, 1
    while a + b < number:
        a, b = b, a + b
    return a + b == number

# Множество простых чисел до 100
primes = set(filter(is_prime, range(2, 101)))

# Множество чисел Фибоначчи до 100
fibonacci = set(filter(is_fibonacci, range(2, 101)))

# Множество простых чисел до 100, которые одновременно являются
# числами Фибоначчи
prime_fibonacci = primes.intersection(fibonacci)

# Или используя оператор `&`, который определён для множеств
prime_fibonacci = fibonacci & primes

print(prime_fibonacci)

# Вывод (порядок может быть другим):
{2, 3, 5, 13, 89}

При использовании оператора & необходимо, чтобы оба операнда были объектами типа set. Метод intersection, в свою очередь, принимает любой iterable-объект. Если необходимо изменить исходное множество, а не возращать новое, то можно использовать метод intersection_update, который работает подобно методу intersection, но изменяет исходный объект-множество.

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

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

i_know: set = {"Python", "Go", "Java"}
you_know: dict = {
    "Go": 0.4, 
    "C++": 0.6, 
    "Rust": 0.2, 
    "Java": 0.9
}

# Обратите внимание, что оператор `-` работает только
# для объектов типа set
you_know_but_i_dont = set(you_know) - i_know
print(you_know_but_i_dont)

# Вывод (порядок может быть другим):
{"Rust", "C++"}

# Метод difference может работать с любым iterable-объектом,
# каким является dict, например
i_know_but_you_dont = i_know.difference(you_know)
print(i_know_but_you_dont)

# Вывод:
{"Python"}

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

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

fruits = {"apple", "orange", "banana"}

# Удаление элемента из множества. Если удаляемого элемента
# нет в множестве, то ничего не происходит
fruits.discard("orange")
fruits.discard("pineapple")
print(fruits)

# Вывод (порядок может быть другим):
{"apple", "banana"}

# Метод remove работает аналогично discard, но генерирует исключение,
# если удаляемого элемента нет в множестве
fruits.remove("pineapple")  # KeyError: "pineapple"

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

non_positive = {-3, -2, -1, 0}
non_negative = range(4)

non_zero = non_positive.symmetric_difference(non_negative)
print(non_zero)

# Вывод (порядок может быть другим):
{-1, -2, -3, 1, 2, 3}

# Метод symmetric_difference_update изменяет исходное множество
colors = {"red", "green", "blue"}
colors.symmetric_difference_update(["green", "blue", "yellow"])
print(colors)

# Вывод (порядок может быть другим):
{"red", "yellow"}

Заключение

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

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

Множества (Статья на Википедии)
Документация по типу set
Iterable-объекты (Глоссарий Python)
Hashable-объекты (Глоссарий Python)
Sets in Python
Set Theory: the Method To Database Madness

Множества в Python ✅ Подробный справочник Set

Множества в Python – это структура данных, которые содержат неупорядоченные элементы. Элементы также не является индексированным. Как и список, множество позволяет внесение и удаление элементов. Однако, есть ряд особенных характеристик, которые определяют и отделяют множество от других структур данных:

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

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

Содержание:

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

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

Есть вопросы по Python?

На нашем форуме вы можете задать любой вопрос и получить ответ от всего нашего сообщества!

Telegram Чат & Канал

Вступите в наш дружный чат по Python и начните общение с единомышленниками! Станьте частью большого сообщества!

Паблик VK

Одно из самых больших сообществ по Python в социальной сети ВК. Видео уроки и книги для вас!

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

Рассмотрим пример создания множества в Python:

num_set = {1, 2, 3, 4, 5, 6}
print(num_set)

num_set = {1, 2, 3, 4, 5, 6}

print(num_set)

Результат:

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

string_set = {«Nicholas», «Michelle», «John», «Mercy»}
print(string_set)

string_set = {«Nicholas», «Michelle», «John», «Mercy»}

print(string_set)

Результат:

{‘Michelle’, ‘Nicholas’, ‘John’, ‘Mercy’}

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

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

mixed_set = {2.0, «Nicholas», (1, 2, 3)}
print(mixed_set)

mixed_set = {2.0, «Nicholas», (1, 2, 3)}

print(mixed_set)

Результат:

{2.0, ‘Nicholas’, (1, 2, 3)}

Все элементы в упомянутом выше множестве принадлежат разным типам.

Мы также можем создать множество из списков. Это можно сделать, вызвав встроенную функцию Python под названием set(). Например:

num_set = set([1, 2, 3, 4, 5, 6])
print(num_set)

num_set = set([1, 2, 3, 4, 5, 6])

print(num_set)

Результат:

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

num_set = set([1, 2, 3, 1, 2])
print(num_set)

num_set = set([1, 2, 3, 1, 2])

print(num_set)

Результат:

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

num_set = {1, 2, 3, 1, 2}
print(num_set)

num_set = {1, 2, 3, 1, 2}

print(num_set)

Результат:

И снова, множество удалило дубликаты и вернуло только один из дублируемых объектов.

Создание пустого множества подразумевает определенную хитрость. Если вы используете пустые фигурные скобки {} в Python, вы скорее создадите пустой словарь, а не множество. Например:

Результат:

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

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

x = set()
print(type(x))

x = set()

print(type(x))

Результат:

Выдача показывает, что мы создали множество.

Доступ к элементам множеств

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

months = set([«Jan», «Feb», «March», «Apr», «May», «June», «July», «Aug», «Sep», «Oct», «Nov», «Dec»])

for m in months:
print(m)

months = set([«Jan», «Feb», «March», «Apr», «May», «June», «July», «Aug», «Sep», «Oct», «Nov», «Dec»])

for m in months:

print(m)

Результат:

March
Feb
Dec
Jan
May
Nov
Oct
Apr
June
Aug
Sep
July

March

Feb

Dec

Jan

May

Nov

Oct

Apr

June

Aug

Sep

July

Мы также можем проверить наличие элемента во множестве при помощи in, как показано ниже:

months = set([«Jan», «Feb», «March», «Apr», «May», «June», «July», «Aug», «Sep», «Oct», «Nov», «Dec»])

print(«May» in months)

months = set([«Jan», «Feb», «March», «Apr», «May», «June», «July», «Aug», «Sep», «Oct», «Nov», «Dec»])

print(«May» in months)

Результат:

Код возвращает «True«, а это означает, что элемент был найден во множестве. Аналогичным образом, при поиске элемента, который отсутствует во множестве, мы получим «False«, как показано ниже:

months = set([«Jan», «Feb», «March», «Apr», «May», «June», «July», «Aug», «Sep», «Oct», «Nov», «Dec»])

print(«Nicholas» in months) # False

months = set([«Jan», «Feb», «March», «Apr», «May», «June», «July», «Aug», «Sep», «Oct», «Nov», «Dec»])

print(«Nicholas» in months) # False

Как и ожидалось, код вернул «False«.

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

Python позволяет нам вносить новые элементы во множество при помощи функции add(). Например:

months = set([«Jan», «March», «Apr», «May», «June», «July», «Aug», «Sep», «Oct», «Nov», «Dec»])

months.add(«Feb»)
print(months)

months = set([«Jan», «March», «Apr», «May», «June», «July», «Aug», «Sep», «Oct», «Nov», «Dec»])

months.add(«Feb»)

print(months)

Результат:

{‘Oct’, ‘Dec’, ‘Feb’, ‘July’, ‘May’, ‘Jan’, ‘June’, ‘March’, ‘Sep’, ‘Aug’, ‘Nov’, ‘Apr’}

Элемент «Feb» успешно внесен во множество. Если это было множество чисел, мы не можем передать новый элемент внутри скобочек, как мы делаем это для строк. Например:

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

num_set = {1, 2, 3}

num_set.add(4)

print(num_set)

Результат:

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

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

Python позволяет нам удалять элемент из множества, но не используя индекс, так как множество элементов не индексированы. Элементы могут быть удалены при помощи обоих методов discard() и remove().

Помните, что метод discard() не будет выдавать ошибку, если элемент не был найден во множестве. Однако, если метод remove() используется и элемент не был найден, возникнет ошибка.

Давайте продемонстрируем как удалять элемент при помощи метода discard():

num_set = {1, 2, 3, 4, 5, 6}
num_set.discard(3)
print(num_set)

num_set = {1, 2, 3, 4, 5, 6}

num_set.discard(3)

print(num_set)

Результат:

Элемент 3 был удален из множества.

Аналогично, метод remove() может использоваться следующим образом:

num_set = {1, 2, 3, 4, 5, 6}
num_set.remove(3)
print(num_set)

num_set = {1, 2, 3, 4, 5, 6}

num_set.remove(3)

print(num_set)

Результат:

Теперь попробуем удалить элемент, которого нет во множестве. Сначала используем метод discard():

num_set = {1, 2, 3, 4, 5, 6}
num_set.discard(7)
print(num_set)

num_set = {1, 2, 3, 4, 5, 6}

num_set.discard(7)

print(num_set)

Результат:

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

num_set = {1, 2, 3, 4, 5, 6}
num_set.remove(7)
print(num_set)

num_set = {1, 2, 3, 4, 5, 6}

num_set.remove(7)

print(num_set)

Результат:

Traceback (most recent call last):
File «C:\Users\admin\sets.py», line 2, in <module>
num_set.remove(7)
KeyError: 7

Traceback (most recent call last):

File «C:\Users\admin\sets.py», line 2, in <module>

num_set.remove(7)

KeyError: 7

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

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

Например:

num_set = {1, 2, 3, 4, 5, 6}
print(num_set.pop())

num_set = {1, 2, 3, 4, 5, 6}

print(num_set.pop())

Результат:

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

num_set = {1, 2, 3, 4, 5, 6}
num_set.pop()
print(num_set)

num_set = {1, 2, 3, 4, 5, 6}

num_set.pop()

print(num_set)

Результат:

Эти элементы остаются во множестве.

Метод Python под названием clear() поможет удалить все элементы во множестве. Например:

num_set = {1, 2, 3, 4, 5, 6}
num_set.clear()
print(num_set)

num_set = {1, 2, 3, 4, 5, 6}

num_set.clear()

print(num_set)

Результатом является пустой set() без каких-либо элементов внутри.

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

Предположим, у нас есть два множества, А и В. Объединение этих двух множеств — это множество со всеми элементами обеих множеств. Такая операция выполняется при помощи функции Python под названием union().

Рассмотрим пример:

months_a = set([«Jan», «Feb», «March», «Apr», «May», «June»])
months_b = set([«July», «Aug», «Sep», «Oct», «Nov», «Dec»])

all_months = months_a.union(months_b)
print(all_months)

months_a = set([«Jan», «Feb», «March», «Apr», «May», «June»])

months_b = set([«July», «Aug», «Sep», «Oct», «Nov», «Dec»])

all_months = months_a.union(months_b)

print(all_months)

Результат:

{‘Oct’, ‘Jan’, ‘Nov’, ‘May’, ‘Aug’, ‘Feb’, ‘Sep’, ‘March’, ‘Apr’, ‘Dec’, ‘June’, ‘July’}

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

x = {1, 2, 3}
y = {4, 5, 6}
z = {7, 8, 9}

output = x.union(y, z)

print(output)

x = {1, 2, 3}

y = {4, 5, 6}

z = {7, 8, 9}

output = x.union(y, z)

print(output)

Результат:

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

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

x = {1, 2, 3}
y = {4, 3, 6}
z = {7, 4, 9}

output = x.union(y, z)

print(output)

x = {1, 2, 3}

y = {4, 3, 6}

z = {7, 4, 9}

output = x.union(y, z)

print(output)

Результат:

Оператор | может также использоваться при поиске объединения двух или более множеств. Например:

months_a = set([«Jan»,»Feb», «March», «Apr», «May», «June»])
months_b = set([«July», «Aug», «Sep», «Oct», «Nov», «Dec»])

print(months_a | months_b)

months_a = set([«Jan»,»Feb», «March», «Apr», «May», «June»])

months_b = set([«July», «Aug», «Sep», «Oct», «Nov», «Dec»])

print(months_a | months_b)

Результат:

{‘Feb’, ‘Apr’, ‘Sep’, ‘Dec’, ‘Nov’, ‘June’, ‘May’, ‘Oct’, ‘Jan’, ‘July’, ‘March’, ‘Aug’}

Если вы хотите создать объединение из более двух множеств, разделите названия множеств при помощи оператора | . Взглянем на пример:

x = {1, 2, 3}
y = {4, 3, 6}
z = {7, 4, 9}

print(x | y | z)

x = {1, 2, 3}

y = {4, 3, 6}

z = {7, 4, 9}

print(x | y | z)

Результат:

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

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

Операция пересечения во множествах может быть достигнута как при помощи оператора &, так и метода intersection(). Рассмотрим пример:

x = {1, 2, 3}
y = {4, 3, 6}

print(x & y) # Результат: 3

x = {1, 2, 3}

y = {4, 3, 6}

print(x & y) # Результат: 3

В обеих множествах 3 является общим элементом. То же самое может быть достигнуто при использовании метода intersection():

x = {1, 2, 3}
y = {4, 3, 6}

z = x.intersection(y)
print(z) # Результат: 3

x = {1, 2, 3}

y = {4, 3, 6}

z = x.intersection(y)

print(z) # Результат: 3

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

Разница между множествами

Предположим, у вас есть два множества: А и В. Разница между А и В (А — В) — это множество со всеми элементами, которые содержатся в А, но не в В. Соответственно, (В — А) — это множество со всеми элементами в В, но не в А.

КОД

Для определения разницы между множествами в Python, мы можем использовать как функцию difference(), так и оператор — . Рассмотрим пример:

set_a = {1, 2, 3, 4, 5}
set_b = {4, 5, 6, 7, 8}
diff_set = set_a.difference(set_b)
print(diff_set)

set_a = {1, 2, 3, 4, 5}

set_b = {4, 5, 6, 7, 8}

diff_set = set_a.difference(set_b)

print(diff_set)

Результат:

В показанном выше скрипте, только первые три элемента множества set_a отсутствуют во множестве set_b, формируя нашу выдачу. set_b)

Результат:

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

Мы можем сравнить множества в зависимости от того, какие элементы в них содержатся. Таким образом, мы можем сказать, является ли множество родительским, или дочерним от другого множества. Результат такого сравнения будет либо True, либо False.

Чтобы проверить, является ли множество А дочерним от В, мы можем выполнить следующую операцию:

Чтобы узнать является ли множество В дочерним от А, мы можем выполнить следующую операцию, соответственно:

Например:

months_a = set([«Jan», «Feb», «March», «Apr», «May», «June»])
months_b = set([«Jan», «Feb», «March», «Apr», «May», «June», «July», «Aug», «Sep», «Oct», «Nov», «Dec»])

subset_check = months_a <= months_b
superset_check = months_b >= months_a

print(subset_check)
print(superset_check)

months_a = set([«Jan», «Feb», «March», «Apr», «May», «June»])

months_b = set([«Jan», «Feb», «March», «Apr», «May», «June», «July», «Aug», «Sep», «Oct», «Nov», «Dec»])

subset_check = months_a <= months_b

superset_check = months_b >= months_a

print(subset_check)

print(superset_check)

Результат:

Дочернее и родительское множество может также быть проверено при помощи методов issubset() и issuperset(), как показано ниже:

months_a = set([«Jan»,»Feb», «March», «Apr», «May», «June»])
months_b = set([«Jan»,»Feb», «March», «Apr», «May», «June», «July», «Aug», «Sep», «Oct», «Nov», «Dec»])

subset_check = months_a.issubset(months_b)
superset_check = months_b.issuperset(months_a)

print(subset_check)
print(superset_check)

months_a = set([«Jan»,»Feb», «March», «Apr», «May», «June»])

months_b = set([«Jan»,»Feb», «March», «Apr», «May», «June», «July», «Aug», «Sep», «Oct», «Nov», «Dec»])

subset_check = months_a.issubset(months_b)

superset_check = months_b.issuperset(months_a)

print(subset_check)

print(superset_check)

Результат:

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

Методы множеств

Python содержит огромное количество встроенных методов, включая следующие:

Метод copy()

Этот метод возвращает копию множества. Например:

string_set = {«Nicholas», «Michelle», «John», «Mercy»}
x = string_set.copy()

print(x)

string_set = {«Nicholas», «Michelle», «John», «Mercy»}

x = string_set.copy()

print(x)

Результат:

{‘John’, ‘Michelle’, ‘Nicholas’, ‘Mercy’}

Выдача показывает, что х является копией множества string_set.

Метод isdisjoint()

Этот метод проверяет, является ли множество пересечением или нет. Если множества не содержат общих элементов, метод возвращает True, в противном случае — False. Например:

names_a = {«Nicholas», «Michelle», «John», «Mercy»}
names_b = {«Jeff», «Bosco», «Teddy», «Milly»}

x = names_a.isdisjoint(names_b)
print(x)

names_a = {«Nicholas», «Michelle», «John», «Mercy»}

names_b = {«Jeff», «Bosco», «Teddy», «Milly»}

x = names_a.isdisjoint(names_b)

print(x)

Результат:

Оба множества не имеют общих элементов, что делает выдачу True.

Метод len()

Этот метод возвращает длину множества, которая является общим количеством элементов во множестве. Пример:

names_a = {«Nicholas», «Michelle», «John», «Mercy»}

print(len(names_a)) # Результат: 4

names_a = {«Nicholas», «Michelle», «John», «Mercy»}

print(len(names_a)) # Результат: 4

Выдача показывает, что длина множества является 4.

Frozenset в Python

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

Множества являются изменяемыми и нехешируемыми, это значит, что мы не можем использовать их как словарные ключи. Замороженные множества (frozenset) являются хешированными и могут использоваться в качестве ключей словаря.

Для создания замороженного множества, мы используем метод frozenset(). Давайте создадим два замороженных множества, Х и Y:

X = frozenset([1, 2, 3, 4, 5, 6])
Y = frozenset([4, 5, 6, 7, 8, 9])

print(X)
print(Y)

X = frozenset([1, 2, 3, 4, 5, 6])

Y = frozenset([4, 5, 6, 7, 8, 9])

print(X)

print(Y)

Результат:

frozenset({1, 2, 3, 4, 5, 6})
frozenset({4, 5, 6, 7, 8, 9})

frozenset({1, 2, 3, 4, 5, 6})

frozenset({4, 5, 6, 7, 8, 9})

Замороженные множества поддерживают использование множественных методов Python, таких как copy(), difference(), symmetric_difference(), isdisjoint(), issubset(), intersection(), issuperset() и union().

Вывод

Данная статья предоставляет подробное введение во множества языка программирования Python. Математическое определение множеств аналогично определению множеств в Python.

Множество — это набор элементов в произвольном порядке. Само по себе, множество является изменяемым, однако его элементы являются неизменяемыми.

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

Являюсь администратором нескольких порталов по обучению языков программирования Python, Golang и Kotlin. В составе небольшой команды единомышленников, мы занимаемся популяризацией языков программирования на русскоязычную аудиторию. Большая часть статей была адаптирована нами на русский язык и распространяется бесплатно.

E-mail: [email protected]

Образование
Universitatea Tehnică a Moldovei (utm.md)

2014 — 2018 Технический Университет Молдовы, ИТ-Инженер. Тема дипломной работы «Автоматизация покупки и продажи криптовалюты используя технический анализ»
2018 — 2020 Технический Университет Молдовы, Магистр, Магистерская диссертация «Идентификация человека в киберпространстве по фотографии лица»

Множества в Python ~ PythonRu

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

Что это

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

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

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

Создать объект set в Python можно двумя путями:

Использовать фигурные скобки {}
Использовать встроенную функцию set()

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

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

s1 = {}  
s2 = {1, 'pythonru', 20.67}

Еще один способ создать (или определить) множество Python — использовать функцию set(). Пример ниже.

s1 = set()  
s2 = set({1, 'pythonru', 20.67})

Первый способ (с использованием фигурных скобок {}) определенно проще.

Нет ограничений на количество элементов в объекте set, но запрещено добавлять элементы изменяемых типов, такие как список или словарь. Если попробовать добавить список (с набором элементов), интерпретатор выдаст ошибку.

s5 = { 1, 2, 3, [5, 6, 7, 8] }
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

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

Объекты set в Python поддерживают добавление элементов двумя путями: по одному с помощью метода add() или группами с помощью update(). Оба описаны дальше.

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

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

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

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

Больше одного элемента можно добавить с помощью update(). Код следующий.

set2 = {1, 2, 3}
set2.update([4, 5, 6])
print(set2)

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

Один или несколько элементов можно удалить из объекта set с помощью следующих методов. Их отличие в виде возвращаемого значения.

remove()
discard()
pop()

remove()

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

Следующий код показывает метод remove() в действии.

set1 = {1, 2, 3, 4, 'a', 'p'}
set1.remove(2)
print(set1) 
{1, 3, 4, 'a', 'p'}

set1.remove(5)

discard()

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

set1 = {1, 3, 4, 'a', 'p'} 
set1.discard('a')
print(set1)


set1.discard(6)
print(set1)

pop()

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

set1 = {1, 3, 4, “p”} 
set1.pop()
3

Методы множеств Python

У объектов set есть несколько встроенных методов. Увидеть их все можно с помощью команды dir(). dir(object) в Python показывает самые важные атрибуты разных типов объектов.

Вот что выдаст функция для объекта set в Python.

set1 = { 1, 2, 3, 4}

dir(set1)
['__and__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__iand__', '__init__', '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']

Часто используемые функции множеств Python

Из всех методов, перечисленных в dir(), только несколько из них используются постоянно. Вы уже знакомы с add, update, remove, pop и discard.

Вот на какие также стоит обратить внимание.

Функция принадлежности (членства)

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

num_set = {1 ,3, 5, 7, 9, 10}
7 in num_set


2 in num_set


1 not in num_set

Разные функции

len(num_set) — вернет количество элементов в объекте set.

copy() — создает копию существующего множества и сохраняет ее в новом объекте.

new_set = num_set.copy()

clear() —очищает множество (удаляет все элементы за раз)

num_set.clear()

del — удаляет множество целиком

del num_set

Дальше речь пойдет об операциях union, issubset, issuperset, difference_update и других.

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

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

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

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

A = {1, 2, 3}
B = {2, 3, 4, 5}
C = A | B  
C = A.union(B) 
print(C)

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

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

A = {1, 2, 3, 4}
B = {3,4,5,6}
C = A & B  
C = A.intersection(B)  
print(C)

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

При использовании на двух множествах вы получаете новый объект, содержащий элементы, которые есть в первом, но не втором (в данном случае — в множестве “A”). B
C = A.symmetric_difference(B)
print(C)

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

Множество B (SetB) называется подмножество A (SetA), если все элементы SetB есть в SetA. Проверить на подмножество в Python можно двумя способами: с помощью символа <= или метода issubset(). Он возвращает True или False в зависимости от результата.

A = {1, 2, 3, 4, 5} 
B = {2,3,4}
B <= A  
B.issubset(A)

Множество A (SetA) называется надмножество B (SetB), если все элементы SetB есть в SetA. Проверить на надмножество в Python можно двумя способами: с помощью символа >= или метода issuperset(). Он возвращает True или False в зависимости от результата.

A = {1, 2, 3, 4, 5} 
B = {2,3,4}
A >= B  
A.issuperset(B)

Бонус

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

Ответ: просто передайте список функции set() и все дубли будут удалены автоматически. Результат потом можно снова передать в функцию list(), чтобы он снова стал списком.

List1 = [1, 2, 3, 5, 3, 2, 4, 7]
List_without_duplicate = set(List1)
print(List_without_duplicate)


back_to_list = list(List_without_duplicate)

Выводы

Теперь вы знакомы с объектами set в Python и теорией множеств на практике. Знаете как создавать множества, менять их, добавляя или удаляя элементы. Вы также знаете, как использовать метод dir и другие методы для множеств в Python. Наконец, познакомились с операциями union, intersection, difference, symmetric difference, subset и superset.

урок по работе с множествами для начинающих ~ PythonRu

Предыдущий урок: Кортежи (tuple)

Множества — неупорядоченная и не индексируемая последовательность. В Python множества пишутся в фигурных скобках.
Создание множества:

thisset = {"set", "list", "tuple"}
print(thisset)

Вывод:

{'set', 'tuple', 'list'}

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

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

thisset = {"set", "list", "tuple", "list"}
print(thisset)

Вывод:

{'set', 'tuple', 'list'}

Доступ к элементам

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

thisset = {"set", "list", "tuple"}
for x in thisset:  
    print(x)

Вывод:

set
list
tuple

Проверим присутствует ли "dict" этой последовательности:

thisset = {"set", "list", "tuple"}
print("dict" in thisset)

Вывод:

False

Изменение элементов

Вы не можете менять элементы set, но можете добавлять новые.

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

Чтобы добавить один элемент в set используйте метод add().
Чтобы добавить больше одного — метод update().

thisset = {"set", "list", "tuple"}
thisset.add("dict")  
print(thisset)

Вывод:

{'tuple', 'set', 'list', 'dict'}

Добавьте несколько элементов в thisset, используя метод update():

thisset = {"set", "list", "tuple"}
thisset.update(["dict",  "class",  "int"])
print(thisset)

Вывод:

{'dict', 'tuple', 'set', 'list', 'class', 'int'}

Получите длину set

Чтобы определить сколько элементов есть в наборе, воспользуйтесь методом len().

thisset = {"set", "list", "tuple"}
print(len(thisset))

Вывод:

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

Чтобы удалить элемент в множестве, воспользуйтесь методом remove(), или discard().
Уберем «list» используя метод remove():

thisset = {"set", "list", "tuple"}
thisset.remove("list")  
print(thisset)

Вывод:

{'tuple', 'set'}

Примечание: Если элемент, который нужно удалить не существует, remove() вызовет ошибку.
Убрать “list” используя метод discard():

thisset = {"set", "list", "tuple"}
thisset.discard("list")  
print(thisset)

Вывод:

{'tuple', 'set'}

Примечание. Если элемент для удаления не существует, discard() не будет вызывать ошибку.

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

Возвращаемое значение метода pop () — это удаленный элемент.

thisset = {"set", "list", "tuple"}
x =  thisset.pop()  
print(x)  
print(thisset)

Вывод:

list
{'tuple', 'set'}

Метод clear() очистит множество:

thisset = {"set", "list", "tuple"}
thisset.clear()  
print(thisset)

Вывод:

set()

Ключевое слово del полностью удалит множество:

thisset = {"set", "list", "tuple"}
del thisset
print(thisset)

Конструктор set()

Есть так же возможность использовать конструктор set() для создания множества.

thisset = set(("set", "list", "tuple"))  
print(thisset)

Вывод:

{'set', 'tuple', 'list'}

Методы Set

В Python есть встроенные методы, с помощью которых вы можете работать с sets.

Метод	Значение
add(x)	Добавляет элементы x в set
clear()	Удаляет элементы из set
copy()	Возвращает копию set
x.difference(y)	Возвращает множество элементов, которые есть в х, но нет в y
x.difference_update(y)	Удаляет элементы, которые есть в x и y
discard(x)	Удаляет указанный элемент
x.intersection(y)	Возвращает множество, являющийся пересечением x и y
intersection_update(y)	Удаляет элементы в множестве, которых нет в других заданных y
x.isdisjoint(y)	True, если x и y не имеют общих элементов
x.issubset(y)	True, если все элементы из x есть в y
issuperset()	True, если все элементы из y есть в x
pop()	Удаляет и возвращает последний элемент
remove()	Удаляет указанный элемент
x.symmetric_difference(y)	Возвращает множество элементов, которые не пересекаются в х и y
symmetric_difference_update()	Добавляет элементы, которых нет в другом множестве
union()	Объединяет несколько множеств
x.update(y, z)	Объединяет несколько множеств, перезаписывая x

Далее: Словарь (dict)

Наборы Python

myset = {«яблоко», «банан», «вишня»}

Набор

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

Set — один из 4 встроенных типов данных в Python, используемых для хранения коллекций
данные, остальные 3 — список,
Кортеж и Словарь — все с разным качеством и использованием.

Набор — это набор, состоящий одновременно из неупорядоченных и неиндексированных .

Наборы записываются фигурными скобками.

Пример

Создать набор:

thisset = {«яблоко», «банан», «вишня»}
печать (thisset)

Попробуй сам »

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

Предметы набора

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

Неупорядоченный

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

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

без изменений

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

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

Дубликаты не допускаются

В наборах не может быть двух предметов с одинаковым значением.

Пример

Повторяющиеся значения игнорируются:

thisset = {«яблоко», «банан», «вишня», «яблоко»}

печать (thisset)

Попробуй сам »

Определите длину набора

Чтобы определить, сколько элементов в наборе, используйте метод len () .

Пример

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

thisset = {«яблоко», «банан», «вишня»}

print (len (thisset))

Попробуй сам »

Установить элементы — типы данных

Элементы набора могут иметь любой тип данных:

Пример

Типы данных String, int и boolean:

set1 = {«яблоко», «банан», «вишня»}
set2 = {1, 5, 7, 9, 3}
set3 = {True, False, False}

Попробуй сам »

Набор может содержать разные типы данных:

Пример

Набор со строками, целыми числами и логическими значениями:

set1 = {«abc», 34, True, 40, «мужской»}

Попробуй сам »

тип ()

С точки зрения Python, наборы определяются как объекты с типом данных set:

<класс 'набор'>

Пример

Какой тип данных у набора?

myset = {«яблоко», «банан», «вишня»}
print (type (myset))

Попробуй сам »

Конструктор set ()

Также можно использовать set ()
конструктор для создания набора.

Пример

Использование конструктора set () для создания набора:

thisset = set ((«яблоко», «банан», «вишня»)) # обратите внимание на двойные круглые скобки
print (thisset)

Попробуй сам »

Коллекции Python (массивы)

В языке программирования Python существует четыре типа коллекционных данных:

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

* Начиная с версии Python 3.7, словари упорядочены как .
В Python 3.6 и ранее словари неупорядоченные .

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

8.7. наборы — неупорядоченные коллекции уникальных элементов — документация Python 2.7.18

Не рекомендуется, начиная с версии 2.6: Встроенный набор / frozenset типов заменяет этот модуль.

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

Как и другие коллекции, наборы поддерживают x в наборе , len (set) и для x in установить. Будучи неупорядоченной коллекцией, наборы не записывают позицию элемента или
порядок вставки. Соответственно, наборы не поддерживают индексацию, нарезку или
другое поведение, подобное последовательности.

Большинство установленных приложений используют класс Set , который предоставляет все методы набора
кроме __hash __ () .Для продвинутых приложений, требующих хеш-метода,
класс ImmutableSet добавляет метод __hash __ () , но опускает методы
которые изменяют содержимое набора. Оба Set и ImmutableSet
унаследован от BaseSet , абстрактного класса, полезного для определения того,
что-то есть набор: isinstance (obj, BaseSet) .

Заданные классы реализованы с помощью словарей. Соответственно,
требования к элементам набора такие же, как и к ключам словаря; а именно,
что элемент определяет как __eq __ () , так и __hash __ () .Как результат,
наборы не могут содержать изменяемые элементы, такие как списки или словари. Тем не мение,
они могут содержать неизменяемые коллекции, такие как кортежи или экземпляры
ImmutableSet . Для удобства реализации наборов наборов внутренние наборы
автоматически преобразуются в неизменяемую форму, например,
Set ([Set (['dog'])]) преобразуется в Set ([ImmutableSet (['dog'])]) .

класс комплектов. Установить ([ итерация ]): Создает новый пустой объект Set .Если необязательный итерируемый
параметр, обновляет набор элементами, полученными в результате итерации.
Все элементы в итеративном должны быть неизменными или преобразовываться в
неизменяемый, используя протокол, описанный в разделе Протокол для автоматического преобразования в неизменяемый.

класс комплектов. ImmutableSet ([ итерация ])

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

Поскольку объекты ImmutableSet предоставляют метод __hash __ () , они
могут использоваться как элементы набора или как ключи словаря. ImmutableSet
объекты не имеют методов для добавления или удаления элементов, поэтому все
элементы должны быть известны при вызове конструктора.

8.7.1. Установить объекты

Экземпляры Set и ImmutableSet обеспечивают следующее
операций:

Эксплуатация	Эквивалент	Результат
`лён (с)`		количество элементов в наборе с (мощность)
`x дюймов`		тест x для членства в s
`x не в с`		тест x на отсутствие членства в с
`с.issubset (т)`	`с <= t`	проверяет, каждый ли элемент в с есть в т
`s.issuperset (t)`	`s> = t`	проверяет, каждый ли элемент в т находится в дюймах с
`s.union (t)`	`с \| т`	новый набор с элементами из обоих s и t
`с.перекресток (т)`	`S&T`	новый набор с элементами, общими для s и t
`s разница (т)`	`с - т`	новый комплект с элементами s но не в т
`s.symmetric_difference (t)`	`с ^ т`	новый набор с элементами либо s или t , но не оба
`с.копия ()`		новый набор с мелкой копией с

Обратите внимание, неоператорные версии union () , correction () ,
difference () и symric_difference () примет любую итерацию как
Аргумент. Напротив, их аналогам на основе операторов требуются их
аргументы, которые должны быть установлены. Это исключает подверженные ошибкам конструкции вроде
Set ('abc') & 'cbs' в пользу более читабельного
Набор ('abc').перекресток ('cbs') .

Изменено в версии 2.3.1: Раньше требовалось устанавливать все аргументы.

Кроме того, как Set , так и ImmutableSet поддерживают набор для установки
сравнения. Два набора равны тогда и только тогда, когда каждый элемент каждого набора равен
содержится в другом (каждый является подмножеством другого). Набор меньше
другой набор тогда и только тогда, когда первый набор является правильным подмножеством второго набора
(является подмножеством, но не равно). Набор больше другого, если и только
если первый набор является правильным надмножеством второго набора (является надмножеством, но является
не равный).

Сравнение подмножества и равенства не сводится к полному упорядочиванию.
функция. Например, любые два непересекающихся множества не равны и не являются подмножествами
друг друга, поэтому все следующего возвращают Ложь : a , a == b , или a> b . Соответственно, наборы не реализуют метод __cmp __ () .

Поскольку наборы определяют только частичное упорядочение (отношения подмножеств), вывод метод list.sort () не определен для списков наборов.

В следующей таблице перечислены операции, доступные в ImmutableSet , но не найдено в Set :

Эксплуатация	Результат
`хеш (ов)`	возвращает хеш-значение для с

В следующей таблице перечислены операции, доступные в Set , но не найденные в ImmutableSet :

Эксплуатация	Эквивалент	Результат
`с.обновление (t)`	с \| = т	возвратный комплект с с элементами добавлено т
`s.intersection_update (t)`	с & = т	возвратный комплект с только сохранение элементы также найдены в т
`s.difference_update (t)`	с - = т	возвратный комплект с после снятия элементы найдены в т
`с.= т`	возвратный комплект с с элементами от с или т , но не одновременно
`s.add (x)`		добавить элемент x для установки s
`с. Удалить (x)`		удалить x из набора s ; поднимает `KeyError` , если отсутствует
`с.выбросить (x)`		удаляет x из набора s , если присутствует
`s.pop ()`		удалить и вернуть произвольный элемент от с ; поднимает `KeyError` , если пусто
`s.clear ()`		удалить все элементы из набора с

Обратите внимание, неоператорные версии update () , correction_update () , difference_update () и symric_difference_update () примет любой итеративный аргумент.

Изменено в версии 2.3.1: Раньше требовалось устанавливать все аргументы.

Также обратите внимание, что модуль также включает в себя метод union_update () , который является псевдоним для обновления () . Метод включен для обратной совместимости. Программистам следует предпочесть метод update () , потому что он поддерживается встроенный набор () и фризенсет () типов.

`8.7.2. Пример`

 >>> из наборов импорта Установить
>>> инженеры = Set (['Джон', 'Джейн', 'Джек', 'Дженис'])
>>> программисты = Set (['Джек', 'Сэм', 'Сьюзен', 'Дженис'])
>>> manager = Set (['Джейн', 'Джек', 'Сьюзен', 'Зак'])
>>> сотрудники = инженеры | программисты | менеджеры # союз
>>> engineering_management = инженеры и менеджеры # перекресток
>>> fulltime_management = менеджеры - инженеры - программисты # разница
>>> инженеры.add ('Marvin') # добавить элемент
>>> инженеры печати
Установить (['Джейн', 'Марвин', 'Дженис', 'Джон', 'Джек'])
>>> employee.issuperset (инженеры) # суперсет-тест
Ложь
>>> employee.update (инженеры) # обновление из другого набора
>>> employee.issuperset (инженеры)
Правда
>>> для группы в [инженеры, программисты, менеджеры, сотрудники]:
... group.discard ('Susan') # безоговорочно удалить элемент
... группа печати
...
Установить (['Джейн', 'Марвин', 'Дженис', 'Джон', 'Джек'])
Установить (['Дженис', 'Джек', 'Сэм'])
Установить (['Джейн', 'Зак', 'Джек'])
Установить (['Джек', 'Сэм', 'Джейн', 'Марвин', 'Дженис', 'Джон', 'Зак'])

`8.7.3. Протокол автоматического преобразования в неизменяемый`

Наборы могут содержать только неизменяемые элементы. Для удобства изменяемый Set объекты автоматически копируются в ImmutableSet перед добавлением как элемент набора.

Механизм состоит в том, чтобы всегда добавлять хешируемый элемент, или, если он не является hashable, элемент проверяется на наличие __as_immutable __ () метод, который возвращает неизменяемый эквивалент.

Начиная с , объекты Set имеют метод __as_immutable __ () , возвращающий экземпляр ImmutableSet , можно создавать наборы наборов.

Аналогичный механизм необходим для __contains __ () и remove () методы, которым необходимо хешировать элемент, чтобы проверить его членство в наборе. Те методы проверяют элемент на хэшируемость и, если нет, проверяют наличие __as_tempohibited_immutable __ () метод, который возвращает элемент, обернутый класс, который предоставляет временные методы для __hash __ () , __eq __ () , и __ne __ () .

Альтернативный механизм избавляет от необходимости создавать отдельную копию оригинала. изменяемый объект.

Установить объекты , реализующие метод __as_tempoporary_immutable __ () который возвращает объект Set , обернутый новым классом _TempoporaryImmutableSet .

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

`8.7.4. Сравнение со встроенным набором`

типа

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

Set и ImmutableSet были переименованы в set и морозильник .
Нет эквивалента BaseSet .Вместо этого используйте isinstance (x, (комплект, фрозенсет)) .
Хэш-алгоритм для встроенных модулей работает значительно лучше (меньше столкновения) для большинства наборов данных.
Во встраиваемых версиях соленые огурцы занимают больше места.
Встроенные версии не имеют метода union_update () . Вместо этого используйте эквивалентный метод update () .
Встроенные версии не имеют метода _repr (sorted = True) .Вместо этого используйте встроенные функции repr () и sorted () : (отсортировано) .
Встроенная версия не имеет протокола для автоматического преобразования в неизменный. Многие сочли эту функцию запутанной, и никто в сообществе сообщили, что нашли ему реальное применение.

Набор объектов

`- документация Python 3.10.0`

В этом разделе подробно описан общедоступный API для set и frozenset объекты.Любые функции, не перечисленные ниже, лучше всего доступны с помощью протокол абстрактных объектов (включая PyObject_CallMethod () , PyObject_RichCompareBool () , PyObject_Hash () , PyObject_Repr () , PyObject_IsTrue () , PyObject_Print () и PyObject_GetIter () ) или протокол абстрактного числа (включая PyNumber_And () , PyNumber_Subtract () , PyNumber_Or () , PyNumber_Xor () , PyNumber_InPlaceAnd () , PyNumber_InPlaceSubtract () , PyNumber_InPlaceOr () и PyNumber_InPlaceXor () ).

тип PySetObject: Этот подтип PyObject используется для хранения внутренних данных для обоих устанавливает и frozenset объектов. Это похоже на PyDictObject в том, что это фиксированный размер для небольших наборов (во многом как хранилище кортежей) и будет указывать на отдельный блок памяти переменного размера для среднего и большого размера наборы (аналогично хранилищу списков). Ни одно из полей этой структуры не должно быть считаются общедоступными и могут быть изменены.Весь доступ должен осуществляться через документированный API, а не путем манипулирования значениями в структуре.

PyTypeObject PySet_Type: Часть стабильного ABI. Это экземпляр PyTypeObject , представляющий Python набор типа.

PyTypeObject PyFrozenSet_Type: Часть стабильного ABI. Это экземпляр PyTypeObject , представляющий Python фризенсет тип.

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

int PySet_Check (PyObject * p ): Возвращает истину, если p является объектом набора или экземпляром подтипа. Эта функция всегда успешна.

int PyFrozenSet_Check (PyObject * p ): Вернуть true, если p является объектом frozenset или экземпляром подтип.Эта функция всегда успешна.

int PyAnySet_Check (PyObject * p ): Вернуть true, если p является объектом set , объектом frozenset или экземпляр подтипа. Эта функция всегда успешна.

int PySet_CheckExact (PyObject * p ): Вернуть истину, если p является объектом набора , но не экземпляром подтип.Эта функция всегда успешна.

int PyAnySet_CheckExact (PyObject * p ): Вернуть true, если p является объектом set или объектом frozenset , но не экземпляр подтипа. Эта функция всегда успешна.

int PyFrozenSet_CheckExact (PyObject * p ): Вернуть true, если p является объектом frozenset , но не экземпляром подтип.Эта функция всегда успешна.

PyObject * PySet_New (PyObject * итерация ): Возвращаемое значение: Новая ссылка. Часть стабильного ABI. Вернуть новый набор , содержащий объекты, возвращенные итерацией . В итерация может быть NULL для создания нового пустого набора. Верните новый набор на успех или NULL в случае неудачи. Поднимите TypeError , если итерация не является на самом деле итеративно.Конструктор также полезен для копирования набора ( c = набор (-ов) ).

PyObject * PyFrozenSet_New (PyObject * итерация ): Возвращаемое значение: Новая ссылка. Часть стабильного ABI. Вернуть новый frozenset , содержащий объекты, возвращенные итерацией . Итерируемый может иметь значение NULL для создания нового пустого фризенсета. Верните новый устанавливается в случае успеха или NULL в случае неудачи.Поднимите TypeError , если итерабельно на самом деле не повторяется.

Следующие функции и макросы доступны для экземпляров set или frozenset или экземпляры их подтипов.

Py_ssize_t PySet_Size (PyObject * любой набор ): Часть стабильного ABI. Возвращает длину объекта set или frozenset . Эквивалентно len (любая) .Вызывает PyExc_SystemError , если anyset не является устанавливает , frozenset или экземпляр подтипа.

Py_ssize_t PySet_GET_SIZE (PyObject * anyset ): Макро-форма PySet_Size () без проверки ошибок.

int PySet_Contains (PyObject * anyset , PyObject * ключ ): Часть стабильного ABI. Вернуть 1 , если найдено, 0 , если не найдено, и -1 , если обнаружена ошибка. В отличие от метод Python __contains __ () , эта функция не выполняет автоматически преобразовать нехешируемые наборы во временные замороженные наборы. Вызов TypeError , если ключ не кэшируется. Поднимите PyExc_SystemError , если anyset не является устанавливает , frozenset или экземпляр подтипа.

int PySet_Add (PyObject * набор , PyObject * ключ ): Часть стабильного ABI. Добавить ключ к экземпляру набора . Также работает с frozenset экземпляры (например, PyTuple_SetItem () его можно использовать для заполнения значений новых фрозенсетов до того, как они будут подвергнуты воздействию другого кода). Возврат 0 на успех или -1 при неудаче. Вызов TypeError , если ключ бесстрашный. Поднимите MemoryError , если нет места для роста. Поднять SystemError , если set не является экземпляром set или его подтип.

Следующие функции доступны для экземпляров set или его подтипы, но не для экземпляров frozenset или его подтипов.

int PySet_Discard (PyObject * установить , PyObject * ключ ): Часть стабильного ABI. Вернуть 1 , если найдено и удалено, 0 , если не найдено (никаких действий не предпринимается), и -1 , если обнаружена ошибка.Не вызывает KeyError при отсутствии ключей. Поднять TypeError , если ключ не хэшируется. В отличие от Python discard () метод, эта функция не преобразует автоматически нехешируемые наборы в временные фрозенсеры. Поднимите PyExc_SystemError , если set не является экземпляр задает или его подтип.

PyObject * PySet_Pop (PyObject * установить ): Возвращаемое значение: Новая ссылка. Часть стабильного ABI. Возвращает новую ссылку на произвольный объект в наборе и удаляет объект из набора . Вернуть NULL в случае ошибки. Поднимите KeyError , если набор пуст. Поднимите SystemError , если set не является экземпляром задает или его подтип.

int PySet_Clear (PyObject * установить ): Часть стабильного ABI. Очистить существующий набор от всех элементов.

`Наборов в Python - Real Python`

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

`Операторы и методы`

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

Для двух наборов, x1 и x2 , объединение x1 и x2 представляет собой набор, состоящий из всех элементов любого набора.

Рассмотрим эти два набора:

  x1 = {'foo', 'bar', 'baz'}
x2 = {'baz', 'qux', 'quux'}

Объединение x1 и x2 составляет {'foo', 'bar', 'baz', 'qux', 'quux'} .

Примечание: Обратите внимание, что элемент 'baz' , который появляется как в x1 , так и в x2 , появляется в объединении только один раз. Наборы никогда не содержат повторяющихся значений.

В Python объединение множеств можно выполнить с помощью | оператор:

>>>

  >>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'baz', 'qux', 'quux'}
>>> x1 | x2
{'baz', 'quux', 'qux', 'bar', 'foo'}

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

>>>

  >>> x1.union (x2)
{'baz', 'quux', 'qux', 'bar', 'foo'}

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

Обратите внимание на разницу между этими двумя утверждениями:

>>>

  >>> x1 | ('баз', 'qux', 'quux')
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
    x1 | ('баз', 'qux', 'quux')
TypeError: неподдерживаемые типы операндов для |: 'set' и 'tuple'

>>> x1.union (('баз', 'qux', 'quux'))
{'baz', 'quux', 'qux', 'bar', 'foo'}

Оба пытаются вычислить объединение x1 и кортежа ('baz', 'qux', 'quux') .Это не удается с | , но успешно с помощью метода .union () .

`Доступные операторы и методы`

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

x1.union (x2 [, x3...])

x1 | x2 [| x3 ...]

Вычислить объединение двух или более множеств.

Набор Union

x1.union (x2) и x1 | x2 оба возвращают набор всех элементов в x1 или x2 :

>>>

  >>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'baz', 'qux', 'quux'}

>>> x1.union (x2)
{'foo', 'qux', 'quux', 'baz', 'bar'}

>>> x1 | x2
{'foo', 'qux', 'quux', 'baz', 'bar'}

Оператором или методом можно указать более двух наборов:

>>>

  >>> a = {1, 2, 3, 4}
>>> b = {2, 3, 4, 5}
>>> c = {3, 4, 5, 6}
>>> d = {4, 5, 6, 7}

>>> а.союз (b, c, d)
{1, 2, 3, 4, 5, 6, 7}

>>> а | б | c | d
{1, 2, 3, 4, 5, 6, 7}

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

x1.пересечение (x2 [, x3 ...])

x1 и x2 [& x3 ...]

Вычислить пересечение двух или более множеств.

Set Intersection

x1.intersection (x2) и x1 & x2 возвращает набор элементов, общих для x1 и x2 :

>>>

  >>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'baz', 'qux', 'quux'}

>>> x1.пересечение (x2)
{'baz'}

>>> x1 и x2
{'baz'}

Вы можете указать несколько наборов с помощью метода и оператора пересечения, как и с помощью set union:

>>>

  >>> a = {1, 2, 3, 4}
>>> b = {2, 3, 4, 5}
>>> c = {3, 4, 5, 6}
>>> d = {4, 5, 6, 7}

>>> a.intersection (b, c, d)
{4}

>>> a & b & c & d
{4}

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

разность x1 (x2 [, x3 ...])

x1 - x2 [- x3 ...]

Вычислите разницу между двумя или более наборами.

Set Difference

x1.difference (x2) и x1 - x2 возвращают набор всех элементов, которые находятся в x1 , но не в x2 :

>>>

  >>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'baz', 'qux', 'quux'}

>>> x1.difference (x2)
{'фу', 'бар'}

>>> x1 - x2
{'фу', 'бар'}

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

Еще раз, вы можете указать более двух наборов:

>>>

  >>> a = {1, 2, 3, 30, 300}
>>> b = {10, 20, 30, 40}
>>> c = {100, 200, 300, 400}

>>> a. разница (b, c)
{1, 2, 3}

>>> а - б - в
{1, 2, 3}

Если указано несколько наборов, операция выполняется слева направо.Оператор допускает несколько наборов, метод .symmetric_difference () не поддерживает:

>>>

  >>> a = {1, 2, 3, 4, 5}
>>> b = {10, 2, 3, 4, 50}
>>> c = {1, 50, 100}

>>> a.symmetric_difference (b, c)
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
    a.symmetric_difference (b, c)
TypeError: symric_difference () принимает ровно один аргумент (задано 2)

x1.isdisjoint (x2)

Определяет, есть ли у двух наборов какие-либо общие элементы.

x1.isdisjoint (x2) возвращает True , если x1 и x2 не имеют общих элементов:

>>>

  >>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'baz', 'qux', 'quux'}

>>> x1.isdisjoint (x2)
Ложь

>>> x2 - {'baz'}
{'quux', 'qux'}
>>> x1.isdisjoint (x2 - {'baz'})
Правда

Если x1.isdisjoint (x2) равно True , то x1 & x2 - это пустой набор:

>>>

  >>> x1 = {1, 3, 5}
>>> x2 = {2, 4, 6}

>>> x1.isdisjoint (x2)
Правда
>>> x1 и x2
установленный()

Примечание: Нет оператора, соответствующего методу .isdisjoint () .

x1. Подмножество (x2)

x1 <= x2

Определите, является ли один набор подмножеством другого.

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

x1.issubset (x2) и x1 <= x2 возвращает True , если x1 является подмножеством x2 :

>>>

  >>> x1 = {'foo', 'bar', 'baz'}
>>> x1.issubset ({'foo', 'bar', 'baz', 'qux', 'quux'})
Правда

>>> x2 = {'baz', 'qux', 'quux'}
>>> х1 <= х2
Ложь

Набор считается подмножеством самого себя:

>>>

  >>> x = {1, 2, 3, 4, 5}
>>> х.issubset (x)
Правда
>>> х <= х
Правда

Может показаться странным. Но это соответствует определению - каждый элемент x находится в x .

x1

Определяет, является ли один набор подходящим подмножеством другого.

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

x1 возвращает True , если x1 является правильным подмножеством x2 :

>>>

  >>> x1 = {'foo', 'bar'}
>>> x2 = {'foo', 'bar', 'baz'}
>>> x1 >> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'foo', 'bar', 'baz'}
>>> x1

Хотя набор считается подмножеством самого себя, он не является правильным подмножеством самого себя:

>>>

  >>> x = {1, 2, 3, 4, 5}
>>> х <= х
Правда
>>> х <х
Ложь

Примечание: Оператор < - единственный способ проверить, является ли набор правильным подмножеством.Соответствующего метода нет.

x1. Набор (x2)

x1> = x2

Определите, является ли один набор надмножеством другого.

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

x1.issuperset (x2) и x1> = x2 возвращает True , если x1 является расширенным набором x2 :

>>>

  >>> x1 = {'foo', 'bar', 'baz'}

>>> x1.Issueperset ({'фу', 'бар'})
Правда

>>> x2 = {'baz', 'qux', 'quux'}
>>> x1> = x2
Ложь

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

>>>

  >>> x = {1, 2, 3, 4, 5}
>>> x.issuperset (x)
Правда
>>> х> = х
Правда

x1> x2

Определяет, является ли один набор подходящим надмножеством другого.

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

x1> x2 возвращает True , если x1 является правильным расширением x2 :

>>>

  >>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'foo', 'bar'}
>>> x1> x2
Правда

>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'foo', 'bar', 'baz'}
>>> x1> x2
Ложь

Набор не является полноценным надмножеством самого себя:

>>>

  >>> x = {1, 2, 3, 4, 5}
>>> х> х
Ложь

Примечание: Оператор > - единственный способ проверить, является ли набор правильным надмножеством.Соответствующего метода нет.

Набор Python

`(с примерами)`

Набор - это неупорядоченный набор предметов. Каждый элемент набора уникален (без дубликатов) и должен быть неизменяемым (не может быть изменен).

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

Наборы

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

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

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

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

  # Различные типы наборов в Python
# набор целых чисел
my_set = {1, 2, 3}
печать (my_set)

# набор смешанных типов данных
my_set = {1.0, "Привет", (1, 2, 3)}
печать (my_set)

Выход

  {1, 2, 3}
{1.0, (1, 2, 3), "Привет"}

Попробуйте также следующие примеры.

  # set не может иметь дубликатов
# Вывод: {1, 2, 3, 4}
my_set = {1, 2, 3, 4, 3, 2}
печать (my_set)

# мы можем сделать набор из списка
# Вывод: {1, 2, 3}
my_set = set ([1, 2, 3, 2])
печать (my_set)

# набор не может иметь изменяемые элементы
# здесь [3, 4] - изменяемый список
# это вызовет ошибку.

my_set = {1, 2, [3, 4]}

Выход

  {1, 2, 3, 4}
{1, 2, 3}
Отслеживание (последний вызов последний):
  Файл «<строка>», строка 15, в <модуле>
    my_set = {1, 2, [3, 4]}
TypeError: нехешируемый тип: 'list'

Создать пустой набор немного сложно.

Пустые фигурные скобки {} сделают пустой словарь в Python. Чтобы создать набор без каких-либо элементов, мы используем функцию set () без аргументов.

  # Различать набор и словарь при создании пустого набора

# инициализировать a с помощью {}
а = {}

# проверить тип данных
печать (тип (а))

# инициализировать a с помощью set ()
а = набор ()

# проверить тип данных
печать (тип (а))

Выход

  <класс 'dict'>

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

Наборы изменяемы.Однако, поскольку они неупорядочены, индексация не имеет смысла.

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

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

  # инициализировать my_set
my_set = {1, 3}
печать (my_set)

# my_set [0]
# если вы раскомментируете строку выше
# вы получите сообщение об ошибке
# TypeError: объект 'set' не поддерживает индексацию

# добавить элемент
# Вывод: {1, 2, 3}
my_set.добавить (2)
печать (my_set)

# добавить несколько элементов
# Вывод: {1, 2, 3, 4}
my_set.update ([2, 3, 4])
печать (my_set)

# добавить список и установить
# Вывод: {1, 2, 3, 4, 5, 6, 8}
my_set.update ([4, 5], {1, 6, 8})
печать (my_set)

Выход

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

`Снятие элементов из набора`

Определенный элемент можно удалить из набора с помощью методов discard () и remove () .

Единственное различие между ними состоит в том, что функция discard () оставляет набор без изменений, если элемент отсутствует в наборе. С другой стороны, функция remove () вызовет ошибку в таком состоянии (если элемент отсутствует в наборе).

Это проиллюстрировано на следующем примере.

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

# инициализировать my_set
my_set = {1, 3, 4, 5, 6}
печать (my_set)

# отбросить элемент
# Вывод: {1, 3, 5, 6}
my_set.выбросить (4)
печать (my_set)

# удалить элемент
# Вывод: {1, 3, 5}
my_set.remove (6)
печать (my_set)

# отбросить элемент
# отсутствует в my_set
# Вывод: {1, 3, 5}
my_set.discard (2)
печать (my_set)

# удалить элемент
# отсутствует в my_set
# вы получите сообщение об ошибке.
# Вывод: KeyError

my_set.remove (2)

Выход

  {1, 3, 4, 5, 6}
{1, 3, 5, 6}
{1, 3, 5}
{1, 3, 5}
Отслеживание (последний вызов последний):
  Файл «<строка>», строка 28, в <модуле>
KeyError: 2

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

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

Мы также можем удалить все элементы из набора с помощью метода clear () .

  # инициализировать my_set
# Вывод: набор уникальных элементов
my_set = set ("HelloWorld")
печать (my_set)

# выталкиваем элемент
# Вывод: случайный элемент
печать (my_set.pop ())

# вытолкнуть другой элемент
my_set.pop ()
печать (my_set)

# очистить my_set
# Вывод: set ()
my_set.Чисто()
печать (my_set)

печать (my_set)

Выход

  {'H', 'l', 'r', 'W', 'o', 'd', 'e'}
ЧАС
{'r', 'W', 'o', 'd', 'e'}
набор ()

`Операции над наборами Python`

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

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

  >>> A = {1, 2, 3, 4, 5}
>>> B = {4, 5, 6, 7, 8}

`Комплект Union`

Набор Union в Python

Объединение A и B - это набор всех элементов из обоих наборов.

Объединение выполняется с использованием | оператор. То же самое можно сделать с помощью метода union () .

  # Установить метод объединения
# инициализировать A и B
А = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}

# использовать | оператор
# Вывод: {1, 2, 3, 4, 5, 6, 7, 8}
печать (A | B)

Выход

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

Попробуйте следующие примеры в оболочке Python.

  # использовать функцию объединения
>>> А.союз (B)
{1, 2, 3, 4, 5, 6, 7, 8}

# использовать функцию объединения на B
>>> B. союз (A)
{1, 2, 3, 4, 5, 6, 7, 8}

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

Set Intersection в Python

Intersection of A и B - это набор элементов, общих для обоих наборов.

Пересечение выполняется с помощью оператора и . То же самое можно сделать с помощью метода crossction () .

  # Пересечение множеств
# инициализировать A и B
А = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}

# используйте & оператор
# Вывод: {4, 5}
печать (A и B)

Выход

  {4, 5}

Попробуйте следующие примеры в оболочке Python.

  # использовать функцию пересечения на A
>>> A. пересечение (B)
{4, 5}

# использовать функцию пересечения на B
>>> Б. пересечение (А)
{4, 5}

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

Set Difference в Python

Отличие набора B от набора A ( A - B ) - это набор элементов, которые есть только в A , но не в B . Аналогично, B - A - это набор элементов в B , но не в A .

Разница выполняется с помощью оператора - . То же самое можно сделать с помощью метода difference () .

  # Разница двух наборов
# инициализировать A и B
А = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}

# использовать - оператор на A
# Вывод: {1, 2, 3}
печать (A - B)

Выход

  {1, 2, 3}

Попробуйте следующие примеры в оболочке Python.

  # использовать функцию разницы на A
>>> А.Б)

Выход

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

Попробуйте следующие примеры в оболочке Python.

  # использовать функцию symric_difference на A
>>> A.symmetric_difference (B)
{1, 2, 3, 6, 7, 8}

# использовать функцию symric_difference на B
>>> Б.symmetric_difference (A)
{1, 2, 3, 6, 7, 8}

`Другие методы набора Python`

Существует множество методов набора, некоторые из которых мы уже использовали выше.Вот список всех методов, доступных с заданными объектами:

Метод	Описание
добавить ()	Добавляет элемент в набор
прозрачный ()	Удаляет все элементы из набора
копия ()	Возвращает копию набора
разница ()	Возвращает разницу двух или более наборов как новый набор
difference_update ()	Удаляет все элементы другого набора из этого набора
отказаться ()	Удаляет элемент из набора, если он является членом.(Ничего не делать, если элемент отсутствует в наборе)
перекресток ()	Возвращает пересечение двух наборов как новый набор
crossction_update ()	Обновляет набор с пересечением самого себя и другого
isdisjoint ()	Возвращает `Истина` , если два набора имеют нулевое пересечение
issubset ()	Возвращает `Истина` , если другой набор содержит этот набор
Issueperset ()	Возвращает `True` , если этот набор содержит другой набор
поп ()	Удаляет и возвращает произвольный элемент набора.Вызывает `KeyError` , если набор пуст
удалить ()	Удаляет элемент из набора. Если элемент не является членом, вызывает `KeyError`
simric_difference ()	Возвращает симметричную разность двух наборов как новый набор
simric_difference_update ()	Обновляет набор с симметричной разницей между собой и другим
штуцер ()	Возвращает объединение наборов в новом наборе
обновление ()	Обновляет набор объединением себя и других

`Прочие операции с наборами`

`Установить тест на членство`

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

  # ключевое слово в наборе
# инициализировать my_set
my_set = set ("яблоко")

# проверяем, присутствует ли 'a'
# Вывод: True
print ('a' в my_set)

# проверяем, присутствует ли 'p'
# Вывод: Ложь
print ('p' отсутствует в my_set)

Выход

  Верно
Ложь

`Итерация по набору`

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

  >>> для буквы в наборе ("яблоко"):
... печать (письмо)
...
а
п
е
л

`Встроенные функции с набором`

Встроенные функции, такие как all () , any () , enumerate () , len () , max () , min () , sorted () , sum () и т. Д. Обычно используются с наборами для выполнения различных задач.

Функция	Описание
все ()	Возвращает `True` , если все элементы набора истинны (или если набор пуст).
любой ()	Возвращает `True` , если какой-либо элемент набора истинен. Если набор пуст, возвращает `False` .
перечислить ()	Возвращает перечисляемый объект. Он содержит индекс и значение для всех элементов набора в виде пары.
лён ()	Возвращает длину (количество элементов) в наборе.
макс. ()	Возвращает самый большой элемент в наборе.
мин ()	Возвращает наименьший элемент в наборе.
отсортировано ()	Возвращает новый отсортированный список из элементов в наборе (не сортирует сам набор).
сумма ()	Возвращает сумму всех элементов в наборе.

`Питон Frozenset`

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

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

Frozensets можно создать с помощью функции frozenset ().

Этот тип данных поддерживает такие методы, как copy () , difference () , correction () , isdisjoint () , issubset () , Issueperset () , Simric_difference () и . союз () .Будучи неизменным, он не имеет методов, которые добавляют или удаляют элементы.

  # Frozensets
# инициализировать A и B
A = frozenset ([1, 2, 3, 4])
B = Frozenset ([3, 4, 5, 6])

Попробуйте эти примеры в оболочке Python.

  >>> A.isdisjoint (B)
Ложь
>>> A. разница (B)
Frozenset ({1, 2})
>>> A | B
Frozenset ({1, 2, 3, 4, 5, 6})
>>> A.add (3)
...
AttributeError: объект 'frozenset' не имеет атрибута 'add'

`Набор Python ()`

Функция set () создает набор в Python.

`Пример`

  list_numbers = [1, 2, 3, 4, 2, 5]

  # создать набор из списка
numbers_set = набор (list_numbers) 
печать (набор_числов)

# Вывод: {1, 2, 3, 4, 5}

`set () Синтаксис`

Синтаксис set () :

 набор (итерация)

Рекомендуемая литература: Python устанавливает

`set () Параметры`

set () принимает единственный необязательный параметр:

iterable (необязательно) - последовательность (строка, кортеж и т. Д.)) или коллекции (набор, словарь и т. д.) или объект-итератор, который нужно преобразовать в набор.

`set () Возвращаемое значение`

set () возвращает:

пустой набор, если параметры не переданы
набор, составленный из заданного итеративного параметра

`Пример 1. Создание наборов из строки, кортежа, списка и диапазона`

  # пустой набор
печать (установить ())

# из строки
  print (set ('Python')) 

# из кортежа
print (set (('a', 'e', 'i', 'o', 'u')))

# из списка
print (set (['a', 'e', 'i', 'o', 'u']))

# из диапазона
  отпечаток (набор (диапазон (5)))

Выход

  комплект ()
{'P', 'o', 't', 'n', 'y', 'h'}
{'a', 'o', 'e', 'u', 'i'}
{'a', 'o', 'e', 'u', 'i'}
{0, 1, 2, 3, 4}

Примечание: Мы не можем создавать пустые наборы, используя синтаксис {} , поскольку он создает пустой словарь.Чтобы создать пустой набор, мы используем set () .

`Пример 2: Создание наборов из другого набора, словаря и фиксированного набора`

  # из набора
print (set ({'a', 'e', 'i', 'o', 'u'}))

# из словаря
  print (set ({'a': 1, 'e': 2, 'i': 3, 'o': 4, 'u': 5})) 

# из замороженного набора
  frozen_set = frozenset (('а', 'е', 'я', 'о', 'и'))
print (set (frozen_set))

Выход

  {'a', 'o', 'i', 'e', 'u'}
{'a', 'o', 'i', 'e', 'u'}
{'a', 'o', 'e', 'u', 'i'}

`Пример 3. Создание set () для настраиваемого итеративного объекта`

  класс PrintNumber:
    def __init __ (self, max):
        себя.макс = макс

    def __iter __ (сам):
        self.num = 0
        вернуть себя

    def __next __ (сам):
        если (self.num> = self.max):
            поднять StopIteration
        self.num + = 1
        вернуть self.num

# print_num - повторяемый
print_num = PrintNumber (5)

# создание набора
  печать (набор (print_num))

Выход

  {1, 2, 3, 4, 5}

`Python Sets Tutorial: Set Operations & Sets vs Lists`

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

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

Если вы хотите отточить свои навыки Python или вы только новичок, обязательно ознакомьтесь с нашей карьерой программиста Python на DataCamp.

Итак, приступим.

`Инициализировать набор`

Наборы - это изменяемая коллекция различных (уникальных) неизменяемых значений, которые не упорядочены.

Вы можете инициализировать пустой набор с помощью set () .

  emptySet = set ()

Чтобы инициализировать набор со значениями, вы можете передать список в set () .

  dataScientist = set (['Python', 'R', 'SQL', 'Git', 'Tableau', 'SAS'])
dataEngineer = set (['Python', 'Java', 'Scala', 'Git', 'SQL', 'Hadoop'])

Если вы посмотрите на выходные данные переменных dataScientist и dataEngineer выше, обратите внимание, что значения в наборе не в том порядке, в котором они были добавлены.Это потому, что наборы неупорядочены.

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

  dataScientist = {'Python', 'R', 'SQL', 'Git', 'Tableau', 'SAS'}
dataEngineer = {'Python', 'Java', 'Scala', 'Git', 'SQL', 'Hadoop'}

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

`Добавление и удаление значений из наборов`

Чтобы добавить или удалить значения из набора, вы сначала должны инициализировать набор.

  # Инициализировать набор со значениями
graphicDesigner = {'InDesign', 'Photoshop', 'Acrobat', 'Premiere', 'Bridge'}

`Добавить значения в набор`

Вы можете использовать метод add , чтобы добавить значение в набор.

  graphicDesigner.add ('Иллюстратор')

Важно отметить, что вы можете добавлять в набор только неизменяемое значение (например, строку или кортеж).Например, вы получите TypeError, если попытаетесь добавить список в набор.

  graphicDesigner.add (['Powerpoint', 'Blender'])

`Удалить значения из набора`

Есть несколько способов удалить значение из набора.

Вариант 1: Для удаления значения из набора можно использовать метод remove .

  graphicDesigner.remove ('Иллюстратор')

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

Вариант 2: Для удаления значения из набора можно использовать метод discard .

  graphicDesigner.discard ('Премьера')

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

Вариант 3: Вы также можете использовать метод pop , чтобы удалить и вернуть произвольное значение из набора.

  graphicDesigner.pop ()

Важно отметить, что метод вызывает KeyError, если набор пуст.

`Удалить все значения из набора`

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

  graphicDesigner.clear ()

`Перебор набора`

Как и многие стандартные типы данных Python, можно выполнять итерацию по набору.

  # Инициализировать набор
dataScientist = {'Python', 'R', 'SQL', 'Git', 'Tableau', 'SAS'}

за умение работать с данными
    печать (умение)

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

`Преобразовать набор в упорядоченные значения`

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

  тип (отсортировано (dataScientist))

Приведенный ниже код выводит значения в наборе dataScientist в убывающем алфавитном порядке (в данном случае Z-A).

  отсортировано (dataScientist, reverse = True)

`Удалить дубликаты из списка`

Часть содержимого этого раздела ранее была исследована в учебнике 18 «Наиболее распространенные вопросы о списках Python», но важно подчеркнуть, что наборы - это самый быстрый способ удаления дубликатов из списка. Чтобы показать это, давайте изучим разницу в производительности между двумя подходами.

Подход 1: Используйте набор для удаления дубликатов из списка.

  печать (список (набор ([1, 2, 3, 1, 7])))

Подход 2: Используйте составление списка для удаления дубликатов из списка (если вы хотите освежить в памяти понимание списка, см. Это руководство).

  def remove_duplicates (исходный):
    unique = []
    [unique.append (n) для n в оригинале, если n не в уникальном]
    возврат (уникальный)

print (remove_duplicates ([1, 2, 3, 1, 7]))

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

  импортное время

# Подход 1: время выполнения
print (timeit.timeit ('список (набор ([1, 2, 3, 1, 7]))', число = 10000))

# Подход 2: время выполнения
print (timeit.timeit ('remove_duplicates ([1, 2, 3, 1, 7])', globals = globals (), number = 10000))

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

`Установить методы работы`

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

В наборах Python

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

Прежде чем исследовать эти методы, давайте начнем с инициализации двух наборов dataScientist и dataEngineer.

  dataScientist = set (['Python', 'R', 'SQL', 'Git', 'Tableau', 'SAS'])
dataEngineer = set (['Python', 'Java', 'Scala', 'Git', 'SQL', 'Hadoop'])

`штуцер`

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

  # установить встроенную функцию union
dataScientist.union (dataEngineer)

# Эквивалентный результат
dataScientist | dataEngineer

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

`перекресток`

Пересечение двух наборов dataScientist и dataEngineer, обозначаемое dataScientist ∩ dataEngineer, представляет собой набор всех значений, которые являются значениями как dataScientist, так и dataEngineer.

  # Операция пересечения
dataScientist.пересечение (dataEngineer)

# Эквивалентный результат
dataScientist & DataEngineer

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

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

  # Инициализировать набор
graphicDesigner = {'Illustrator', 'InDesign', 'Photoshop'}

# У этих наборов есть общие элементы, поэтому он вернет False
dataScientist.isdisjoint (dataEngineer)

# У этих наборов нет общих элементов, поэтому он вернет True
dataScientist.isdisjoint (graphicDesigner)

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

`разница`

Разница между двумя наборами dataScientist и dataEngineer, обозначаемая dataScientist \ dataEngineer, представляет собой набор всех значений dataScientist, которые не являются значениями dataEngineer.

  # Разница в работе
dataScientist.difference (dataEngineer)

# Эквивалентный результат
dataScientist - dataEngineer

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

`симметричная_разница`

Симметричная разность двух наборов dataScientist и dataEngineer, обозначаемая dataScientist △ dataEngineer, представляет собой набор всех значений, которые являются значениями ровно одного из двух наборов, но не обоих.dataEngineer

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

`Установить понимание`

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

  {навык для навыков в ['SQL', 'SQL', 'PYTHON', 'PYTHON']}

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

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

  {навык для навыка в ['GIT', 'PYTHON', 'SQL'], если навык не в {'GIT', 'PYTHON', 'JAVA'}}

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

`Тесты на членство`

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

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

  # Инициализировать список
possibleList = ['Python', 'R', 'SQL', 'Git', 'Tableau', 'SAS', 'Java', 'Spark', 'Scala']

# Тест на членство
"Python" в списке возможных

Нечто подобное можно сделать и для наборов.Наборы просто оказываются более эффективными.

  # Инициализировать набор
possibleSet = {'Python', 'R', 'SQL', 'Git', 'Tableau', 'SAS', 'Java', 'Spark', 'Scala'}

# Тест на членство
'Python' в возможном наборе

Поскольку possibleSet является набором, а значение 'Python' является значением possibleSet , это можно обозначить как 'Python' ∈ possibleSet .

Если бы у вас было значение, которое не было частью набора, например 'Fortran' , оно было бы обозначено как 'Fortran' ∉ possibleSet .

`Подмножество`

Практическое применение понимания членства - это подмножества.

Давайте сначала инициализируем два набора.

  possibleSkills = {'Python', 'R', 'SQL', 'Git', 'Tableau', 'SAS'}
mySkills = {'Python', 'R'}

Если каждое значение набора mySkills также является значением набора possibleSkills , тогда mySkills считается подмножеством possibleSkills , математически записанным mySkills ⊆ possibleSkills .

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

  mySkills.issubset (possibleSkills)

Поскольку в этом случае метод возвращает True, это подмножество. На диаграмме Венна ниже обратите внимание, что каждое значение набора mySkills также является значением набора possibleSkills .

`Frozensets`

Вы встретили вложенные списки и кортежи.

  # Вложенные списки и кортежи
nestedLists = [['the', 12], ['to', 11], ['of', 9], ['and', 7], ['that', 6]]
nestedTuples = (('то', 12), ('к', 11), ('из', 9), ('и', 7), ('то', 6))

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

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

Вы делаете фризенсет, используя фризенсет () .

  # Инициализировать заморозку
immutableSet = frozenset ()

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

  nestedSets = set ([frozenset ()])

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

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

.