Как выглядит инструкция добавления элемента х в множество s

Время на прочтение
10 мин

Количество просмотров 38K

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

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

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

a = { "a", "b", "c", "d", "e", "f", "f" }
# конструктору set можно передать любой итерируемый объект
b = set(["a", "b", "c", "d", "e", "f"])
c = set(("a", "b", "c", "d", "e", "e", "f", "f"))
# порядок элементов неважен
d = set(["d", "e", "f", "a", "b", "c"])
# деструктурирование списка
e = { *["a", "b", "c", "d", "e", "f"] }
assert a == b == c == d == e

# в одном множестве могут храниться значения разных типов
f = set(["a", True, 123])
g = { "a", True, 123, True, 123 }
assert f == g

# set() - это множество, а {} - это словарь
assert set() != {}

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

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

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

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

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

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

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

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

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

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

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

a = { "a", "b" , "c" }
b = { "a", "c", "d" }

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

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

def add_to_set1(a, b):
    a.update(b)
    return a

def add_to_set2(a, b):
    a = a.union(b)
    return a

a = { "a", "b" , "c" }
b = { "a", "c", "d" }

# Исходный объект был модифицирован
# и будет равен возвращённому объекту
assert a == add_to_set1(a, b)

a = { "a", "b" , "c" }
b = { "a", "c", "d" }

# Исходный объект НЕ был модифицирован
# и не будет равен возвращённому объекту
assert a != add_to_set2(a, b)

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

a = { "a", "b" , "c" }
b = { "a", "c", "d" }
assert { *a, *b } == { "a", "b", "c", "d" }

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

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

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

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

  • Аналог .add() — .remove().

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

  • Аналог .union() — .difference() или -.

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

a = { "a", "b" , "c" }
a.remove("b")
assert a == { "a", "c" }

a = { "a", "b" , "c" } 
# Так же, как .update(), эта команда ожидает итерируемый объект
# В результате здесь удаляются "a" и "b",
# а не целая строка "ab"
a.difference_update("ab")
assert a == { "c" }

a = { "a", "b" , "c" } 
a.difference_update(["ab"])
# "ab" нет в составе элементов множества, поэтому ничего не удаляется
assert a == { "a", "b", "c" }

# Оператор -, эквивалент метода .difference(),
# не модифицирует исходный объект
a = { "a", "b" , "c" } 
b = a - { "b", "c" }
assert a != b and b == { "a" }

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

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

  • .clear() — очищает множество.

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

  • .pop() — удалит случайный элемент из множества и вернёт этот элемент.

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

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

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

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

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

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

Пример:

a = { "a", "b", "c" }
b = { "b", "c", "d" }
assert a & b == { "b", "c" }

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

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

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

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

Пример:

a = { "a", "b", "c" }
b = { "b", "c", "d" }
assert a ^ b == { "a", "d" }

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

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

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

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

a = { "a", "b", "c" }
assert "a" in a
assert "d" not in a

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

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

a = { "a", "b", "c" }
b = { "a", "b" }
assert a.issubset(b) == (a <= b) == False
assert b.issubset(a) == (b <= a) == True
# Множество - это подмножество (но не истинное подмножество) самого себя
assert a.issubset(a) == (a <= a) and not a < a
# изменение направления
assert a >= b and a > b

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

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

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

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

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

# преобразование списка в множество с добавлением 1 к каждому элементу
assert { i+1 for i in [1, 2, 3, 4] } == { 2, 3, 4, 5 }

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

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

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

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

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

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

# можно перейти от ключа к значениям
graph = {
    "A": ["B", "D", "F"],
    "B": ["C", "F"],
    "C": ["D", "E"],
    "D": "A",
    "E": "F",
    "F": "B",
}

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

Граф

Граф

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

from graphviz import Digraph

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

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

import random

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

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

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

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

Итоги

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

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

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

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

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

Присоединяйтесь к нашей команде.

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

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

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

# Создаем множество с помощью фигурных скобок
my_set = {1, 2, 3, 4, 5}
print(my_set)  # Вывод: {1, 2, 3, 4, 5}

# Создаем множество с помощью функции set()
my_set = set([1, 2, 3, 4, 5])
print(my_set)  # Вывод: {1, 2, 3, 4, 5}

Обратите внимание, что множества не содержат повторяющихся элементов:

duplicates_set = {1, 2, 2, 3, 3, 3}
print(duplicates_set)  # Вывод: {1, 2, 3}

Python-разработчик: новая работа через 9 месяцев

Получится, даже если у вас нет опыта в IT

Получить
программу

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

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

Для добавления элемента в множество используется метод add():

my_set = {1, 2, 3}
my_set.add(4)
print(my_set)  # Вывод: {1, 2, 3, 4}

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

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

my_set = {1, 2, 3, 4}
my_set.remove(4)
print(my_set)  # Вывод: {1, 2, 3}

my_set.discard(3)
print(my_set)  # Вывод: {1, 2}

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

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

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

union_set = set_a.union(set_b)
# или
union_set = set_a | set_b

print(union_set)  # Вывод: {1, 2, 3, 4, 5, 6}

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

Для нахождения пересечения множеств используется метод intersection() или оператор &.

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

intersection_set = set_a.intersection(set_b)
# или
intersection_set = set_a &amp; set_b

print(intersection_set)  # Вывод: {3, 4}

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

Для нахождения разности множеств используется метод difference() или оператор -.

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

difference_set = set_a.difference(set_b)
# или
difference_set = set_a - set_b

print(difference_set)  # Вывод: {1, 2}

Заключение

Мы рассмотрели основные операции над множествами в Python. Теперь вы знаете, как создавать множества, добавлять и удалять элементы, а также выполнять такие операции, как объединение, пересечение и разность множеств. Используйте эти знания для улучшения своего кода и обработки наборов данных. Удачи вам в изучении Python! 😉

Время чтения 2 мин.

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

Содержание

  1. Добавление элемента набора в Python
  2. Синтаксис
  3. Параметры
  4. Возвращаемое значение
  5. Пример
  6. Добавление кортежа в Python Set
  7. Добавление списка в набор
  8. Добавление набора в существующий набор в Python

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

Синтаксис

Параметры

set add() принимает параметр element, который необходимо добавить в набор.

Возвращаемое значение

Метод add() не возвращает никакого значения.

Пример

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

data = {«Snyder», «Cut», «Trailer», «Is»}

print(data)

data.add(«Here»)

print(«After appending an element»)

print(data)

Вывод:

{‘Cut’, ‘Is’, ‘Trailer’, ‘Snyder’}

After appending an element

{‘Is’, ‘Snyder’, ‘Cut’, ‘Trailer’, ‘Here’}

Вывод неупорядочен, и он добавил элемент «Here» в набор. Set не гарантирует печать элементов в том порядке, в котором они определены.

Метод add() полезен для добавления к набору только одного значения.

Добавление кортежа в Python Set

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

data = {«Batman», «Joker», «Superman», «Wonder Woman»}

# tuple

tup =(«Flash», «Aquaman»)

print(data)

# using add() function to add tuple

data.add(tup)

print(«After appending a tuple»)

print(data)

Вывод:

{‘Batman’, ‘Wonder Woman’, ‘Superman’, ‘Joker’}

After appending a tuple

{‘Batman’, ‘Wonder Woman’,(‘Flash’, ‘Aquaman’), ‘Superman’, ‘Joker’}

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

Чтобы добавить кортеж в набор Python, используйте метод set.update(). Python set update() — это встроенный метод, используемый для добавления элементов из набора в другой набор.

data = {«Batman», «Joker», «Superman», «Wonder Woman»}

tup =(«Flash», «Aquaman»)

print(data)

data.update(tup)

print(«After appending a tuple using update() method»)

print(data)

Вывод:

{‘Wonder Woman’, ‘Joker’, ‘Batman’, ‘Superman’}

After appending a tuple using update() method

{‘Joker’, ‘Aquaman’, ‘Superman’, ‘Wonder Woman’, ‘Flash’, ‘Batman’}

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

Добавление списка в набор

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

data = {«Batman», «Joker», «Superman», «Wonder Woman»}

list = [«Flash», «Aquaman»]

print(data)

data.update(list)

print(«After appending a list using update() method»)

print(data)

Вывод:

{‘Wonder Woman’, ‘Superman’, ‘Batman’, ‘Joker’}

After appending a list using update() method

{‘Wonder Woman’, ‘Superman’, ‘Aquaman’, ‘Joker’, ‘Flash’, ‘Batman’}

Добавление набора в существующий набор в Python

Чтобы добавить набор в существующий набор Python, используйте метод set.update().

data = {«Batman», «Joker», «Superman», «Wonder Woman»}

set = {«Flash», «Aquaman»}

print(data)

data.update(set)

print(«After appending a set using update() method»)

print(data)

Вывод:

{‘Joker’, ‘Batman’, ‘Superman’, ‘Wonder Woman’}

After appending a set using update() method

{‘Aquaman’, ‘Flash’, ‘Wonder Woman’, ‘Joker’, ‘Superman’, ‘Batman’}

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

Для хранения наборов уникальных объектов в Python был введен еще один тип данных, называемый «множества».

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

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

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

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

