Оригінальна публікація: Python Code Example Handbook – Sample Script Coding Tutorial for Beginners

Вітаю! Якщо ви вивчаєте Python, то ця публікація для вас. Ви знайдете докладний опис синтаксису Python та багато прикладів коду, які допоможуть вам під час подорожі програмуванням.

Що ми розглянемо:

Готові? Тоді розпочнемо! 🔅

💡 Важливо: у цій публікації я використовуватиму <>, щоб вказати, що частина синтаксису буде змінена елементом, вказаним у тексті. Наприклад, <змінна> буде змінена змінною під час написання коду.

🔹 Визначення змінних у Python

Головним будівельним блоком будь-якої мови програмування є змінна. Змінна — це назва та місце в пам’яті, яке ми зберігаємо для значення.

У Python ми використовуємо цей синтаксис, щоб створити змінну та надати їй значення:

<назва_змінної> = <значення>

Наприклад:

вік = 56
ім'я = "Нора"
колір = "Голубий"
бали = [67, 100, 87, 56]

Якщо назва змінної містить більше ніж одне слово, посібник з написання коду Python рекомендує відокремлювати слова нижньою рискою, «щоб забезпечити хорошу читабельність».

Наприклад:

мій_список = [1, 2, 3, 4, 5]

💡 Важливо: посібник з написання коду Python (PEP 8) містить чудові поради, яких варто дотримуватись для написання чистого коду Python.

🔸 Програма «Hello, World!» у Python

Перш ніж ми почнемо занурюватись у типи та структури даних, які можна використовувати у Python, подивимось як написати першу програму.

Вам потрібно викликати функцію print() та написати "Hello, World!" у круглих дужках:

print("Hello, World!")

Після запуску програми ви побачите це повідомлення:

"Hello, World!"

💡 Важливо: програма "Hello, World!" — це традиція у спільноті розробників. Більшість розробників починають програмувати саме з неї.

Чудово! Ви написали свою першу програму. Тепер почнемо вивчати типи даних та вбудовані структури даних, які можна використовувати у Python.

🔹 Типи даних та вбудовані структури даних у Python

Існує декілька основних типів даних і вбудованих структур даних, з якими можна працювати в наших програмах. Кожен має свої особливості застосування. Розглянемо їх у деталях.

Числа у Python: цілі числа, плаваючі числа та складні числа

У Python є наступні типи чисел, з якими можна працювати:

Цілі числа

Цілі числа — це числа без десяткових знаків. Ви можете перевірити, чи число ціле, за допомогою функції type(). Якщо виводом буде <class 'int'>, тоді число є цілим.

Наприклад:

>>> type(1)
<class 'int'>

>>> type(15)
<class 'int'>

>>> type(0)
<class 'int'>

>>> type(-46)
<class 'int'>

Плаваючі числа

Плаваючі числа — це числа з десятковими знаками. Їх можна помітити завдяки крапці. Якщо ми викличемо type(), щоб перевірити тип даних цих значень, то отримаємо такий вивід:

<class 'float'>

Ось декілька прикладів:

>>> type(4.5)
<class 'float'>

>>> type(5.8)
<class 'float'>

>>> type(2342423424.3)
<class 'float'>

>>> type(4.0)
<class 'float'>

>>> type(0.0)
<class 'float'>

>>> type(-23.5)
<class 'float'>

Складні числа

Складні числа мають реальну частину та уявну частину, яка позначена j. У Python складні числа можна створити за допомогою complex(). Першим аргументом буде реальна частина, а другим — уявна частина.

Ось декілька прикладів:

>>> complex(4, 5)
(4+5j)

>>> complex(6, 8)
(6+8j)

>>> complex(3.4, 3.4)
(3.4+3.4j)

>>> complex(0, 0)
0j

>>> complex(5)
(5+0j)

>>> complex(0, 4)
4j

Рядки у Python

Рядки неймовірно корисні у Python. Вони містять ряд символів та зазвичай їх використовують для тексту в коді.

Наприклад:

"Hello, World!"
'Hello, World!'

Ми можемо використовувати одинарні '' або подвійні лапки "", щоб визначити рядок. Обидва варіанти дійсні та еквівалентні, але протягом усієї програми варто використовувати лише одні з них.

💡 Важливо: ви використали рядок, коли писали програму "Hello, World!". Якщо ви бачите значення в одинарних або подвійних лапках у Python — це рядок.

Рядки можуть містити будь-який символ, який можна ввести на клавіатурі, включно з цифрами та спеціальними знаками.

Наприклад:

"45678"
"мій_емейл@email.com"
"#ялюблюPython"

💡 Важливо: пробіл зараховується як символ у рядку.

Лапки всередині рядків

Якщо ми визначили рядок подвійними лапками "", тоді всередині рядка можна використати одинарні лапки. Наприклад:

"Моя улюблена книжка — 'Чуття і чуттєвість'"

Якщо ми визначили рядок одинарними лапками '', тоді всередині рядка можна використати подвійні лапки. Наприклад:

'Моя улюблена книжка – "Чуття і чуттєвість"'

Індексація рядків

У програмі Python символи рядка можуть бути доступні за допомогою індексів. Індекс — це число, яке представляє певне місце в рядку. Вони пов’язані з символом на цьому місці.

Ось діаграма рядка "Hello":

Рядок:    H e l l o
Індекс:   0 1 2 3 4

💡 Важливо: індекси починаються з 0 та збільшуються на 1 з кожним символом праворуч.

Наприклад:

>>> мій_рядок = "Hello"

>>> мій_рядок[0]
'H'

>>> мій_рядок[1]
'e'

>>> мій_рядок[2]
'l'

>>> мій_рядок[3]
'l'

>>> мій_рядок[4]
'o'

Також можна використовувати від’ємні індекси:

>>> мій_рядок = "Hello"

>>> мій_рядок[-1]
'o'

>>> мій_рядок[-2]
'l'

>>> мій_рядок[-3]
'l'

>>> мій_рядок[-4]
'e'

>>> мій_рядок[-5]
'H'

💡 Важливо: часто використовують -1, щоб отримати доступ до останнього символу рядка.

Зрізи рядків

Іноді потрібно отримати лише частину рядка. Це можна зробити за допомогою зрізів рядка.

Ось загальний синтаксис:

<змінна_рядка>[початок:кінець:крок]
  • початок — це індекс першого символу, який буде включено до зрізу. За замовчуванням це 0.
  • кінець — це індекс останнього символу в зрізі (цей символ не буде включено). За замовчуванням це останній символ рядка (якщо ми опустимо це значення, останній символ також буде включено).
  • крок — скільки ми додамо до поточного індексу, щоб отримати наступний індекс.

Ми можемо вказати два значення та використати значення кроку за замовчуванням, яке дорівнює 1. Це включатиме всі символи між початком та кінцем (але не включатиме їх самих):

<змінна_рядка>[початок:кінець]

Наприклад:

>>> freecodecamp = "freeCodeCamp"

>>> freecodecamp[2:8]
'eeCode'

>>> freecodecamp[0:3]
'fre'

>>> freecodecamp[0:4]
'free'

>>> freecodecamp[4:7]
'Cod'

>>> freecodecamp[4:8]
'Code'

>>> freecodecamp[8:11]
'Cam'

>>> freecodecamp[8:12]
'Camp'

>>> freecodecamp[8:13]
'Camp'

💡 Важливо: якщо значення параметра виходить за межі допустимого діапазону індексів, зріз все одно буде. Таким чином творці Python реалізували цю функцію.

Якщо ми налаштуємо крок, то будемо «стрибати» від одного індексу до іншого, залежно від значення.

Наприклад:

>>> freecodecamp = "freeCodeCamp"

>>> freecodecamp[0:9:2]
'feCdC'

>>> freecodecamp[2:10:3]
'eoC'

>>> freecodecamp[1:12:4]
'roa'

>>> freecodecamp[4:8:2]
'Cd'

>>> freecodecamp[3:9:2]
'eoe'

>>> freecodecamp[1:10:5]
'rd'

Також можна використати від’ємне число, щоб піти справа наліво:

>>> freecodecamp = "freeCodeCamp"

>>> freecodecamp[10:2:-1]
'maCedoCe'

>>> freecodecamp[11:4:-2]
'paeo'

>>> freecodecamp[5:2:-4]
'o'

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

>>> freecodecamp = "freeCodeCamp"

# Початок та крок за замовчуванням
>>> freecodecamp[:8]
'freeCode'

# Кінець та крок за замовчуванням
>>> freecodecamp[4:]
'CodeCamp'

# Початок за замовчуванням
>>> freecodecamp[:8:2]
'feCd'

# Кінець за замовчуванням
>>> freecodecamp[4::3]
'Cem'

# Початок та кінець за замовчуванням
>>> freecodecamp[::-2]
'paeoer'

# Початок та кінець за замовчуванням
>>> freecodecamp[::-1]
'pmaCedoCeerf'

💡 Важливо: останній приклад — один із найвідоміших способів перевернути рядок.

f-рядки

У Python 3.6 та новіших версіях ми можемо використати тип рядка під назвою f-рядок, який допомагає форматувати рядки.

Щоб визначити f-рядок потрібно додати f перед одинарними або подвійними лапками. Потім, всередині рядка, ми беремо змінні або вирази у фігурні дужки {}. Значення зміниться, коли ми запустимо програму.

Наприклад:

ім'я = "Нора"
улюблена_мова = "Python"

print(f"Привіт, я {ім'я}. Я вивчаю {улюблена_мова}.")

Вивід:

Привіт, я Нора. Я вивчаю Python.

Ось приклад, де ми обчислюємо значення виразу та замінюємо результат у рядку:

значення = 5

print(f"{значення} помножити на 2 дорівнює: {значення * 2}")

У виводі змінено значення:

5 помножити на 2 дорівнює: 10

Ми також можемо викликати методи у фігурних дужках. Коли ми запустимо програму, значення буде змінено:

freecodecamp = "FREECODECAMP"

print(f"{freecodecamp.lower()}")

Вивід:

freecodecamp

Методи рядка

Рядки мають методи, які представляють загальні функції, реалізовані розробниками Python, тому ми можемо використовувати їх безпосередньо в програмах. Вони стають в нагоді при виконанні типових операцій.

Ось загальний синтаксис, щоб викликати рядковий метод:

<змінна_рядка>.<назва_методу>(<аргументи>)

Наприклад:

>>> freecodecamp = "freeCodeCamp"

>>> freecodecamp.capitalize()
'Freecodecamp'

>>> freecodecamp.count("C")
2

>>> freecodecamp.find("e")
2

>>> freecodecamp.index("p")
11

>>> freecodecamp.isalnum()
True

>>> freecodecamp.isalpha()
True

>>> freecodecamp.isdecimal()
False

>>> freecodecamp.isdigit()
False

>>> freecodecamp.isidentifier()
True

>>> freecodecamp.islower()
False

>>> freecodecamp.isnumeric()
False

>>> freecodecamp.isprintable()
True

>>> freecodecamp.isspace()
False

>>> freecodecamp.istitle()
False

>>> freecodecamp.isupper()
False

>>> freecodecamp.lower()
'freecodecamp'

>>> freecodecamp.lstrip("f")
'reeCodeCamp'

>>> freecodecamp.rstrip("p")
'freeCodeCam'

>>> freecodecamp.replace("e", "a")
'fraaCodaCamp'

>>> freecodecamp.split("C")
['free', 'ode', 'amp']

>>> freecodecamp.swapcase()
'FREEcODEcAMP'

>>> freecodecamp.title()
'Freecodecamp'

>>> freecodecamp.upper()
'FREECODECAMP'

Щоб дізнатись більше про методи Python, див. публікацію із документації Python.

