Додаток B — Вступ до мови програмування Python

B.1 Коментарі коду

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

# print("Привіт усім")
# Це коментар
# Ці рядки коду не змінять жодних значень
# все, що слідує за першим #, не виконується як код

Ви можете побачити текст, укладений у потрійні лапки (""" вставте текст тут """). Такий синтаксис представлятиме багаторядкове коментування, але це не зовсім точно. Це особливий тип string, що називаєтьсяdocstring і використовується для пояснення призначення функції.

""" This is a special string """

' This is a special string '

B.2 Змінна

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

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

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

my_integer = 50
print(my_integer, type(my_integer))

50 <class 'int'>

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

one = 1
print(one)

1

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

my_float = 1.0
print(my_float, type(my_float))
my_float = float(1)
print(my_float, type(my_float))

1.0 <class 'float'>
1.0 <class 'float'>

Змінна типу float не округлятиме число, яке ви в ній зберігаєте, тоді як змінна типу integer округлятиме. Це робить floats більш придатними для математичних обчислень, де потрібно більше, ніж просто цілі числа.

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

my_int = int(3.14159)
print(my_int, type(my_int))

3 <class 'int'>

Функція int() також усіче будь-які цифри, які число може містити після десяткової коми!

Рядки дозволяють включати текст як змінну для роботи. Вони визначаються з використанням або одинарних лапок (’’), або подвійних лапок (““).

my_string = 'This is a string with single quotes'
print(my_string)
my_string = "This is a string with double quotes"
print(my_string)

This is a string with single quotes
This is a string with double quotes

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

my_string = '"Jabberwocky", by Lewis Carroll'
print(my_string)
my_string = "'Twas brillig, and the slithy toves / Did gyre and gimble in the wabe;"
print(my_string)

"Jabberwocky", by Lewis Carroll
'Twas brillig, and the slithy toves / Did gyre and gimble in the wabe;

Логічні значення, або bools, - це двійкові типи змінних. bool може приймати лише одне з двох значень, це True або False. У цій ідеї істинних значень є набагато більше, коли мова заходить про програмування, про що ми розповімо пізніше в розділі Логічні оператори цього зошита.

my_bool = True
print(my_bool, type(my_bool))

True <class 'bool'>

Існує ще багато типів даних, які ви можете призначити змінними в Python, але це основні з них!

B.3 Базова математика

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

Підтримуються всі основні арифметичні операції: +, -, /, і *. Ви можете створювати експоненти за допомогою **, а модульна арифметика вводиться за допомогою оператора mod, %.

print('Addition: ', 2 + 2)
print('Subtraction: ', 7 - 4)
print('Multiplication: ', 2 * 5)
print('Division: ', 10 / 2)
print('Exponentiation: ', 3**2)

Addition:  4
Subtraction:  3
Multiplication:  10
Division:  5.0
Exponentiation:  9

Якщо ви не знайомі з оператором mod, він працює як функція залишку. Якщо ми введемо \(15 \ \% \ 4\), він поверне залишок після ділення \(15\) на \(4\).

print('Частка: ', 15 % 4)

Частка:  3

Математичні функції також працюють зі змінними!

first_integer = 4
second_integer = 5
print(first_integer * second_integer)

20

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

first_integer = 11
second_integer = 3
print(first_integer / second_integer)

3.6666666666666665

first_number = 11.0
second_number = 3.0
print(first_number / second_number)

3.6666666666666665

Python має кілька вбудованих математичних функцій. Найбільш помітними з них є:

• abs()
• round()
• max()
• min()
• sum()

Усі ці функції діють так, як ви очікували, враховуючи їх назви. Виклик abs() для числа поверне його абсолютне значення. Функція round() округлить число до вказаної кількості десяткових знаків (значення за замовчуванням дорівнює \(0\)). Виклик max() або min() для набору чисел поверне, відповідно, максимальне або мінімальне значення в наборі. Виклик sum() для набору чисел призведе до їх підсумовування. Якщо ви не знайомі з тим, як працюють колекції значень у Python, не хвилюйтеся! Ми детально розглянемо набір в наступному розділі.