# Множество из одного эл-та.
s_1 = {1}
print(s_1, end='nn')		

# Множество из 3-х эл-тов.
s_2 = {'a', 0.1, ('b', 2)}
print(s_2, end='nn')		
			
# Вывело {1, 'a'}.
s_3 = {'a', 1, 1}
print(s_3, end='nn')			

# unhashable type: 'list'
s_1 = {'a', 0.1, ['b', 2]}	
{1}

{0.1, 'a', ('b', 2)}

{1, 'a'}

unhashable type: 'list'





		
			

Пример №1. Создание множеств в Python (часть 1).

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

Однако создать пустое множество можно при помощи встроенного конструктора типа
set([iterable]), который в качестве аргумента может принимать итерируемый объект, например, строку или список.
Если использовать конструктор без аргумента, он как раз и вернет нам пустое множество set(). Если же использовать
конструктор с аргументом, он вернет нам множество с элементами переданного итерируемого объекта (см. пример №2).

# Пустое множество.
s_0 = set()
print(s_0, end='nn')			

# Мн-во с 1 эл-том (запятая обязательна).
s_1 = set((1,))
print(s_1, end='nn')		

# Множество из 3-х эл-тов.
s_2 = set(('a', 0.1, ('b', 2)))
print(s_2, end='nn')		
			
# Вывело {1, 'a'}.
s_3 = set(('a', 1, 1))
print(s_3, end='nn')			
			
# Получаем поверхностную копию мно-ва.
s_4 = set(s_3)
print(s_4, end='nn')

# unhashable type: 'list'
s_5 = set(('a', 0.1, ['b', 2]))
set()

{1}

{0.1, ('b', 2), 'a'}

{1, 'a'}

{1, 'a'}

unhashable type: 'list'
 
 
 






		
			

Пример №2. Создание множеств в Python (часть 2).

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

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

# Генерируем множество из строки.
s_1 = {simb for simb in '123'}
# У меня вывело {'3', '2', '1'}.
print(s_1, end='nn')

# Используем более сложное выражение.
s_2 = {int(num)*5 for num in '123'}
# У меня вывело {10, 5, 15}.
print(s_2)
{'3', '2', '1'}

{10, 5, 15}




		
			

Пример №3. Создание множеств в Python (часть 3).

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

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

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

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

  • s_1 >= s_2 – возвращает True, если множество
    s_1 является надмножеством s_2, т.е. каждый элемент второго
    множества есть в первом множестве (см. пример №4);
  • s_1 > s_2 – возвращает True, если множество
    s_1 является надмножеством s_2 и при этом они не равны
    (поэтому, например, проверка {1, 2} > {1, 2} вернет False);
  • s_1 <= s_2 – возвращает True, если множество
    s_1 является подмножеством s_2, т.е. каждый элемент первого
    множества есть во втором множестве;
  • s_1 < s_2 – возвращает True, если множество
    s_1 является подмножеством s_2 и при этом они не равны
    (поэтому, например, проверка {1, 2} < {1, 2} вернет False);
  • s_1 | s_2 – возвращает новое множество, образуемое через объединение множеств (такое множество
    состоит из всех элементов, которые есть хотя бы в одном из множеств, участвующих в операции);
  • s_1 |= s_2 – обновляет множество s_1, добавляя элементы из
    множества s_2;
  • s_1 & s_2 – возвращает новое множество, образуемое через пересечение множеств (такое множество
    состоит из всех элементов, которые есть сразу в обоих множествах, участвующих в операции);
  • s_1 &= s_2 – обновляет множество s_1, оставляя в нем только
    элементы, которые есть сразу в обоих множествах, участвующих в операции;
  • s_1 — s_2 – возвращает новое множество, образуемое через разность множеств (такое множество
    состоит из всех элементов, которые есть в уменьшаемом множестве (левый операнд), но нет в вычитаемом множестве (правый операнд));
  • s_1 -= s_2 – обновляет множество s_1, оставляя в нем только
    элементы, которых нет в множестве s_2;
  • s_1 ^ s_2 – возвращает новое множество, образуемое через симметричную разность множеств (такое
    множество состоит из всех элементов, которые есть в одном из множеств, участвующих в операции, но не в обоих сразу).
  • s_1 ^= s_2 – обновляет множество s_1, оставляя в нем только
    элементы, которые есть в одном из множеств, участвующих в операции, но не в обоих сразу.
# Сохраняем множества в переменных.
s_1 = {1, 2}
s_2 = {1, 2, 3}
				
# Вернет True.
print('s_1 < s_2 ->', s_1 < s_2)
# Вернет False.
print('s_1 > s_2 ->', s_1 > s_2, end='nn')		

# Получаем новые мн-ва, исх. не изменяются.

# Пересечение: {1, 2}.
print('s_1 & s_2 ->', s_1 & s_2)		
# Объединение: {1, 2, 3}.
print('s_1 | s_2 ->', s_1 | s_2)		
# Разность: set(), т.е. пустое мн-во.
print('s_1 - s_2 ->', s_1 - s_2)		
# Сим. разность: {3}.
print('s_1 ^ s_2 ->', s_1 ^ s_2, end='nn')

# Здесь изменяется мн-во s_1.		
		
# Теперь s_1 == {1, 2}.
s_1 &= s_2
print('s_1 &= s_2 ->', s_1)		
# Теперь s_1 == {1, 2, 3}.
s_1 |= s_2
print('s_1 |= s_2 ->', s_1)		
# Теперь s_1 == set().
s_1 -= s_2
print('s_1 -= s_2 ->', s_1)		
# Теперь s_1 == {2, 1, 3}.
s_1 ^= s_2
print('s_1 ^= s_2 ->', s_1)
s_1 < s_2 -> True
s_1 > s_2 -> False

s_1 & s_2 -> {1, 2}
s_1 | s_2 -> {1, 2, 3}
s_1 - s_2 -> set()
s_1 ^ s_2 -> {3}

s_1 &= s_2 -> {1, 2}
s_1 |= s_2 -> {1, 2, 3}
s_1 -= s_2 -> set()
s_1 ^= s_2 -> {2, 1, 3}




















		
			

Пример №4. Математические операции над множествами.

Следует помнить, что известные нам математические операторы >, >=,
< и <= не сравнивают множества по количеству элементов, а проверяют
на вхождение одного множества в другое (поэтому, например, операция {1, 2, 3} > {4, 5} вернет
False, хотя элементов в первом множестве больше).

Что касается оператора проверки на вхождение in, то примени­тельно к мно­жествам он совершает поиск
переданного объекта (левый операнд) среди элементов целевого множества (правый операнд). В случае успеха операция возвращает
True, иначе – False (см. пример №5).

# Сохраняем множество в переменной.
s_1 = {1, 2, 3}
				
# Вернет True.
print('2 in s_1 ->', 2 in s_1, end='nn')
# Вернет False.
print("'2' in s_1 ->", '2' in s_1, end='nn')		
# Вернет True.
print("'2' not in s_1 ->", '2' not in s_1)
2 in s_1 -> True

'2' in s_1 -> False

'2' not in s_1 -> True


		
			

Пример №5. Использование оператора in применительно к множествам.

Применим к множествам и оператор цикла for, который обходит множество по его элементам (см. пример
№6).

# Сохраняем множество в переменной.
s_1 = {1, 2, 0.3}
				
# Запускаем цикл по значениям мн-ва.
for val in s_1:
	
    # Если эл-т не является целым числом,
    if not isinstance(val, int):
        # выводим на экран сообщение 
        print('Не все эл-ты мн-ва целые числа.')			
        # и прерываем цикл.
        break

# Eсли цикл завершился успешно,
else:
    # выводим положительный результат. 
    print('Все эл-ты мн-ва - целые числа.')
Не все эл-ты мн-ва целые числа.














		
			

Пример №6. Использование цикла for для обхода элементов множества.

Функции и методы множеств в Python

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

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

  • set.isdisjoint(other) – возвращает True, если у множества
    set нет общих элементов с указанным множеством other
    (см. пример №7).
  • set.issubset(other) – тоже самое, что и set <= other
    (см. операторы выше).
  • set.issuperset(other) – тоже самое, что и set >= other.
  • set.union(*others) – тоже самое, что и set | other | ….

  • set.intersection(*others) – тоже самое, что и
    set & other & ….

  • set.difference(*others) – тоже самое, что и set — other — ….
  • set.symmetric_difference(other) – тоже самое, что и set ^ other.

# Сохраняем множества в переменных.
s_1 = {1, 2}
s_2 = {2, 3}
s_3 = {3, 4}
			
# Вернет False.
res = s_1.issubset(s_2)
print('s_1.issubset(s_2) ->', res)		
# Вернет False.
res = s_1.isdisjoint(s_2)
print('s_1.isdisjoint(s_2) ->', res)
# Вернет True.
res = s_1.isdisjoint(s_3)
print('s_1.isdisjoint(s_3) ->', res, end='nn')		

# Получаем новые мн-ва, исх. не изменяются.

