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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Что это

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

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

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

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

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

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

s1 = {}  # Это создаст пустое множество
s2 = {1, 'pythonru', 20.67}

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

s1 = set()  # Это создаст пустое множество
s2 = set({1, 'pythonru', 20.67})

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

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

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

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

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

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

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

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

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

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

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

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

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

1. remove()
2. discard()
3. pop()

remove()

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

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

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

set1.remove(5)
# Error element not found

discard()

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

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

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

pop()

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

set1 = {1, 3, 4, “p”} 
set1.pop()
3  # случайный элемент будет удален (ваш результат может отличаться)

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

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

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

set1 = { 1, 2, 3, 4}

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

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

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

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

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

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

num_set = {1 ,3, 5, 7, 9, 10}
7 in num_set
# True

2 in num_set
# False

1 not in num_set
# False

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

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

6

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

new_set = num_set.copy()

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

num_set.clear()

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

del num_set

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

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

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

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

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

A = {1, 2, 3}
B = {2, 3, 4, 5}
C = A | B  # используя символьный метод
C = A.union(B) # используя метод union
print(C)
# {1, 2, 3, 4, 5}

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

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

A = {1, 2, 3, 4}
B = {3,4,5,6}
C = A & B  # используя символьный метод
C = A.intersection(B)  # используя метод intersection
print(C)
# {3,4}

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

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

A = {1, 2, 3, 4} 
B = {3,4,5,6}
C = A - B # используя символьный метод
C = A.difference(B) # используя метод difference
print(C)
# {1,2}

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

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

C = A ^ B  # используя символьный метод
C = A.symmetric_difference(B)  # используя метод symmetric_difference
print(C)
# {1, 2, 5, 6}

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

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

A = {1, 2, 3, 4, 5} 
B = {2,3,4}
B <= A  # используя символьный метод
B.issubset(A) # используя метод issubset
# True

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

A = {1, 2, 3, 4, 5} 
B = {2,3,4}
A >= B  # используя символьный метод
A.issuperset(B) # используя метод issubset
# True

Бонус

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

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

List1 = [1, 2, 3, 5, 3, 2, 4, 7]
List_without_duplicate = set(List1)
print(List_without_duplicate)
# (1, 2, 3, 5, 4, 7)  преобразован в множество

back_to_list = list(List_without_duplicate)
# [1, 2, 3, 5, 4, 7]  снова преобразован в список

Выводы

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

Множества в 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}

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

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

Для добавления элемента в множество используется метод
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 & 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! 😉

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

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

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

Содержание:

• Создание множеств
• Доступ к элементам множеств
• Добавление элементов во множество
• Удаление элементов из множеств
• Объединение множеств
• Пересечение множеств
• Разница множеств
• Сравнение множеств
• Методы множеств
• Frozenset в Python
• Вывод

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

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

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

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

Результат:

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

Результат:

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

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

Результат:

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

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

Результат:

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

Результат:

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

Результат:

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

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

Результат:

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

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

Результат:

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

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

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

Результат:

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

Результат:

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

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

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

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

Результат:

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

Результат:

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

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

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

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

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

Результат:

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

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

Результат:

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

Результат:

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

Результат:

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

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

Например:

Результат:

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

Результат:

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

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

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

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

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

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

Результат:

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

Результат:

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

Результат:

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

Результат:

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

Результат:

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

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

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

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

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

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

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

КОД

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

Результат:

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

Результат:

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

Результат:

Симметричную разницу можно также найти следующим образом:

Результат:

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

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

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

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

Например:

Результат:

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

Результат:

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

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

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

Метод copy()

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

Результат:

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

Метод isdisjoint()

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

Результат:

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

Метод len()

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

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

Frozenset в Python

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

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

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

Результат:

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

Вывод

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

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

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