Python пропонує широкий набір типів даних, які дозволяють ефективно організовувати та обробляти інформацію. Серед них особливо виділяються колекції даних: словники, кортежі та множини. У цій частині ми детально розглянемо, як використовувати ці структури для зберігання і маніпуляції даними в реальних проєктах. Ви дізнаєтеся, як створювати словники з парами ключ-значення для зручного доступу до інформації, як використовувати кортежі для зберігання впорядкованих наборів даних та як застосовувати множини для роботи з унікальними елементами.
Словники – це впорядкований тип даних, що змінюється:
дані у словнику – це пари ключ: значення
доступ до значень здійснюється за ключом, а не за номером, як у списках
дані у словнику впорядковані за порядком додавання елементів
оскільки словники змінюються, то елементи словника можна змінювати, додавати, видаляти
ключ має бути об’єктом незмінного типу: число, рядок, кортеж
значення може бути даними будь-якого типу
В інших мовах програмування тип даних подібний до словника може називатися асоціативний масив, хеш або хеш-таблиця.
Приклад словника:
london = {'name': 'London1', 'location': 'London Str', 'vendor': 'Cisco'}
Можна записувати і так:
london = {
'id': 1,
'name': 'London',
'it_vlan': 320,
'user_vlan': 1010,
'mngmt_vlan': 99,
'to_name': None,
'to_id': None,
'port': 'G1/0/11'
}
Для того, щоб отримати значення зі словника, треба звернутися по ключу, так само, як це було в списках, тільки замість номера використовуватиметься ключ:
In [1]: london = {'name': 'London1', 'location': 'London Str'}
In [2]: london['name']
Out[2]: 'London1'
In [3]: london['location']
Out[3]: 'London Str'
Аналогічно можна додати нову пару ключ-значення:
In [4]: london['vendor'] = 'Cisco'
In [5]: print(london)
{'vendor': 'Cisco', 'name': 'London1', 'location': 'London Str'}
У словнику як значення можна використовувати словник:
london_co = {
'r1': {
'hostname': 'london_r1',
'location': '21 New Globe Walk',
'vendor': 'Cisco',
'model': '4451',
'ios': '15.4',
'ip': '10.255.0.1'
},
'r2': {
'hostname': 'london_r2',
'location': '21 New Globe Walk',
'vendor': 'Cisco',
'model': '4451',
'ios': '15.4',
'ip': '10.255.0.2'
},
'sw1': {
'hostname': 'london_sw1',
'location': '21 New Globe Walk',
'vendor': 'Cisco',
'model': '3850',
'ios': '3.6.XE',
'ip': '10.255.0.101'
}
}
Отримати значення із вкладеного словника можна так:
In [7]: london_co['r1']['ios'] Out[7]: '15.4' In [8]: london_co['r1']['model'] Out[8]: '4451' In [9]: london_co['sw1']['ip'] Out[9]: '10.255.0.101'
Функція sorted сортує ключі словника за зростанням та повертає новий список із відсортованими ключами:
In [1]: london = {'name': 'London1', 'location': 'London Str', 'vendor': 'Cisco'}
In [2]: sorted(london)
Out[2]: ['location', 'name', 'vendor']
clearМетод clearдозволяє очистити словник:
In [1]: london = {'name': 'London1', 'location': 'London Str'}
In [2]: london.clear()
In [3]: london
Out[3]: {}
copyМетод copyдозволяє створити повну копію словника.
Якщо вказати, що один словник дорівнює іншому:
In [4]: london = {'name': 'London1', 'location': 'London Str', 'vendor': 'Cisco'}
In [5]: london2 = london
In [6]: id(london)
Out[6]: 25489072
In [7]: id(london2)
Out[7]: 25489072
In [8]: london['vendor'] = 'Juniper'
In [9]: london2['vendor']
Out[9]: 'Juniper'
У цьому випадку london2 це ще одне ім’я, яке посилається на словник. І при змінах словника london змінюється і словник london2, оскільки це посилання на той самий об’єкт.
Тому, якщо потрібно зробити копію словника, треба використовувати метод copy():
In [10]: london = {'name': 'London1', 'location': 'London Str', 'vendor': 'Cisco'}
In [11]: london2 = london.copy()
In [12]: id(london)
Out[12]: 25524512
In [13]: id(london2)
Out[13]: 25563296
In [14]: london['vendor'] = 'Juniper'
In [15]: london2['vendor']
Out[15]: 'Cisco'
getЯкщо при зверненні до словника вказується ключ, якого немає у словнику, виникає помилка:
In [16]: london = {'name': 'London1', 'location': 'London Str', 'vendor': 'Cisco'}
In [17]: london['ios']
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
<ipython-input-17-b4fae8480b21> in <module>()
----> 1 london['ios']
KeyError: 'ios'
Метод getзапитує ключ, і якщо немає, замість помилки повертає None.
In [18]: london = {'name': 'London1', 'location': 'London Str', 'vendor': 'Cisco'}
In [19]: print(london.get('ios'))
None
Метод get() дозволяє також вказувати інше значення замість None:
In [20]: print(london.get('ios', 'Ooops'))
Ooops
setdefaultМетод setdefault шукає ключ, і якщо він не існує, замість помилки створює ключ зі значенням None.
In [21]: london = {'name': 'London1', 'location': 'London Str', 'vendor': 'Cisco'}
In [22]: ios = london.setdefault('ios')
In [23]: print(ios)
None
In [24]: london
Out[24]: {'name': 'London1', 'location': 'London Str', 'vendor': 'Cisco', 'ios': None}
Якщо ключ є, setdefault повертає значення, яке відповідає:
In [25]: london.setdefault('name')
Out[25]: 'London1'
Другий аргумент дозволяє вказати, яке значення має відповідати ключу:
In [26]: model = london.setdefault('model', 'Cisco3580')
In [27]: print(model)
Cisco3580
In [28]: london
Out[28]:
{'name': 'London1',
'location': 'London Str',
'vendor': 'Cisco',
'ios': None,
'model': 'Cisco3580'}
Метод setdefault замінює таку конструкцію:
In [30]: if key in london:
...: value = london[key]
...: else:
...: london[key] = 'somevalue'
...: value = london[key]
...:
keys, values, itemsМетоди keys, values, items:
In [24]: london = {'name': 'London1', 'location': 'London Str', 'vendor': 'Cisco'}
In [25]: london.keys()
Out[25]: dict_keys(['name', 'location', 'vendor'])
In [26]: london.values()
Out[26]: dict_values(['London1', 'London Str', 'Cisco'])
In [27]: london.items()
Out[27]: dict_items([('name', 'London1'), ('location', 'London Str'), ('vendor', 'Cisco')])
Всі три методи повертають спеціальні об’єкти view, які відображають ключі, значення та пари ключ-значення словника відповідно. Дуже важлива особливість view полягає в тому, що вони змінюються разом зі зміною словника.
На прикладі методу keys:
In [28]: london = {'name': 'London1', 'location': 'London Str', 'vendor': 'Cisco'}
In [29]: keys = london.keys()
In [30]: print(keys)
dict_keys(['name', 'location', 'vendor'])
Зараз змінною keys відповідає view dict_keys, в якому три ключі: name, location та vendor.
Якщо додати до словника ще одну пару ключ-значення, об’єкт keys також зміниться:
In [31]: london['ip'] = '10.1.1.1' In [32]: keys Out[32]: dict_keys(['name', 'location', 'vendor', 'ip'])
Якщо потрібно отримати звичайний список ключів, який не змінюватиметься зі змінами словника, достатньо конвертувати view в список:
In [33]: list_keys = list(london.keys()) In [34]: list_keys Out[34]: ['name', 'location', 'vendor', 'ip']
delВидалити ключ і значення:
In [35]: london = {'name': 'London1', 'location': 'London Str', 'vendor': 'Cisco'}
In [36]: del london['name']
In [37]: london
Out[37]: {'location': 'London Str', 'vendor': 'Cisco'}
updateМетод update дозволяє додавати до словника вміст іншого словника:
In [38]: r1 = {'name': 'London1', 'location': 'London Str'}
In [39]: r1.update({'vendor': 'Cisco', 'ios':'15.2'})
In [40]: r1
Out[40]: {'name': 'London1', 'location': 'London Str', 'vendor': 'Cisco', 'ios': '15.2'}
Аналогічним чином можна оновити значення:
In [41]: r1.update({'name': 'london-r1', 'ios':'15.4'})
In [42]: r1
Out[42]:
{'name': 'london-r1',
'location': 'London Str',
'vendor': 'Cisco',
'ios': '15.4'}
Словник можна створити за допомогою літералу:
In [1]: r1 = {'model': '4451', 'ios': '15.4'}
Конструктор dict дозволяє створювати словник кількома способами.
Якщо у ролі ключів використовуються рядки, можна використати такий варіант створення словника:
In [2]: r1 = dict(model='4451', ios='15.4')
In [3]: r1
Out[3]: {'model': '4451', 'ios': '15.4'}
Другий варіант створення словника за допомогою dict:
In [4]: r1 = dict([('model', '4451'), ('ios', '15.4')])
In [5]: r1
Out[5]: {'model': '4451', 'ios': '15.4'}
У ситуації, коли треба створити словник з відомими ключами, але поки що порожніми значеннями (або однаковими значеннями), дуже зручний метод fromkeys() :
In [5]: d_keys = ['hostname', 'location', 'vendor', 'model', 'ios', 'ip']
In [6]: r1 = dict.fromkeys(d_keys)
In [7]: r1
Out[7]:
{'hostname': None,
'location': None,
'vendor': None,
'model': None,
'ios': None,
'ip': None}
За замовчуванням метод fromkeys підставляє значення None. Але можна вказувати і свій варіант значення:
In [8]: router_models = ['ISR2811', 'ISR2911', 'ISR2921', 'ASR9002']
In [9]: models_count = dict.fromkeys(router_models, 0)
In [10]: models_count
Out[10]: {'ISR2811': 0, 'ISR2911': 0, 'ISR2921': 0, 'ASR9002': 0}
Цей варіант створення словника підходить не для всіх випадків. Наприклад, при використанні змінного типу даних у значенні буде створено посилання на один і той самий об’єкт:
In [10]: router_models = ['ISR2811', 'ISR2911', 'ISR2921', 'ASR9002']
In [11]: routers = dict.fromkeys(router_models, [])
...:
In [12]: routers
Out[12]: {'ISR2811': [], 'ISR2911': [], 'ISR2921': [], 'ASR9002': []}
In [13]: routers['ASR9002'].append('london_r1')
In [14]: routers
Out[14]:
{'ISR2811': ['london_r1'],
'ISR2911': ['london_r1'],
'ISR2921': ['london_r1'],
'ASR9002': ['london_r1']}
У цьому випадку кожен ключ посилається на той самий список. Тому при додаванні значення до одного зі списків оновлюються й інші.
Кортеж у Python це:
послідовність елементів, які розділені між собою комою та укладені у дужки
незмінний упорядкований тип даних
Грубо кажучи, кортеж – це список, який не можна змінити. Тобто у кортежі є лише права на читання. Це може бути захист від випадкових змін.
Створити порожній кортеж:
In [1]: tuple1 = tuple() In [2]: print(tuple1) ()
Кортеж з одного елемента (зверніть увагу на кому):
In [3]: tuple2 = ('password',)
Кортеж зі списку:
In [4]: list_keys = ['hostname', 'location', 'vendor', 'model', 'ios', 'ip']
In [5]: tuple_keys = tuple(list_keys)
In [6]: tuple_keys
Out[6]: ('hostname', 'location', 'vendor', 'model', 'ios', 'ip')
До об’єктів у кортежі можна звертатись, як і до об’єктів списку, за порядковим номером:
In [7]: tuple_keys[0] Out[7]: 'hostname'
Але оскільки кортеж незмінний, привласнити нове значення не можна:
In [8]: tuple_keys[1] = 'test' --------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-9-1c7162cdefa3> in <module>() ----> 1 tuple_keys[1] = 'test' TypeError: 'tuple' object does not support item assignment
Функція sorted сортує елементи кортежу за зростанням та повертає новий список із відсортованими елементами:
In [2]: tuple_keys = ('hostname', 'location', 'vendor', 'model', 'ios', 'ip')
In [3]: sorted(tuple_keys)
Out[3]: ['hostname', 'ios', 'ip', 'location', 'model', 'vendor']
Множини – це змінюваний невпорядкований тип даних. У багатьох завжди містяться тільки унікальні елементи. Множини Python – це послідовність елементів, які розділені між собою комою і укладені у фігурні дужки.
За допомогою Множин можна легко прибрати повторювані елементи:
In [1]: vlans = [10, 20, 30, 40, 100, 10]
In [2]: set(vlans)
Out[2]: {10, 20, 30, 40, 100}
In [3]: set1 = set(vlans)
In [4]: print(set1)
{40, 100, 10, 20, 30}
add()Метод add()додає елемент у множину:
In [1]: set1 = {10,20,30,40}
In [2]: set1.add(50)
In [3]: set1
Out[3]: {10, 20, 30, 40, 50}
discard()Метод discard()дозволяє видаляти елементи, не видаючи помилку, якщо елемента в множині немає:
In [3]: set1
Out[3]: {10, 20, 30, 40, 50}
In [4]: set1.discard(55)
In [5]: set1
Out[5]: {10, 20, 30, 40, 50}
In [6]: set1.discard(50)
In [7]: set1
Out[7]: {10, 20, 30, 40}
clear()Метод clear()очищає множину:
In [8]: set1 = {10,20,30,40}
In [9]: set1.clear()
In [10]: set1
Out[10]: set()
Багато корисні тим, що з ними можна робити різні операції і знаходити об’єднання множин, перетин і так далі.
Об’єднання множин можна отримати за допомогою методу union() або оператора |:
In [1]: vlans1 = {10, 20, 30, 50, 100}
In [2]: vlans2 = {100, 101, 102, 200}
In [3]: vlans1.union(vlans2)
Out[3]: {10, 20, 30, 50, 100, 101, 102, 200}
In [4]: vlans1 | vlans2
Out[4]: {10, 20, 30, 50, 100, 101, 102, 200}
Перетин множин можна отримати за допомогою методу intersection() або оператора &:
In [5]: vlans1 = {10, 20, 30, 50, 100}
In [6]: vlans2 = {100, 101, 102, 200}
In [7]: vlans1.intersection(vlans2)
Out[7]: {100}
In [8]: vlans1 & vlans2
Out[8]: {100}
Не можна створити порожню множину за допомогою літералу (оскільки в такому випадку це буде не безліч, а словник):
In [1]: set1 = {}
In [2]: type(set1)
Out[2]: dict
Але порожню множину можна створити таким чином:
In [3]: set2 = set() In [4]: type(set2) Out[4]: set
Множина з рядка:
In [5]: set('long long long long string')
Out[5]: {' ', 'g', 'i', 'l', 'n', 'o', 'r', 's', 't'}
Множина зі списку:
In [6]: set([10, 20, 30, 10, 10, 30])
Out[6]: {10, 20, 30}
Словники, кортежі та множини в Python є важливими структурами даних, кожна з яких має свої унікальні особливості та сфери застосування.
Словники дозволяють зберігати пари “ключ: значення” та забезпечують швидкий доступ до даних за ключем. Вони підходять для випадків, коли потрібно зберігати зв’язані дані та мати швидкий доступ до них.
Кортежі є незмінними послідовностями, що дозволяє використовувати їх як ключі в словниках або для зберігання даних, які не повинні змінюватися. Це робить їх корисними для захисту інформації від випадкових змін.
Множини забезпечують зберігання унікальних елементів та підтримують швидкі операції об’єднання, перетину та різниці. Вони підходять для видалення дублікатів та ефективної обробки неповторюваних даних.
Правильне використання цих структур дозволяє оптимізувати зберігання та обробку даних у Python, забезпечуючи ефективність та читабельність коду.