# Объединение: {1, 2, 3, 4}.
res = set.union(s_1, s_2, s_3)
print('set.union(s_1, s_2, s_3) ->', res)		
# Пересечение: set(), т.е. пустое мн-во.
res = s_1.intersection(s_2, s_3)
print('s_1.intersection(s_2, s_3) ->', res)		
# Разность: {1}.
res = set.difference(s_1, s_2, s_3)
print('set.difference(s_1, s_2, s_3) ->', res)		
# Сим. разность: {1, 3}.
res = s_1.symmetric_difference(s_2)
print('s_1.symmetric_difference(s_2) ->', res)
s_1.issubset(s_2) -> False
s_1.isdisjoint(s_2) -> False
s_1.isdisjoint(s_3) -> True

set.union(s_1, s_2, s_3) -> {1, 2, 3, 4}
s_1.intersection(s_2, s_3) -> set()
set.difference(s_1, s_2, s_3) -> {1}
s_1.symmetric_difference(s_2) -> {1, 3}















	
	
	
		
	
			

Пример №7. Методы множеств (часть 1).

Обратите внимание, что вышеперечисленные методы исходные множества не изменяют. Кроме того, как видно из примера, многие методы можно использовать
как в форме общего метода класса, так и в форме метода конкретного объекта. Например, инструкции
set.union(s_1, s_2, s_3) и s_1.union(s_2, s_3) в обоих случаях вернут
множество {1, 2, 3, 4}.

А вот update-методы должны использоваться в форме метода конкретного объекта. Они обновляют само множество и
возвращают None (см. пример №8).

  • set.update(*others) – тоже самое, что и set |= other | ….
  • set.intersection_update(*others) – тоже самое, что и
    set &= other & ….

  • set.difference_update(*others) – тоже самое, что и set -= other | ….

  • set.symmetric_difference_update(other) – тоже самое, что и set ^= other.

# Сохраняем множества в переменных.
s_1 = {1, 2}
s_2 = {2, 3}
s_3 = {3, 4}
			
# Здесь изменяется мн-во s_1.		
		
# Теперь s_1 == {1, 2, 3, 4}.
s_1.update(s_2, s_3)
print('s_1.union(s_2, s_3) ->', s_1)		
# Теперь s_1 == {3}.
s_1.intersection_update(s_2, s_3)
print('s_1.intersection_update(s_2, s_3) ->', s_1)		
# Теперь s_1 == set().
s_1.difference_update(s_2, s_3)
print('s_1.difference(s_2, s_3) ->', s_1)		
# Теперь s_1 == {2, 3}.
s_1.symmetric_difference_update(s_2)
print('s_1.symmetric_difference_update(s_2) ->', s_1)
s_1.union(s_2, s_3) -> {1, 2, 3, 4}
s_1.intersection_update(s_2, s_3) -> {3}
s_1.difference(s_2, s_3) -> set()
s_1.symmetric_difference_update(s_2) -> {2, 3}









	
	
	
		
	
			

Пример №8. Методы множеств (часть 2).

  • set.add(elem) – добавляет в множество указанный элемент elem
    и возвращает None (см. пример №9).
  • set.discard(elem) – удаляет указанный элемент elem, если он
    присутствует в множестве, и возвращает None.
  • set.remove(elem) – также удаляет указанный элемент elem, если он
    присутствует в множестве и возвращает None. Однако, в отличие от метода выше, если множество такого элемента
    не содержит, метод возбудит исключение KeyError.
  • set.pop() – удаляет и возвращает произвольный элемент множества. Если множество окажется пустым,
    метод возбудит исключение KeyError.

  • set.copy() – возвращает поверхностную копию множества.

  • set.clear() – очищает множество, удаляя все его элементы, и возвращает
    None.

# Сохраняем множество в переменной.
s_1 = {1, 2, 3}
					
# Теперь s_1 == {1, 2, 3, 4}.
s_1.add(4)
print('s_1.add(4) ->', s_1)		
# Теперь s_1 == {1, 2, 4}.
s_1.discard(3)
print('s_1.discard(3) ->', s_1)		
# Теперь s_1 == {1, 4}.
s_1.remove(2)
print('s_1.remove(2) ->', s_1)	
# У меня s_1 == {4}.
s_1.pop()
print('s_1.pop() ->', s_1, end='nn')			

# s_1 == s_2 == {4}.
s_2 = s_1.copy()
print('s_1.copy() ->', s_2)		
# Теперь s_2 == set().
s_2.clear()
print('s_2.clear() ->', s_2)			
# Выкинет 5 (KeyError).
s_1.remove(5)
s_1.add(4) -> {1, 2, 3, 4}
s_1.discard(3) -> {1, 2, 4}
s_1.remove(2) -> {1, 4}
s_1.pop() -> {4}

s_1.copy() -> {4}
s_2.clear() -> set()
5










	
	
	
		
	
			

Пример №9. Методы множеств (часть 3).

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

Фиксированные множества в Python

Довольно часто возникают ситуации, когда нужно обеспечить неизменяемость используемого множества. В таких случаях при создании или преобразовании
множества необходимо вместо конструктора set([iterable]) использовать конструктор
frozenset([iterable]), который создает
фиксированное множество. Единственное отличие фиксированного множества от
обычного заключается в том, что оно неизменяемо. Соответственно, как и в ситуации с кортежами и списками, для фиксированных множеств становятся
недоступны ряд методов, которые пытаются их изменить (см. пример №10).

# Фиксируем множество.
s_1 = frozenset({1, 2, 3})		

# Выведет 3.
print('len(s_1) ->', len(s_1))		
# 'frozenset' object has no attribute 'remove'
s_1.remove(2)
len(s_1) -> 3
'frozenset' object has no attribute 'remove'
	
	
		
	
			

Пример №10. Использование фиксированных множеств.

Краткие итоги параграфа

  • В Python множества представляют собой неупорядоченные изме­няемые коллек­ции объектов
    неизменяемого типа.
  • Чтобы создать литерал множества, нужно просто перечислить элементы множества через запятую внутри фигурных скобок (например,
    s = {‘a’, ‘b’, ‘c’}). В случае необходимости последний элемент множества можно также завершить запятой.
    Это никак не повлияет на количество элементов множества, а значит и его длину. При этом следует помнить, что пустое множество при помощи
    фигурных скобок создать не получится, т.к. конструкция {} зарезервирована под пустой словарь.
  • Также множества могут быть созданы при помощи конструктора типа set([iterable]), который в качестве аргумента
    может принимать итерируемый объект, например, строку или список. Если использовать конструктор без аргумента, он вернет пустое множество
    set(). Если использовать конструктор с аргументом, он вернет множество с элементами переданного итерируемого
    объекта. Например, инструкция set(‘abc’) вернет множество {‘a’, ‘b’, ‘c’}.
  • Опять же, для создания множеств в Python могут использоваться генераторы множеств, которые применяют выражение
    к каждому элементу передаваемого итерируемого объекта и на основе их вычисления возвращают новое множество. Например, генератор
    {x: for x in ‘abc’} вернет нам все то же множество {‘a’, ‘b’, ‘c’}.

  • Что касается операторов +, +=, * и
    *=, то они с множествами напрямую не используются. Однако к множествам применимы оператор
    in и цикл for. Первый проверяет наличие в множестве целевого объекта, а
    второй позволяет совершить обход всех элементов множества.
  • Кроме того, множествам доступен целый ряд других математических операторов, которые позволяют выполнять над множествами операции объединения
    (например, {1, 2} | {2, 3}), пересечения (например, {1, 2} & {2, 3}),
    разности (например, {1, 2} — {2, 3}) и ряд других операций.
  • Далее мы познакомились с рядом методов типа set, которые дают нам возможность выполнять широкий спектр операций над
    множествами. При этом не стоит забывать, что множества изменяемы, поэтому их методы в основном изменяют множество непосредственно, а не возвращают его
    измененную копию. Обязательно посетите подраздел «Set Types – set, frozenset»
    раздела «Built-in types» стандартной библиотеки.
  • В конце параграфа мы познакомились с фиксированными множествами frozenset, которые отличаются от
    обычных множеств тем, что их нельзя изменять. Как и в случае с кортежами, неизменяемость фиксированных множеств приводит к тому, что многие
    методы, изменяющие множества непосредственно, становятся для них недоступны.

Вопросы и задания для самоконтроля

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

Показать решение.

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

2. Можно ли удалять элементы из множества или добавлять в него новые? Почему?

Показать решение.

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

3. Какие из представленых литералов относятся к типу set:
{1: ‘один’, 2: ‘два’}, {3, 4}, [3, 4],
«{5, 6}»? Проверьте типы программно.

Показать решение.

Ответ. Тип set: {3, 4}.

# Выводим типы представленных литералов.
print("Тип {1: 'один', 2: 'два'}:", type({1: 'один', 2: 'два'}))
print("Тип {3, 4}:", type({3, 4}))
print("Тип [3, 4]:", type([3, 4]))
print('Тип "{3, 4}":', type("{3, 4}"))
Тип {1: 'один', 2: 'два'}: <class 'dict'>
Тип {3, 4}: <class 'set'>
Тип [3, 4]: <class 'list'>
Тип "{3, 4}": <class 'str'>
			

4. Какими будут результаты выполнения инструкций st = set(); st.add(1); print(st) и
st = set(); st.add([1, 2, 3]); print(st). Объясните ответ.

