У цій інструкції ви ознайомитеся з основами використання множин у Python, а також різноманітними методами, що дозволяють маніпулювати цими структурами даних.
Множини є однією з базових структур даних, вбудованих у Python. Коли виникає потреба працювати з колекцією елементів, де не допускаються повторення, саме множина стає ідеальним вибором.
У наступних розділах ми детально розглянемо ключові аспекти множин Python, а також методи, які використовуються для взаємодії з ними. Згодом, ми навчимося виконувати стандартні операції над множинами в Python.
Розпочнімо!
Основи множин Python
В Python, множина – це неупорядкований збірник унікальних елементів. Це означає, що кожен елемент у множині повинен бути відмінним від інших.
Ви можете додавати або вилучати елементи з множини, тому вона є змінною структурою даних. Множина може вміщувати елементи різних типів даних, але кожен з них повинен бути хешованим.
В Python об’єкт вважається хешованим, якщо його значення хешу залишається незмінним протягом всього часу його існування. Більшість незмінних об’єктів, як рядки, кортежі та словники Python, можна хешувати.
Розгляньмо детальніше створення множин. Наразі давайте проаналізуємо два наступних приклади множин:
py_set = {0,1,2,(2,3,4),'Cool!'}
py_set = {0,1,2,[2,3,4],'Oops!'}
# Output
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-40-2d3716c7fe01> in <module>()
----> 1 py_set = {0,1,2,[2,3,4],'Oops!'}
TypeError: unhashable type: 'list'
Перша множина включає три числа, кортеж і рядок. Її ініціалізація проходить успішно. В той час, як друга множина містить список замість кортежу. Список є змінною колекцією, тому його не можна хешувати, і при спробі ініціалізації виникає TypeError.
📑 Підсумовуючи, ми можемо визначити множину Python як змінну колекцію унікальних хешованих елементів.
Способи створення множини Python
Розглянемо способи створення множин в Python.
#1. Застосування явної ініціалізації
Для створення множини в Python, потрібно перерахувати її елементи, відокремлюючи їх комами (,) і помістити всю цю послідовність у фігурні дужки {}.
py_set1 = {'Python','C','C++','JavaScript'}
type(py_set1)
# Output
set
Якщо ви мали досвід роботи зі списками Python, то вам відомо, що [] створює порожній список. Хоч множини Python і укладаються в фігурні дужки {}, не можна використовувати пару {} для створення множини. Це пов’язано з тим, що {} ініціалізує словник Python, а не множину.
py_set2 = {}
type(py_set2)
# Output
dict
Для перевірки, ви можете знову скористатись функцією type(), щоб переконатися, що py_set є словником (dict).
#2. Використання функції set().
Для ініціалізації порожньої множини, з подальшим додаванням елементів, можна скористатися функцією set().
py_set3 = set() type(py_set3) # Output set
#3. Конвертація інших ітерабельних об’єктів у множину
Ще один метод створення множин полягає в конвертації інших ітерабельних об’єктів, таких як списки і кортежі, в множини за допомогою функції set(iterable).
py_list = ['Python','C','C++','JavaScript','C']
py_set4 = set(py_list)
print(py_set4)
# {'C++', 'C', 'JavaScript', 'Python'} # повторюваний елемент 'C' видалено
type(py_set4)
# set
У наведеному вище прикладі елемент “C” зустрічається в py_list двічі. Проте в py_set4 він з’являється лише один раз, оскільки множина зберігає лише унікальні значення. Цей метод конвертації до множини часто застосовується для видалення дублікатів зі списків Python.
Додавання елементів до множини Python
Давайте створимо порожню множину py_set і будемо працювати з нею протягом цього уроку.
py_set = set() len(py_set) # повертає довжину множини # Output 0
#1. Використання методу .add().
Для додавання елементів до множини можна використати метод .add(). set.add(element) додає елемент до множини.
Для наочності, ми будемо додавати елементи до множини Python, виводячи набір на екран на кожному етапі.
▶️ Давайте додамо рядок “Python” до py_set.
py_set.add('Python')
print(py_set)
# Output
{'Python'}
Далі, додамо ще один елемент.
py_set.add('C++')
print(py_set)
# Output
{'Python', 'C++'}
Важливо розуміти, що метод .add() додає елемент до множини тільки в тому випадку, якщо його ще там немає. Якщо елемент вже присутній у множині, операція додавання не матиме ніякого ефекту.
Щоб переконатися в цьому, давайте спробуємо додати “C++” до py_set повторно.
py_set.add('C++')
print(py_set)
# Output
{'Python', 'C++'}
Оскільки множина вже містить “C++”, операція додавання не приносить змін.
▶️ Додамо ще декілька елементів до множини.
py_set.add('C')
print(py_set)
py_set.add('JavaScript')
print(py_set)
py_set.add('Rust')
print(py_set)
# Output
{'Python', 'C++', 'C'}
{'JavaScript', 'Python', 'C++', 'C'}
{'Rust', 'JavaScript', 'Python', 'C++', 'C'}
#2. Використання методу .update().
До цього моменту ми навчилися додавати елементи до вже існуючої множини по одному.
А що робити, якщо вам потрібно додати одразу декілька елементів з певної послідовності?
Для цього можна скористатися методом .update() з таким синтаксисом: set.update(collection). Колекція може бути списком, кортежем, словником і т.д.
py_set.update(['Julia','Ruby','Scala','Java'])
print(py_set)
# Output
{'C', 'C++', 'Java', 'JavaScript', 'Julia', 'Python', 'Ruby', 'Rust', 'Scala'}
Цей метод є корисним, якщо потрібно додати колекцію елементів до множини без створення нового об’єкта в пам’яті.
У наступному розділі ми розглянемо методи видалення елементів з множини.
Видалення елементів з множини Python
Розглянемо наступну множину (py_set до операції оновлення).
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
#1. Використання методу .pop().
Метод set.pop() випадковим чином вилучає елемент з множини і повертає його. Давайте викличемо метод pop для py_set і подивимось, що він поверне.
py_set.pop() # Output 'Rust'
В даному випадку виклик методу .pop() повернув рядок “Rust”.
Примітка: Оскільки .pop() повертає елемент у випадковому порядку, результат може відрізнятися при виконанні коду на вашому комп’ютері.
Якщо ми перевіримо множину, “Rust” більше не буде присутнім у ній.
print(py_set)
# Output
{'JavaScript', 'Python', 'C++', 'C'}
#2. Використання методів .remove() та discard().
Часто необхідно видалити певні елементи з множини. Для цього можна скористатися методами .remove() і .discard().
set.remove(element) вилучає вказаний елемент з множини.
py_set.remove('C')
print(py_set)
# Output
{'JavaScript', 'Python', 'C++'}
Якщо спробувати видалити елемент, якого немає у множині, виникне KeyError.
py_set.remove('Scala')
# Output
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
<ipython-input-58-a1abab3a8892> in <module>()
----> 1 py_set.remove('Scala')
KeyError: 'Scala'
Давайте ще раз поглянемо на py_set. Тепер в ньому залишилось три елементи.
print(py_set)
# Output
{'JavaScript', 'Python', 'C++'}
З синтаксисом set.discard(element), метод .discard() також вилучає елементи з множини.
py_set.discard('C++')
print(py_set)
# Output
{'JavaScript', 'Python'}
Проте, на відміну від .remove(), він не викликає KeyError при спробі видалення елемента, якого немає в множині.
Якщо ми спробуємо видалити “Scala” (якого немає) зі списку за допомогою .discard(), помилки не буде.
py_set.discard('Scala') #без помилки!
print(py_set)
# Output
{'JavaScript', 'Python'}
Доступ до елементів множини Python
На даний момент ми навчилися додавати та видаляти елементи з множин Python. Проте, ми ще не розглянули способи доступу до окремих елементів множини.
Оскільки множина є неупорядкованою колекцією, вона не підтримує індексацію. Тому, спроба отримати доступ до елементів множини за індексом призведе до помилки.
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
print(py_set[0])
# Output
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-27-0329274f4580> in <module>()
----> 1 print(py_set[0])
TypeError: 'set' object is not subscriptable
Отже, як отримати доступ до елементів множини?
Існує два поширені методи:
- Ітерація по елементах множини
- Перевірка наявності конкретного елемента в множині
▶️ Ітерація по елементах множини за допомогою циклу for.
for elt in py_set: print(elt) # Output C++ JavaScript Python Rust C
На практиці, можна перевірити наявність певного елемента в множині за допомогою оператора in.
Примітка: Операція element in set повертає True, якщо елемент присутній в множині, інакше повертає False.
У цьому прикладі py_set містить “C++” і не містить “Julia”, оператор in поверне True і False відповідно.
'C++' in py_set # True 'Julia' in py_set # False
Визначення довжини множини Python
Як ми вже бачили, для визначення кількості елементів у множині можна скористатися функцією len().
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
len(py_set)
# Output: 5
Очищення множини Python
Для очищення множини, тобто видалення всіх її елементів, використовується метод .clear().
Давайте скористаємося методом .clear() на py_set.
py_set.clear()
При спробі вивести її на екран, ми отримаємо set(), що свідчить про те, що множина порожня. Також, можна скористатися функцією len() для підтвердження нульової довжини множини.
print(py_set) # set() print(len(py_set)) # 0
Наразі ми навчилися виконувати основні операції CRUD над множинами Python:
- Створення: використання функції set(), конвертація типів та ініціалізація
- Читання: отримання доступу до елементів за допомогою циклів та оператора in для перевірки наявності елемента
- Оновлення: додавання, вилучення елементів та оновлення множин
- Видалення: очищення множини, шляхом видалення всіх її елементів
Основні операції з множинами, на прикладах Python
Множини Python також дозволяють виконувати стандартні операції. Розглянемо їх в цьому розділі.
#1. Об’єднання множин в Python
В теорії множин, об’єднання двох множин – це сукупність елементів, що входять хоча б в одну з двох множин. Якщо маємо дві множини A та B, то об’єднання містить елементи, які присутні лише в A, лише в B, а також елементи, наявні як в A, так і в B.
Для отримання об’єднання двох множин, можна використати оператор | або метод .union(), з синтаксисом setA.union(setB).
setA = {1,3,5,7,9}
setB = {2,4,6,8,9}
print(setA | setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8, 9}
setA.union(setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8, 9}
Об’єднання множин є комутативною операцією, тому AUB еквівалентно BU A. Перевіримо це, змінивши порядок множин у виклику .union().
setB.union(setA)
# Output
{1, 2, 3, 4, 5, 6, 7, 8, 9}
#2. Перетин множин в Python
Інша поширена операція над множинами – це перетин двох множин, A і B. Результатом перетину є множина, що містить усі елементи, які входять як до A, так і до B.
Для обчислення перетину, можна використати оператор & або метод .intersection(), як показано в прикладі нижче.
print(setA & setB)
# Output
{9}
setA.intersection(setB)
# Output
{9}
В цьому прикладі, елемент 9 входить як до множини A, так і до множини B, тому множина перетину містить тільки цей елемент.
Так само як і об’єднання, перетин множин також є комутативною операцією.
setB.intersection(setA)
# Output
{9}
#3. Різниця множин в Python
Для двох заданих множин, об’єднання та перетин дозволяють нам знайти елементи, що присутні в обох і принаймні в одній з множин, відповідно. З іншого боку, різниця множин допомагає знайти елементи, що присутні в одній множині, але відсутні в іншій.
– setA.difference(setB) повертає множину елементів, що присутні тільки в setA, але не в setB.
– setB.difference(setA) повертає множину елементів, що присутні тільки в setB, але не в setA.
print(setA - setB)
print(setB - setA)
# Output
{1, 3, 5, 7}
{8, 2, 4, 6}
Зрозуміло, що AB не дорівнює BA, отже, різниця множин не є комутативною операцією.
setA.difference(setB)
# {1, 3, 5, 7}
setB.difference(setA)
# {2, 4, 6, 8}
#4. Симетрична різниця множин в Python
В той час, як перетин множин повертає елементи, що присутні в обох множинах, симетрична різниця повертає множину елементів, що присутні лише в одній з множин.
Розглянемо наступний приклад.
setA = {1,3,5,7,10,12}
setB = {2,4,6,8,10,12}
Для обчислення симетричної різниці, можна використати оператор ^ або метод .symmetric_difference().
print(setA ^ setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8}
Елементи 10 та 12 присутні як в множині A, так і в множині B. Отже, вони відсутні в множині симетричної різниці.
setA.symmetric_difference(setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8}
Оскільки симетрична різниця збирає всі елементи, що з’являються лише в одній з двох множин, результат не залежить від порядку збору елементів. Отже, симетрична різниця множин є комутативною операцією.
setB.symmetric_difference(setA)
# Output
{1, 2, 3, 4, 5, 6, 7, 8}
#5. Підмножини та надмножини в Python
В теорії множин, підмножини та надмножини допомагають зрозуміти зв’язки між двома множинами.
Для двох множин A і B, множина B є підмножиною множини A, якщо всі елементи множини B також присутні в множині A. В такому випадку, множина A є надмножиною множини B.
Розглянемо приклад двох множин: languages та languages_extended.
languages = {'Python', 'JavaScript','C','C++'}
languages_extended = {'Python', 'JavaScript','C','C++','Rust','Go','Scala'}
В Python, для перевірки того, чи є дана множина підмножиною іншої, використовується метод .issubset().
setA.issubset(setB) повертає True, якщо setA є підмножиною setB, інакше повертає False.
В цьому прикладі languages є підмножиною languages_extended.
languages.issubset(languages_extended) # Output True
Аналогічно, для перевірки, чи є дана множина надмножиною іншої, використовується метод .issuperset().
setA.issuperset(setB) повертає True, якщо setA є надмножиною setB, інакше повертає False.
languages_extended.issuperset(languages) # Output True
Оскільки languages_extended є надмножиною languages, languages_extended.issuperset(languages) повертає True, як показано вище.
Висновок
Сподіваємося, ця інструкція допомогла вам розібратися з принципами роботи множин в Python, методами CRUD та основними операціями. Наступним кроком буде застосування цих знань у ваших проектах на Python.
Можете ознайомитися з іншими нашими деталізованими інструкціями по Python. Приємного навчання!