💡 Важливо: усі методи рядка повертають копію рядка. Вони не змінюють рядок, оскільки рядки незмінні в Python.

Булеві у Python

Булевими значеннями у Python є True та False. Вони повинні починатися з великої літери, щоб бути розпізнаними як булеве значення.

Наприклад:

>>> type(True)
<class 'bool'>

>>> type(False)
<class 'bool'>

Якщо напишемо з малої літери, отримаємо помилку:

>>> type(true)
Traceback (most recent call last):
  File "<pyshell#92>", line 1, in <module>
    type(true)
NameError: name 'true' is not defined

>>> type(false)
Traceback (most recent call last):
  File "<pyshell#93>", line 1, in <module>
    type(false)
NameError: name 'false' is not defined

Списки у Python

Ми розглянули основні типи даних у Python, тому перейдемо до вбудованих структур даних. Розпочнемо зі списків.

Щоб визначити список використовуємо квадратні дужки [] з елементами, розділеними комою.

💡 Важливо: рекомендовано додати пробіл після кожної коми, щоб зробити код читабельнішим.

Ось приклади списків:

[1, 2, 3, 4, 5]
["a", "b", "c", "d"]
[3.4, 2.4, 2.6, 3.5]

Список може містити значення різних типів даних, тож цей список буде дійсним у Python:

[1, "Емілі", 3.4]

Ми також можемо призначити список змінній:

мій_список = [1, 2, 3, 4, 5]
літери = ["a", "b", "c", "d"]

Вкладені списки

Списки можуть містити значення будь-якого типу даних, навіть інші списки. Ці внутрішні списки називаються вкладеними списками. 

[[1, 2, 3], [4, 5, 6]]

У прикладі вкладеними списками є [1, 2, 3] та [4, 5, 6].

Ось інші приклади:

[["a", "b", "c"], ["d", "e", "f"], ["g", "h", "i"]]
[1, [2, 3, 4], [5, 6, 7], 3.4]

Ми можемо отримати доступ до вкладених списків за допомогою відповідного індексу:

>>> мій_список = [[1, 2, 3], [4, 5, 6]]

>>> мій_список[0]
[1, 2, 3]

>>> мій_список[1]
[4, 5, 6]

Вкладені списки можна використати, наприклад, для структури простої ігрової 2D-дошки, де кожен номер представлений елементом або клітинкою:

# Зразок дошки, де: 
# 0 = Порожня клітинка
# 1 = Монета
# 2 = Ворог
# 3 = Ціль
дошка = [[0, 0, 1],
         [0, 2, 0],
         [1, 0, 3]]

Довжина списку

Ми можемо використати функцію len(), щоб отримати довжину списку (кількість елементів, розміщених в ньому).

Наприклад:

>>> мій_список = [1, 2, 3, 4]

>>> len(мій_список)
4

Оновити значення у списку

Ми можемо оновити значення певного індексу за допомогою такого синтаксису:

<змінна_списку>[<індекс>] = <значення>

Наприклад:

>>> літери = ["a", "b", "c", "d"]

>>> літери[0] = "j"

>>> літери
['j', 'b', 'c', 'd']

Додати значення до списку

Ми можемо додати нове значення в кінці списку за допомогою методу .append().

Наприклад:

>>> мій_список = [1, 2, 3, 4]

>>> мій_список.append(5)

>>> мій_список
[1, 2, 3, 4, 5]

Вилучити значення зі списку

Ми можемо вилучити значення зі списку за допомогою методу .remove().

Наприклад:

>>> мій_список = [1, 2, 3, 4]

>>> мій_список.remove(3)

>>> мій_список
[1, 2, 4]

💡 Важливо: це видалить лише один елемент. Наприклад, якщо ми спробуємо вилучити число 3 зі списку, який містить два числа 3, друге число не буде видалено:

>>> мій_список = [1, 2, 3, 3, 4]

>>> мій_список.remove(3)

>>> мій_список
[1, 2, 3, 4]

Індексація списків

Ми можемо індексувати список так само, як ми індексуємо рядки. Індекси починаються з 0:

>>> літери = ["a", "b", "c", "d"]

>>> літери[0]
'a'

>>> літери[1]
'b'

>>> літери[2]
'c'

>>> літери[3]
'd'

Нарізка списку

Ми також можемо отримати фрагмент списку, використовуючи той самий синтаксис, який ми використовували для рядків, і ми можемо опустити параметри, щоб використовувати їхні значення за замовчуванням. Зараз ми будемо додавати елементи списку, а не символи.

<змінна_списку>[початок:кінець:крок]

Наприклад:

>>> мій_список = ["a", "b", "c", "d", "e", "f", "g", "h", "i"]

>>> мій_список[2:6:2]
['c', 'e']

>>> мій_список[2:8]
['c', 'd', 'e', 'f', 'g', 'h']

>>> мій_список[1:10]
['b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']

>>> мій_список[4:8:2]
['e', 'g']

>>> мій_список[::-1]
['i', 'h', 'g', 'f', 'e', 'd', 'c', 'b', 'a']

>>> мій_список[::-2]
['i', 'g', 'e', 'c', 'a']

>>> мій_список[8:1:-1]
['i', 'h', 'g', 'f', 'e', 'd', 'c']

Методи списку

У Python вже реалізовані методи списку, які допомагають виконувати типові операції над списками. Ось декілька прикладів найпопулярніших методів списку:

>>> мій_список = [1, 2, 3, 3, 4]

>>> мій_список.append(5)
>>> мій_список
[1, 2, 3, 3, 4, 5]

>>> мій_список.extend([6, 7, 8])
>>> мій_список
[1, 2, 3, 3, 4, 5, 6, 7, 8]

>>> мій_список.insert(2, 15)
>>> мій_список
[1, 2, 15, 3, 3, 4, 5, 6, 7, 8, 2, 2]

>>> мій_список.remove(2)
>>> мій_список
[1, 15, 3, 3, 4, 5, 6, 7, 8, 2, 2]

>>> мій_список.pop()
2

>>> мій_список.index(6)
6

>>> мій_список.count(2)
1

>>> мій_список.sort()
>>> мій_список
[1, 2, 3, 3, 4, 5, 6, 7, 8, 15]

>>> мій_список.reverse()
>>> мій_список
[15, 8, 7, 6, 5, 4, 3, 3, 2, 1]

>>> мій_список.clear()
>>> мій_список
[]

Щоб дізнатись більше про методи списку у Python, див. публікацію із документації Python.

Кортежі у Python

Щоб визначити кортеж у Python, ми використовуємо круглі дужки () та розділяємо елементи комою. Рекомендовано додати пробіл після кожної коми, щоб зробити код читабельнішим.

(1, 2, 3, 4, 5)
("a", "b", "c", "d")
(3.4, 2.4, 2.6, 3.5)

Кортежі можна призначити до змінних:

мій_кортеж = (1, 2, 3, 4, 5)

Індексація кортежів

Ми можемо отримати доступ до кожного елемента кортежу за допомогою відповідного індексу:

>>> мій_кортеж = (1, 2, 3, 4)

>>> мій_кортеж[0]
1

>>> мій_кортеж[1]
2

>>> мій_кортеж[2]
3

>>> мій_кортеж[3]
4

Також можна використовувати від’ємні індекси:

>>> мій_кортеж = (1, 2, 3, 4)

>>> мій_кортеж[-1]
4

>>> мій_кортеж[-2]
3

>>> мій_кортеж[-3]
2

>>> мій_кортеж[-4]
1

Довжина кортежу

Щоб знайти довжину кортежу використовуємо функцію len(), передаючи кортеж як аргумент:

>>> мій_кортеж = (1, 2, 3, 4)

>>> len(мій_кортеж)
4

Вкладені кортежі

Кортежі можуть містити значення будь-якого типу даних, навіть списки та інші кортежі. Ці внутрішні кортежі називаються вкладеними кортежами. 

([1, 2, 3], (4, 5, 6))

У цьому прикладі є вкладений кортеж (4, 5, 6) та список. Ви можете отримати доступ до цих вкладених структур даних за допомогою відповідного індексу.

Наприклад:

>>> мій_кортеж = ([1, 2, 3], (4, 5, 6))

>>> мій_кортеж[0]
[1, 2, 3]

>>> мій_кортеж[1]
(4, 5, 6)

Нарізка кортежу

Ми можемо нарізати кортежі так само, як списки та рядки. Застосовують той самий принцип і правила.

Це загальний синтаксис:

<змінна_кортежу>[початок:кінець:крок]

Наприклад:

>>> мій_кортеж = (4, 5, 6, 7, 8, 9, 10)

>>> мій_кортеж[3:8]
(7, 8, 9, 10)

>>> мій_кортеж[2:9:2]
(6, 8, 10)

>>> мій_кортеж[:8]
(4, 5, 6, 7, 8, 9, 10)

>>> мій_кортеж[:6]
(4, 5, 6, 7, 8, 9)

>>> мій_кортеж[:4]
(4, 5, 6, 7)

>>> мій_кортеж[3:]
(7, 8, 9, 10)

>>> мій_кортеж[2:5:2]
(6, 8)

>>> мій_кортеж[::2]
(4, 6, 8, 10)

>>> мій_кортеж[::-1]
(10, 9, 8, 7, 6, 5, 4)

>>> мій_кортеж[4:1:-1]
(8, 7, 6)

Методи кортежу

У Python є два вбудовані методи кортежу:

>>> мій_кортеж = (4, 4, 5, 6, 6, 7, 8, 9, 10)

>>> мій_кортеж.count(6)
2

>>> мій_кортеж.index(7)
5

💡 Важливо: кортежі незмінні. Їх не можна змінити, тому ми не можемо додати, оновити чи вилучити елементи з кортежу. Якщо потрібно це зробити, тоді варто створити нову копію кортежу.

Присвоєння кортежу

У Python є справді крута функція «присвоєння кортежу». З її допомогою ми можемо присвоювати значення декільком змінним в одному рядку.

Значення присвоюються відповідним змінним за тим порядком, яким вони представлені. Наприклад, в a, b = 1, 2 значення 1 присвоєне змінній a та значення 2 присвоєне змінній b.

Наприклад:

# Присвоєння кортежу
>>> a, b = 1, 2

>>> a
1

>>> b
2

💡 Важливо: присвоєння кортежу часто використовують, щоб поміняти місцями значення двох змінних:

>>> a = 1

>>> b = 2

# Поміняти значення
>>> a, b = b, a

>>> a
2

>>> b
1

Словники у Python

Тепер зануримось у словники. Ця вбудована структура даних дозволяє створювати пари значень, де одне значення пов’язане з іншим.

Щоб визначити словник у Python використовуємо фігурні дужки {} з парами ключ-значення, розділеними комою.

Ключ і значення розділені двокрапкою :, ось так:

{"a": 1, "b": 2, "c"; 3}

Словники можна призначити до змінних:

мій_словник = {"a": 1, "b": 2, "c"; 3}

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

  • Рядки: {"Місто 1": 456, "Місто 2": 577, "Місто 3": 678}
  • Числа: {1: "Наліво", 2: "Направо", 3: "Вгору", 4: "Вниз"}
  • Кортежі: {(0, 0): "Початок", (2, 4): "Мета"}

Значенням словника може бути будь-який тип даних, тому ми можемо призначити рядки, числа, списки, кортежі, набори та навіть інші словники як значення. Ось декілька прикладів:

{"id_продукту": 4556, "інгредієнти": ["помідор", "сир", "гриби"], "ціна": 10.67}
{"id_продукту": 4556, "інгредієнти": ("помідор", "сир", "гриби"), "ціна": 10.67}
{"id": 567, "ім'я": "Емілі", "бали": {"Математика": 80, "Біологія": 74, "Англійська": 97}}