Показать решение.

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

# Выведет {1}.
st = set(); st.add(1); print(st)
# unhashable type: list
st = set(); st.add([1, 2, 3]); print(st)
{1}
unhashable type: 'list'

			

5. Даны два множества {1, 2, 3} и {2, 3, 4}. Какое из множеств
{3, 4} и {1, 2} является их пересечением, а какое разностью первого и второго множеств?

Показать решение.

Ответ. {3, 4} – результат пересечения, {1, 2}
результат разности.

# Сохраняем множества в переменных.
s_1 = {1, 2, 3, 4}
s_2 = {3, 4, 5}
    
# Разность: {1, 2}.
print('s_1 - s_2 ->', s_1 - s_2)		
# Пересечение: {3, 4}.
print('s_1 & s_2 ->', s_1 & s_2)
s_1 - s_2 -> {1, 2}
s_1 & s_2 -> {3, 4}





			

6. Исправьте в коде пять ошибок.

Показать решение.

# Сохраним множество в переменной.
s = [1, 2, 3, 4]		

# Добавляем в множество новый эл-т.
s.apend(5)		
# Удаляем из множества 3.
s.remuve('3')
# Очищаем множество.
clear(s) 

# Сохраним множество в переменной.
s = [1, 2, 3, 4]		

# Добавляем в множество новый эл-т.
s.apend(5)		
# Удаляем из множества 3.
s.remuve('3')
# Очищаем множество.
clear(s)
# [1, 2, 3, 4].
s = {1, 2, 3, 4}		

# s.apend(5).
s.add(5)		
# s.remuve('3').
s.remove(3)
# clear(s).
s.clear()

7. Дополнительные тесты по теме расположены в разделе
«Множества» нашего сборника тестов.

8. Дополнительные упражнения и задачи по теме расположены в разделе
«Множества» нашего сборника задач и упражнений.

Быстрый переход к другим страницам

Войти на сайте МЭШ

Войдите с учетной записью ученика или учителя МЭШ,
чтобы получить доступ к личному кабинету.

Множества. Как создать?

Множества

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

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

Встроенный тип set в Python имеет следующие характеристики:

  • элементы множества неупорядочены (это значит, что два множества эквивалентны, если содержат одинаковые элементы). Хранятся элементы множества не последовательно, а по определенным алгоритмам, которые позволяют быстро определять принадлежность элемента множеству (без перебора всех элементов);
  • элементы множества уникальны. Повторяющиеся элементы не допускаются;
  • множества изменяемы (например, можно добавить элемент в множество), но сами элементы внутри множества должны быть неизменяемые (числа, строки, кортежи). Вы не можете сделать элементом множества список или другое множество;
Создание множества
1 способ

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

x = {«school», «teacher», «class», student}
 

2 способ 

Используйте встроенную функцию set().

x = set()    # пустое множество
list_name = ["Andry", "Bob", "Caroline"]
y = set(list_name)    # можно создать множество 
                      # из любого итерируемого объекта
z = set(["Andry", "Bob", "Caroline"])     # {'Bob', 'Caroline', 'Andry'}
k = set(("Andry", "Bob", "Caroline"))     # {'Bob', 'Caroline', 'Andry'}
s = "string s"
m = set(s)    # {'i', 't', 'g', 'r', 'n', 's', ' '} - 
              # обратите внимание! 
              # порядок элементов может быть любой,
              # элементы не повторяются
n = {42, 'foo', 3.14159, None, (1, 2, 3)}    # элементы в наборе  
                                             # могут быть разного типа

 

Вывод множества

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

z = set(["Andry", "Bob", "Caroline"]) 
print(z)     # {'Bob', 'Caroline', 'Andry'}
print(*z)    # Bob Andry Caroline

Задача для тренировки:

Множества. Как создать?

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

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

Количество элементов в множестве

Метод len() возвращает количество элементов в множестве.

k = {42, 'foo', 3.14159, None, (1, 2, 3)} 
print(len(k))    # 5
Определение, есть ли элемент в множестве (оператор принадлежности in)
k = {42, 'foo', 3.14159, None, (1, 2, 3)} 
print(42 in k)    # True
print(2 in k)     # False

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

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

x.add(<elem>)
ко множеству  x добавляет <elem>, который должен быть единственным неизменяемым объектом.

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

1) x.remove(<elem>)
удаляется <elem> из множества x. Python вызывает исключение (ошибка), если <elem> нет в x.

2) x.discard(<elem>)
то же удаляет, но в случае отсутствия элемента в множестве не вызывает исключения.

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

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

Задача для тренировки:

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

Работа с множествами. Методы — 2

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

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

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

x1 = {'foo', 'bar', 'baz'}
x2 = {'baz', 'qux', 'quux'}
print(x1 | x2)         # {'bar', 'baz', 'qux', 'quux', 'foo'}
print(x1.union(x2))    # {'bar', 'baz', 'qux', 'quux', 'foo'}

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

Примечание

Итерируемый объект (iterable) — это объект, который способен возвращать элементы по одному. 

Обратите внимание на разницу

x1 = {'foo', 'bar', 'baz'} 
print(x1.union(('baz', 'qux', 'quux')))    # {'baz', 'bar', 'quux', 'foo', 'qux'}
print(x1 | ('baz', 'qux', 'quux'))         # builtins.TypeError: 
                                           # unsupported operand type(s) for |: 'set' and 'tuple'

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

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

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

Название Метод Оператор Описание
объединение x1.union(x2[, x3, …]) x1 | x2 [| x3 …] возвращает множество всех элементов, которые присутствуют либо в x1 либо в x2 (либо других)
пересечение множеств x1.intersection(x2[, x3, …]) x1 & x2 [& x3 …] возвращает множество элементов, общих для x1 и x2 (и других)
разница между множествами x1.difference(x2) x1 - x2 [- x3 …] возвращает множество элементов, которые есть в x1, но нет в x2 (только —  поддерживает множественность)
симметричная разница между множествами x1.symmetric_difference(x2) x1 ^ x2 [^ x3] возвращает множество элементов, которые есть в x1 или x2, но не в обоих сразу
(оператор ^ поддерживает множественность)
общие элементы в наборах x1.isdisjoint(x2) нет возвращает True, если x1 и x2 не имеют общих элементов
x1 подмножество x2 x1.issubset(x2) x1 <= x2 True, если x1 подмножество x2, иначе — False
Правильное подмножество - x1 < x2 True, если x1 является правильным подмножеством x2
x1 надмножество x2 x1.issuperset(x2) x1 >= x2 True, если x1 содержит все элементы x2
правильное надмножество - x1 > x2 True, если x1 является правильным надмножеством x2
объединение множеств x1.update(x2[, x3 ...]) x1 |= x2 [| x3 ...] Добавляет к x1 элементы x2, которых нет в x1
пересечение множеств x1.intersection_update(x2[, x3 ...]) x1 &= x2 [& x3 ...] Обновляет x1, сохраняя элементы, которые есть в обоих множествах x1 и x2
разница множеств x1.difference_update(x2[, x3 ...]) x1 -= x2 [| x3 ...] Обновляет x1, удаляя элементы, найденные в x2
симметричная разность x1.symmetric_difference_update(x2) x1 ^= x2 Обновляет x1, сохраняя элементы, найденные в x1 ли x2, но не в обоих

Задача для тренировки:

Работа с множествами. Методы — 2

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

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

Как мы знаем, порядок следования элементов в множестве не учитывается. Поэтому есть ли смысл говорить о сортировке множеств в Python 3?! (Именно поэтому в заголовке стоит знак вопроса)

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

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

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

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

Давайте попытаемся вывести данные одного типа (например, только числа):

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

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

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

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

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

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

Задача для тренировки:

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

Тип данных set в Python поддерживает все операции, которые проводятся над множествами в математике:

  • пересечение;
  • объединение;
  • дополнение;
  • разность;
  • симметрическую разность.

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

1. В Python два вида множеств – обычное, изменяемое set и замороженное, неизменяемое frozenset. Замороженные множества нельзя изменить после создания, но все операции по объединению, пересечению и разности они поддерживают: результатом этих операций тоже будут frozenset.

2. Множество может включать в себя только неизменяемые типы данных – строки, числа, кортежи (в любой комбинации). Попытка добавить в множество список, словарь или изменяемое множество приведет к ошибке:

        >>> a_set = {[2, 3], [4, 7]}
Traceback (most recent call last):
  File "<pyshell>", line 1, in <module>
TypeError: unhashable type: 'list'

    

Неизменяемое множество frozenset, в отличие от set, может входить в изменяемое множество:

        >>> set_a = {1, 2, 3}
>>> set_b = frozenset({4, 5, 6})
>>> set_c = {7, 8, 9, set_a}
Traceback (most recent call last):
  File "<pyshell>", line 1, in <module>
TypeError: unhashable type: 'set'
>>> set_c = {7, 8, 9, set_b}
>>> print(set_c)
{8, 9, frozenset({4, 5, 6}), 7}

    

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

        >>> set_a = set('123')
>>> print(set_a)
{'3', '2', '1'}
>>> print(set[1])
Traceback (most recent call last):
  File "<pyshell>", line 1, in <module>
