Операции с множествами (например, определение объединения множеств, произведения множеств и подмножеств) с помощью типа множеств Python

Бизнес

Python предоставляет встроенный тип данных set, который работает с множествами.

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

В этом разделе объясняются основные операции в наборах типа set с примером кода.

  • Создание объектов набора: {},set()
  • обозначение включения множества
  • Количество элементов в наборе:len()
  • Добавление элемента в набор:add()
  • Удалить элемент из множества: discard(),remove(),pop(),clear()
  • Вассет (слияние, объединение):|оператор,union()
  • Наборы продуктов (общие части, пересечения, перекрестки):& оператор,intersection()
  • относительное дополнение:-оператор,difference()
  • набор различий симметрии:^ оператор,symmetric_difference()
  • подмножество или нет:<= оператор,issubset()
  • Верхний набор или нет:>= оператор,issuperset()
  • Определение того, являются ли они взаимно простыми или нет:isdisjoint()

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

Создание объекта набора:: {}, set()

Генерируется волновыми скобками {}

Объекты типа set можно создавать, заключая элементы в скобки {}.

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

s = {1, 2, 2, 3, 1, 4}

print(s)
print(type(s))
# {1, 2, 3, 4}
# <class 'set'>

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

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

s = {1.23, 'abc', (0, 1, 2), 'abc'}

print(s)
# {(0, 1, 2), 1.23, 'abc'}

# s = {[0, 1, 2]}
# TypeError: unhashable type: 'list'

Различные типы, такие как int и float, считаются дубликатами, если их значения эквивалентны.

s = {100, 100.0}

print(s)
# {100}

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

s = {}

print(s)
print(type(s))
# {}
# <class 'dict'>

Генерируется конструктором set()

Объекты типа set также могут быть созданы с помощью конструктора set().

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

l = [1, 2, 2, 3, 1, 4]

print(l)
print(type(l))
# [1, 2, 2, 3, 1, 4]
# <class 'list'>

s_l = set(l)

print(s_l)
print(type(s_l))
# {1, 2, 3, 4}
# <class 'set'>

Неизменяемые типы frozenset создаются с помощью конструктора frozenset().

fs_l = frozenset(l)

print(fs_l)
print(type(fs_l))
# frozenset({1, 2, 3, 4})
# <class 'frozenset'>

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

s = set()

print(s)
print(type(s))
# set()
# <class 'set'>

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

Чтобы преобразовать тип set в список или кортеж, используйте list(),tuple().

l = [2, 2, 3, 1, 3, 4]

l_unique = list(set(l))
print(l_unique)
# [1, 2, 3, 4]

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

обозначение включения множества

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

s = {i**2 for i in range(5)}

print(s)
# {0, 1, 4, 9, 16}

Более подробную информацию о нотации понимания списка см. в следующей статье.

Количество элементов в наборе: len()

Количество элементов в множестве можно получить с помощью встроенной функции len().

s = {1, 2, 2, 3, 1, 4}

print(s)
print(len(s))
# {1, 2, 3, 4}
# 4

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

Добавление элемента в набор: add()

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

s = {0, 1, 2}

s.add(3)
print(s)
# {0, 1, 2, 3}

Удалить элемент из множества: discard(),remove(),pop(),clear()

Чтобы удалить элемент из набора, используйте методы discard(), remove(), pop() и clear().

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

s = {0, 1, 2}

s.discard(1)
print(s)
# {0, 2}

s = {0, 1, 2}

s.discard(10)
print(s)
# {0, 1, 2}

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

s = {0, 1, 2}

s.remove(1)
print(s)
# {0, 2}

# s = {0, 1, 2}

# s.remove(10)
# KeyError: 10

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

s = {2, 1, 0}

v = s.pop()

print(s)
print(v)
# {1, 2}
# 0

s = {2, 1, 0}

print(s.pop())
# 0

print(s.pop())
# 1

print(s.pop())
# 2

# print(s.pop())
# KeyError: 'pop from an empty set'

Метод clear() удаляет все элементы и делает набор пустым.

s = {0, 1, 2}

s.clear()
print(s)
# set()

Вассет (слияние, объединение): |оператор, union()

Объединенное множество (объединение, union) можно получить с помощью оператора | или метода union().

s1 = {0, 1, 2}
s2 = {1, 2, 3}
s3 = {2, 3, 4}

s_union = s1 | s2
print(s_union)
# {0, 1, 2, 3}

s_union = s1.union(s2)
print(s_union)
# {0, 1, 2, 3}

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

s_union = s1.union(s2, s3)
print(s_union)
# {0, 1, 2, 3, 4}

s_union = s1.union(s2, [5, 6, 5, 7, 5])
print(s_union)
# {0, 1, 2, 3, 5, 6, 7}

Наборы продуктов (общие части, пересечения, перекрестки): & оператор, intersection()

Набор произведений (общая часть, пересечение и пересечение) можно получить с помощью оператора & или метода intersection().

s_intersection = s1 & s2
print(s_intersection)
# {1, 2}

s_intersection = s1.intersection(s2)
print(s_intersection)
# {1, 2}

s_intersection = s1.intersection(s2, s3)
print(s_intersection)
# {2}

относительное дополнение: -оператор, difference()

Набор разностей можно получить с помощью оператора — или метода difference().

s_difference = s1 - s2
print(s_difference)
# {0}

s_difference = s1.difference(s2)
print(s_difference)
# {0}

s_difference = s1.difference(s2, s3)
print(s_difference)
# {0}

набор различий симметрии: ^ оператор, symmetric_difference()

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

Эквивалент исключительной дизъюнкции (XOR) в логических операциях.

s_symmetric_difference = s1 ^ s2
print(s_symmetric_difference)
# {0, 3}

s_symmetric_difference = s1.symmetric_difference(s2)
print(s_symmetric_difference)
# {0, 3}

подмножество или нет: <= оператор, issubset()

Чтобы определить, является ли множество подмножеством другого множества, используйте оператор <= или метод issubset().

s1 = {0, 1}
s2 = {0, 1, 2, 3}

print(s1 <= s2)
# True

print(s1.issubset(s2))
# True

И оператор <=, и метод issubset() возвращают true для эквивалентных множеств.

Чтобы определить, является ли оно истинным подмножеством, используйте оператор <=, который возвращает false для эквивалентных множеств.

print(s1 <= s1)
# True

print(s1.issubset(s1))
# True

print(s1 < s1)
# False

Верхний набор или нет: >= оператор, issuperset()

Чтобы определить, является ли одно множество супермножеством другого, используйте оператор >= или issuperset().

s1 = {0, 1}
s2 = {0, 1, 2, 3}

print(s2 >= s1)
# True

print(s2.issuperset(s1))
# True

Как оператор >=, так и метод issuperset() возвращают true для эквивалентных множеств.

Чтобы определить, является ли оно истинным супермножеством, используйте оператор >=, который возвращает false для эквивалентных множеств.

print(s1 >= s1)
# True

print(s1.issuperset(s1))
# True

print(s1 > s1)
# False

Определение того, являются ли они взаимно простыми или нет: isdisjoint()

Чтобы определить, являются ли два множества простыми друг для друга, используйте метод isdisjoint().

s1 = {0, 1}
s2 = {1, 2}
s3 = {2, 3}

print(s1.isdisjoint(s2))
# False

print(s1.isdisjoint(s3))
# True
Copied title and URL