Операції з наборами (наприклад, визначення множин об’єднань, наборів продуктів і підмножин) із типом набору Python

Бізнес

Python надає вбудований тип даних set, який обробляє набори.

Набір типів являє собою набір неповторюваних елементів (елементів, які не мають однакового значення, унікальних елементів) і може виконувати операції з наборами, такі як набір об’єднань, набір продуктів і набір різниць.

У цьому розділі основні операції в операціях з наборами типу набору пояснюються зі зразком коду.

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

Тип набору є змінюваним типом, який може додавати та видаляти елементи, а також є тип замороженого набору, який має ту ж операцію набору та інші методи, що й тип набору, але є незмінним (не може бути змінений шляхом додавання, видалення чи іншої зміни елементів ).

Створення об’єкта набору::{},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}

Оскільки порожня дужка {} вважається типом словника, об’єкт типу порожнього набору (порожній набір) можна створити за допомогою конструктора, описаного далі.

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'>

Якщо аргумент опущено, створюється порожній об’єкт типу множини (порожній набір).

s = set()

print(s)
print(type(s))
# set()
# <class '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()

Wasset (злиття, об’єднання):|оператор,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(), також можуть бути вказані як аргументи. Те ж саме стосується наступних операторів і методів.

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()

Набір різниць можна отримати за допомогою оператора – або методу different().

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