Додаткові математичні функції можуть бути додані разом з пакетом math.

import math

Математична бібліотека додає довгий список нових математичних функцій до Python. Не соромтеся ознайомитися з документацією для отримання повного списку та деталей. У ній ви знайдете деякі математичні константи.

print('Pi: ', math.pi)
print("Euler's Constant: ", math.e)

Pi:  3.141592653589793
Euler's Constant:  2.718281828459045

А також деякі часто використовувані математичні функції

print('Cosine of pi: ', math.cos(math.pi))

Cosine of pi:  -1.0

B.4 Колекції

B.4.1 Списки (lists)

Список у Python - це впорядкована колекція об’єктів, яка може містити будь-який тип даних. Ми визначаємо список, використовуючи квадратні дужки ([]).

my_list = [1, 2, 3]
print(my_list)

[1, 2, 3]

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

print(my_list[0])
print(my_list[2])

1
3

Індексація в Python починається з $ 0$. Якщо у вас є список довжиною \(n\), перший елемент списку знаходиться з індексом \(0\), другий елемент з індексом \(1\), і так далі, і тому подібне. Останній елемент списку матиме індекс \(n-1\). Будьте обережні! Спроба отримати доступ до неіснуючого індексу призведе до помилки.

print('The first, second, and third list elements: ', my_list[0], my_list[1], my_list[2])
print('Accessing outside the list bounds causes an error: ', my_list[3])

The first, second, and third list elements:  1 2 3

IndexError: list index out of range

Ми можемо побачити кількість елементів у списку, викликавши функцію len().

print(len(my_list))

3

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

print(my_list)
my_list[0] = 42
print(my_list)

[1, 2, 3]
[42, 2, 3]

Це принципово відрізняється від того, як обробляються рядки. Список є змінним, ви можете змінювати елементи списку без зміни самого списку. Деякі типи даних, такі як рядки, є незмінними. Як тільки рядок або інший незмінний тип даних був створений, він не може бути безпосередньо змінений без створення абсолютно нового об’єкта.

my_string = "Strings never change"
my_string[0] = 'Z'

TypeError: 'str' object does not support item assignment

Як ми вже говорили раніше, список може містити будь-який тип даних. Таким чином, списки також можуть містити рядки.

my_list_2 = ['one', 'two', 'three']
print(my_list_2)

['one', 'two', 'three']

Списки також можуть містити кілька різних типів даних одночасно!

my_list_3 = [True, 'False', 42]

Якщо ви хочете об’єднати два списки, їх можна об’єднати символом +.

my_list_4 = my_list + my_list_2 + my_list_3
print(my_list_4)

[42, 2, 3, 'one', 'two', 'three', True, 'False', 42]

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

my_list = ['friends', 'romans', 'countrymen', 'lend', 'me', 'your', 'ears']

B.4.1.1 Зріз (slicing)

Ми використовуємо двокрапку (:) для нарізки списків.

print(my_list[2:4])

['countrymen', 'lend']

Використовуючи :, ми можемо вибрати групу елементів у списку, починаючи з першого вказаного елемента і закінчуючи (але не включаючи) останнім зазначеним елементом.

Ми також можемо вибрати все після певного значення

print(my_list[1:])

['romans', 'countrymen', 'lend', 'me', 'your', 'ears']

І все перед конкретним значенням

print(my_list[:4])

['friends', 'romans', 'countrymen', 'lend']

Використання негативних чисел буде відлічуватися з кінця індексів, а не з початку. Наприклад, індекс -1 вказує на останній елемент списку.

print(my_list[-1])

ears

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

print(my_list[0:7:2])

['friends', 'countrymen', 'me', 'ears']

Тут ми вибрали весь список (оскільки 0:7 дасть елементи від 0 до 6), і ми вибрали розмір кроку 2. Отже, це виведе елемент 0, елемент 2, елемент 4 тощо на вибраний елемент списку. Ми можемо пропустити вказаний початок і кінець нашого фрагмента, вказавши лише крок.