Довжина словника

Щоб отримати кількість пар ключ-значення використовуємо функцію len():

>>> мій_словник = {"a": 1, "b": 2, "c": 3, "d": 4}

>>> len(мій_словник)
4

Отримати значення у словнику

Щоб отримати значення в словнику, ми використовуємо його ключ із таким синтаксисом:

<змінна_зі_словником>[<ключ>]

Цей вираз буде замінено на значення, яке відповідає ключу.

Наприклад:

мій_словник = {"a": 1, "b": 2, "c": 3, "d": 4}

print(мій_словник["a"])

Виводом є значення, пов’язане з "a":

1

Оновити значення у словнику

Щоб оновити значення, пов’язане з наявним ключем, використовуємо той самий синтаксис, але тепер додаємо оператор присвоєння та значення:

<змінна_зі_словником>[<ключ>] = <значення>

Наприклад:

>>> мій_словник = {"a": 1, "b": 2, "c": 3, "d": 4}

>>> мій_словник["b"] = 6

Тепер словник такий:

{'a': 1, 'b': 6, 'c': 3, 'd': 4}

Додати пару ключ-значення до словника

Ключі словника повинні бути унікальними. Щоб додати нову пару ключ-значення використовуємо той самий синтаксис, що й для оновлення значення, але тепер ключ повинен бути новим.

<змінна_зі_словником>[<новий_ключ>] = <значення>

Наприклад:

>>> мій_словник = {"a": 1, "b": 2, "c": 3, "d": 4}

>>> мій_словник["e"] = 5

Тепер словник має нову пару ключ-значення:

{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

Видалити пару ключ-значення зі словника

Використайте інструкцію del, щоб видалити пару ключ-значення:

del <змінна_словника>[<ключ>]

Наприклад:

>>> мій_словник = {"a": 1, "b": 2, "c": 3, "d": 4}

>>> del мій_словник["c"]

Тепер словник такий:

{'a': 1, 'b': 2, 'd': 4}

Методи словника

Ось декілька прикладів найпопулярніших методів словника:

>>> мій_словник = {"a": 1, "b": 2, "c": 3, "d": 4}

>>> мій_словник.get("c")
3

>>> мій_словник.items()
dict_items([('a', 1), ('b', 2), ('c', 3), ('d', 4)])

>>> мій_словник.keys()
dict_keys(['a', 'b', 'c', 'd'])

>>> мій_словник.pop("d")
4

>>> мій_словник.popitem()
('c', 3)

>>> мій_словник.setdefault("a", 15)
1

>>> мій_словник
{'a': 1, 'b': 2}

>>> мій_словник.setdefault("f", 25)
25

>>> мій_словник
{'a': 1, 'b': 2, 'f': 25}

>>> мій_словник.update({"c": 3, "d": 4, "e": 5})

>>> мій_словник.values()
dict_values([1, 2, 25, 3, 4, 5])

>>> мій_словник.clear()

>>> мій_словник
{}

Щоб дізнатись більше про методи словника у Python, див. публікацію із документації Python.

🔸 Оператори Python

Чудово! Тепер ви знаєте синтаксис основних типів даних і вбудованих структур даних у Python, тому зануримось в оператори у Python. Вони необхідні для виконання операцій і формування виразів.

Математичні оператори в Python

До цих операторів належать:

Додавання: +

>>> 5 + 6
11

>>> 0 + 6
6

>>> 3.4 + 5.7
9.1

>>> "Hello" + ", " + "World"
'Hello, World'

>>> True + False
1

💡 Важливо: останні два приклади цікаві, правда? Цей оператор поводиться по-різному, залежно від типу даних операндів.

Якщо вони є рядками, цей оператор об’єднує рядки, а якщо булевими значеннями, то він виконує певну операцію.

У Python True дорівнює 1 та False дорівнює 0. Ось чому результат 1 + 0 = 1

Віднімання: -

>>> 5 - 6
-1

>>> 10 - 3
7

>>> 5 - 6
-1

>>> 4.5 - 5.6 - 2.3
-3.3999999999999995

>>> 4.5 - 7
-2.5

>>> - 7.8 - 6.2
-14.0

Множення: *

>>> 5 * 6
30

>>> 6 * 7
42

>>> 10 * 100
1000

>>> 4 * 0
0

>>> 3.4 *6.8
23.119999999999997

>>> 4 * (-6)
-24

>>> (-6) * (-8)
48

>>> "Hello" * 4
'HelloHelloHelloHello'

>>> "Hello" * 0
''

>>> "Hello" * -1
''

💡 Важливо: ви можете «помножити» рядок на ціле число, щоб повторити рядок задану кількість разів.

Піднесення до степеня: **

>>> 6 ** 8
1679616

>>> 5 ** 2
25

>>> 4 ** 0
1

>>> 16 ** (1/2)
4.0

>>> 16 ** (0.5)
4.0

>>> 125 ** (1/3)
4.999999999999999

>>> 4.5 ** 2.3
31.7971929089206

>>> 3 ** (-1)
0.3333333333333333

Ділення: /

>>> 25 / 5
5.0

>>> 3 / 6
0.5

>>> 0 / 5
0.0

>>> 2467 / 4673
0.5279263856195163

>>> 1 / 2
0.5

>>> 4.5 / 3.5
1.2857142857142858

>>> 6 / 7
0.8571428571428571

>>> -3 / -4
0.75

>>> 3 / -4
-0.75

>>> -3 / 4
-0.75

💡 Важливо: цей оператор повертає float як результат, навіть якщо десяткова частина .0

Якщо ви спробуєте поділити на 0, то отримаєте ZeroDivisionError:

>>> 5 / 0
Traceback (most recent call last):
  File "<pyshell#109>", line 1, in <module>
    5 / 0
ZeroDivisionError: division by zero

Обчислення неповної частки від ділення: //

Цей оператор повертає ціле число, якщо операнди є цілими числами. Якщо вони є плаваючими числами, результатом буде плаваюче число з десятковою частиною .0, оскільки вона скорочує десяткову частину.

>>> 5 // 6
0

>>> 8 // 2
4

>>> -4 // -5
0

>>> -5 // 8
-1

>>> 0 // 5
0

>>> 156773 // 356
440

Обчислення остачі: %

>>> 1 % 5
1

>>> 2 % 5
2

>>> 3 % 5
3

>>> 4 % 5
4

>>> 5 % 5
0

>>> 5 % 8
5

>>> 3 % 1
0

>>> 15 % 3
0

>>> 17 % 8
1

>>> 2568 % 4
0

>>> 245 % 15
5

>>> 0 % 6
0

>>> 3.5 % 2.4
1.1

>>> 6.7 % -7.8
-1.0999999999999996

>>> 2.3 % 7.5
2.3

Оператори порівняння

До цих операторів належать:

  • Більше ніж: >
  • Більше або дорівнює: >=
  • Менше ніж: <
  • Менше або дорівнює: <=
  • Рівні: ==
  • Не рівні: !=

Ці оператори порівняння створюють вирази, які мають значення True або False. Ось декілька прикладів:

>>> 5 > 6
False

>>> 10 > 8
True

>>> 8 > 8
False

>>> 8 >= 5
True

>>> 8 >= 8
True

>>> 5 < 6
True

>>> 10 < 8
False

>>> 8 < 8
False

>>> 8 <= 5
False

>>> 8 <= 8
True

>>> 8 <= 10
True

>>> 56 == 56
True

>>> 56 == 78
False

>>> 34 != 59
True

>>> 67 != 67
False

Їх також можна використати, щоб порівняти рядки за алфавітним порядком:

>>> "Hello" > "World"
False
>>> "Hello" >= "World"
False
>>> "Hello" < "World"
True
>>> "Hello" <= "World"
True
>>> "Hello" == "World"
False
>>> "Hello" != "World"
True

Зазвичай їх використовують, щоб порівняти значення двох або більше змінних:

>>> a = 1
>>> b = 2

>>> a < b
True

>>> a <= b
True

>>> a > b
False

>>> a >= b
False

>>> a == b
False

>>> a != b
True

💡 Важливо: зауважте, що оператором порівняння є ==, а оператором присвоєння є =. У них різна дія: == повертає True або False, а = присвоює значення змінній.

Ланцюжки з операторів порівняння

У Python ми можемо використовувати «ланцюжок з операторів порівняння», у якому ми об’єднуємо оператори порівняння, щоб зробити більш ніж одне порівняння.

Наприклад, тут перевіряється, чи a менше за b та чи b менше за c:

a < b < c

Ось декілька прикладів:

>>> a = 1
>>> b = 2
>>> c = 3

>>> a < b < c
True

>>> a > b > c
False

>>> a <= b <= c
True

>>> a >= b >= c
False

>>> a >= b > c
False

>>> a <= b < c
True

Логічні оператори

У Python існує три логічні оператори: and, or та not. У кожного з них власна таблиця істинності і вони важливі для роботи з умовами.

Оператор and:

>>> True and True
True

>>> True and False
False

>>> False and True
False

>>> False and False
False

Оператор or:

>>> True or True
True

>>> True or False
True

>>> False or True
True

>>> False or False
False

Оператор not:

>>> not True
False

>>> not False
True

Ці оператори використовують для формування більш складних виразів, які поєднують різні оператори та змінні.

Наприклад:

>>> a = 6
>>> b = 3

>>> a < 6 or b > 2
True

>>> a >= 3 and b >= 1
True

>>> (a + b) == 9 and b > 1
True

>>> ((a % 3) < 2) and ((a + b) == 3)
False

Оператори присвоєння

Оператори присвоєння використовують для того, щоб присвоїти значення змінній.

До них належать: =, +=, -=, *=, %=, /=, //=, **=

  • Оператор = присвоює значення змінній.
  • Інші оператори виконують операцію над наявним значенням змінної і новим значенням та присвоюють результат тій самій змінній.

Наприклад:

>>> x = 3
>>> x
3

>>> x += 15
>>> x
18

>>> x -= 2
>>> x
16

>>> x *= 2
>>> x
32

>>> x %= 5
>>> x
2

>>> x /= 1
>>> x
2.0

>>> x //= 2
>>> x
1.0

>>> x **= 5
>>> x
1.0

💡 Важливо: ці оператори виконують бітові операції перед тим, як присвоїти результат змінній: &=, |=, ^=, >>=, <<=.

Оператори приналежності

Перевірити чи елемент належить до послідовності можна за допомогою цих операторів: in та not in. Результатом буде True або False.

Наприклад:

>>> 5 in [1, 2, 3, 4, 5]
True

>>> 8 in [1, 2, 3, 4, 5]
False

>>> 5 in (1, 2, 3, 4, 5)
True

>>> 8 in (1, 2, 3, 4, 5)
False

>>> "a" in {"a": 1, "b": 2}
True

>>> "c" in {"a": 1, "b": 2}
False

>>> "h" in "Hello"
False

>>> "H" in "Hello"
True

>>> 5 not in [1, 2, 3, 4, 5]
False

>>> 8 not in (1, 2, 3, 4, 5)
True

>>> "a" not in {"a": 1, "b": 2}
False

>>> "c" not in {"a": 1, "b": 2}
True

>>> "h" not in "Hello"
True

>>> "H" not in "Hello"
False

Зазвичай їх використовують зі змінними, які зберігають послідовності, як у цьому прикладі:

>>> повідомлення = "Hello, World!"

>>> "e" in повідомлення
True

🔹 Умови у Python

Тепер розглянемо, чи можна написати умови, щоб певні частини нашого коду запускались (чи не запускались), залежно від умови True або False.

Інструкція if у Python

Ось синтаксис для основної інструкції if:

if <умова>:
    <код>
  • Якщо умова True, код запуститься.
  • Якщо умова False, код не запуститься.

💡 Важливо: в кінці першого рядка стоїть двокрапка (:) і код з відступом. Це важливо для Python, щоб зробити код належним до умов.

Ось декілька прикладів:

Умова False (брехня)

x = 5

if x > 9:
    print("Hello, World!")

Умова x > 9, а код — print("Hello, World!").

В цьому разі умова False, тому немає виводу.

Умова True (правда)

Ось інший приклад. Тепер умова True:

колір = "Голубий"

if колір == "Голубий":
    print("Це мій улюблений колір")

Вивід:

"Це мій улюблений колір"

Код після умови

Тут ми маємо приклад із кодом, який виконується після завершення умови. Зверніть увагу, що останній рядок без відступу, тобто він не належить до умови.

x = 5

if x > 9:
    print("Привіт!")

print("Кінець")

У цьому прикладі умовою x > 9 є False, тому перша умова не виконується, але виконується остання умова, оскільки вона не є частиною умови. Тому вивід такий:

Кінець

Проте, якщо умова True, як у цьому прикладі:

x = 15

if x > 9:
    print("Привіт!")

print("Кінець")

Вивід буде такий:

Привіт!
Кінець

Приклади умов

Ще один приклад умови:

улюблена_пора = "Літо"

if улюблена_пора == "Літо":
    print("Я також люблю цю пору року!")

В цьому разі вивід буде такий:

Я також люблю цю пору року!

Але якщо ми змінимо значення улюбленої_пори:

улюблена_пора = "Зима"

if улюблена_пора == "Літо":
    print("Я також люблю цю пору року!")

Не буде виводу, оскільки умова буде False.

Умови if/else у Python

Ми можемо додати пункт else до умови, якщо потрібно, аби щось відбувалось, коли умова False.

Ось загальний синтаксис:

if <умова>:
    <код>
else:
    <код>

💡 Важливо: зауважте, що два блоки коду мають відступ (if та else). Це важливо для того, щоб Python міг відрізнити код, який належить до основної програми, від коду, який належить до умови.

Розглянемо приклад з else.

Умова True (правда)

x = 15

if x > 9:
    print("Привіт!")
else:
    print("Бувай!")

print("Кінець")

Вивід:

Привіт!
Кінець

Якщо умовою пункту if є True, пункт працює. Пункт else не працює.

Умова False (брехня)

Тепер пункт else працює, оскільки умова False.

x = 5

if x > 9:
    print("Привіт!")
else:
    print("Бувай!")

print("Кінець")

Тепер вивід такий:

Бувай!
Кінець

Умови if/elif/else у Python

Щоб детальніше налаштувати умови, можна додати один або більше пунктів elif для перевірки та обробки декількох умов. Виконуватиметься лише код першої умови, яка має значення True .

💡 Важливо: elif потрібно писати після if та перед else.

Перша умова True (правда)

x = 5

if x < 9:
    print("Привіт!")
elif x < 15:
    print("Рада тебе бачити")
else:
    print("Бувай!")

print("Кінець")

У нас дві умови: x < 9 та x < 15. Буде виконано лише код першої умови, де умова True.

У цьому разі вивід такий:

Привіт!
Кінець

Тому що перша умова True: x < 9.

Друга умова True (правда)

Якщо перша умова False, тоді перевіриться друга умова.

У цьому прикладі перша умова x < 9 є False, але друга умова x < 15 є True, тому код, який належить до цього пункту, буде працювати.

x = 13

if x < 9:
    print("Привіт!")
elif x < 15:
    print("Рада тебе бачити")
else:
    print("Бувай!")

print("Кінець")

Вивід:

Рада тебе бачити
Кінець

Всі умови False (брехня)

Якщо всі умови False, тоді спрацює пункт else:

x = 25

if x < 9:
    print("Привіт!")
elif x < 15:
    print("Рада тебе бачити")
else:
    print("Бувай!")

print("Кінець")

Вивід:

Бувай!
Кінець

Декілька пунктів elif

Ми можемо додати стільки пунктів elif, скільки потрібно. Ось приклад умови з двома пунктами elif:

if улюблена_пора == "Зима":
    print("Я також люблю цю пору року")
elif улюблена_пора == "Літо":
    print("Літо чудове")
elif улюблена_пора == "Весна":
    print("Я люблю весну")
else:
    print("Осінь – улюблена пора моєї мами")

Кожна умова буде перевірена. Першою спрацює та умова, яка має значення True. Якщо жодна з них не True, тоді спрацює пункт else.

🔸 Цикли for у Python

Тепер ви знаєте як писати умови у Python, тому перейдемо до циклів. Цикли for — це дивовижні структури програмування, які можна використовувати для того, щоб повторити блок коду певну кількість разів.

Основний синтаксис для написання циклу for у Python:

for <змінна_циклу> in <ітерований_об'єкт>:
    <код>

Ітерованим об’єктом може бути список, кортеж, словник, рядок, послідовність, яку повертає діапазон, файл або інший тип ітерованого об’єкта у Python. Розпочнемо з range().

Функція range() у Python

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

💡 Важливо: кожне ціле число присвоюється змінній циклу по одному за кожну ітерацію.

Ось загальний синтаксис для написання циклу for з range():

for <змінна_циклу> in range(<початок>, <кінець>, <крок>):
    <код>

Як бачите, функція приймає такі параметри:

  • початок: де починається послідовність чисел. За замовчуванням 0.
  • кінець: де закінчується послідовність чисел (не включає це значення).
  • крок: значення, додане до кожного елемента для отримання наступного елемента у послідовності. За замовчуванням 1.

Ви можете передати 1, 2 або 3 аргументи до range():

  • Якщо 1 аргумент, значення присвоєно до параметру кінець, а для інших двох використовуються значення за замовчуванням.
  • Якщо 2 аргументи, значення присвоєно до параметрів початок та кінець, а для кроку використано значення за замовчуванням.
  • Якщо 3 аргументи, значення присвоєно до параметрів початок, кінець та крок (за порядком).

Ось приклад з одним параметром:

for i in range(5):
    print(i)

Вивід:

0
1
2
3
4

💡 Важливо: змінна циклу автоматично оновлюється.

>>> for j in range(15):
    print(j * 2)

Вивід:

0
2
4
6
8
10
12
14
16
18
20
22
24
26
28

У прикладі нижче ми повторюємо рядок стільки разів, скільки вказано значенням змінної циклу:

>>> for num in range(8):
	print("Привіт" * num)

Вивід:

Привіт
ПривітПривіт
ПривітПривітПривіт
ПривітПривітПривітПривіт
ПривітПривітПривітПривітПривіт
ПривітПривітПривітПривітПривітПривіт
ПривітПривітПривітПривітПривітПривітПривіт

Цикли for також можна використовувати для вбудованих структур даних, як-от списки:

>>> мій_список = ["a", "b", "c", "d"]

>>> for i in range(len(мій_список)):
	print(мій_список[i])

Вивід:

a
b
c
d

💡 Важливо: якщо ви використаєте range(len(<seq>)), ви отримаєте послідовність чисел від 0 до len(<seq>)-1. Це представляє послідовність дійсних індексів.

Ось приклад з двома параметрами:

>>> for i in range(2, 10):
	print(i)

Вивід:

2
3
4
5
6
7
8
9

Код:

>>> for j in range(2, 5):
	print("Python" * j)

Вивід:

PythonPython
PythonPythonPython
PythonPythonPythonPython

Код:

>>> мій_список = ["a", "b", "c", "d"]

>>> for i in range(2, len(мій_список)):
	print(мій_список[i])

Вивід:

c
d

Код:

>>> мій_список = ["a", "b", "c", "d"]

>>> for i in range(2, len(мій_список)-1):
	мій_список[i] *= i

Тепер список такий: ['a', 'b', 'cc', 'd']

Ось приклад з трьома параметрами:

>>> for i in range(3, 16, 2):
	print(i)

Вивід:

3
5
7
9
11
13
15

Код:

>>> for j in range(10, 5, -1):
	print(j)

Вивід:

10
9
8
7
6

Код:

>>> мій_список = ["a", "b", "c", "d", "e", "f", "g"]

>>> for i in range(len(мій_список)-1, 2, -1):
	print(мій_список[i])

Вивід:

g
f
e
d

Ітерація у Python

Ми можемо ітерувати ітеровані об’єкти, як-от списки, кортежі, словники, рядки та файли, які використовують цикли for. За кожну ітерацію ми будемо отримувати по одному елементу.

Розглянемо декілька прикладів.

Ітерація над рядком

Якщо ми ітеруємо рядок, його символи будуть призначені змінній циклу один за одним (включно з пробілами та символами).

>>> повідомлення = "Hello, World!"

>>> for char in повідомлення:
	print(char)

	
H
e
l
l
o
,
 
W
o
r
l
d
!

Ми також можемо ітерувати модифіковані копії рядка, викликавши метод рядка, де вказуємо ітерацію у циклі for. Це призначить копію рядка як ітеровану, ось так:

>>> слово = "Hello"

>>> for char in слово.lower(): # виклик рядкового методу
	print(char)

	
h
e
l
l
o
>>> слово = "Hello"

>>> for char in слово.upper(): # виклик рядкового методу
	print(char)

	
H
E
L
L
O

Ітерація над списками та кортежами

>>> мій_список = [2, 3, 4, 5]

>>> for num in мій_список:
	print(num)

Вивід:

2
3
4
5

Код:

>>> мій_список = (2, 3, 4, 5)

>>> for num in мій_список:
	if num % 2 == 0:
		print("Парне")
	else:
		print("Непарне")

Вивід:

Парне
Непарне
Парне
Непарне

Ітерація над ключами, значеннями та парами ключ-значення словника

Ми можемо ітерувати ключі, значення та пари ключ-значення словника, викликавши певний метод словника. Розглянемо детальніше.

Щоб ітерувати ключі ми пишемо:

for <змінна> in <змінна_словника>:
    <код>

Ми просто пишемо назву змінної, яка зберігає словник як ітерований об’єкт.

💡 Важливо: можна написати <змінна_словника>.keys(), але пряме написання назви змінної стисліше, а працює так само.

Наприклад:

>>> мій_словник = {"a": 1, "b": 2, "c": 3}

>>> for ключ in мій_словник:
	print(ключ)

	
a
b
c

💡 Важливо: змінній циклу можна призначити будь-яку назву.

Щоб ітерувати значення ми використовуємо:

for <змінна> in <змінна_словника>.values():
    <код>

Наприклад:

>>> мій_словник = {"a": 1, "b": 2, "c": 3}

>>> for значення in мій_словник.values():
	print(значення)

	
1
2
3

Щоб ітерувати пару ключ-значення ми використовуємо:

for <ключ>, <значення> in <змінна_словника>.items():
    <код>

💡 Важливо: ми визначаємо дві змінні циклу, тому що потрібно призначити ключ і значення змінним, які можна використовувати у циклі.

>>> мій_словник = {"a": 1, "b": 2, "c": 3}

>>> for ключ, значення in мій_словник.items():
	print(ключ, значення)

	
a 1
b 2
c 3

Якщо ми визначимо лише одну змінну циклу, вона міститиме кортеж із парою ключ-значення:

>>> мій_словник = {"a": 1, "b": 2, "c": 3}
>>> for пара in мій_словник.items():
	print(пара)

	
('a', 1)
('b', 2)
('c', 3)

Break та Continue у Python

Тепер ви розумієте ітерацію у Python. У нас також є контрольні інструкції для налаштування того, що відбувається під час виконання циклу: break та continue.

Інструкція break

Інструкцію break використовують, щоб негайно зупинити цикл.

Коли знайдено інструкцію break, цикл зупиняється та програма повертається до нормального виконання поза циклом.

У наведеному нижче прикладі ми зупиняємо цикл, коли знайдено парний елемент.

>>> мій_список = [1, 2, 3, 4, 5]

>>> for elem in мій_список:
	if elem % 2 == 0:
		print("Парне:", elem)
		print("break")
		break
	else:
		print("Непарне:", elem)

		
Непарне: 1
Парне: 2
break

Інструкція continue

Інструкцію continue використовують, щоб пропустити решту поточної ітерації.

Коли її знайдено, ітерація зупиняється та починається нова з оновленим значенням циклової змінної.

У наведеному нижче прикладі ми пропускаємо наявну ітерацію, якщо елемент парний та друкуємо значення, якщо елемент непарний:

>>> мій_список = [1, 2, 3, 4, 5]

>>> for elem in мій_список:
	if elem % 2 == 0:
		print("continue")
		continue
	print("Непарне:", elem)

	
Непарне: 1
continue
Непарне: 3
continue
Непарне: 5

Функція zip() у Python

zip() — це неймовірна вбудована функція, яку використовують у Python, щоб ітерувати декілька послідовностей одночасно, отримавши відповідні елементи.

Нам лише потрібно передати послідовності як аргументи до функції zip() та використати цей результат у циклі.

Наприклад:

>>> мій_список1 = [1, 2, 3, 4]
>>> мій_список2 = [5, 6, 7, 8]

>>> for elem1, elem2 in zip(мій_список1, мій_список2):
	print(elem1, elem2)

	
1 5
2 6
3 7
4 8

Функція enumerate() у Python

Завдяки функції enum() можна відстежувати лічильник, поки запущений цикл. Її часто використовують, щоб ітерувати послідовності або отримати відповідний індекс.

💡 Важливо: за замовчуванням лічильник починається з 0.

Наприклад:

>>> мій_список = [5, 6, 7, 8]

>>> for i, elem in enumerate(мій_список):
	print(i, elem)

	
0 5
1 6
2 7
3 8
>>> слово = "Hello"

>>> for i, char in enumerate(слово):
	print(i, char)

	
0 H
1 e
2 l
3 l
4 o

Якщо лічильник починається із 0, ви можете використати індекс та наявне значення у тій самій ітерації, щоб змінити послідовність:

>>> мій_список = [5, 6, 7, 8]

>>> for індекс, num in enumerate(мій_список):
	мій_список[індекс] = num * 3

>>> мій_список
[15, 18, 21, 24]

Лічильник можна почати з іншого числа, передавши другий аргумент до enumerate():

>>> слово = "Hello"

>>> for i, char in enumerate(слово, 2):
	print(i, char)

	
2 H
3 e
4 l
5 l
6 o

Умова else

Цикли for також мають умову else. Цю умову можна додати до циклу, якщо ви хочете запустити певний блок коду, коли цикл закінчує всі ітерації, не знайшовши інструкції break.

💡 Важливо: якщо знайдено break, то умова else не виконується; якщо не знайдено break, то умова else виконується.

У наведеному нижче прикладі ми спробуємо знайти елемент у списку, який більший за 6. Елемент не знайдено, тому break не виконується, а умова else виконується.

мій_список = [1, 2, 3, 4, 5]

for elem in мій_список:
    if elem > 6:
        print("Знайдено")
        break
else:
    print("Не знайдено")

Вивід:

Не знайдено

Однак, якщо інструкція break виконується, тоді не виконується умова else. Це можна побачити у прикладі нижче:

мій_список = [1, 2, 3, 4, 5, 8] # Тепер список має значення 8

for elem in мій_список:
    if elem > 6:
        print("Знайдено")
        break
else:
    print("Не знайдено")

Вивід:

Знайдено

🔹 Цикли while у Python

Цикли while схожі до циклів for тим, що дозволяють повторити блок коду. Різниця в тому, що цикли while виконуються, якщо умова True.

У циклі while ми визначаємо значення, а не кількість ітерацій. Цикл зупиняється, якщо умова False.

Це загальний синтаксис циклу while:

while <умова>:
    <код>

💡 Важливо: у циклах while ви повинні оновлювати змінні, які є частиною умови, аби переконатись, що умова стане False.

Наприклад:

>>> x = 6

>>> while x < 15:
	print(x)
	x += 1

	
6
7
8
9
10
11
12
13
14
>>> x = 4

>>> while x >= 0:
	print("Привіт" * x)
	x -= 1

	
ПривітПривітПривітПривіт
ПривітПривітПривіт
ПривітПривіт
Привіт
>>> num = 5

>>> while num >= 1:
	print("*" * num)
	num -= 2

	
*****
***
*

Break та continue

Ми можемо використовувати break та continue з циклами while. Вони працюють так само:

  • break негайно зупиняє цикл while.
  • continue зупиняє поточну ітерацію та починає наступну.

Наприклад:

>>> x = 5

>>> while x < 15:
	if x % 2 == 0:
		print("Парне:", x)
		break
	print(x)
	x += 1
    

5
Парне: 6
>>> x = 5

>>> while x < 15:
	if x % 2 == 0:
		x += 1
		continue
	print("Непарне:", x)
	x += 1

	
Непарне: 5
Непарне: 7
Непарне: 9
Непарне: 11
Непарне: 13

Умова else

До циклу while також можна додати умову else. Якщо знайдено break, то умова else не виконується; якщо не знайдено інструкцію break, то виконується умова else.

У наведеному нижче прикладі не знайдено інструкцію break, оскільки жодне з чисел не є парним перед тим, як інструкція стає False, тому виконується умова else.

x = 5

while x < 15:
	if x % 2 == 0:
		print("Знайдено парне число")
		break
	print(x)
	x += 2
else:
	print("Всі числа непарні")

Вивід:

5
7
9
11
13
Всі числа непарні

Але в цьому прикладі не знайдено інструкції break і не виконується умова else:

x = 5

while x < 15:
	if x % 2 == 0:
		print("Знайдено парне число")
		break
	print(x)
	x += 1 # Тепер збільшуємо значення на 1
else:
	print("Всі числа непарні")

Вивід:

5
Знайдено парне число

Безкінечні цикли while

Коли ми пишемо та працюємо з циклами while, у нас можуть бути так звані «безкінечні цикли». Якщо інструкція ніколи не False, цикл ніколи не зупиниться без зовнішнього втручання.

Зазвичай це трапляється, коли змінні в інструкції не оновлені належним чином під час виконання циклу.

💡 Важливо: ви повинні вносити необхідні оновлення до цих змінних, аби переконатись, що інструкція буде False.

Наприклад:

>>> x = 5

>>> while x > 2:
	print(x)

	
5
5
5
5
5
5
5
5
5
.
.
.
# Вивід триває безкінечно

💡 Важливо: надрукуйте CTRL + C, щоб зупинити цей процес. Ви повинні побачити повідомлення KeyboardInterrupt.

🔸 Вкладені цикли у Python

Ми можемо написати цикли for всередині циклів for або цикли while всередині циклів while. Ці внутрішні цикли називають вкладеними циклами.

💡 Важливо: внутрішній цикл виконується для кожної ітерації зовнішнього циклу.

Вкладені цикли for у Python

>>> for i in range(3):
	for j in range(2):
		print(i, j)

		
0 0
0 1
1 0
1 1
2 0
2 1

Якщо ми додамо інструкції print, то побачимо, що відбувається за лаштунками:

>>> for i in range(3):
	print("===> Зовнішній цикл")
	print(f"i = {i}")
	for j in range(2):
		print("Внутрішній цикл")
		print(f"j = {j}")

		
===> Зовнішній цикл
i = 0
Внутрішній цикл
j = 0
Внутрішній цикл
j = 1
===> Зовнішній цикл
i = 1
Внутрішній цикл
j = 0
Внутрішній цикл
j = 1
===> Зовнішній цикл
i = 2
Внутрішній цикл
j = 0
Внутрішній цикл
j = 1

Внутрішній цикл завершує дві ітерації кожної ітерації зовнішнього циклу. Циклові змінні циклу оновлюються, коли починається нова ітерація.

Ще один приклад:

>>> num_рядків = 5

>>> for i in range(5):
	for num_стовпчиків in range(num_рядків-i):
		print("*", end="")
	print()

	
*****
****
***
**
*

Вкладені цикли while у Python

Маємо приклад вкладених циклів while. У цьому разі ми повиннні оновити змінні, які є частиною кожної інструкції, аби переконатись, що цикли зупиняться.

>>> i = 5

>>> while i > 0:
	j = 0
	while j < 2:
		print(i, j)
		j += 1
	i -= 1

	
5 0
5 1
4 0
4 1
3 0
3 1
2 0
2 1
1 0
1 1

💡 Важливо: ми можемо мати цикли for всередині циклів while та цикли while всередині циклів for.

🔹 Функції у Python

У Python можна визначити функції, щоб зробити код повторновикористовуваним, читабельнішим та організованішим. Ось базовий синтаксис функції Python:

def <назва_функції>(<параметр1>, <параметр2>, ...):
    <код>

💡 Важливо: функція може мати нуль, один або декілька параметрів.

Функція без параметрів у Python

Функція без параметрів має порожню пару круглих дужок після своєї назви у визначенні функції. Наприклад:

def надрукувати_схему():
    size = 4
    for i in range(size):
        print("*" * size)

При виклику функції отримаємо такий вивід:

>>> надрукувати_схему()
****
****
****
****

💡 Важливо: ви повинні написати порожню пару круглих дужок після назви функції, щоб викликати її.

Функція з одним параметром у Python

Функція з одним або більше параметром має список параметрів у дужках після свого імені у визначенні функції:

def новий_учень(ім'я):
    print(f"Привіт, {ім'я}! Вітаємо в нашому класі.")

Коли ми викликаємо функцію, нам потрібно передати одне значення як аргумент. Це значення буде замінено там, де ми використовуємо параметр у визначенні функції:

>>> новий_учень("Нора")
Привіт, Нора! Вітаємо у нашому класі.

Ще один приклад: функція друкує схему з зірочок. Потрібно вказати, скільки рядків ви хочете:

def надрукувати_схему(num_рядків):
    for i in range(num_рядків):
        for num_стовпчиків in range(num_рядків-i):
            print("*", end="")
        print()

Можна побачити різні виводи для різних значень num_рядків:

>>> надрукувати_схему(3)
***
**
*

>>> надрукувати_схему(5)
*****
****
***
**
*

>>> надрукувати_схему(8)
********
*******
******
*****
****
***
**
*

Функції з двома і більше параметрами у Python

Щоб визначити два або більше параметри, розділяємо їх комою:

def надрукувати_суму(a, b):
    print(a + b)

Коли викликаємо функцію, потрібно передати два аргументи:

>>> надрукувати_суму(4, 5)
9

>>> надрукувати_суму(8, 9)
17

>>> надрукувати_суму(0, 0)
0

>>> надрукувати_суму(3, 5)
8

Ми можемо адаптувати функцію з одним параметром (яку ми щойно бачили), щоб вона працювала з двома параметрами та друкувала схему із налаштованим символом:

def надрукувати_схему(num_рядків, char):
	for i in range(num_рядків):
		for num_стовпчиків in range(num_рядків-i):
			print(char, end="")
		print()

Ви бачите, що вивід із налаштованим символом полягає в тому, що ми викликаємо функцію, передаючи два аргументи:

>>> надрукувати_схему(5, "A")
AAAAA
AAAA
AAA
AA
A

>>> надрукувати_схему(8, "%")
%%%%%%%%
%%%%%%%
%%%%%%
%%%%%
%%%%
%%%
%%
%

>>> надрукувати_схему(10, "#")
##########
#########
########
#######
######
#####
####
###
##
#

Як повернути значення у Python

Чудово! Тепер ви знаєте, як визначити функцію. Розберемось із інструкцією return.

Часто потрібно повернути значення з функції. У Python це можна зробити за допомогою інструкції return. Це потрібно написати у визначенні функції:

return <значення_для_повернення>

💡 Важливо: функція негайно зупиняється, коли знайдено return і значення повернуто.

Маємо приклад:

def отримати_площу_прямокутника(довжина, ширина):
    return довжина * ширина

Тепер ми можемо викликати функцію та призначити результат до змінної, оскільки результат повертається функцією:

>>> площа = отримати_площу_прямокутника(4, 5)
>>> площа
20

Також можна використати return з інструкцією повертати значення на основі умови True або False.

У цьому прикладі функція повертає перший парний елемент, знайдений у послідовності:

def отримати_перший_парний(послідовність):
    for elem in послідовність:
        if elem % 2 == 0:
            return elem
    else:
        return None

Коли викличемо функцію, то отримаємо очікувані результати:

>>> значення1 = отримати_перший_парний([2, 3, 4, 5])
>>> значення1
2
>>> значення2 = отримати_перший_парний([3, 5, 7, 9])
>>> print(значення2)
None

💡 Важливо: якщо функція не має інструкції return або не знаходить її, за замовчуванням повертається None.

Посібник з написання коду Python рекомендує використовувати інструкції return послідовно. Там згадується:

Будьте послідовними в інструкціях return. Або всі інструкції return повертають вираз, або жодна. Якщо будь-яка інструкція return повертає вираз, то інструкції, у яких не повертається значення, повинні повертати None, а інструкція return повинна бути в кінці функції (якщо її можна отримати)

Оригінал (англійською):

Be consistent in return statements. Either all return statements in a function should return an expression, or none of them should. If any return statement returns an expression, any return statements where no value is returned should explicitly state this as return None, and an explicit return statement should be present at the end of the function (if reachable)

Аргументи за замовчуванням у Python

Ми можемо призначити аргументи за замовчуванням для параметрів нашої функції. Щоб це зробити потрібно написати <параметр>=<значення> у списку параметрів.

💡 Важливо: посібник з написання коду Python згадує, що не потрібно «використовувати пробіли навколо знака =, якщо він використовується для позначення ключового аргумента».

У цьому прикладі ми призначаємо параметру b значення 5 за замовчуванням. Якщо ми опустимо це значення при виклику функції, використається значення за замовчуванням.

def надрукувати_продукт(a, b=5):
    print(a * b)

Якщо викликати функцію без цього аргументу, вивід буде такий:

>>> надрукувати_продукт(4)
20

Ми підтвердили, що в операції використовувався аргумент 5 за замовчуванням.

Але ми також можемо призначити власне значення для b, передавши другий аргумент:

>>> надрукувати_продукт(3, 4)
12

💡 Важливо: параметри з аргументами за замовчуванням повинні бути визначені в кінці списку параметрів. Інакше ви побачите цю помилку: SyntaxError: non-default argument follows default argument.

Маємо ще один приклад функції, яку ми написали, щоб надрукувати схему. Ми призначили значення "*" до параметру char за замовчуванням.

def надрукувати_схему(num_рядків, char="*"):
	for i in range(num_рядків):
		for num_стовпчиків in range(num_рядків-i):
			print(char, end="")
		print()

Тепер ми можемо використати значення за замовчуванням або налаштувати його:

>>> надрукувати_схему(5)
*****
****
***
**
*

>>> надрукувати_схему(6, "&")
&&&&&&
&&&&&
&&&&
&&&
&&
&

🔸 Рекурсія у Python

Рекурсія — це функція, яка викликає себе. Ці функції мають базовий випадок, який зупиняє рекурсивний процес, і рекурсивний випадок, який продовжує рекурсивний процес, здійснюючи інший рекурсивний виклик.

Ось декілька прикладів у Python:

def factorial(n):
    if n == 0 or n == 1:
        return 1
    else:
        return n * factorial(n-1)
Рекурсивна факторіальна функція
def fibonacci(n):
    if n == 0 or n == 1:
        return n
    else:
        return fibonacci(n-1) + fibonacci(n-2)
Функція Фібоначчі
def find_power(a, b):
    if b == 0:
        return 1
    else:
        return a * find_power(a, b-1)
Функція рекурсивного знаходження степеня

🔹 Обробка винятків у Python

Помилку або неочікувану подію при виконанні програми називають винятком. Завдяки елементам, які ми скоро розберемо, можна уникнути раптового завершення програми.

Розглянемо типи винятків у Python та що з ними робити.

Поширені винятки у Python

Ось список найпоширеніших винятків та причини їхньої появи:

  • ZeroDivisionError: виникає, коли другий аргумент операції ділення або модуля дорівнює нулю.
>>> 5 / 0
Traceback (most recent call last):
  File "<pyshell#0>", line 1, in <module>
    5 / 0
ZeroDivisionError: division by zero

>>> 7 // 0
Traceback (most recent call last):
  File "<pyshell#1>", line 1, in <module>
    7 // 0
ZeroDivisionError: integer division or modulo by zero

>>> 8 % 0
Traceback (most recent call last):
  File "<pyshell#2>", line 1, in <module>
    8 % 0
ZeroDivisionError: integer division or modulo by zero
  • IndexError: виникає, коли ми пробуємо використати недійсний індекс, щоб отримати доступ до елемента послідовності.
>>> мій_список = [3, 4, 5, 6]

>>> мій_список[15]
Traceback (most recent call last):
  File "<pyshell#4>", line 1, in <module>
    мій_список[15]
IndexError: list index out of range
  • KeyError: виникає, коли ми пробуємо отримати доступ до пари ключ-значення, яка не існує, оскільки в словнику немає ключа.
>>> мій_словник = {"a": 1, "b": 2, "c": 3}

>>> мій_словник["d"]
Traceback (most recent call last):
  File "<pyshell#6>", line 1, in <module>
    мій_словник["d"]
KeyError: 'd'
  • NameError: виникає, коли ми використовуємо змінну, яку не було визначено раніше.
>>> b
Traceback (most recent call last):
  File "<pyshell#8>", line 1, in <module>
    b
NameError: name 'b' is not defined
  • RecursionError: виникає, коли інтерпретатор виявляє, що перевищено максимальну глибину рекурсії. Зазвичай це відбувається, коли процес ніколи не досягає базового випадку.

У прикладі нижче ми отримаємо RecursionError. Функція factorial реалізована рекурсивно, але аргументом, переданим до рекурсивного виклику, є n замість n-1. Якщо значення не дорівнює 0 або 1, базовий випадок не буде досягнуто, оскільки аргумент не зменшується, тому процес продовжиться, і ми отримаємо цю помилку.

>>> def factorial(n):
	if n == 0 or n == 1:
		return 1
	else:
		return n * factorial(n)

	
>>> factorial(5)
Traceback (most recent call last):
  File "<pyshell#6>", line 1, in <module>
    factorial(5)
  File "<pyshell#5>", line 5, in factorial
    return n * factorial(n)
  File "<pyshell#5>", line 5, in factorial
    return n * factorial(n)
  File "<pyshell#5>", line 5, in factorial
    return n * factorial(n)
  [Previous line repeated 1021 more times]
  File "<pyshell#5>", line 2, in factorial
    if n == 0 or n == 1:
RecursionError: maximum recursion depth exceeded in comparison

💡 Важливо: щоб дізнатись більше про ці винятки, див. публікацію із документації Python.

try / except у Python

У Python можна використати try/except, щоб спіймати винятки та обробити їх належним чином. У такий спосіб програма може належно завершитись або навіть відновитися після винятку.

Базовий синтаксис:

try:
    <код_який_може_викликати_виняток>
except:
    <код_для_обробки_винятку_якщо_він_виникає>

Наприклад, якщо ми використовуємо введені користувачем дані для доступу до елемента в списку, ввід може бути недійсним індексом, тому може виникнути виняток:

індекс = int(input("Введіть індекс: "))

try:
    мій_список = [1, 2, 3, 4]
    print(мій_список[індекс])
except:
    print("Будь ласка, введіть дійсний індекс.")

Якщо ми введемо недійсний індекс (наприклад, 15), виводом буде:

Будь ласка, введіть дійсний індекс.

Це тому, що виконується умова except. Однак, якщо значення дійсне, код у try виконуватиметься належним чином.

Ось ще один приклад:

a = int(input("Введіть a: "))
b = int(input("Введіть b: "))

try:
    division = a / b
    print(division)
except:
    print("Будь ласка, введіть дійсні значення.")

Вивід:

Введіть a: 5
Введіть b: 0

Будь ласка, введіть дійсні значення.

Як спіймати винятки певного типу у Python

Замість того, щоб перехоплювати та обробляти всі можливі винятки, які можуть виникнути в умові try, ми можемо спіймати та обробити певний тип винятку. Нам просто потрібно вказати тип винятку після ключового слова except:

try:
    <код_який_може_викликати_виняток>
except <тип_винятку>:
    <код_для_обробки_винятку_якщо_він_виникає>

Наприклад:

індекс = int(input("Введіть індекс: "))

try:
    мій_список = [1, 2, 3, 4]
    print(мій_список[індекс])
except IndexError: # вкажіть тип
    print("Будь ласка, введіть дійсний індекс.")
a = int(input("Введіть a: "))
b = int(input("Введіть b: "))

try:
    division = a / b
    print(division)
except ZeroDivisionError: # вкажіть тип
    print("Будь ласка, введіть дійсні значення.")

Як призначити назву до об’єкта винятку в Python

Можна вказати назву об’єкта винятку, призначивши її змінній, яку ми використали в умові except. Це надасть доступ до опису та атрибутів.

Потрібно просто додати as <назва>, ось так:

try:
    <код_який_може_викликати_виняток>
except <тип_винятку> as <назва>:
    <код_для_обробки_винятку_якщо_він_виникає>

Наприклад:

індекс = int(input("Введіть індекс: "))

try:
    мій_список = [1, 2, 3, 4]
    print(мій_список[індекс])
except IndexError as e:
    print("Трапився виняток:", e)

Вивід буде такий, якщо ввести 15 як виняток:

Введіть індекс: 15
Трапився виняток: list index out of range

Ще один приклад:

a = int(input("Введіть a: "))
b = int(input("Введіть b: "))

try:
    division = a / b
    print(division)
except ZeroDivisionError as err:
    print("Будь ласка, введіть дійсні значення.", err)

Вивід буде такий, якщо ми введемо значення 0 для b:

Будь ласка, введіть дійсні значення. division by zero

try / except / else у Python

До цієї структури можна додати умову else після except, якщо потрібно обрати, що відбувається, коли під час виконання умови try нічого не відбувається:

try:
    <код_який_може_викликати_виняток>
except:
    <код_для_обробки_винятку_якщо_він_виникає>
else:
    <код_який_виконується_якщо_немає_винятку_у_try>

Наприклад:

a = int(input("Введіть a: "))
b = int(input("Введіть b: "))

try:
    division = a / b
    print(division)
except ZeroDivisionError as err:
    print("Будь ласка, введіть дійсні значення.", err)
else:
    print("Обидва значення дійсні.")

Якщо ввести значення 5 та 0 для a та b відповідно, вивід буде такий:

Будь ласка, введіть дійсні значення. division by zero

Але якщо обидва значення дійсні, наприклад 5 та 4 для a та b відповідно, умова else виконується після того, як виконано try:

1.25
Обидва значення дійсні.

try / except / else / finally у Python

Ми можено додати умову finally, якщо нам потрібно запустити код, який має виконуватися завжди, навіть якщо у try є виняток.

Наприклад:

a = int(input("Введіть a: "))
b = int(input("Введіть b: "))

try:
    division = a / b
    print(division)
except ZeroDivisionError as err:
    print("Будь ласка, введіть дійсні значення.", err)
else:
    print("Обидва значення дійсні.")
finally:
    print("Нарешті!")

Якщо обидва значення дійсні, виводом буде результат ділення та:

Обидва значення дійсні.
Нарешті!

А якщо буде виняток, оскільки b є 0, то побачимо:

Будь ласка, введіть дійсні значення. division by zero
Нарешті!

Умова finally виконується завжди.

💡 Важливо: ця умова буде використана, наприклад, щоб закрити файли, навіть якщо код викидає виняток.

🔸 Об’єктноорієнтоване програмування у Python

В об’єктноорієнтованому програмуванні (ООП) ми визначаємо класи, які діють як план для створення об’єктів у Python з атрибутами та методами (функціями, пов’язаними з об’єктами).

Це загальний синтаксис для визначення класу:

class <НазваКласу>:

    <назва_атрибуту_класу> = <значення>

    def __init__(self,<параметр1>, <параметр2>, ...):
        self.<атрибут1> = <параметр1>
        self.<атрибут2> = <параметр2>
        .
        .
        .
        # Стільки атрибутів, скільки потрібно
    
   def <назва_методу>(self, <параметр1>, ...):
       <код>
       
   # Стільки методів, скільки потрібно

💡 Важливо: self посилається на клас (об’єкт, створений на основі плану (класу)).

Як ви могли помітити, клас має багато різних елементів, тому розберемо їх.

Заголовок класу

Перший рядок визначення класу містить ключове слово class та назву класу:

class Собака:
class Будинок:

class М'яч:

💡 Важливо: якщо клас успадковує атрибути та методи з іншого класу, ми побачимо назву класу в круглих дужках:

class Пудель(Собака):
class Вантажівка(Автомобіль):
class Мама(ЧленСім'ї):

Назви класу у Python пишуться верхнім верблюдячим регістром, де кожне слово починається з великої літери. Наприклад: ЧленСім'ї.

__init__ та атрибути екземпляра

Ми використовуємо класи для створення об’єктів у Python так само, як ми використовуємо плани для побудови будинків.

Об’єкти матимуть атрибути, які ми визначимо у класі. Зазвичай ці атрибути ініціалізовують у __init__. Цей метод запускається, коли ми створюємо екземпляр класу.

Загальний синтаксис:

def __init__(self, <параметр1>, <параметр2>, ...):
        self.<атрибут1> = <параметр1>  # Атрибут екземпляра
        self.<атрибут2> = <параметр2>  # Атрибут екземпляра
        .
        .
        .
        # Стільки атрибутів екземпляра, скільки потрібно

Ми вказуємо стільки параметрів, скільки потрібно для налаштування значень атрибутів об’єкта, який буде створено.

Ось приклад цього методу з класом Собака:

class Собака:

    def __init__(self, ім'я, вік):
        self.ім'я = ім'я
        self.вік = вік

💡 Важливо: зверніть увагу на підкреслення у назві __init__.

Як створити екземпляр

Щоб створити екземпляр для Собаки, нам потрібно вказати ім’я та вік собаки, щоб призначити ці значення до атрибутів:

моя_собака = Собака("Нора", 10)

Чудово! Тепер наш екземпляр можна використовувати у програмі.

Деякі класи не вимагають аргументів для створення екземплярів. У такому разі ми пишемо порожні круглі дужки. Наприклад:

class Коло:

    def __init__(self):
        self.радіус = 1

Щоб створити екземпляр:

>>> моє_коло = Коло()

💡 Важливо: self є параметром, який діє «за лаштунками», тож навіть якщо ви бачите його у визначенні методу, вам не слід враховувати його, коли ви передаєте аргументи.

Аргументи за замовчуванням

Атрибутам можна призначати значення за замовчуванням, а користувачам можна надати можливість налаштовувати значення.

У такому випадку ми би написали <атрибут>=<значення> у списку параметрів.

Ось приклад:

class Коло:

    def __init__(self, радіус=1):
        self.радіус = радіус

Тепер ми можемо створити екземпляр Кола зі значенням радіуса за замовчуванням, опустивши значення, або налаштувати його, передавши значення: 

# Значення за замовчуванням
>>> моє_коло1 = Коло()

# Налаштоване значення
>>> моє_коло2 = Коло(5)

Як отримати атрибут екземпляра

Щоб отримати атрибут екземпляра використовуємо цей синтаксис:

<змінна_об'єкта>.<атрибут>

Наприклад:

# Визначення класу
>>> class Собака:

    def __init__(self, ім'я, вік):
        self.ім'я = ім'я
        self.вік = вік

# Створіть екземпляр        
>>> моя_собака = Собака("Нора", 10)

# Отримайте атрибути
>>> моя_собака.ім'я
'Нора'

>>> моя_собака.вік
10

Як оновити атрибут екземпляра

Щоб оновити атрибут екземпляра використовуємо цей синтаксис:

<змінна_об'єкта>.<атрибут> = <нове_значення>

Наприклад:

>>> class Собака:

    def __init__(self, ім'я, вік):
        self.ім'я = ім'я
        self.вік = вік

        
>>> моя_собака = Собака("Нора", 10)

>>> моя_собака.ім'я
'Нора'

# Оновіть атрибут
>>> моя_собака.ім'я = "Норіта"

>>> моя_собака.ім'я
'Норіта'

Як вилучити атрибут екземпляра

Щоб вилучити атрибут екземпляра, використовуємо цей синтаксис:

del <змінна_об'єкта>.<атрибут>

Наприклад:

>>> class Собака:

    def __init__(self, ім'я, вік):
        self.ім'я = ім'я
        self.вік = вік

        
>>> моя_собака = Собака("Нора", 10)

>>> моя_собака.ім'я
'Нора'

# Видаліть цей атрибут
>>> del моя_собака.ім'я

>>> моя_собака.ім'я
Traceback (most recent call last):
  File "<pyshell#77>", line 1, in <module>
    моя_собака.ім'я
AttributeError: 'Собака' object has no attribute 'ім'я'

Як видалити екземпляр

Видалити екземпляр можна за допомогою del:

>>> class Собака:

    def __init__(self, ім'я, вік):
        self.ім'я = ім'я
        self.вік = вік

        
>>> моя_собака = Собака("Нора", 10)

>>> моя_собака.ім'я
'Нора'

# Видаліть екземпляр
>>> del моя_собака

>>> моя_собака
Traceback (most recent call last):
  File "<pyshell#79>", line 1, in <module>
    моя_собака
NameError: name 'моя_собака' is not defined

Публічні та непублічні атрибути у Python

У Python немає модифікаторів доступу, щоб обмежити доступ до атрибутів екземпляра, тому ми покладаємося на угоди про іменування.

Наприклад, можна використати нижню риску, аби повідомити інших розробників, що атрибут повинен бути непублічним.

Наприклад:

class Собака:

    def __init__(self, ім'я, вік):
        self.ім'я = ім'я  # Публічний атрибут
        self._вік = вік   # Непублічний атрибут

Документація Python згадує:

Використовуйте на початку одну нижню риску лише для непублічних методів або змінних екзмеплярів.

Завжди вирішуйте, чи повинні методи та змінні екземпляра (разом «атрибути») бути публічними чи непублічними. Якщо сумніваєтеся, виберіть непублічний; простіше зробити його публічним пізніше, ніж навпаки.

Непублічними є атрибути, які не призначені для використання третіми сторонами; ви не гарантуєте, що непублічні атрибути не будуть змінені або навіть видалені.

Оригінал (англійською):

Use one leading underscore only for non-public methods and instance variables.

Always decide whether a class's methods and instance variables (collectively: "attributes") should be public or non-public. If in doubt, choose non-public; it's easier to make it public later than to make a public attribute non-public.

Non-public attributes are those that are not intended to be used by third parties; you make no guarantees that non-public attributes won't change or even be removed. - source

Однак у документації також згадується:

Ми не використовуємо термін «приватний», оскільки жоден атрибут не є приватним у Python (без зайвої роботи).

Оригінал (англійською):

We don't use the term "private" here, since no attribute is really private in Python (without a generally unnecessary amount of work). - source

💡 Важливо: технічно, ми можемо отримати доступ до атрибута та змінити його, якщо додамо нижню риску перед назвою, але не варто цього робити.

Атрибути класу у Python

Атрибути класу є спільними для всіх екземплярів класу. Усі вони мають доступ до цього атрибута, і на них також вплинуть будь-які зміни, внесені до цих атрибутів.

class Пес:

    # Атрибути класу
    царство = "Тварини"
    вид = "Вовк"

    def __init__(self, ім'я, вік):
        self.ім'я = ім'я
        self.вік = вік

💡 Важливо: зазвичай їх пишуть перед методом __init__.

Як отримати атрибут класу

Щоб отримати значення атрубуту класу використовуємо цей синтаксис:

<назва_класу>.<атрибут>

Наприклад:

>>> class Пес:

    царство = "Тварини"

    def __init__(self, ім'я, вік):
        self.ім'я = ім'я
        self.вік = вік

        
>>> Пес.царство
'Тварини'

💡 Важливо: цей синтаксис можна використовувати в межах класу.

Як оновити атрибут класу

Щоб оновити атрубут класу, використовуємо цей синтаксис:

<назва_класу>.<атрибут> = <значення>

Наприклад:

>>> class Пес:

    царство = "Тварини"

    def __init__(self, ім'я, вік):
        self.ім'я = ім'я
        self.вік = вік

        
>>> Пес.царство
'Тварини'

>>> Пес.царство = "Нове царство"

>>> Пес.царство
'Нове царство'

Як видалити атрибут класу

Видаляють атрибут класу за допомогою del. Наприклад:

>>> class Пес:

    царство = "Тварини"

    def __init__(self, ім'я, вік):
        self.ім'я = ім'я
        self.вік = вік

>>> Пес.царство
'Тварини'
        
# Видаліть атрибут класу
>>> del Пес.царство

>>> Пес.царство
Traceback (most recent call last):
  File "<pyshell#88>", line 1, in <module>
    Пес.царство
AttributeError: type object 'Пес' has no attribute 'царство'

Як визначити методи

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

💡 Важливо: методи екземпляра можуть працювати з атрибутами екземпляра, який викликає метод, якщо ми напишемо self.<атрибут> у визначенні методу.

Це загальний синтаксис методу в класі. Зазвичай вони розташовані під __init__:

class <НазваКласу>:

    # Атрибути класу

    # __init__

    def <назва_методу>(self, <параметр1>, ...):
        <код>

Вони можуть мати нуль, один або більше параметрів (так само як функції!), але методи екземпляра завжди повинні мати self як перший параметр.

Наприклад, ось метод гавкіт без параметрів (на додаток до self):

class Собака:

    def __init__(self, ім'я, вік):
        self.ім'я = ім'я
        self.вік = вік

    def гавкіт(self):
        print(f"гав-гав. Я {self.ім'я}")

Щоб викликати цей метод, використовуємо такий синтаксис:

<змінна_об'єкта>.<метод>(<аргументи>)

Наприклад:

# Створіть екземпляр
>>> моя_собака = Собака("Нора", 10)

# Викличте метод
>>> моя_собака.гавкіт()
гав-гав. Я Нора

Тут маємо клас Гравець з методом збільшення_швидкості з одним параметром:

class Гравець:

    def __init__(self, ім'я):
        self.ім'я = ім'я
        self.швидкість = 50

    def збільшення_швидкості(self, значення):
        self.швидкість += значення

Щоб викликати метод:

# Створіть екземпляр       
>>> мій_гравець = Гравець("Нора")

# Перевірте збільшення швидкості, щоб побачити зміну
>>> мій_гравець.швидкість
50

# Збільште швидкість
>>> мій_гравець.збільшення_швидкості(5)

# Підтвердьте зміну
>>> мій_гравець.швидкість
55

💡 Важливо: щоб додати більше параметрів, просто розділіть їх комою. Рекомендовано додати пробіл після коми.

Властивості, getters та setters у Python

Getters та setters — це методи, які ми можемо визначити, щоб отримати або встановити значення атрибуту екземпляра відповідно. Вони працюють як посередники, які «захищають» атрибути від змін.

У Python здебільшого використовують властивості, а не getters чи setters. Розглянемо, як ними можна користуватись.

Щоб визначити властивість пишемо метод з таким синтаксисом:

@property
def <назва_властивості>(self):
    return self.<атрибут>

Цей метод діятиме як getter, тому він буде викликаний, коли ми спробуємо отримати доступ до значення атрибута.

Тепер потрібно визначити setter:

@<назва_властивості>.setter
def <назва_властивості>(self, <параметр>):
    self.<атрибут> = <параметр>

Та deleter, щоб видалити атрибут:

@<назва_властивості>.deleter
def <назва_властивості>(self):
    del self.<атрибут>

💡 Важливо: ви можете написати будь-який потрібний код у цих методах, щоб отримати, встановити та видалити атрибут. Рекомендовано зробити їх максимально простими.

Ось приклад:

class Собака:

    def __init__(self, ім'я):
        self._ім'я = ім'я

    @property
    def ім'я(self):
        return self._ім'я

    @ім'я.setter
    def ім'я(self, нове_ім'я):
        self._ім'я = нове_ім'я

    @ім'я.deleter
    def ім'я(self):
        del self._ім'я

Якщо ми додамо інструкції друку, то побачимо, що вони викликаються, коли ми виконуємо їхню операцію:

>>> class Собака:

    def __init__(self, ім'я):
        self._ім'я = ім'я

    @property
    def ім'я(self):
        print("Виклик getter")
        return self._ім'я

    @ім'я.setter
    def ім'я(self, нове_ім'я):
        print("Виклик setter")
        self._ім'я = нове_ім'я

    @ім'я.deleter
    def ім'я(self):
        print("Виклик deleter")
        del self._ім'я

        
>>> моя_собака = Собака("Нора")

>>> моя_собака.ім'я
Виклик getter
'Нора'

>>> моя_собака.ім'я = "Норіта"
Виклик setter

>>> моя_собака.ім'я
Виклик getter
'Норіта'

>>> del моя_собака.ім'я
Виклик deleter

🔹 Як працювати з файлами у Python

Робота з файлами важлива для створення сильних програм. Розглянемо як це робити у Python.

Як читати файли у Python

У Python рекомендовано використовувати інструкцію with при роботі з файлами, оскільки вона відкриває файли, коли потрібно та автоматично закриває їх, коли процес закінчено.

Щоб прочитати файл використовуємо цей синтаксис:

with open("<шлях_файлу>") as <змінна_файлу>:
    <код>

За допомогою "r" можна вказати, що ми хочемо відкрити файл у режимі читання:

with open("<шлях_файлу>", "r") as <змінна_файлу>:
    <код>

Проте цей режим встановлено за замовчуванням, тому його можна опустити, як у першому прикладі.

Ось приклад:

with open("відомі_цитати.txt") as файл:
    for рядок in файл:
        print(рядок)

або...

with open("відомі_цитати.txt", "r") as файл:
    for рядок in файл:
        print(рядок)

💡 Важливо: правильно! Ми можемо ітерувати рядки файлу за допомогою циклу for. Шлях файлу може бути відносним до сценарію Python, який ми запускаємо, або абсолютним.

Як писати файл у Python

Існує два шляхи написання файлу. Ви можете або замінити весь вміст файлу перед додаванням нового вмісту, або додати до наявного вмісту.

with open("<шлях_файлу>", "w") as <змінна_файлу>:
    <код>

Щоб повністю замінити вміст використовуємо режим "w", тому ми передаємо рядок як другий аргумент до open(). Ми викликаємо метод .write() до об’єкта файлу, передаючи вміст, який потрібно записати як аргумент.

Наприклад:

слова = ["Неймовірний", "Зелений", "Python", "Код"]

with open("відомі_цитати.txt", "w") as файл:
    for слово in слова:
        файл.write(слово + "\n")

При запуску програми буде створено новий файл, якщо його досі не існує у шляху, який ми вказали.

Вміст файлу буде таким:

Неймовірний
Зелений
Python
Код

Як додати вміст до файлу у Python

Якщо ви хочете додати вміст, використайте режим "a":

with open("<шлях_файлу>", "a") as <змінна_файлу>:
    <код>

Наприклад:

слова = ["Неймовірний", "Зелений", "Python", "Код"]

with open("відомі_цитати.txt", "a") as файл:
    for слово in слова:
        файл.write(слово + "\n")

Ця маленька зміна збереже наявний вміст файлу та додасть новий у кінці.

Якщо ми запустимо програму ще раз, то ці рядки буде додано в кінці файлу:

Неймовірний
Зелений
Python
Код
Неймовірний
Зелений
Python
Код

Як видалити файл у Python

Для видалення файлу можна використати модуль os. Перед викликом функції remove() з модуля рекомендовано перевірити, чи існує файл:

import os

if os.path.exists("<шлях_файлу>"):
  os.remove("<шлях_файлу>")
else:
  <код>

Наприклад:

import os

if os.path.exists("відомі_цитати.txt"):
  os.remove("відомі_цитати.txt")
else:
  print("Такого файлу не існує")

Ви, мабуть, помітили перший рядок import os. Це інструкція імпорту. Розглянемо, чому вони важливі.

🔸 Інструкції імпорту у Python

Свій код краще впорядковувати в декілька файлів залежно від того, як програма зростає в розмірах і складності. Але нам потрібно знайти спосіб об’єднати ці файли, щоб програма працювала правильно, і саме це роблять інструкції імпорту.

Написавши інструкцію імпорту, ми можемо імпортувати модуль (файл, який містить визначення та інструкції Python) до іншого файлу.

Нижче подано перелік альтернатив для інструкцій імпорту:

Перша альтернатива:

import <назва_модулю>

Наприклад:

import math

💡 Важливо: math є вбудованим модулем Python.

Якщо ми використовуємо цю інструкцію імпорту, також потрібно додати назву модулю перед назвою функції або елементу:

>>> import math
>>> math.sqrt(25)
5.0

Ми чітко згадуємо в нашому коді модуль, до якого належить елемент.

Друга альтернатива:

import <модуль> as <нова_назва>

Наприклад:

import math as m

У нашому коді можна використати нову назву замість початкової назви модуля:

>>> import math as m
>>> m.sqrt(25)
5.0

Третя альтернатива:

from <назва_модуля> import <елемент>

Наприклад:

from math import sqrt

За допомогою цієї інструкції імпорту можна викликати функцію, не вказавши назву модуля:

>>> from math import sqrt
>>> sqrt(25)
5.0

Четверта альтернатива:

from <назва_модуля> import <елемент> as <нова_назва>

Наприклад:

from math import sqrt as квадратний_корінь

За допомогою цієї інструкції імпорту можна призначити нову назву до елемента, імпортованого із модуля:

>>> from math import sqrt as квадратний_корінь
>>> квадратний_корінь(25)
5.0

П’ята альтернатива:

from <назва_модуля> import *

Ця інструкція імпортує всі елементи модуля. До них можна звертатись за їхньою назвою, а не назвою модуля.

Наприклад:

>>> from math import *

>>> sqrt(25)
5.0

>>> factorial(5)
120

>>> floor(4.6)
4

>>> gcd(5, 8)
1

💡 Важливо: через цю інструкцію імпорту може бути незрозуміло, до якого модуля належать елементи, особливо коли їх імпортують з інших модулів.

У посібнику з написання коду Python згадується:

Варто уникати імпорт Wildcard (from <module> import *), оскільки через них незрозуміло, які назви присутні у «namespace», що може заплутати як читачів, так і автоматизовані інструменти.

Оригінал (англійською):

Wildcard imports (from <module> import *) should be avoided, as they make it unclear which names are present in the namespace, confusing both readers and many automated tools.

🔹 Розуміння списку та словника у Python

Дійсно хороша функція, про яку ви повинні знати: розуміння списку та словника. Це компактніший спосіб створити списки та словники.

Розуміння списку у Python

Синтаксис для визначення розуміння списку зазвичай відповідає одному з цих чотирьох шаблонів:

[<значення_яке_буде_включено> for <змінна> in <послідовність>]
[<значення_яке_буде_включено> for <змінна1> in <послідовність1> for <змінна2> in <послідовність2>]
[<значення_яке_буде_включено> for <змінна> in <послідовність> if <умова>]
[<значення> for <змінна1> in <послідовність1> for <змінна2> in <послідовність2> if <умова>]

💡 Важливо: їх потрібно використовувати лише тоді, коли вони не роблять код важчим для читання та розуміння.

Ось декілька прикладів:

>>> [i for i in range(4, 15)]
[4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

>>> [chr(i) for i in range(67, 80)]
['C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O']

>>> [i**3 for i in range(2, 5)]
[8, 27, 64]

>>> [i + j for i in range(5, 8) for j in range(3, 6)]
[8, 9, 10, 9, 10, 11, 10, 11, 12]

>>> [k for k in range(3, 35) if k % 2 == 0]
[4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34]

>>> [i * j for i in range(2, 6) for j in range(3, 7) if i % j == 0]
[9, 16, 25]

Розуміння списку vs. вирази-генератори у Python

Розуміння списку визначають квадратними дужками [], а вирази-генератори визначають круглими дужками (). Вони подібні, але зовсім різні. Розглянемо чому.

  • Розуміння списку генерують всю послідовність одразу та зберігають її у пам’яті.
  • Вирази-генератори видають по одному елементу за запитом.

Це можна перевірити за допомогою модуля sys. У нижче наведеному прикладі можна побачити різницю пам’яті:

>>> import sys
>>> sys.getsizeof([i for i in range(500)])
2132
>>> sys.getsizeof((i for i in range(500)))
56

Вирази-генератори можна використовувати для ітерації у циклах for та отримати один елемент за раз. А якщо потрібно зберегти елементи у списку, варто використати розуміння списку.

Розуміння словника у Python

Тепер зануримося у розуміння словника. Загальний синтаксис, який потрібно використовувати для визначення розуміння словника:

{<значення_ключа>: <значення> for <змінна> in <послідовність>}
{<значення_ключа>: <значення> for <змінна> in <послідовність> if <умова>}

Ось декілька прикладів розуміння словника:

>>> {num: num**3 for num in range(3, 15)}
{3: 27, 4: 64, 5: 125, 6: 216, 7: 343, 8: 512, 9: 729, 10: 1000, 11: 1331, 12: 1728, 13: 2197, 14: 2744}

>>> {x: x + y for x in range(4, 8) for y in range(3, 7)}
{4: 10, 5: 11, 6: 12, 7: 13}

Ось приклад з умовою, де ми беремо наявний словник та створюємо новий словник з студентами, які отримали прохідний бал (60):

>>> бали = {"Іра": 78, "Макар": 100, "Назар": 56, "Софія": 45, "Саша": 67}

>>> апробовані_студенти = {студент: бал for (студент, бал) in бали.items() if бал >= 60}

>>> апробовані_студенти
{'Іра': 78, 'Макар': 100, 'Саша': 67}

Я дуже сподіваюся, що ця публікація вам сподобалася та була корисною. Тепер ви знаєте, як писати та працювати з найважливішими елементами у Python.

⭐ Підпишіться на мене у ютубі та твіттері, щоб знайти більше туторіалів та порад.