TypeError: 'type' object is not subscriptable

    

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

        >>> set_a = {1, 3, 4, 5, 2, 9, 7}
>>> print(set_a[2:5])
Traceback (most recent call last):
  File "<pyshell>", line 1, in <module>
TypeError: 'set' object is not subscriptable

    

5. Все элементы множества – уникальны, повторяющиеся данные в set игнорируются; это свойство множеств может пригодиться для решения практических задач:

        >>> my_set = {2, 2, 2}
>>> print(my_set)
{2}

    

6. Множества не поддерживают конкатенацию и повторение:

        >>> set_a = {1, 3, 5}
>>> set_b = {9, 4, 8}
>>> print(set_a + set_b)
Traceback (most recent call last):
  File "<pyshell>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'set' and 'set'
>>> print(set_a * 2)
Traceback (most recent call last):
  File "<pyshell>", line 1, in <module>
TypeError: unsupported operand type(s) for *: 'set' and 'int'

    

7. Множества занимают значительно больший объем памяти, нежели списки и кортежи. По этой причине лучше не использовать множества для решения задач с лимитом на объем памяти:

        >>> from sys import getsizeof
>>> number = 100500
>>> my_list = list(range(number))
>>> my_tuple = tuple(range(number))
>>> my_set = set(range(number))
>>> my_list_size = getsizeof(my_list)
>>> my_tuple_size = getsizeof(my_tuple)
>>> my_set_size = getsizeof(my_set)
>>> print(f'Размер списка: {round(my_list_size / 1024 / 1024, 3)} Мб')
Размер списка: 0.431 Мб
>>> print(f'Размер кортежа: {round(my_tuple_size / 1024 / 1024, 3)} Мб')
Размер кортежа: 0.383 Мб
>>> print(f'Размер множества: {round(my_set_size / 1024 / 1024, 3)} Мб')
Размер множества: 2.0 Мб

    

8. Хотя множества занимают гораздо больший объем памяти, чем списки и кортежи, работают они гораздо быстрее. Этот код сравнивает время, затраченное на проведение операции над списком, кортежем и множеством с одинаковым количеством элементов:

        from time import time
number = 15000
my_set = set(range(number))
my_list = list(range(number))
my_tuple = tuple(range(number))

t = time()
for i in range(number):
    if i in my_list:
        pass
print(f"Операция со списком: {time() - t} секунд")
my_list.clear()

t = time()
for i in range(number):
    if i in my_tuple:
        pass
print(f"Операция с кортежeм: {time() - t} секунд")

t = time()
for i in range(number):
    if i in my_set:
        pass
print(f"Операция со множеством: {time() - t} секунд")
my_set.clear()

    

Результат:

        Операция со списком: 1.810847282409668 секунд
Операция с кортежeм: 1.6490623950958252 секунд
Операция со множеством: 0.0013110637664794922 секунд

    

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

Пустое множество можно создать только одним способом, с помощью set():

        >>> my_set = set()
>>> print(type(my_set))
<class 'set'>

    

Попытка создать пустое множество с помощью фигурных скобок {} обречена на провал – вместо set будет создан словарь dict:

        >>> my_set = {}
>>> print(type(my_set))
<class 'dict'>

    

Множество с данными можно создать несколькими способами.

Способ 1: Перечисление элементов

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

        >>> set_a = {3, 7, 9, 0, 2, 1}
>>> set_b = {'а', 'б', 'в', 'г'}
>>> set_c = {'Мастер и Маргарита', 450, 1250, 'переплет'}
>>> set_d = {2, 4, 5, (2, 9, 0)}

    

Способ 2: Преобразование других типов данных

Множество можно создать на основе символов либо слов строки:

        >>> print(set('абырвалг'))
{'р', 'в', 'л', 'г', 'б', 'а', 'ы'}
>>> print(set('Множества в Python'.split()))
{'Множества', 'в', 'Python'}

    

Множество из списка:

        >>> print(set([3, 6, 4, 5, 5]))
{3, 4, 5, 6}

    

Множество на основе кортежа:

        >>> print(set(('красный', 'синий', 'зеленый')))
{'зеленый', 'красный', 'синий'}

    

При создании множества из dict от словаря останутся только ключи:

        >>> print(set({'артикул': 'А123', 'цвет': 'черный'}))
{'артикул', 'цвет'}

    

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

        >>> print(set(123))
Traceback (most recent call last):
  File "<pyshell>", line 1, in <module>
TypeError: 'int' object is not iterable

    

Но с применением str преобразование проходит без ошибок:

        >>> print(set(str(1812)))
{'8', '2', '1'}

    

Способ 3: Генераторы множеств

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

        >>> print({i ** 2 for i in range(15)})
{0, 1, 64, 121, 4, 36, 100, 196, 9, 169, 16, 49, 81, 144, 25}

    

В генераторах можно использовать любые условия:

        >>> print({int(i) for i in '3в2о7ыр3р74ртрчфрежр4рфф23468795323' if i.isdigit() and int(i) < 7})
{2, 3, 4, 5, 6}

    

В генератор можно включить любые дополнительные функции, например, ввод input() и функцию ord() для возвращения числового кода символа из таблицы Unicode:

        >>> print({ord(i) for i in input() if i.isalpha()})
ewr73694yrhf897349ugg05fhshcvnaWQXXldoaxsd
{81, 87, 88, 97, 99, 100, 101, 102, 103, 104, 108, 110, 111, 114, 115, 117, 118, 119, 120, 121}

    

Помимо условия if, в генератор можно добавить обработку else:

        >>> set_a = {i ** 2 if i % 2 == 0 else i ** 3 for i in (map(int, input().split()))}
2 5 12 13 4 56 71 33 9 10
>>> print(set_a)
{3136, 35937, 4, 100, 144, 16, 2197, 357911, 729, 125}

    

Стандартные методы множеств в Python

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

Длина, сумма, min и max элементы

Эти методы работают со множествами точно так же, как и со списками и кортежами:

        >>> set_a = {2, 4, 5, 6, 1, 9, 7, 12}
>>> print(f'Количество элементов: {len(set_a)}, сумма элементов: {sum(set_a)}')
Количество элементов: 8, сумма элементов: 46
>>> print(f'Минимальный элемент: {min(set_a)}, максимальный элемент: {max(set_a)}')
Минимальный элемент: 1, максимальный элемент: 12

    

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

        >>> my_set = {'математика', 'физика', 'химия'}
>>> print('математика' in my_set)
True
>>> print('биология' not in my_set)
True

    

Сортировка

Как и в случае с кортежами, результатом сортировки множества будет список:

        >>> numbers = {25, 15, 7, 8, 19, 34, 52, 0, 12, 59, 91, 4}
>>> print(sorted(numbers))
[0, 4, 7, 8, 12, 15, 19, 25, 34, 52, 59, 91]
>>> print(sorted(numbers, reverse=True))
[91, 59, 52, 34, 25, 19, 15, 12, 8, 7, 4, 0]

    

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

Множества можно сравнивать с помощью операторов == и !=:

        >>> set_a = {5, 1, 4, 8, 6, 9}
>>> set_b = {6, 2, 5, 9, 7, 10}
>>> print(set_b != set_a)
True

    

Другие операторы сравнения, например > и <, дают неожиданный на первый взгляд результат:

        >>> set_a = {1, 2, 3}
>>> set_b = {4, 5, 6, 7}
>>> print(set_b > set_a)
False

    

Это связано с тем, что при сравнении множеств Python определяет, является ли одно из них под- или надмножеством другого (подробнее об этом – ниже):

        >>> set_a = {1, 2, 3}
>>> set_b = {1, 2, 3, 4}
>>> print(set_b > set_a)
True

    

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

Метод add() добавляет во множество новый элемент:

        >>> letters = {'а', 'б', 'в'}
>>> letters.add('г')
>>> print(letters)
{'г', 'в', 'а', 'б'}

    

Несколько элементов можно добавить с помощью цикла for (мы рассмотрим его в следующей статье) или с помощью генератора:

        >>> set_a = set()
>>> gen = {set_a.add(i) for i in range(12)}
>>> print(set_a)
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}

    

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

Для удаления элемента нужно воспользоваться одним из поддерживаемых методов:

1. remove() – возвращает сообщение об ошибке, если элемент не будет найден:

        >>> my_set = {1, 2, 3}
>>> my_set.remove(2)
>>> print(my_set)
{1, 3}

    

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

        >>> my_set = {'красный', 'черный', 'синий'}
>>> my_set.discard('синий')
>>> print(my_set)
{'красный', 'черный'}
>>> my_set.discard('розовый')
>>> 

    

3. pop() – в отличие от аналогичного списочного метода, удаляет случайный элемент и возвращает его значение:

        >>> my_set = {2, 4, 6, 1, 12}
>>> print(my_set.pop())
1

    

4. Метод clear() удаляет все элементы множества сразу – так можно освободить оперативную память после завершения операции с объемным set:

        >>> my_set = {6, 2, 9, 0}
>>> my_set.clear()
>>> print(my_set)
set()

    

Специальные методы множеств