print(my_list[::2])

['friends', 'countrymen', 'me', 'ears']

Списки неявно вибирають початок і кінець списку, якщо не вказано інше.

print(my_list[:])

['friends', 'romans', 'countrymen', 'lend', 'me', 'your', 'ears']

При негативному розмірі кроку ми можемо навіть перевернути список!

print(my_list[::-1])

['ears', 'your', 'me', 'lend', 'countrymen', 'romans', 'friends']

Python не має власних матриць. Інші пакети, такі як numpy, додають матриці як окремий тип даних, але в базовому Python найкращим способом створення матриці є використання списку списків.

Ми також можемо використовувати вбудовані функції для створення списків. Зокрема, ми розглянемо range() (тому що ми будемо використовувати його пізніше!). Діапазон може приймати кілька різних вхідних даних і поверне список.

b = 10
my_list = range(b)
print(my_list)

range(0, 10)

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

a = 0
b = 10
my_list = range(a, b)
print(my_list)

range(0, 10)

Ми також можемо вказати розмір кроку. Це знову має таку ж поведінку, як і зріз.

a = 0
b = 10
step = 2
my_list = range(a, b, step)
print(my_list)

range(0, 10, 2)

B.4.2 Кортежі (Tuples)

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

my_tuple = 'I', 'have', 30, 'cats'
print(my_tuple)

('I', 'have', 30, 'cats')

my_tuple = ('I', 'have', 30, 'cats')
print(my_tuple)

('I', 'have', 30, 'cats')

Як згадувалося раніше, кортежі незмінні. Ви не можете змінити будь-яку їх частину, не визначивши новий кортеж.

my_tuple[3] = 'dogs' # Намагається змінити значення 'cats', що зберігається в кортежі, на 'dogs'

TypeError: 'tuple' object does not support item assignment

Ви можете нарізати кортежі так само, як ви нарізаєте списки!

print(my_tuple[1:3])

('have', 30)

І об’єднайте їх так, як ви б це зробили з рядками!

my_other_tuple = ('make', 'that', 50)
print(my_tuple + my_other_tuple)

('I', 'have', 30, 'cats', 'make', 'that', 50)

Ми можемо упакувати значення разом, створивши кортеж (як зазначено вище), або ми можемо розпакувати значення з кортежу, витягуючи їх.

str_1, str_2, int_1 = my_other_tuple
print(str_1, str_2, int_1)

make that 50

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

B.4.3 Множини (Sets)

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

things_i_like = {'dogs', 7, 'the number 4', 4, 4, 4, 42, 'lizards', 'man I just LOVE the number 4'}
print(things_i_like, type(things_i_like))

{'lizards', 'dogs', 'the number 4', 4, 'man I just LOVE the number 4', 7, 42} <class 'set'>

Зверніть увагу, як будь-які додаткові екземпляри одного і того ж елемента видаляються в остаточному наборі. Ми також можемо створити множину зі списку, використовуючи функцію set().

animal_list = ['cats', 'dogs', 'dogs', 'dogs', 'lizards', 'sponges', 'cows', 'bats', 'sponges']
animal_set = set(animal_list)
print(animal_set) # видаляємо всі дублікати зі списку

{'dogs', 'bats', 'lizards', 'cats', 'sponges', 'cows'}

Виклик len() для множини повідомить вам, скільки в ньому елементів.

print(len(animal_set))

6

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

'cats' in animal_set # Тут ми перевіряємо наявність членства, використовуючи ключове слово 'in'.

True

Тут ми перевірили, чи міститься рядок cats у нашому animal_set, і він повернув True, повідомивши нам, що він насправді знаходиться в нашому наборі.

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

print(animal_set | things_i_like) # Ви також можете написати things_i_like / animal_set без будь-якої різниці

{'dogs', 'the number 4', 4, 'bats', 'man I just LOVE the number 4', 7, 42, 'lizards', 'cats', 'sponges', 'cows'}

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

