07.05.2025
8 хв
720
Python надає широкі можливості для роботи з базовими типами даних, які є основою будь-якої програми. Розуміння цих типів дозволяє ефективно організовувати зберігання, обробку та маніпулювання інформацією. У цій статті ми розглянемо ключові концепції, пов’язані з базовими типами даних у Python, зокрема способи перетворення та перевірки типів, виклик методів ланцюжком та основи сортування даних.
Використання правильного типу даних у Python не тільки підвищує продуктивність коду, а й спрощує реалізацію складних логічних структур та алгоритмів. Правильна організація даних сприяє оптимальному використанню ресурсів та покращує зчитуваність коду. У цій статті ми надамо корисні рекомендації та практичні приклади для тих, хто прагне поглибити свої знання з базових типів даних та їх ефективного використання в Python. Дізнайтесь, як грамотно працювати з різними типами даних у Python та впроваджувати кращі практики в написанні коду.
Булеві значення в Python це дві константи Trueі False.
У Python істинними та хибними значеннями вважаються не тільки True та False.
Справжнє значення:
будь-яке ненульове число
будь-який непустий рядок
будь-який непустий об’єкт
Хибне значення:
0
Жоден
порожній рядок
порожній об’єкт
Інші справжні і хибні значення, як правило, логічно випливають із умови.
Для перевірки булевого значення об’єкта, можна скористатися bool:
In [2]: items = [1, 2, 3] In [3]: empty_list = [] In [4]: bool(empty_list) Out[4]: False In [5]: bool(items) Out[5]: True In [6]: bool(0) Out[6]: False In [7]: bool(1) Out[7]: True
Python має кілька корисних вбудованих функцій, які дозволяють перетворити дані з одного типу в інший.
intintперетворює рядок на int:
In [1]: int("10")
Out[1]: 10
За допомогою функції int можна перетворити і число в двійковому записі на десятковий (двійковий запис повинен бути у вигляді рядка)
In [2]: int("11111111", 2)
Out[2]: 255
binПеретворити десяткове число у двійковий формат можна за допомогою bin:
In [3]: bin(10) Out[3]: '0b1010' In [4]: bin(255) Out[4]: '0b11111111'
hexАналогічна функція є і для перетворення на шістнадцятковий формат:
In [5]: hex(10) Out[5]: '0xa' In [6]: hex(255) Out[6]: '0xff'
listФункція listперетворює аргумент на список:
In [7]: list("string")
Out[7]: ['s', 't', 'r', 'i', 'n', 'g']
In [8]: list({1, 2, 3})
Out[8]: [1, 2, 3]
In [9]: list((1, 2, 3, 4))
Out[9]: [1, 2, 3, 4]
setФункція setперетворює аргумент на безліч:
In [10]: set([1, 2, 3, 3, 4, 4, 4, 4])
Out[10]: {1, 2, 3, 4}
In [11]: set((1, 2, 3, 3, 4, 4, 4, 4))
Out[11]: {1, 2, 3, 4}
In [12]: set("string string")
Out[12]: {' ', 'g', 'i', 'n', 'r', 's', 't'}
Ця функція є дуже корисною, коли потрібно отримати унікальні елементи в послідовності.
tupleФункція tupleперетворює аргумент на кортеж:
In [13]: tuple([1, 2, 3, 4])
Out[13]: (1, 2, 3, 4)
In [14]: tuple({1, 2, 3, 4})
Out[14]: (1, 2, 3, 4)
In [15]: tuple("string")
Out[15]: ('s', 't', 'r', 'i', 'n', 'g')
strФункція strперетворює аргумент у рядок:
In [16]: str(10) Out[16]: '10'
При перетворенні типів даних можуть виникнути такі помилки:
In [1]: int('a')
------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-42-b3c3f4515dd4> in <module>()
----> 1 int('a')
ValueError: invalid literal for int() with base 10: 'a'
Помилка абсолютно логічна. Ми намагаємося перетворити на десятковий формат рядок „a“. І якщо приклад виглядає, можливо, дурним, проте, коли потрібно, наприклад, пройтися за списком рядків і перетворити на число тих, які містять числа, можна отримати таку помилку.
isdigitУ Python такі методи є. Наприклад, щоб перевірити, чи складається рядок з одних цифр, можна використовувати метод isdigit:
In [2]: "a".isdigit() Out[2]: False In [3]: "a10".isdigit() Out[3]: False In [4]: "10".isdigit() Out[4]: True
isalphaМетод isalphaдозволяє перевірити, чи складається рядок з одних літер:
In [7]: "a".isalpha() Out[7]: True In [8]: "a100".isalpha() Out[8]: False In [9]: "a-- ".isalpha() Out[9]: False In [10]: "a ".isalpha() Out[10]: False
isalnumМетод isalnumдозволяє перевірити, чи складається рядок із букв або цифр:
In [11]: "a".isalnum() Out[1]: True In [12]: "a10".isalnum() Out[12]: True
typeІноді, залежно від результату, бібліотека чи функція може виводити різні типи об’єктів.
In [13]: type("string")
Out[13]: str
In [14]: type("string") == str
Out[14]: True
Аналогічно з кортежем (та іншими типами даних):
In [15]: type((1,2,3)) Out[15]: tuple In [16]: type((1,2,3)) == tuple Out[16]: True In [17]: type((1,2,3)) == list Out[17]: False
Часто з даними треба виконати кілька операцій, наприклад:
In [1]: line = "switchport trunk allowed vlan 10,20,30"
In [2]: words = line.split()
In [3]: words
Out[3]: ['switchport', 'trunk', 'allowed', 'vlan', '10,20,30']
In [4]: vlans_str = words[-1]
In [5]: vlans_str
Out[5]: '10,20,30'
In [6]: vlans = vlans_str.split(",")
In [7]: vlans
Out[7]: ['10', '20', '30']
Або у скрипті:
line = "switchport trunk allowed vlan 10,20,30"
words = line.split()
vlans_str = words[-1]
vlans = vlans_str.split(",")
print(vlans)
У цьому випадку змінні використовуються для зберігання проміжного результату та наступні методи/дії виконуються вже зі змінною. Це цілком нормальний варіант коду, особливо спочатку, коли важко сприймати складніші висловлювання.
Однак у Python часто зустрічаються вирази, в яких дії або методи застосовуються один за одним в одному виразі. Наприклад, попередній код можна записати так:
line = "switchport trunk allowed vlan 10,20,30"
vlans = line.split()[-1].split(",")
print(vlans)
Так як тут немає виразів у дужках, які б вказували на пріоритет виконання, все виконується зліва направо. Спочатку виконується line.split()– отримуємо список, потім до отриманого списку застосовується [-1]– отримуємо останній елемент списку, рядок 10,20,30. До цього рядка застосовується метод split(",")і в результаті отримуємо список .['10', '20', '30']
Головний нюанс при написанні таких ланцюжків попередній метод/дія має повертати те, що чекає наступний метод/дія. І обов’язково, щоб щось поверталося, інакше буде помилка.
При сортуванні даних типу списку списків або списку кортежів sortedсортує по першому елементу вкладених списків (кортежів), а якщо перший елемент однаковий, по другому:
In [1]: data = [[1, 100, 1000], [2, 2, 2], [1, 2, 3], [4, 100, 3]] In [2]: sorted(data) Out[2]: [[1, 2, 3], [1, 100, 1000], [2, 2, 2], [4, 100, 3]]
Якщо сортування робиться для списку чисел, які записані як рядки, сортування буде лексикографічним, не натуральним і порядок буде таким:
In [7]: vlans = ['1', '30', '11', '3', '10', '20', '30', '100'] In [8]: sorted(vlans) Out[8]: ['1', '10', '100', '11', '20', '3', '30', '30']
Щоб сортування було «правильним», треба перетворити владу на числа.
Ця ж проблема проявляється, наприклад, з IP-адресами:
In [2]: ip_list = ["10.1.1.1", "10.1.10.1", "10.1.2.1", "10.1.11.1"] In [3]: sorted(ip_list) Out[3]: ['10.1.1.1', '10.1.10.1', '10.1.11.1', '10.1.2.1']
Розуміння базових типів даних у Python є ключовим аспектом ефективного програмування. Знання про булеві значення, перетворення типів, методи перевірки та сортування дозволяє створювати більш надійний і гнучкий код. Володіння навичками роботи з різними типами даних допомагає зберігати дані у відповідних структурах, уникати помилок та підвищувати продуктивність програм.
Уміння застосовувати методи ланцюжком оптимізує код і робить його більш читабельним, а використання правильних методів перевірки та перетворення типів дозволяє уникнути небажаних винятків. Поглиблене розуміння цих аспектів допоможе програмісту ефективніше використовувати можливості Python у розв’язанні практичних завдань.