Как уже упоминалось выше, объекты set в Python поддерживают все операции, которые проводятся над множествами в математике. Эти операции делятся на три группы:

  • Не изменяющие исходные множества – эти методы возвращают новые множества.
  • Изменяющие исходные множества.
  • Определяющие, являются ли множества под(над)множествами друг друга – эти методы возвращают True или False.

Рассмотрим методы из этих групп подробнее.

Методы, не изменяющие исходные множества

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

Объединение множеств union () – это множество, которое состоит из элементов, входящих в состав хотя бы одного из объединяемых множеств:

        >>> set_a = {1, 2, 3}
>>> set_b = {4, 5, 6}
>>> print(set_a.union(set_b))
{1, 2, 3, 4, 5, 6}

    

Вместо union() можно использовать оператор |:

        >>> set_a = {'синий', 'розовый', 'черный'}
>>> set_b = {'зеленый', 'красный', 'желтый'}
>>> print(set_a | set_b)
{'синий', 'красный', 'желтый', 'розовый', 'черный', 'зеленый'}

    

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

Пересечением множеств intersection() называется множество, которое состоит из элементов, входящих в каждое из пересекающихся множеств:

        >>> set_a = {2, 3, 5, 1, 8}
>>> set_b = {2, 5, 0, 9, 7}
>>> print(set_a.intersection(set_b))
{2, 5}

    

Вместо intersection() можно использовать оператор &:

        >>> set_a = {'a', 'b', 'd', 'k'}
>>> set_b = {'v', 'b', 'e', 'k'}
>>> print(set_a & set_b)
{'k', 'b'}

    

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

Разностью множеств difference() называется множество, в которое входят все элементы первого множества, не входящие во второе множество:

        >>> set_a = {4, 9, 7, 2, 1, 0}
>>> set_b = {5, 8, 3, 1, 4, 9}
>>> print(set_a.difference(set_b))
{0, 2, 7}

    

Вместо difference() можно использовать оператор - :

        >>> set_a = {'a', 'b', 'g', 'j'}
>>> set_b = {'f', 'b', 's', 'g'}
>>> print(set_a - set_b)
{'a', 'j'}

    

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

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

        >>> set_a = {1, 2, 3, 4}
>>> set_b = {6, 8, 4, 3}
>>> print(set_a.symmetric_difference(set_b))
{1, 2, 6, 8}

    

В качестве оператора симметрической разности используется ^:

        >>> set_a = {'h', 'v', 'a', 'w', 'q'}
>>> set_b = {'v', 'h', 'u', 'f', 'o'}
>>> print(set_a ^ set_b)
{'u', 'w', 'f', 'q', 'a', 'o'}

    

Методы, изменяющие исходные множества

Метод update()

Изменяет исходное множество по объединению:

        >>> set_a = {1, 2, 3}
>>> set_b = {4, 5, 6}
>>> set_a.update(set_b)
>>> print(set_a)
{1, 2, 3, 4, 5, 6}

    

Оператор метода update|=:

        >>> set_a = {'a', 'b', 'd'}
>>> set_b = {'c', 'e', 'f'}
>>> set_a |= set_b
>>> print(set_a)
{'b', 'c', 'f', 'a', 'e', 'd'}

    

Метод intersection_update()

Изменяет исходное множество по пересечению:

        >>> set_a = {1, 2, 3}
>>> set_b = {3, 4, 5}
>>> set_a.intersection_update(set_b)
>>> print(set_a)
{3}

    

Оператор intersection_update()&=:

        >>> set_a = {'a', 'b', 'd', 'q'}
>>> set_b = {'h', 'f', 'b', 'a'}
>>> set_a &= set_b
>>> print(set_a)
{'a', 'b'}

    

Метод difference_update()

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

        >>> set_a = {3, 2, 7, 8, 0}
>>> set_b = {4, 5, 6, 3, 8}
>>> set_a.difference_update(set_b)
>>> print(set_a)
{0, 2, 7}

    

Оператор difference_update()-=:

        >>> set_a = {'v', 's', 'a', 'q', 'r'}
>>> set_b = {'d', 's', 'a', 'f', 'e'}
>>> set_a -= set_b
>>> print(set_a)
{'q', 'r', 'v'}

    

Метод symmetric_difference_update()

Изменяет исходное множество по симметрической разности:

        >>> set_a = {1, 2, 3, 4, 5}
>>> set_b = {8, 2, 4, 6, 1}
>>> set_a.symmetric_difference_update(set_b)
>>> print(set_a)
{3, 5, 6, 8}

    

Оператор symmetric_difference_update() ^=:

        >>> set_a = {'a', 'k', 'r', 'o', 'p'}
>>> set_b = {'d', 'a', '$', 'o', '@'}
>>> set_a ^= set_b
>>> print(set_a)
{'@', 'p', 'd', 'k', 'r', '$'}

    

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

Множество set_a считается подмножеством set_b в том случае, если все элементы set_a входят в set_b. В свою очередь, множество set_b этом случае считается надмножеством set_a. При этом любое множество считается подмножеством самого себя, или нестрогим подмножеством.

Для определения под- и надмножеств в Python есть три метода:

1. issuperset() – возвращает True, если первое множество является подмножеством второго, и False в обратном случае. Такой же результат можно получить с помощью операторов < (строгое подмножество) и <= (нестрогое подмножество):

        >>> set_a = {1, 2, 3}
>>> set_b = {4, 5, 1, 2, 3}
>>> print(set_a.issubset(set_b))
True
>>> print(set_a <= set_b)
True
>>> print(set_a < set_b)
True

    

2. issubset() – возвращает True, если одно множество является надмножеством другого, и False в противном случае. Аналог – операторы > (строгое надмножество) и >= (нестрогое надмножество):

        >>> set_a = {'XS', 'S', 'M', 'L', 'XL', 'XXL'}
>>> set_b = {'S', 'M', 'L'}
>>> print(set_a.issuperset(set_b))
True
>>> print(set_a > set_b)
True
>>> print(set_a >= set_b)
True

    

3. isdisjoint() – возвращает True, если множества не имеют общих элементов, и False, если такие элементы есть:

        >>> set_a = {1, 2, 3}
>>> set_b = {4, 5, 6}
>>> set_c = {1, 3, 5}
>>> print(set_a.isdisjoint(set_b))
True
>>> print(set_c.isdisjoint(set_b))
False

    

Практика

Задание 1

Напишите программу, которая получает на вход три слова и определяет, являются ли они анаграммами друг друга.

Пример ввода:

        кластер
стрелка
сталкер

    

Вывод:

        Да
    

Решение:

        set_a, set_b, set_c = set(input()), set(input()), set(input())
print('Да' if set_a == set_b == set_c else 'Нет')

    

Задание 2

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

Пример ввода:

        кино книги велосипед хоккей кулинария цветы кошки
кошки кино путешествия футбол кулинария автомобили дайвинг

    

Вывод:

        Совпадение интересов: 27.27%
    

Решение:

        hobbies1 = input().split()
hobbies2 = input().split()
result = len(set(hobbies1) & set(hobbies2)) / float(len(set(hobbies1) | set(hobbies2))) * 100
print(f'Совпадение интересов: {result:.2f}%')

    

Задание 3

Напишите программу, которая получает на вход строку, и определяет, является ли строка панграммой (т.е. содержатся ли в ней все 33 буквы русского алфавита).

Пример ввода:

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

Вывод:

        Да
    

Решение:

        result = {i.lower() for i in input() if i.isalpha()}
print('Да' if len(result) == 33 else 'Нет')

    

Задание 4

Напишите программу, которая получает n слов, и вычисляет количество уникальных символов во всех словах.

Пример ввода:

        5
программа
код
компьютер
монитор
интерпретатор

    

Вывод:

        Количество уникальных символов во всех словах: 14
    

Решение:

        n = int(input())
print('Количество уникальных символов во всех словах:', len(set(''.join([input().lower() for _ in range(n)]))))

    

Задание 5

Напишите программу, которая:

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

Пример ввода:

        Мастер и Маргарита, Война и мир, Тихий Дон, Евгений Онегин
Джейн Эйр, Террор, Война и мир, Мастер и Маргарита, Нос

    

Вывод:

        2
    

Решение:

        print(len(set(input().split(', ')) & set(input().split(', '))))
    

Задание 6

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

Пример ввода:

        4 12 6 11 0 8 7 5 1 25
2 1 4 5 56 6 8 7 14 33

    

Вывод:

        1 4 5 6 7 8
    

Задание 7

Напишите программу, которая получает два числа и выводит Есть, если числа содержат общие цифры, и Нет в противном случае.

Пример ввода:

        5678
3421

    

Вывод:

        Нет
    

Решение:

        print('Есть' if set(input()) & set(input()) else 'Нет')
    

Задание 8

Напишите программу, которая получает строку с именами файлов, и выводит уникальные имена .jpg файлов, отсортированные в алфавитном порядке.

Пример ввода:

        book_cover.jpg cover.png Book_cover.jpg illustration.jpg ILLUSTRATION.JPG my_cover.png photo.gif award.jpg Award.jpg award.JPG
    

Вывод:

        award.jpg book_cover.jpg illustration.jpg
    

Решение:

        files = input().split()