print(animal_set & things_i_like) # Ви також можете написати things_i_like & animal_set без будь-якої різниці

{'lizards', 'dogs'}

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

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

B.4.4 Словники (Dictionaries)

Ще однією важливою структурою даних у Python є словник. Словники визначаються за допомогою комбінації фігурних дужок ({}) і двокрапок (:). Фігурні дужки визначають початок і кінець словника, а двокрапки вказують пари ключ-значення. Словник - це, по суті, набір пар ключ-значення. Ключ будь-якого запису повинен бути незмінним типом даних. Це робить кандидатами як рядки, так і кортежі. Ключі можуть бути як додані, так і видалені.

У наступному прикладі ми маємо словник, що складається з пар ключ-значення, де ключовим є жанр художньої літератури (рядок), а значенням є список книг (list) у цьому жанрі. Оскільки колекція все ще вважається єдиною сутністю, ми можемо використовувати її для збору декількох змінних або значень в одну пару ключ-значення.

my_dict = {"High Fantasy": ["Wheel of Time", "Lord of the Rings"],
           "Sci-fi": ["Book of the New Sun", "Neuromancer", "Snow Crash"],
           "Weird Fiction": ["At the Mountains of Madness", "The House on the Borderland"]}

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

print(my_dict["Sci-fi"])

['Book of the New Sun', 'Neuromancer', 'Snow Crash']

Ми також можемо змінити значення, пов’язане з даним ключем

my_dict["Sci-fi"] = "I can't read"
print(my_dict)

{'High Fantasy': ['Wheel of Time', 'Lord of the Rings'], 'Sci-fi': "I can't read", 'Weird Fiction': ['At the Mountains of Madness', 'The House on the Borderland']}

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

my_dict["Historical Fiction"] = ["Pillars of the Earth"]
print(my_dict["Historical Fiction"])

['Pillars of the Earth']

print(my_dict)

{'High Fantasy': ['Wheel of Time', 'Lord of the Rings'], 'Sci-fi': "I can't read", 'Weird Fiction': ['At the Mountains of Madness', 'The House on the Borderland'], 'Historical Fiction': ['Pillars of the Earth']}

B.5 Рядки (Strings)

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

Символ + вказує на конкатенацію мовою рядків. Це об’єднає два рядки в довший рядок.

first_string = '"Beware the Jabberwock, my son! /The jaws that bite, the claws that catch! /'
second_string = 'Beware the Jubjub bird, and shun /The frumious Bandersnatch!"/'
third_string = first_string + second_string
print(third_string)

"Beware the Jabberwock, my son! /The jaws that bite, the claws that catch! /Beware the Jubjub bird, and shun /The frumious Bandersnatch!"/

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

my_string = 'Supercalifragilisticexpialidocious'
print('The first letter is: ', my_string[0]) # Uppercase S
print('The last letter is: ', my_string[-1]) # lowercase s
print('The second to last letter is: ', my_string[-2]) # lowercase u
print('The first five characters are: ', my_string[0:5]) # Remember: slicing doesn't include the final element!
print('Reverse it!: ', my_string[::-1])

The first letter is:  S
The last letter is:  s
The second to last letter is:  u
The first five characters are:  Super
Reverse it!:  suoicodilaipxecitsiligarfilacrepuS

Вбудовані об’єкти та класи часто мають пов’язані з ними спеціальні функції, які називаються методами. Ми отримуємо доступ до цих методів, використовуючи точку (‘.’).

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

print('Count of the letter i in Supercalifragilisticexpialidocious: ', my_string.count('i'))
print('Count of "li" in the same word: ', my_string.count('li'))

Count of the letter i in Supercalifragilisticexpialidocious:  7
Count of "li" in the same word:  3

Ми також можемо знайти перший екземпляр символу або групи символів у рядку.

print('The first time i appears is at index: ', my_string.find('i'))

The first time i appears is at index:  8

А також замінити символи в рядку.

print("All i's are now a's: ", my_string.replace('i', 'a'))

All i's are now a's:  Supercalafragalastacexpaaladocaous

