У цій частині ми детально розглянемо, як використовувати ці структури для зберігання і маніпуляції даними в реальних проєктах.
33 
Дізнайтесь, як працюють базові типи даних у Python, включаючи числа, текстові рядки та списки. Ці елементи формують основу для роботи з інформацією у будь-якій програмі. У цьому розділі ви навчитесь створювати, змінювати та ефективно використовувати найпоширеніші структури даних, без яких не обійдеться жоден Python-розробник. Навчання супроводжується прикладами, що спрощують розуміння і пришвидшують практичне застосування знань.
У Python є кілька стандартних типів даних:
Numbers (числа)
Strings (рядки)
Lists (списки)
Dictionaries (словники)
Tuples (кортежі)
Sets (множини)
Boolean (логічний тип даних)
Ці типи даних можна, своєю чергою, класифікувати за кількома ознаками:
змінювані (списки, словники та множини)
незмінні (числа, рядки та кортежі)
упорядковані (списки, кортежі, рядки та словники)
невпорядковані (множини)
З числами можна виконувати різні математичні операції.
In [1]: 1 + 2 Out[1]: 3 In [2]: 1.0 + 2 Out[2]: 3.0 In [3]: 10 - 4 Out[3]: 6 In [4]: 2**3 Out[4]: 8
Поділ int та float:
In [5]: 10/3 Out[5]: 3.3333333333333335 In [6]: 10/3.0 Out[6]: 3.3333333333333335
За допомогою функції round можна округляти числа до потрібної кількості символів:
In [9]: round(10/3.0, 2) Out[9]: 3.33 In [10]: round(10/3.0, 4) Out[10]: 3.3333
Залишок від розподілу:
In [11]: 10 % 3 Out[11]: 1
Оператори порівняння
In [12]: 10 > 3.0 Out[12]: True In [13]: 10 < 3 Out[13]: False In [14]: 10 == 3 Out[14]: False In [15]: 10 == 10 Out[15]: True In [16]: 10 <= 10 Out[16]: True In [17]: 10.0 == 10 Out[17]: True
Функція int() дозволяє виконувати конвертацію в тип int.
In [18]: a = '11' In [19]: int(a) Out[19]: 11
Якщо вказати, що рядок a треба сприймати як двійкове число, то результат буде таким:
In [20]: int(a, 2) Out[20]: 3
Конвертація в int типу float:
In [21]: int(3.333) Out[21]: 3 In [22]: int(3.9) Out[22]: 3
Функція bin дозволяє отримати двійкове уявлення числа (зверніть увагу, що результат – рядок):
In [23]: bin(8) Out[23]: '0b1000' In [24]: bin(255) Out[24]: '0b11111111'
Аналогічно, функція hex() дозволяє отримати шістнадцяткове значення:
In [25]: hex(10) Out[25]: '0xa'
І, звичайно ж, можна робити кілька перетворень одночасно:
In [26]: int('ff', 16)
Out[26]: 255
In [27]: bin(int('ff', 16))
Out[27]: '0b11111111'
Для більш складних математичних функцій у Python є модуль math :
In [28]: import math In [29]: math.sqrt(9) Out[29]: 3.0 In [30]: math.sqrt(10) Out[30]: 3.1622776601683795 In [31]: math.factorial(3) Out[31]: 6 In [32]: math.pi Out[32]: 3.141592653589793
Рядок у Python це:
послідовність символів, укладена в лапки
незмінний упорядкований тип даних
Приклади рядків:
In [9]: 'Hello' Out[9]: 'Hello' In [10]: "Hello" Out[10]: 'Hello' In [11]: tunnel = """ ....: interface Tunnel0 ....: ip address 10.10.10.1 255.255.255.0 ....: ip mtu 1416 ....: ip ospf hello-interval 5 ....: tunnel source FastEthernet1/0 ....: tunnel protection ipsec profile DMVPN ....: """ In [12]: tunnel Out[12]: '\ninterface Tunnel0\n ip address 10.10.10.1 255.255.255.0\n ip mtu 1416\n ip ospf hello-interval 5\n tunnel source FastEthernet1/0\n tunnel protection ipsec profile DMVPN\n' In [13]: print(tunnel) interface Tunnel0 ip address 10.10.10.1 255.255.255.0 ip mtu 1416 ip ospf hello-interval 5 tunnel source FastEthernet1/0 tunnel protection ipsec profile DMVPN
Рядки можна підсумовувати. Тоді вони об’єднуються в один рядок:
In [14]: intf = 'interface' In [15]: tun = 'Tunnel0' In [16]: intf + tun Out[16]: 'interfaceTunnel0' In [17]: intf + ' ' + tun Out[17]: 'interface Tunnel0'
Рядок можна множити на число. У цьому випадку рядок повторюється вказану кількість разів:
In [18]: intf * 5 Out[18]: 'interfaceinterfaceinterfaceinterfaceinterface' In [19]: '#' * 40 Out[19]: '########################################'
Те, що рядки є впорядкованим типом даних, дозволяє звертатися до символів у рядку за номером, починаючи з нуля:
In [20]: string1 = 'interface FastEthernet1/0' In [21]: string1[0] Out[21]: 'i'
Нумерація всіх символів у рядку йде з нуля. Але, якщо потрібно звернутися до якогось за рахунком символу, починаючи з кінця, можна вказувати негативні значення (на цей раз з одиниці).
In [22]: string1[1] Out[22]: 'n' In [23]: string1[-1] Out[23]: '0'
Крім звернення до конкретного символу, можна робити зрізи рядків, вказавши діапазон номерів (зріз виконується за другим числом, не включаючи його):
In [24]: string1[0:9] Out[24]: 'interface' In [25]: string1[10:22] Out[25]: 'FastEthernet'
Якщо не вказується друге число, то зріз буде до кінця рядка:
In [26]: string1[10:] Out[26]: 'FastEthernet1/0'
Зрізати три останні символи рядка:
In [27]: string1[-3:] Out[27]: '1/0'
Також у зрізі можна вказувати крок. Так можна отримати непарні числа:
In [28]: a = '0123456789' In [29]: a[1::2] Out[29]: '13579'
А в такий спосіб можна отримати всі парні числа рядка a:
In [31]: a[::2] Out[31]: '02468'
Зрізи також можна використовувати для отримання рядка у зворотному порядку:
In [28]: a = '0123456789' In [29]: a[::] Out[29]: '0123456789' In [30]: a[::-1] Out[30]: '9876543210'
Записи
a[::]іaдають однаковий результат, але подвійна двокрапка дозволяє вказувати, що треба брати не кожен елемент, а, наприклад, кожен другий.
Функція lenдозволяє отримати кількість символів у рядку:
In [1]: line = 'interface Gi0/1' In [2]: len(line) Out[2]: 15
Функція та метод відрізняються тим, що метод прив’язаний до об’єкта конкретного типу, а функція, як правило, універсальніша і може застосовуватися до об’єктів різного типу. Наприклад, функція lenможе застосовуватися до рядків, списків, словників тощо, а метод startswithстосується лише рядків.
При автоматизації дуже часто треба буде працювати з рядками, так як конфігураційний файл, виведення команд і команди, що відправляються – це рядки. Знання різних методів (дій), які можна застосовувати до рядків, допомагає ефективно працювати з ними. Рядки – незмінний тип даних. Тому всі методи, які перетворюють рядок, повертають новий рядок, а вихідний рядок залишається незмінним.
Метод joinзбирає список рядків в один рядок із роздільником, який вказаний перед join:
In [16]: vlans = ['10', '20', '30'] In [17]: ','.join(vlans) Out[17]: '10,20,30'
Методи upper(), lower(), swapcase(), capitalize()виконують перетворення регістра рядка:
In [25]: string1 = 'FastEthernet' In [26]: string1.upper() Out[26]: 'FASTETHERNET' In [27]: string1.lower() Out[27]: 'fastethernet' In [28]: string1.swapcase() Out[28]: 'fASTeTHERNET' In [29]: string2 = 'tunnel 0' In [30]: string2.capitalize() Out[30]: 'Tunnel 0'
Дуже важливо звертати увагу на те, що методи часто повертають перетворений рядок. І, отже, треба не забути привласнити її якоюсь змінною (можна тією ж).
In [31]: string1 = string1.upper() In [32]: print(string1) FASTETHERNET
Метод count()використовується для підрахунку того, скільки разів символ або підрядок зустрічаються в рядку:
In [33]: string1 = 'Hello, hello, hello, hello'
In [34]: string1.count('hello')
Out[34]: 3
In [35]: string1.count('ello')
Out[35]: 4
In [36]: string1.count('l')
Out[36]: 8
Методу find()можна передати підрядок або символ, і він покаже, на якій позиції знаходиться перший символ підрядка (для першого збігу):
In [37]: string1 = 'interface FastEthernet0/1'
In [38]: string1.find('Fast')
Out[38]: 10
In [39]: string1[string1.find('Fast')::]
Out[39]: 'FastEthernet0/1'
Якщо збіг не знайдено, метод find повертає -1.
Перевірка на те, чи починається чи закінчується рядок на певні символи (методи startswith(), endswith()):
In [40]: string1 = 'FastEthernet0/1'
In [41]: string1.startswith('Fast')
Out[41]: True
In [42]: string1.startswith('fast')
Out[42]: False
In [43]: string1.endswith('0/1')
Out[43]: True
In [44]: string1.endswith('0/2')
Out[44]: False
Методам можна передавати кілька значень (обов’язково startswith()як endswith()кортеж):
In [1]: "test".startswith(("r", "t"))
Out[1]: True
In [2]: "test".startswith(("r", "a"))
Out[2]: False
In [3]: "rtest".startswith(("r", "a"))
Out[3]: True
In [4]: "rtest".endswith(("r", "a"))
Out[4]: False
In [5]: "rtest".endswith(("r", "t"))
Out[5]: True
Заміна послідовності символів у рядку на іншу послідовність (метод replace()):
In [45]: string1 = 'FastEthernet0/1'
In [46]: string1.replace('Fast', 'Gigabit')
Out[46]: 'GigabitEthernet0/1'
Часто під час обробки файлу файл відкривається рядково. Але наприкінці кожного рядка, як правило, є якісь спецсимволи (а можуть бути на початку). Наприклад, переклад рядка.
Для того, щоб позбутися їх, дуже зручно використовувати метод strip():
In [47]: string1 = '\n\tinterface FastEthernet0/1\n'
In [48]: print(string1)
interface FastEthernet0/1
In [49]: string1
Out[49]: '\n\tinterface FastEthernet0/1\n'
In [50]: string1.strip()
Out[50]: 'interface FastEthernet0/1'
За замовчуванням метод strip() забирає пробілові символи. Цей набір символів містить:\t\n\r\f\v
Методу strip можна передати як аргумент будь-які символи.
In [51]: ad_metric = '[110/1045]'
In [52]: ad_metric.strip('[]')
Out[52]: '110/1045'
Метод strip() прибирає спецсимволи і на початку, і в кінці рядка. Якщо потрібно прибрати символи лише зліва або лише праворуч, можна використовувати, відповідно, методи lstrip()та rstrip().
Метод split()розбиває рядок на частини, використовуючи як роздільник якийсь символ (або символи) та повертає список рядків:
In [53]: string1 = 'switchport trunk allowed vlan 10,20,30,100-200' In [54]: commands = string1.split() In [55]: print(commands) ['switchport', 'trunk', 'allowed', 'vlan', '10,20,30,100-200']
У прикладі вище string1.split()розбиває рядок пробілів і повертає список рядків. Список записаний у змінну команд.
За умовчанням як роздільник використовуються пробільні символи (пробіли, таби, переклад рядка), але в дужках можна вказати будь-який роздільник:
In [56]: vlans = commands[-1].split(',')
In [57]: print(vlans)
['10', '20', '30', '100-200']
У списку commands останній елемент – це рядок з вланами, тому використовується індекс -1. Потім рядок розбивається на частини за допомогою split commands[-1].split(','). Оскільки, як роздільник зазначена кома, отримано такий перелік .['10', '20', '30', '100-200']
Приклад поділу адреси на октети:
In [10]: ip = "192.168.100.1"
In [11]: ip.split(".")
Out[11]: ['192', '168', '100', '1']
Корисна особливість методу split з роздільником за замовчуванням — рядок не лише поділяється до списку рядків за пробіловими символами, але пробілові символи також видаляються на початку та в кінці рядка:
In [58]: string1 = ' switchport trunk allowed vlan 10,20,30,100-200\n\n' In [59]: string1.split() Out[59]: ['switchport', 'trunk', 'allowed', 'vlan', '10,20,30,100-200']
У методу split()є ще одна хороша особливість: за замовчуванням метод розбиває рядок не за одним пробіловим символом, а за будь-якою кількістю. Це буде, наприклад, дуже корисним при обробці команд show:
In [60]: sh_ip_int_br = "FastEthernet0/0 15.0.15.1 YES manual up up" In [61]: sh_ip_int_br.split() Out[61]: ['FastEthernet0/0', '15.0.15.1', 'YES', 'manual', 'up', 'up']
А ось так виглядає поділ того ж рядка, коли один пропуск використовується як роздільник:
In [62]: sh_ip_int_br.split(' ')
Out[62]:
['FastEthernet0/0', '', '', '', '', '', '', '', '', '', '', '', '15.0.15.1', '', '', '', '', '', '', 'YES', 'manual', 'up', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', 'up']
При роботі з рядками часто виникають ситуації, коли шаблон рядка треба підставити різні дані. Це можна робити об’єднуючи частини рядка і дані, але в Python є більш зручний спосіб – форматування рядків.
Форматування рядків може допомогти, наприклад, у таких ситуаціях:
необхідно підставити значення в рядок за певним шаблоном
необхідно відформатувати висновок стовпцями
треба конвертувати числа у двійковий формат
Існує кілька варіантів форматування рядків:
з оператором
%– більш старий варіант
метод
format()– відносно новий варіант
f-рядки – новий варіант, який з’явився у Python 3.6.
Незважаючи на те, що рекомендується використовувати метод format, часто можна зустріти форматування рядків і через оператор %.
Так як для повноцінного пояснення f-рядків, треба показувати приклади з циклами та роботою з об’єктами, які ще не розглядалися, ця тема розглядається у розділі Форматування рядків за допомогою f-рядків з додатковими прикладами та поясненнями.
Приклад використання методу format:
In [1]: "interface FastEthernet0/{}".format('1')
Out[1]: 'interface FastEthernet0/1'
Спеціальний символ {}вказує на те, що сюди підставиться значення, яке передається методу format. При цьому кожна пара фігурних дужок позначає місце для підстановки.
Значення, що підставляються у фігурні дужки, можуть бути різного типу. Наприклад, це може бути рядок, число або список:
In [3]: print('{}'.format('10.1.1.1'))
10.1.1.1
In [4]: print('{}'.format(100))
100
In [5]: print('{}'.format([10, 1, 1,1]))
[10, 1, 1, 1]
За допомогою форматування рядків можна виводити результат стовпцями. У форматуванні рядків можна вказувати, яка кількість символів виділена на дані.
Наприклад, таким чином можна вивести дані стовпцями однакової ширини по 15 символів з вирівнюванням праворуч:
In [3]: vlan, mac, intf = ['100', 'aabb.cc80.7000', 'Gi0/1']
In [4]: print("{:>15} {:>15} {:>15}".format(vlan, mac, intf))
100 aabb.cc80.7000 Gi0/1
Вирівнювання по лівій стороні:
In [5]: print("{:15} {:15} {:15}".format(vlan, mac, intf))
100 aabb.cc80.7000 Gi0/1
Приклади вирівнювання:
Шаблон для виведення може бути і багаторядковим:
ip_template = '''
IP address:
{}
'''
In [7]: print(ip_template.format('10.1.1.1'))
IP address:
10.1.1.1
За допомогою форматування рядків можна також впливати на відображення чисел.
Наприклад, можна вказати, скільки цифр після коми виводити:
In [9]: print("{:.3f}".format(10.0/3))
3.333
За допомогою форматування рядків можна конвертувати числа у двійковий формат:
In [11]: '{:b} {:b} {:b} {:b}'.format(192, 100, 1, 1)
Out[11]: '11000000 1100100 1 1'
При цьому, як і раніше, можна вказувати додаткові параметри, наприклад, ширину стовпця:
In [12]: '{:8b} {:8b} {:8b} {:8b}'.format(192, 100, 1, 1)
Out[12]: '11000000 1100100 1 1'
А також можна вказати, що треба доповнити числа нулями, замість прогалин:
In [13]: '{:08b} {:08b} {:08b} {:08b}'.format(192, 100, 1, 1)
Out[13]: '11000000 01100100 00000001 00000001'
У фігурних дужках можна вказувати імена. Це дозволяє передавати аргументи в будь-якому порядку, а також робить шаблон більш зрозумілим:
In [15]: '{ip}/{mask}'.format(mask=24, ip='10.1.1.1')
Out[15]: '10.1.1.1/24'
Ще одна корисна можливість форматування рядків – вказівка номера аргументу:
In [16]: '{1}/{0}'.format(24, '10.1.1.1')
Out[16]: '10.1.1.1/24'
За рахунок цього, наприклад, можна позбутися повторної передачі одних і тих же значень:
ip_template = '''
IP address:
{:<8} {:<8} {:<8} {:<8}
{:08b} {:08b} {:08b} {:08b}
'''
In [20]: print(ip_template.format(192, 100, 1, 1, 192, 100, 1, 1))
IP address:
192 100 1 1
11000000 01100100 00000001 00000001
У прикладі вище октети адреси доводиться передавати двічі – один відображення у десятковому форматі, а другий – для двійкового.
Вказавши індекси значень, які передаються методу format, можна позбутися дублювання:
ip_template = '''
IP address:
{0:<8} {1:<8} {2:<8} {3:<8}
{0:08b} {1:08b} {2:08b} {3:08b}
'''
In [22]: print(ip_template.format(192, 100, 1, 1))
IP address:
192 100 1 1
11000000 01100100 00000001 00000001
У Python є дуже зручна функціональність – об’єднання літералів рядків. Вона дозволяє розбивати рядки на частини при написанні коду і навіть переносити ці частини на різні рядки коду. Це потрібно як для розділення довгого тексту на частини через рекомендації щодо максимальної довжини рядка в Python, так і для зручності сприйняття.
In [1]: s = ('Test' 'String')
In [2]: s
Out[2]: 'TestString'
In [3]: s = 'Test' 'String'
In [4]: s
Out[4]: 'TestString'
Можна переносити складові рядки на різні рядки, але якщо вони в дужках:
In [5]: s = ('Test'
...: 'String')
In [6]: s
Out[6]: 'TestString'
Цим дуже зручно користуватися в регулярних виразах:
regex = ('(\S+) +(\S+) +'
'\w+ +\w+ +'
'(up|down|administratively down) +'
'(\w+)')
Так регулярне вираз можна розбивати на частини і його простіше зрозуміти. Плюс можна додавати пояснювальні коментарі у рядках.
regex = ('(\S+) +(\S+) +' # interface and IP
'\w+ +\w+ +'
'(up|down|administratively down) +' # Status
'(\w+)') # Protocol
Також цим прийомом зручно користуватися, коли треба написати довге повідомлення:
In [7]: message = ('За виконання команди "{}" '
...: 'виникла така помилка "{}".\n'
...: 'Виключити цю команду зі списку? [y/n]')
In [8]: message
Out[8]: 'Під час виконання команди "{}" виникла така помилка "{}".\nИсключить эту команду из списка? [y/n]'
Список у Python це:
послідовність елементів, розділених між собою комою та укладених у квадратні дужки
змінюваний упорядкований тип даних
Приклади списків:
In [1]: list1 = [10,20,30,77] In [2]: list2 = ['one', 'dog', 'seven'] In [3]: list3 = [1, 20, 4.0, 'word']
Створення списку за допомогою літералу:
In [1]: vlans = [10, 20, 30, 50]
Літерал – це вираз, який створює об’єкт.
Створення списку за допомогою функції list() :
In [2]: list1 = list('router')
In [3]: print(list1)
['r', 'o', 'u', 't', 'e', 'r']
Так як список – це впорядкований тип даних, то, як і в рядках, у списках можна звертатися до елемента за номером, робити зрізи:
In [4]: list3 = [1, 20, 4.0, 'word'] In [5]: list3[1] Out[5]: 20 In [6]: list3[1::] Out[6]: [20, 4.0, 'word'] In [7]: list3[-1] Out[7]: 'word' In [8]: list3[::-1] Out[8]: ['word', 4.0, 20, 1]
Перевернути список навпаки можна за допомогою методу reverse():
In [10]: vlans = ['10', '15', '20', '30', '100-200'] In [11]: vlans.reverse() In [12]: vlans Out[12]: ['100-200', '30', '20', '15', '10']
Оскільки зміни змінюються, елементи списку можна змінювати:
In [13]: list3 Out[13]: [1, 20, 4.0, 'word'] In [14]: list3[0] = 'test' In [15]: list3 Out[15]: ['test', 20, 4.0, 'word']
Можна також створювати список списків. І, як і у звичайному списку, можна звертатися до елементів у вкладених списках:
In [16]: interfaces = [['FastEthernet0/0', '15.0.15.1', 'YES', 'manual', 'up', 'up'], ....: ['FastEthernet0/1', '10.0.1.1', 'YES', 'manual', 'up', 'up'], ....: ['FastEthernet0/2', '10.0.2.1', 'YES', 'manual', 'up', 'down']] In [17]: interfaces[0][0] Out[17]: 'FastEthernet0/0' In [18]: interfaces[2][0] Out[18]: 'FastEthernet0/2' In [19]: interfaces[2][1] Out[19]: '10.0.2.1'
Функція len повертає кількість елементів у списку:
In [1]: items = [1, 2, 3] In [2]: len(items) Out[2]: 3
А функція sorted сортує елементи списку зростання і повертає новий список з відсортованими елементами:
In [1]: names = ['John', 'Michael', 'Antony'] In [2]: sorted(names) Out[2]: ['Antony', 'John', 'Michael']
Список – це тип даних, що змінюється, тому дуже важливо звертати увагу на те, що більшість методів для роботи зі списками змінюють список на місці, при цьому нічого не повертаючи.
appendМетод appendдодає до кінця списку зазначений елемент:
In [18]: vlans = ['10', '20', '30', '100-200']
In [19]: vlans.append('300')
In [20]: vlans
Out[20]: ['10', '20', '30', '100-200', '300']
Метод append змінює список на місці та нічого не повертає. Якщо у скрипті треба додати елемент до списку, а потім вивести список print, треба робити це на різних рядках коду.
extendЯкщо потрібно об’єднати два списки, можна використовувати два способи: метод extendі операцію складання. У цих способів є важлива відмінність – extend змінює список, до якого застосовано метод, а підсумовування повертає новий список, що складається з двох.
Метод extend:
In [21]: vlans = ['10', '20', '30', '100-200'] In [22]: vlans2 = ['300', '400', '500'] In [23]: vlans.extend(vlans2) In [24]: vlans Out[24]: ['10', '20', '30', '100-200', '300', '400', '500']
Підсумовування списків:
In [27]: vlans = ['10', '20', '30', '100-200'] In [28]: vlans2 = ['300', '400', '500'] In [29]: vlans + vlans2 Out[29]: ['10', '20', '30', '100-200', '300', '400', '500']
Зверніть увагу, що під час підсумовування списків в ipython з’явився рядок Out. Це означає, що результат підсумовування можна присвоїти у змінну:
In [30]: result = vlans + vlans2 In [31]: result Out[31]: ['10', '20', '30', '100-200', '300', '400', '500']
popМетод popвидаляє елемент, який відповідає вказаному номеру. Але, що важливо, при цьому метод повертає цей елемент:
In [28]: vlans = ['10', '20', '30', '100-200'] In [29]: vlans.pop(-1) Out[29]: '100-200' In [30]: vlans Out[30]: ['10', '20', '30']
Без зазначення номера видаляється останній елемент списку.
removeМетод removeвидаляє вказаний елемент.
remove() не повертає віддалений елемент:
In [31]: vlans = ['10', '20', '30', '100-200']
In [32]: vlans.remove('20')
In [33]: vlans
Out[33]: ['10', '30', '100-200']
У методі remove треба вказувати сам елемент, який треба видалити, а чи не його номер у списку. Якщо вказати номер елемента, виникне помилка:
In [34]: vlans.remove(-1) ------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-32-f4ee38810cb7> in <module>() ----> 1 vlans.remove(-1) ValueError: list.remove(x): x not in list
indexМетод indexвикористовується для того, щоб перевірити, під яким номером у списку зберігається елемент:
In [35]: vlans = ['10', '20', '30', '100-200']
In [36]: vlans.index('30')
Out[36]: 2
insertМетод insertдозволяє вставити елемент на певне місце у списку:
In [37]: vlans = ['10', '20', '30', '100-200'] In [38]: vlans.insert(1, '15') In [39]: vlans Out[39]: ['10', '15', '20', '30', '100-200']
sortМетод sort сортує список на місці:
In [40]: vlans = [1, 50, 10, 15] In [41]: vlans.sort() In [42]: vlans Out[42]: [1, 10, 15, 50]
Типи даних у Python — це основа для ефективного кодування, обробки інформації та автоматизації рутинних задач. У статті ми розглянули ключові категорії вбудованих типів: числа, рядки, списки, словники, кортежі, множини та логічні значення. Для кожного типу даних наведено приклади операцій, методів, особливостей перетворення та форматування.
Розуміння того, які типи є змінюваними чи незмінними, упорядкованими чи невпорядкованими, дає змогу писати надійний, читабельний та масштабований код. Завдяки наочним прикладам з IPython і практичним задачам, кожен розділ стає не просто теоретичним, а безпосередньо корисним у повсякденній розробці та автоматизації мережевих чи системних сценаріїв.
Знання основ типів даних відкриває двері до більш складних тем Python: функцій, класів, обробки файлів, роботи з API та бібліотеками на кшталт Pandas або NumPy. Використовуйте цю базу як стартову платформу для свого подальшого зростання в Python.
33 
57 
147