result = {i.lower() for i in files if i.lower().endswith('.jpg')}
print(*sorted(result))

    

Задание 9

Два дизайнера поспорили о том, кто из них знает больше оттенков цветов. Они перечисляют оттенки, но иногда забывают о том, что уже называли какой-то тон. Напишите программу, которая получает на вход n строк с названиями оттенков, и определяет, есть ли среди них повторы. Если повтор есть, нужно вывести Повтор, если нет – Принято.

Пример ввода:

        6
аспидно-серый
Бананомания
аквамариновый
Баклажановый
агатовый
антрацитовый

    

Вывод:

        Принято
    

Решение:

        colors = [input().lower() for _ in range(int(input()))]
print('Повтор!' if len(colors) > len(set(colors)) else 'Принято')

    

Задание 10

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

  • Сначала программа получает список из m продуктов, которые есть в кладовой.
  • Затем получает n ингредиентов, необходимых для рецепта.
  • Выводит Есть, если ингредиент имеется в кладовой, и Отсутствует в противном случае.

Пример ввода:

        6
5
мука
сахар
Сода
яйца
масло сливочное
масло растительное
Сахар
Мука
Яйца
сливки
масло сливочное

    

Вывод:

        Есть
Есть
Есть
Отсутствует
Есть

    

Решение:

        m, n = [int(input()) for _ in 'mn']
pantry = {input().lower() for _ in range(m)}
[print('Есть' if input().lower() in pantry else 'Отсутствует') for _ in range(n)]

    

Подведем итоги

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

Содержание самоучителя

  1. Особенности, сферы применения, установка, онлайн IDE
  2. Все, что нужно для изучения Python с нуля – книги, сайты, каналы и курсы
  3. Типы данных: преобразование и базовые операции
  4. Методы работы со строками
  5. Методы работы со списками и списковыми включениями
  6. Методы работы со словарями и генераторами словарей
  7. Методы работы с кортежами
  8. Методы работы со множествами
  9. Особенности цикла for
  10. Условный цикл while
  11. Функции с позиционными и именованными аргументами
  12. Анонимные функции
  13. Рекурсивные функции
  14. Функции высшего порядка, замыкания и декораторы
  15. Методы работы с файлами и файловой системой
  16. Регулярные выражения
  17. Основы скрапинга и парсинга
  18. Основы ООП: инкапсуляция и наследование
  19. Основы ООП – абстракция и полиморфизм
  20. Графический интерфейс на Tkinter
  21. Основы разработки игр на Pygame
  22. Основы работы с SQLite
  23. Основы веб-разработки на Flask
  24. Основы работы с NumPy
  25. Основы анализа данных с Pandas

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.

A — B

A.difference(B)

Возвращает разность множеств A и B (элементы, входящие в A,
но не входящие в B).

A -= B

A.difference_update(B)

Удаляет из множества A все элементы, входящие в B.

A ^ B

A.symmetric_difference(B)

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

A ^= 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, к элементам множества не привязан индекс, т. е. мы не можем напрямую получить доступ к любому элементу множества с помощью индекса. Однако мы можем напечатать их все вместе или получить список элементов, перебирая набор.

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

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

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

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

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

Выход:

{'Friday', 'Tuesday', 'Monday', 'Saturday', 'Thursday', 'Sunday', 'Wednesday'}
<class 'set'>
looping through the set elements ... 
Friday
Tuesday
Monday
Saturday
Thursday
Sunday
Wednesday

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

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

Выход:

{'Friday', 'Wednesday', 'Thursday', 'Saturday', 'Monday', 'Tuesday', 'Sunday'}
<class 'set'>
looping through the set elements ... 
Friday
Wednesday
Thursday
Saturday
Monday
Tuesday
Sunday

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

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

# Creating a set which have immutable elements
set1 = {1,2,3, "JavaTpoint", 20.5, 14}
print(type(set1))
#Creating a set which have mutable element
set2 = {1,2,3,["Javatpoint",4]}
print(type(set2))

Выход:

<class 'set'>

Traceback(most recent call last)
 in 
      4 
      5 #Creating a set which holds mutable elements
----> 6 set2 = {1,2,3,["Javatpoint",4]}
      7 print(type(set2))

TypeError: unhashable type: 'list'

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

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

# Empty curly braces will create dictionary
set3 = {}
print(type(set3))

# Empty set using set() function
set4 = set()
print(type(set4))

Выход:

<class 'dict'>
<class 'set'>

Посмотрим, что получится, если мы поместим в множество повторяющийся элемент.

set5 = {1,2,4,4,5,8,9,9,10}
print("Return set with unique elements:",set5)

Выход:

Return set with unique elements: {1, 2, 4, 5, 8, 9, 10}

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

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

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

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

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

Выход:

printing the original set ... 
{'February', 'May', 'April', 'March', 'June', 'January'}

Adding other months to the set...

Printing the modified set...
{'February', 'July', 'May', 'April', 'March', 'August', 'June', 'January'}

looping through the set elements ... 
February
July
May
April
March
August
June
January 

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

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

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

Выход:

printing the original set ... 
{'January', 'February', 'April', 'May', 'June', 'March'}

updating the original set ... 
printing the modified set ... 
{'January', 'February', 'April', 'August', 'October', 'May', 'June', 'July', 'September', 'March'}

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

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

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

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

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

Выход:

printing the original set ... 
{'February', 'January', 'March', 'April', 'June', 'May'}

Removing some months from the set...

Printing the modified set...
{'February', 'March', 'April', 'June'}

looping through the set elements ... 
February
March
April
June

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

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

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

Выход:

printing the original set ... 
{'February', 'June', 'April', 'May', 'January', 'March'}

Removing some months from the set...

Printing the modified set...
{'February', 'June', 'April', 'March'}

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

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

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

Выход:

printing the original set ... 
{'June', 'January', 'May', 'April', 'February', 'March'}

Removing some months from the set...

Printing the modified set...
{'May', 'April', 'February', 'March'}

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

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

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

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

Выход:

printing the original set ... 
{'January', 'May', 'June', 'April', 'March', 'February'}

Removing all the items from the set...

Printing the modified set...
set()

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

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

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

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

Пример:

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

Выход:

printing the original set ... 
{'March', 'January', 'April', 'June', 'February', 'May'}

Removing items through discard() method...

printing the modified set...
{'March', 'January', 'April', 'June', 'February', 'May'}

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

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

Python предоставляет возможность выполнять операции с операторами или методами.

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

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

Объединение наборов Python

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

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

Days1 = {"Monday","Tuesday","Wednesday","Thursday", "Sunday"}  
Days2 = {"Friday","Saturday","Sunday"}  
print(Days1|Days2) #printing the union of the sets   

Выход:

{'Friday', 'Sunday', 'Saturday', 'Tuesday', 'Wednesday', 'Monday', 'Thursday'}

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

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

Days1 = {"Monday","Tuesday","Wednesday","Thursday"}  
Days2 = {"Friday","Saturday","Sunday"}  
print(Days1.union(Days2)) #printing the union of the sets   

Выход:

{'Friday', 'Monday', 'Tuesday', 'Thursday', 'Wednesday', 'Sunday', 'Saturday'}

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

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

Пересечение наборов Python

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

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

Days1 = {"Monday","Tuesday", "Wednesday", "Thursday"}  
Days2 = {"Monday","Tuesday","Sunday", "Friday"}  
print(Days1&Days2) #prints the intersection of the two sets  

Выход:

{'Monday', 'Tuesday'}

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

set1 = {"Devansh","John", "David", "Martin"}  
set2 = {"Steve", "Milan", "David", "Martin"}  
print(set1.intersection(set2)) #prints the intersection of the two sets  

Выход:

{'Martin', 'David'}

Пример 3:

set1 = {1,2,3,4,5,6,7}
set2 = {1,2,20,32,5,9}
set3 = set1.intersection(set2)
print(set3)

Выход:

{1,2,5}

Метод crossction_update()

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

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

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

a = {"Devansh", "bob", "castle"}  
b = {"castle", "dude", "emyway"}  
c = {"fuson", "gaurav", "castle"}  
  
a.intersection_update(b, c)  
  
print(a)  

Выход:

{'castle'}

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

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

Разница между наборами Python

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

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

Days1 = {"Monday",  "Tuesday", "Wednesday", "Thursday"}  
Days2 = {"Monday", "Tuesday", "Sunday"}  
print(Days1-Days2) #{"Wednesday", "Thursday" will be printed}  

Выход:

{'Thursday', 'Wednesday'}

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

Days1 = {"Monday",  "Tuesday", "Wednesday", "Thursday"}  
Days2 = {"Monday", "Tuesday", "Sunday"}  
print(Days1.difference(Days2)) # prints the difference of the two sets Days1 and Days2  

Выход:

{'Thursday', 'Wednesday'}

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

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

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

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

a = {1,2,3,4,5,6}
b = {1,2,9,8,10}
c = a^b
print(c)

Выход:

{3, 4, 5, 6, 8, 9, 10}

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

a = {1,2,3,4,5,6}
b = {1,2,9,8,10}
c = a.symmetric_difference(b)
print(c)

Выход:

{3, 4, 5, 6, 8, 9, 10}

Операторы сравнения

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

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

Days1 = {"Monday",  "Tuesday", "Wednesday", "Thursday"}    
Days2 = {"Monday", "Tuesday"}    
Days3 = {"Monday", "Tuesday", "Friday"}    
    
#Days1 is the superset of Days2 hence it will print true.     
print (Days1>Days2)     
    
#prints false since Days1 is not the subset of Days2     
print (Days1<Days2)    
    
#prints false since Days2 and Days3 are not equivalent     
print (Days2 == Days3)

Вывод:

True
False
False

FrozenSets

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

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

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

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

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

Вывод:

<class 'frozenset'>

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

Frozenset для словаря

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

Dictionary = {"Name":"John", "Country":"USA", "ID":101}     
print(type(Dictionary))    
Frozenset = frozenset(Dictionary); #Frozenset will contain the keys of the dictionary    
print(type(Frozenset))    
for i in Frozenset:     
    print(i)

Вывод:

<class 'dict'>
<class 'frozenset'>
Name
Country
ID

Пример – 1: Напишите программу для удаления данного числа из множества.

my_set = {1,2,3,4,5,6,12,24}  
n = int(input("Enter the number you want to remove"))  
my_set.discard(n)  
print("After Removing:",my_set)

Вывод

Enter the number you want to remove:12
After Removing: {1, 2, 3, 4, 5, 6, 24}

Пример – 2: Напишем программу для добавления нескольких элементов в множество.

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

Вывод

{1, 2, 4, 'Apple', 'John', 'CS', 'Mango', 'Grapes'}

Пример – 3: как найти объединение между двумя множествами.

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

Вывод

{96, 65, 2, 'Joseph', 1, 'Peter', 59}

Пример-4: как найти пересечение между двумя множествами.

set1 = {23,44,56,67,90,45,"Javatpoint"}  
set2 = {13,23,56,76,"Sachin"}  
set3 = set1.intersection(set2)  
print(set3)

Вывод

{56, 23}

Пример – 5: программа для добавления элемента к frozenset.

set1 = {23,44,56,67,90,45,"Javatpoint"}  
set2 = {13,23,56,76,"Sachin"}  
set3 = set1.intersection(set2)  
print(set3)

Вывод

TypeError: 'frozenset' object does not support item assignment

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

Пример – 6: как найти исходное множество, подмножество и надмножество.

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

Вывод

False
False
True
True
Метод Описание
1 add(item) Добавляет элемент в множество.
2 clear() Удаляет все элементы
3 copy() возвращает неглубокую копию множества.
4 difference_update(….) изменяет этот набор, удаляя все элементы, которые также присутствуют в указанных наборах.
5 discard(item) удаляет указанный элемент из множества.
6 intersection() возвращает новый набор, содержащий только общие элементы обоих наборов. (все наборы, если указано более двух).
7 intersection_update(….) удаляет элементы из исходного множества, которые отсутствуют в обоих множествах(все наборы, если указано более одного).
8 Isdisjoint(….) Возвращает значение True, если два множества имеют нулевое пересечение.
9 Issubset(….) содержит ли этот набор другой набор.
10 Issuperset(….) содержит ли другой набор этот набор.
11 pop() Удаляет и возвращает произвольный элемент, который является последним элементом. Вызывает KeyError, если множество пусто.
12 remove(item) Удаляет элемент из множества; он должен быть членом. Если элемент не является членом, вызывает KeyError.
13 symmetric_difference(….) Удаляет элемент из множества; он должен быть членом. Если элемент не является членом, вызывает KeyError.
14 symmetric_difference_update(….) Обновляет множество с симметричной разницей самого себя и другого.
15 union(….) Возвращает объединение множеств в качестве нового множества.
(т.е. все элементы, которые находятся в любом множестве.)
16 update() Обновляет множество с помощью объединения самого себя и других.

Изучаю Python вместе с вами, читаю, собираю и записываю информацию опытных программистов.

Множества

Последнее обновление: 31.06.2017

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

users = {"Tom", "Bob", "Alice", "Tom"}
print(users)	# {"Alice", "Bob", "Tom"}

Обратите внимание, что несмотря на то, что функция print вывела один раз элемент «Tom», хотя в определении множества этот элемент содержится два раза.
Все потому что множество содержит только уникальные значения.

Также для определения множества может применяться функция set(), в которую передается список или кортеж элементов:

people = ["Mike", "Bill", "Ted"]
users = set(people)
print(users)    # {"Mike", "Bill", "Ted"}

Функцию set удобно применять для создания пустого множества:

users = set()

Для получения длины множества применяется встроенная функция len():

users = {"Tom", "Bob", "Alice"}
print(len(users))   	# 3

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

Для добавления одиночного элемента вызывается метод add():

users = set()
users.add("Sam")
print(users)

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

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

users = {"Tom", "Bob", "Alice"}

user = "Tom"
if user in users: 
    users.remove(user)
print(users)	# {"Bob", "Alice"}

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

users = {"Tom", "Bob", "Alice"}

users.discard("Tim")    # элемент "Tim" отсутствует, и метод ничего не делает
print(users)    #  {"Tom", "Bob", "Alice"}

users.discard("Tom")    # элемент "Tom" есть, и метод удаляет элемент
print(users)    #  {"Bob", "Alice"}

Для удаления всех элементов вызывается метод clear():

users.clear()

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

Для перебора элементов можно использовать цикл for:

users = {"Tom", "Bob", "Alice"}

for user in users:
    print(user)

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

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

С помощью метода copy() можно скопировать содержимое одного множества в другую переменную:

users = {"Tom", "Bob", "Alice"}
students = users.copy()
print(students)     # {"Tom", "Bob", "Alice"}

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

Метод union() объединяет два множества и возвращает новое множество:

users = {"Tom", "Bob", "Alice"}
users2 = {"Sam", "Kate", "Bob"}

users3 = users.union(users2)
print(users3)   # {"Bob", "Alice", "Sam", "Kate", "Tom"}

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

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

users = {"Tom", "Bob", "Alice"}
users2 = {"Sam", "Kate", "Bob"}

users3 = users.intersection(users2)
print(users3)   # {"Bob"}

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

users = {"Tom", "Bob", "Alice"}
users2 = {"Sam", "Kate", "Bob"}

print(users & users2)   # {"Bob"}

В этом случае мы получили бы тот же результат.

Модификация метода — intersection_update() заменяет пересеченными элементами первое множество:

users = {"Tom", "Bob", "Alice"}
users2 = {"Sam", "Kate", "Bob"}
users.intersection_update(users2)
print(users)   # {"Bob"}

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

Еще одна операция — разность множеств возвращает те элементы, которые есть в первом множестве, но отсутствуют во втором. Для
получения разности множеств можно использовать метод difference или операцию вычитания:

users = {"Tom", "Bob", "Alice"}
users2 = {"Sam", "Kate", "Bob"}

users3 = users.difference(users2)
print(users3)           # {"Tom", "Alice"}
print(users - users2)   # {"Tom", "Alice"}

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

users = {"Tom", "Bob", "Alice"}
users2 = {"Sam", "Kate", "Bob"}

users3 = users.symmetric_difference(users2)
print(users3)   # {"Tom", "Alice", "Sam", "Kate"}

users4 = users ^ users2
print(users4)   # {"Tom", "Alice", "Sam", "Kate"}

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

Метод issubset позволяет выяснить, является ли текущее множество подмножеством (то есть частью) другого множества:

users = {"Tom", "Bob", "Alice"}
superusers = {"Sam", "Tom", "Bob", "Alice", "Greg"}

print(users.issubset(superusers))   # True
print(superusers.issubset(users))   # False

Метод issuperset, наоборот, возвращает True, если текущее множество является надмножеством (то есть содержит) для другого множества:

users = {"Tom", "Bob", "Alice"}
superusers = {"Sam", "Tom", "Bob", "Alice", "Greg"}

print(users.issuperset(superusers))   # False
print(superusers.issuperset(users))   # True

frozen set

Тип frozen set является видом множеств, которое не может быть изменено. Для его создания используется функция
frozenset:

users = frozenset({"Tom", "Bob", "Alice"})

В функцию frozenset передается набор элементов — список, кортеж, другое множество.

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

  • len(s): возвращает длину множества

  • x in s: возвращает True, если элемент x присутствует в множестве s

  • x not in s: возвращает True, если элемент x отсутствует в множестве s

  • s.issubset(t): возвращает True, если t содержит множество s

  • s.issuperset(t): возвращает True, если t содержится в множестве s

  • s.union(t)

    : возвращает объединение множеств s и t

  • s.intersection(t): возвращает пересечение множеств s и t

  • s.difference(t): возвращает разность множеств s и t

  • s.copy(): возвращает копию множества s

Понравилась статья? Поделить с друзьями:
  • Как выглядит инструкция добавления элемента b в конец списка a
  • Как вывязывать пятку на носках спицами пошаговая инструкция
  • Как выводить цыплят в инкубаторе в домашних условиях инструкция
  • Как выводить утят в инкубаторе в домашних условиях инструкция
  • Как выводить гусят в инкубаторе в домашних условиях температура влажность инструкция