print("It's raining cats and dogs".replace('dogs', 'more cats'))

It's raining cats and more cats

Існують також деякі методи, які є унікальними для рядків. Функція upper() перетворює всі символи в рядку в верхній регістр, в той час як lower() перетворює всі символи в рядку в нижній регістр!

my_string = "I can't hear you"
print(my_string.upper())
my_string = "I said HELLO"
print(my_string.lower())

I CAN'T HEAR YOU
i said hello

B.5.1 Форматування рядків

Використовуючи метод format(), ми можемо додавати значення змінних і форматувати наші рядки.

my_string = "{0} {1}".format('Marco', 'Polo')
print(my_string)

Marco Polo

my_string = "{1} {0}".format('Marco', 'Polo')
print(my_string)

Polo Marco

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

Дивіться format() документація для отримання додаткових прикладів.

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

print('insert %s here' % 'value')

insert value here

Символ % в основному вказує Python на створення заповнювача. Будь-який символ, що слідує за % (у рядку), вказує, який тип матиме значення, введене в заповнювач. Цей символ називається типом перетворення. Після закриття рядка нам знадобиться ще один %, за яким слідують значення для вставки. У випадку одного значення ви можете просто помістити його туди. Якщо ви вставляєте більше одного значення, вони повинні бути укладені в кортеж.

print('There are %s cats in my %s' % (13, 'apartment'))

There are 13 cats in my apartment

У цих прикладах %s вказує, що Python повинен перетворити значення в рядки. Існує кілька типів перетворення, які ви можете використовувати, щоб уточнити форматування. Дивіться форматування рядка для отримання додаткових прикладів та більш повної інформації про використання.

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

B.6.1 Базова логіка

Логічні оператори мають справу з булевими значеннями, як ми коротко розглянули раніше. Якщо ви пам’ятаєте, bool приймає одне з двох значень: True або False (або \(1\) або \(0\)). Основні логічні твердження, які ми можемо зробити, визначаються за допомогою вбудованих компараторів. Це == (дорівнює), != (не дорівнює), < (Менше), > (Більше), <= (менше або дорівнює) і >= (більше або дорівнює).

print(5 == 5)

True

print(5 > 5)

False

Ці компаратори також працюють у поєднанні зі змінними.

m = 2
n = 23
print(m < n)

True

Ми можемо зв’язати ці компаратори разом, щоб створити більш складні логічні оператори, використовуючи логічні оператори or, and і not.

statement_1 = 10 > 2
statement_2 = 4 <= 6
print("Statement 1 truth value: {0}".format(statement_1))
print("Statement 2 truth value: {0}".format(statement_2))
print("Statement 1 and Statement 2: {0}".format(statement_1 and statement_2))

Statement 1 truth value: True
Statement 2 truth value: True
Statement 1 and Statement 2: True

Оператор or виконує логічне обчислення або. Будь-який компонент, об’єднаний за допомогою або, що є True, представлятиме все твердження як True. Оператор and виводить True, лише якщо всі компоненти разом є True. В іншому випадку він видасть False. Твердження not просто інвертує значення істинності будь-якого наступного за ним твердження. Таким чином, твердження True буде оцінено як False, коли перед ним буде поставлено not. Аналогічно, False твердження стане True, коли перед ним буде стояти not.

Припустимо, у нас є два логічні твердження, \(P\) і \(Q\). Таблиця істинності для основних логічних операторів виглядає наступним чином:

P	Q	not P	P and Q	P or Q
True	True	False	True	True
False	True	True	False	True
True	False	False	False	True
False	False	True	False	False

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

print(((2 < 3) and (3 > 0)) or ((5 > 6) and not (4 < 2)))

True

Логічні твердження можуть бути настільки простими або складними, наскільки нам подобається, залежно від того, що нам потрібно висловити. Оцінюючи наведене вище логічне твердження крок за кроком, ми бачимо, що ми оцінюємо (True and True) or (False and not False). Дана конструкція набуваж вигляду True or (False and True). Згодом стає True or False, і в кінцевому рахунку оцінюється як True.

B.6.1.1 Істинність

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

# Cхоже до того, як працюють float() та int(), book () змушує значення вважатися логічним!
print(bool(''))

False

print(bool('I have character!'))

True

print(bool([]))

False

print(bool([1, 2, 3]))

True

І так далі, для інших колекцій та контейнерів. None також оцінюється як False. Число 1 еквівалентно True, а число 0 також еквівалентно False в логічному контексті.

B.6.2 If-оператори

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

Блок if вводиться, коли умова вважається True. Якщо умова оцінюється як False, блок if буде просто пропущений, якщо тільки до нього не додається блок else. Умови створюються за допомогою логічних операторів або за допомогою істинності значень у Python. Оператор if визначається двокрапкою і блоком тексту з відступом.

if "Condition":
    print(True)
else:
    print(False)

True

i = 4
if i == 5:
    print('The variable i has a value of 5')

Оскільки в цьому прикладі i = 4 і оператор if шукає лише те, чи i = 5, оператор print ніколи не буде виконаний. Ми можемо додати оператор else, щоб створити блок коду на випадок надзвичайних ситуацій на випадок, якщо умова в операторі if не буде оцінена як True.

i = 5
if i == 5:
    print("Усі рядки в цьому блоці з відступом є частиною цього блоку")
    print('Змінна i має значення 5')
else:
    print("Усі рядки в цьому блоці з відступом є частиною цього блоку")
    print('Змінна i не дорівнює 5')

Усі рядки в цьому блоці з відступом є частиною цього блоку
Змінна i має значення 5

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

i = 1
if i == 1:
    print('Змінна i має значення 1')
elif i == 2:
    print('Змінна і має значення 2')
elif i == 3:
    print('Змінна і має значення 3')
else:
    print("Мене не хвилює змінна і")

Мене не хвилює змінна і

Ви також можете вкласти оператори if в інші оператори if, щоб перевірити наявність додаткових умов.

i = 10
if i % 2 == 0:
    if i % 3 == 0:
        print('і ділиться як на 2, так і на 3!')
    elif i % 5 == 0:
        print('і ділиться як на 2, так і на 5!')
    else:
        print('i ділиться на 2, але не на 3 або 5!')
else:
    print('Я припускаю, що i - непарне число.')

і ділиться як на 2, так і на 5!

Пам’ятайте, що ми можемо згрупувати кілька умов разом, використовуючи логічні оператори!

i = 11
j = 12
if i < 10 and j > 11:
    print('{0} менше 10 і {1} більше 11!'.format(i, j))

Ви можете використовувати логічні компаратори для порівняння рядків!

my_string = "Farthago delenda est"
if my_string == "Carthago delenda est":
    print('And so it was! For the glory of Rome!')
else:
    print('War elephants are TERRIFYING. I am staying home.')

War elephants are TERRIFYING. I am staying home.

Як і у випадку з іншими типами даних, == перевірить, чи дві речі з обох сторін мають однакове значення.

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

Ключове слово in зазвичай використовується для перевірки приналежності значення до іншого значення. Ми можемо перевірити приналежність у контексті оператора if і використовувати його для виведення значення істини.

if 'a' in my_string or 'e' in my_string:
    print('Those are my favorite vowels!')

Those are my favorite vowels!

Тут ми використовуємо in, щоб перевірити, чи містить змінна my_string містить якісь конкретні літери.

B.7 Циклічні структури

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

i = 10
while i > 0:
    i -= 1
    print('Я зациклений! {0} значень до завершення!'.format(i))

Я зациклений! 9 значень до завершення!
Я зациклений! 8 значень до завершення!
Я зациклений! 7 значень до завершення!
Я зациклений! 6 значень до завершення!
Я зациклений! 5 значень до завершення!
Я зациклений! 4 значень до завершення!
Я зациклений! 3 значень до завершення!
Я зациклений! 2 значень до завершення!
Я зациклений! 1 значень до завершення!
Я зациклений! 0 значень до завершення!

За допомогою циклів while нам потрібно переконатися, що щось насправді змінюється від ітерації до ітерації, щоб цикл фактично закінчувався. У цьому випадку ми використовуємо скорочення i -= 1 (скорочення від i = i - 1), так що значення i стає меншим з кожною ітерацією. Врешті-решт i буде зменшено до 0, що призведе до виконання умови False та виходу з циклу.

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

for i in range(5):
    print('Я зациклений! Я вже на {0}-ій ітерації!'.format(i + 1))

Я зациклений! Я вже на 1-ій ітерації!
Я зациклений! Я вже на 2-ій ітерації!
Я зациклений! Я вже на 3-ій ітерації!
Я зациклений! Я вже на 4-ій ітерації!
Я зациклений! Я вже на 5-ій ітерації!

Зверніть увагу, що в цьому циклі for ми використовуємо ключове слово in. Використання ключового слова in не обмежується перевіркою приналежності, як у прикладі if-конструкцій. Ви можете оброблювати будь-яку колекцію за допомогою циклу for, використовуючи ключове слово in.

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

my_list = {'cats', 'dogs', 'lizards', 'cows', 'bats', 'sponges', 'humans'}
mammal_list = {'cats', 'dogs', 'cows', 'bats', 'humans'} # перераховані всі ссавці в у світі
my_new_list = set()
for animal in my_list:
    if animal in mammal_list:
        # додаємо будь-яку тварину, що знаходиться і в my_list, і в mammal_list
        my_new_list.add(animal)

print(my_new_list)

{'dogs', 'bats', 'cats', 'humans', 'cows'}

Є два твердження, які дуже корисні при роботі як з циклами for, так і з циклами while. Це break і continue. Якщо break трапляється в будь-який момент під час виконання циклу, цикл негайно завершується.

i = 10
while True:
    if i == 14:
        break
    i += 1
    print(i)

11
12
13
14

for i in range(5):
    if i == 2:
        break
    print(i)

0
1

Оператор continue вкаже циклу негайно завершити цю ітерацію і перейти до наступної ітерації циклу.

i = 0
while i < 5:
    i += 1
    if i == 3:
        continue
    print(i)

1
2
4
5

Цей цикл пропускає друк числа \(3\) через інструкцію continue, яка виконується, коли ми вводимо оператор if. Код ніколи не бачить команди для друку числа \(3\), оскільки він уже перейшов до наступної ітерації.

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

for i in range(5):
    loop_string = 'Я виходжу за межі циклу!'
    print('Я вічний! Я {0} і я існую скрізь!'.format(i))

print('Моє значення {0}'.format(i))
print(loop_string)

Я вічний! Я 0 і я існую скрізь!
Я вічний! Я 1 і я існую скрізь!
Я вічний! Я 2 і я існую скрізь!
Я вічний! Я 3 і я існую скрізь!
Я вічний! Я 4 і я існую скрізь!
Моє значення 4
Я виходжу за межі циклу!

Ми також можемо виконувати ітерації по словнику!

my_dict = {'firstname' : 'Inigo', 'lastname' : 'Montoya', 'nemesis' : 'Rugen'}

for key in my_dict:
    print(key)

firstname
lastname
nemesis

Якщо ми просто перебираємо словник, не роблячи нічого іншого, ми отримуємо лише ключі. Ми можемо або використовувати ключі для отримання значень, як у прикладі:

for key in my_dict:
    print(my_dict[key])

Inigo
Montoya
Rugen

Або ми можемо використовувати функцію items(), щоб отримати і ключ, і значення одночасно

for key, value in my_dict.items():
    print(key, ':', value)

firstname : Inigo
lastname : Montoya
nemesis : Rugen

Функція items створює кортеж з кожної пари ключ-значення, а цикл for розпаковує цей кортеж в ключ, значення при кожному окремому виконанні циклу!

B.8 Функції

Функція-це багаторазовий блок коду, який ви можете викликати повторно для виконання обчислень, виведення даних або дійсно робити все, що завгодно. Це один з ключових аспектів використання мови програмування. Щоб додати до вбудованих функцій у Python, ви можете визначити свої власні!

def hello_world():
    """ Виводить Hello, world! """
    print('Hello, world!')

hello_world()

Hello, world!

for i in range(5):
    hello_world()

Hello, world!
Hello, world!
Hello, world!
Hello, world!
Hello, world!

Функції визначаються за допомогою def, імені функції, списку параметрів та двокрапки. Все, що вказано з відступом нижче двокрапки, буде включено у визначення функції.

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

def see_the_scope():
    return "Я тут застряг!"

print(see_the_scope())

Я тут застряг!

a = see_the_scope()
print(a)

Я тут застряг!

Область змінної — це частина блоку коду, де ця змінна прив’язана до певного значення. Функції в Python мають закриту область дії, що робить можливим прямий доступ до змінних лише всередині цих областей. Якщо ми передамо ці значення оператору return, ми можемо отримати їх із функції.

def free_the_scope():
    in_function_string = "Anything you can do I can do better!"
    return in_function_string
my_string = free_the_scope()
print(my_string)

Anything you can do I can do better!

Так само, як ми можемо отримувати значення з функції, ми також можемо розміщувати значення у функції. Ми робимо це, визначаючи нашу функцію з параметрами.

def multiply_by_five(x):
    """ Множимо вхідне значення на 5 """
    return x * 5

n = 4
print(n)
print(multiply_by_five(n))

4
20

У цьому прикладі у нас був лише один параметр для нашої функції, x. Ми можемо легко ввести додаткові параметри, розділивши їх комами.

def calculate_area(length, width):
    """ Визначаємо площу прямокутника """
    return length * width

l = 5
w = 10
print('Area: ', calculate_area(l, w))
print('Length: ', l)
print('Width: ', w)

Area:  50
Length:  5
Width:  10

def calculate_volume(length, width, depth):
    """ Визначаємо об'єм прямокутної призми """
    return length * width * depth

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

def sum_values(*args):
    sum_val = 0
    for i in args:
        sum_val += i
    return sum_val

print(sum_values(1, 2, 3))
print(sum_values(10, 20, 30, 40, 50))
print(sum_values(4, 2, 5, 1, 10, 249, 25, 24, 13, 6, 4))

6
150
343

Використовуйте *args як параметр для вашої функції, коли ви не знаєте, скільки значень можна передати в неї, як у випадку з нашою функцією sum. Зірочка в даному випадку — це синтаксис, який повідомляє Python, що ви збираєтеся передати довільну кількість параметрів у свою функцію. Ці параметри зберігаються у вигляді кортежу.

def test_args(*args):
    print(type(args))

test_args(1, 2, 3, 4, 5, 6)

<class 'tuple'>

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

Тут ми визначаємо функцію, яка повертає логічне значення. Ми можемо легко використовувати це в поєднанні з операторами if та іншими ситуаціями, що потребують логічного значення.

def has_a_vowel(word):
    """
    Перевіряємо, чи містить слово голосну

    """
    vowel_list = ['a', 'e', 'i', 'o', 'u']

    for vowel in vowel_list:
        if vowel in word:
            return True

    return False

my_word = 'catnapping'
if has_a_vowel(my_word):
    print('Містить.')
else:
    print('Не містить.')

Містить.

def point_maker(x, y):
    """ Групує значення x і y в точку, технічно кортеж """
    return x, y

Ця наведена вище функція повертає впорядковану пару вхідних параметрів, збережених як кортеж.

a = point_maker(0, 10)
b = point_maker(5, 3)
def calculate_slope(point_a, point_b):
    """ Обчислює лінійний нахил між двома точками"""
    return (point_b[1] - point_a[1])/(point_b[0] - point_a[0])
print("Кут нахилу між a і b {0}".format(calculate_slope(a, b)))

Кут нахилу між a і b -1.4

B.9 Подальші кроки

Якщо ви хочете заглибитися в матеріал, зверніться до документації по Python.