Функції в Python: Повний посібник для початківців та не тільки

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

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

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

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

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

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

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

II. Вбудовані функції Python: Ваш основний інструментарій

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

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

• Функції для роботи з числами: Ці функції дозволяють виконувати математичні операції та отримувати інформацію про числа.

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

• Функції для перетворення типів: Ці функції дозволяють конвертувати дані з одного типу в інший.

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

• Функції для ітерування: Ці функції допомагають ефективно перебирати елементи послідовностей та інших ітерованих об'єктів.

• Функції для роботи з об'єктами: Ці функції надають інформацію про об'єкти та дозволяють виконувати певні операції над ними.

• Логічні функції: Ці функції використовуються для перевірки істинності значень в ітерованих об'єктах.

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

Зручний хостинг для ваших сайтів на WordPress

Так, це хвилинка реклами в тексті. Але корисної! Ну і мені хотілось би, щоб ви побачили :)

Шукаєте хороший хостинг для ваших сайтів на WordPress? Зверніть увагу на Host4Biz. Це надійний хостинг з сучасними серверами в Європі та українською командою.

А за промокодом MYHOST10 ви отримаєте знижку в 10% на першу оплату. Для цього реєструйтесь за посиланням та введіть код перед оплатою.

print()

Пояснення:

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

Ви можете передавати функції print() різні типи даних (рядки, числа, списки, тощо), і вона спробує їх адекватно відобразити. Також можна керувати роздільником між аргументами та символом завершення рядка за допомогою іменованих аргументів sep та end відповідно. Аргумент file дозволяє перенаправити вивід в інший файловий потік (наприклад, для запису в файл).

Приклад використання:

name = "Іван"
age = 30
print("Привіт,", name, "! Тобі", age, "років.")

print("Перший елемент", "другий елемент", "третій елемент", sep=", ")

print("Це перший рядок.", end=" ")
print("А це - продовження на тому ж рядку.")

Функція len()

Пояснення:

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

Для рядків len() повертає кількість символів у рядку. Для списків і кортежів вона повертає кількість елементів. Для словників len() повертає кількість пар "ключ-значення". Для множин вона повертає кількість унікальних елементів. Функція len() є дуже корисною для ітерації по колекціях, перевірки їх розміру та виконання інших операцій, що залежать від кількості елементів.

Приклад використання:

my_list = [10, 20, 30, 40, 50]
length_list = len(my_list)
print(f"Довжина списку: {length_list}")

my_string = "Python"
length_string = len(my_string)
print(f"Довжина рядка: {length_string}")

my_dict = {"a": 1, "b": 2, "c": 3}
length_dict = len(my_dict)
print(f"Кількість елементів у словнику: {length_dict}")

Функція type()

Пояснення:

Функція type() використовується для визначення типу об'єкта. Вона приймає один аргумент - об'єкт, тип якого потрібно дізнатися, і повертає об'єкт типу type, який представляє тип переданого аргументу.

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

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

Приклад використання:

x = 123
y = 3.14
z = "Привіт"
my_list = [1, 2, 3]
my_dict = {"key": "value"}

print(f"Тип змінної x: {type(x)}")
print(f"Тип змінної y: {type(y)}")
print(f"Тип змінної z: {type(z)}")
print(f"Тип змінної my_list: {type(my_list)}")
print(f"Тип змінної my_dict: {type(my_dict)}")

Також читайте HTML теги та атрибути: як вони працюють і що потрібно знати

Функція abs()

Пояснення:

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

Якщо аргументом є ціле число або число з плаваючою комою, abs() повертає його невід'ємне значення. Якщо аргументом є комплексне число, abs() повертає його модуль (величину). Модуль комплексного числа z=a+bi обчислюється як a2+b2​.

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

Приклад використання:

negative_number = -10
absolute_negative = abs(negative_number)
print(f"Абсолютне значення {negative_number}: {absolute_negative}")

positive_number = 5
absolute_positive = abs(positive_number)
print(f"Абсолютне значення {positive_number}: {absolute_positive}")

floating_point = -3.14
absolute_float = abs(floating_point)
print(f"Абсолютне значення {floating_point}: {absolute_float}")

complex_number = 3 + 4j
absolute_complex = abs(complex_number)
print(f"Модуль комплексного числа {complex_number}: {absolute_complex}")

Функція round()

Пояснення:

Функція round() використовується для округлення числа до вказаної кількості знаків після коми. Вона приймає два аргументи: першим є число, яке потрібно округлити, а другим (необов'язковим) - ціле число, що вказує на кількість знаків після коми.

Якщо другий аргумент не вказано або дорівнює None, функція повертає найближче ціле число. При округленні до цілого числа застосовується правило "округлення до найближчого парного числа" для значень, що знаходяться рівно посередині між двома цілими числами (наприклад, round(2.5) поверне 2, а round(3.5) поверне 4).

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

Функція round() є корисною для представлення чисел з певною точністю, наприклад, при відображенні фінансових даних або результатів наукових розрахунків.

Приклад використання:

number = 3.14159
rounded_pi_2_digits = round(number, 2)
print(f"{number} округлене до 2 знаків: {rounded_pi_2_digits}")

rounded_pi_integer = round(number)
print(f"{number} округлене до цілого: {rounded_pi_integer}")

number2 = 2.5
rounded_2_5 = round(number2)
print(f"{number2} округлене до цілого: {rounded_2_5}")

number3 = 3.5
rounded_3_5 = round(number3)
print(f"{number3} округлене до цілого: {rounded_3_5}")

negative_number = -4.7
rounded_negative = round(negative_number)
print(f"{negative_number} округлене до цілого: {rounded_negative}")

Функція pow()

Пояснення:

Функція pow() використовується для обчислення степеня числа. Вона може приймати два або три аргументи.

Якщо передано два аргументи (pow(base, exp)), функція повертає значення base, піднесене до степеня exp (baseexp).

Якщо передано три аргументи (pow(base, exp, mod)), функція повертає залишок від ділення (base ** exp) на mod ((baseexp(modmod))). Ця форма обчислення є більш ефективною для великих чисел і використовується в криптографії та інших областях.

Функція pow() є зручним способом для виконання операцій піднесення до степеня, особливо коли потрібен залишок від ділення.

Приклад використання:

base = 2
exponent = 3
result = pow(base, exponent)
print(f"{base} в степені {exponent} дорівнює: {result}")

base2 = 5
exponent2 = 2
modulus = 7
result_mod = pow(base2, exponent2, modulus)
print(f"({base2} в степені {exponent2}) % {modulus} дорівнює: {result_mod}")

negative_exponent = pow(2, -1)
print(f"2 в степені -1 дорівнює: {negative_exponent}")

Функція sum()

Пояснення:

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

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

Приклад використання:

numbers = [1, 2, 3, 4, 5]
total_sum = sum(numbers)
print(f"Сума елементів списку: {total_sum}")

numbers_tuple = (10, 20, 30)
sum_tuple = sum(numbers_tuple)
print(f"Сума елементів кортежу: {sum_tuple}")

numbers_with_start = [1, 2, 3]
sum_with_start = sum(numbers_with_start, 10)
print(f"Сума елементів списку з початковим значенням 10: {sum_with_start}")

empty_list = []
sum_empty = sum(empty_list)
print(f"Сума елементів порожнього списку: {sum_empty}")

Функція max()

Пояснення:

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

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

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

Приклад використання:

numbers = [3, 1, 4, 1, 5, 9, 2, 6]
maximum_number = max(numbers)
print(f"Найбільше число в списку: {maximum_number}")

numbers_tuple = (10, 5, 20)
maximum_tuple = max(numbers_tuple)
print(f"Найбільше число в кортежі: {maximum_tuple}")

string1 = "apple"
string2 = "banana"
maximum_string = max(string1, string2)
print(f"Найбільший рядок (за алфавітним порядком): {maximum_string}")

words = ["apple", "banana", "kiwi"]
longest_word = max(words, key=len)
print(f"Найдовше слово: {longest_word}")

empty_list = []
max_empty = max(empty_list, default="Список порожній")
print(f"Максимум в порожньому списку: {max_empty}")

Функція min()

Пояснення:

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

Подібно до max(), якщо функції передається один ітерований об'єкт, вона повертає найменший елемент серед його елементів. Якщо передається кілька аргументів, функція повертає найменший з цих аргументів.

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

Приклад використання:

numbers = [3, 1, 4, 1, 5, 9, 2, 6]
minimum_number = min(numbers)
print(f"Найменше число в списку: {minimum_number}")

numbers_tuple = (10, 5, 20)
minimum_tuple = min(numbers_tuple)
print(f"Найменше число в кортежі: {minimum_tuple}")

string1 = "apple"
string2 = "banana"
minimum_string = min(string1, string2)
print(f"Найменший рядок (за алфавітним порядком): {minimum_string}")

words = ["apple", "banana", "kiwi"]
shortest_word = min(words, key=len)
print(f"Найкоротше слово: {shortest_word}")

empty_list = []
min_empty = min(empty_list, default="Список порожній")
print(f"Мінімум в порожньому списку: {min_empty}")

Функція sorted()

Пояснення:

Функція sorted() використовується для сортування елементів ітерованого об'єкта (такого як список, кортеж або рядок) та повертає новий відсортований список. На відміну від методу sort() списків, який змінює сам список на місці, sorted() створює новий відсортований список, залишаючи оригінальний об'єкт незмінним.

Функція sorted() приймає три необов'язкові аргументи:

• key: Функція, яка буде викликана для кожного елемента перед порівнянням. Результат цієї функції буде використаний як ключ сортування.

• reverse: Логічне значення. Якщо True, список буде відсортовано у зворотному порядку (від найбільшого до найменшого). За замовчуванням має значення False (сортування за зростанням).

Функція sorted() є дуже гнучкою і дозволяє сортувати дані різними способами залежно від потреб.

Приклад використання:

numbers = [3, 1, 4, 1, 5, 9, 2, 6]
sorted_numbers = sorted(numbers)
print(f"Відсортований список чисел: {sorted_numbers}")

numbers_reversed = sorted(numbers, reverse=True)
print(f"Відсортований список чисел у зворотному порядку: {numbers_reversed}")

words = ["apple", "banana", "kiwi"]
sorted_words_by_length = sorted(words, key=len)
print(f"Відсортовані слова за довжиною: {sorted_words_by_length}")

strings_case_insensitive = ["Apple", "banana", "Kiwi"]
sorted_case_insensitive = sorted(strings_case_insensitive, key=str.lower)
print(f"Відсортовані рядки без урахування регістру: {sorted_case_insensitive}")

tuple_of_tuples = [(1, 'b'), (3, 'a'), (2, 'c')]
sorted_by_second_element = sorted(tuple_of_tuples, key=lambda item: item[1])
print(f"Відсортований кортеж кортежів за другим елементом: {sorted_by_second_element}")

Функція int()

Пояснення:

Функція int() використовується для перетворення значення на ціле число. Вона може приймати один або два аргументи.

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

Якщо передано два аргументи, перший аргумент повинен бути рядком, а другий - цілим числом, що представляє основу системи числення (наприклад, 2 для двійкової, 10 для десяткової, 16 для шістнадцяткової). У цьому випадку функція намагається перетворити рядок у ціле число у вказаній системі числення.

Функція int() є важливою для роботи з числовими даними, особливо при отриманні вхідних даних від користувача (які часто є рядками) або при обробці даних з різних джерел.

Приклад використання:

float_number = 3.14159
integer_from_float = int(float_number)
print(f"Ціле число з {float_number}: {integer_from_float}")

string_number = "123"
integer_from_string = int(string_number)
print(f"Ціле число з рядка '{string_number}': {integer_from_string}")

binary_string = "101101"
integer_from_binary = int(binary_string, 2)
print(f"Ціле число з двійкового рядка '{binary_string}': {integer_from_binary}")

hex_string = "FF"
integer_from_hex = int(hex_string, 16)
print(f"Ціле число з шістнадцяткового рядка '{hex_string}': {integer_from_hex}")

negative_float = -2.7
integer_from_negative_float = int(negative_float)
print(f"Ціле число з {negative_float}: {integer_from_negative_float}")

Функція float()

Пояснення:

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

Якщо аргумент є цілим числом, рядком, що представляє дійсне число, або об'єктом, що реалізує метод __float__(), функція повертає відповідне число з плаваючою комою. Рядок може містити десяткову крапку, знак (плюс або мінус), а також експоненційну частину (наприклад, "3.14e-5").

Якщо аргумент не передано, функція повертає 0.0.

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

Приклад використання:

integer_number = 10
float_from_int = float(integer_number)
print(f"Число з плаваючою комою з {integer_number}: {float_from_int}")

string_float = "3.14159"
float_from_string = float(string_float)
print(f"Число з плаваючою комою з рядка '{string_float}': {float_from_string}")

exponential_string = "-2.718e2"
float_from_exponential = float(exponential_string)
print(f"Число з плаваючою комою з рядка '{exponential_string}': {float_from_exponential}")

no_argument = float()
print(f"Виклик float() без аргументів: {no_argument}")

Функція str()

Пояснення:

Функція str() використовується для створення рядкового представлення об'єкта. Вона приймає один необов'язковий аргумент - об'єкт, який потрібно перетворити на рядок.

Якщо аргумент не передано, функція повертає порожній рядок (""). Якщо передано будь-який інший об'єкт, str() викликає метод __str__() цього об'єкта (якщо він визначений) для отримання його рядкового представлення. Для вбудованих типів Python надає стандартні рядкові представлення.

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

Приклад використання:

integer_number = 123
string_from_int = str(integer_number)
print(f"Рядок з цілого числа {integer_number}: {string_from_int}, тип: {type(string_from_int)}")

float_number = 3.14159
string_from_float = str(float_number)
print(f"Рядок з числа з плаваючою комою {float_number}: {string_from_float}, тип: {type(string_from_float)}")

my_list = [1, 2, 3]
string_from_list = str(my_list)
print(f"Рядок зі списку {my_list}: {string_from_list}, тип: {type(string_from_list)}")

my_dict = {"a": 1, "b": 2}
string_from_dict = str(my_dict)
print(f"Рядок зі словника {my_dict}: {string_from_dict}, тип: {type(string_from_dict)}")

no_argument = str()
print(f"Виклик str() без аргументів: '{no_argument}'")

Функція list()

Пояснення:

Функція list() використовується для створення нового об'єкта-списку. Вона може бути викликана без аргументів або з одним аргументом, який має бути ітерованим об'єктом (наприклад, рядком, кортежем, множиною, іншим списком або генератором).

Якщо list() викликається без аргументів, вона повертає порожній список ([]).

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

Функція list() є корисною для перетворення послідовностей або колекцій в змінювані списки, що дозволяє додавати, видаляти або змінювати їхні елементи.

Приклад використання:

# Створення порожнього списку
empty_list = list()
print(f"Порожній список: {empty_list}, тип: {type(empty_list)}")

# Перетворення рядка на список символів
my_string = "hello"
list_from_string = list(my_string)
print(f"Список з рядка '{my_string}': {list_from_string}")

# Перетворення кортежу на список
my_tuple = (1, 2, 3)
list_from_tuple = list(my_tuple)
print(f"Список з кортежу {my_tuple}: {list_from_tuple}")

# Перетворення множини на список (порядок елементів може не зберігатися)
my_set = {3, 1, 2}
list_from_set = list(my_set)
print(f"Список з множини {my_set}: {list_from_set}")

# Створення копії існуючого списку
original_list = [4, 5, 6]
copied_list = list(original_list)
copied_list.append(7)
print(f"Оригінальний список: {original_list}")
print(f"Скопійований список: {copied_list}")

Функція tuple()

Пояснення:

Функція tuple() використовується для створення нового об'єкта-кортежу. Подібно до list(), вона може бути викликана без аргументів або з одним аргументом, який має бути ітерованим об'єктом.

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

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

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

Приклад використання:

# Створення порожнього кортежу
empty_tuple = tuple()
print(f"Порожній кортеж: {empty_tuple}, тип: {type(empty_tuple)}")

# Перетворення рядка на кортеж символів
my_string = "world"
tuple_from_string = tuple(my_string)
print(f"Кортеж з рядка '{my_string}': {tuple_from_string}")

# Перетворення списку на кортеж
my_list = [7, 8, 9]
tuple_from_list = tuple(my_list)
print(f"Кортеж зі списку {my_list}: {tuple_from_list}")

# Перетворення множини на кортеж (порядок елементів може не зберігатися)
my_set = {9, 7, 8}
tuple_from_set = tuple(my_set)
print(f"Кортеж з множини {my_set}: {tuple_from_set}")

# Створення кортежу з іншого кортежу (фактично створення копії)
original_tuple = (10, 11, 12)
copied_tuple = tuple(original_tuple)
print(f"Оригінальний кортеж: {original_tuple}")
print(f"Скопійований кортеж: {copied_tuple}")

Функція set()

Пояснення:

Функція set() використовується для створення нового об'єкта-множини. Множина є невпорядкованою колекцією унікальних елементів. Подібно до list() та tuple(), set() може бути викликана без аргументів або з одним ітерованим аргументом.

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

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

Функція set() є корисною для видалення дублікатів з послідовностей, виконання математичних операцій над множинами (об'єднання, перетин, різниця) та перевірки наявності елемента в колекції.

Приклад використання:

# Створення порожньої множини
empty_set = set()
print(f"Порожня множина: {empty_set}, тип: {type(empty_set)}")

# Створення множини з рядка (унікальні символи)
my_string = "abracadabra"
set_from_string = set(my_string)
print(f"Множина з рядка '{my_string}': {set_from_string}")

# Створення множини зі списку (видалення дублікатів)
my_list = [1, 2, 2, 3, 3, 3]
set_from_list = set(my_list)
print(f"Множина зі списку {my_list}: {set_from_list}")

# Створення множини з кортежу
my_tuple = (4, 5, 5, 6)
set_from_tuple = set(my_tuple)
print(f"Множина з кортежу {my_tuple}: {set_from_tuple}")

# Створення копії існуючої множини
original_set = {7, 8, 9}
copied_set = set(original_set)
copied_set.add(10)
print(f"Оригінальна множина: {original_set}")
print(f"Скопійована множина: {copied_set}")

Функція dict()

Пояснення:

Функція dict() використовується для створення нового об'єкта-словника. Словник є невпорядкованою колекцією пар "ключ-значення", де кожен ключ повинен бути унікальним і незмінюваним. Функцію dict() можна викликати різними способами:

• Без аргументів: Створює порожній словник ({}).

• З одним аргументом, який є іншим словником: Створює копію цього словника.

• З одним аргументом, який є ітерованим об'єктом: Елементи цього об'єкта повинні бути парами (наприклад, кортежами з двох елементів), де перший елемент є ключем, а другий - значенням.

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

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

Приклад використання:

# Створення порожнього словника
empty_dict = dict()
print(f"Порожній словник: {empty_dict}, тип: {type(empty_dict)}")

# Створення словника зі списку кортежів
list_of_tuples = [('a', 1), ('b', 2), ('c', 3)]
dict_from_tuples = dict(list_of_tuples)
print(f"Словник зі списку кортежів: {dict_from_tuples}")

# Створення словника з кортежу списків
tuple_of_lists = (['d', 4], ['e', 5])
dict_from_lists = dict(tuple_of_lists)
print(f"Словник з кортежу списків: {dict_from_lists}")

# Створення словника за допомогою іменованих аргументів
named_dict = dict(name='Alice', age=30, city='New York')
print(f"Словник з іменованих аргументів: {named_dict}")

# Створення копії існуючого словника
original_dict = {'x': 10, 'y': 20}
copied_dict = dict(original_dict)
copied_dict['z'] = 30
print(f"Оригінальний словник: {original_dict}")
print(f"Скопійований словник: {copied_dict}")

Функція bool()

Пояснення:

Функція bool() використовується для перетворення значення на логічний тип даних (True або False). Вона приймає один необов'язковий аргумент.

Якщо аргумент не передано, функція повертає False.

Якщо передано будь-який об'єкт, bool() визначає його "істинність". За замовчуванням більшість об'єктів вважаються "істинними". Об'єкти, які вважаються "хибними":

• False

• None

• Числові нулі (наприклад, 0, 0.0, 0j)

• Порожні послідовності (наприклад, "", [], ())

• Порожні колекції (наприклад, {}, set())

• Об'єкти, у яких визначено метод __bool__(), що повертає False, або метод __len__(), що повертає 0.

Функція bool() є ключовою для виконання логічних операцій, умовних перевірок та керування потоком виконання програми.

Приклад використання:

print(f"bool(10): {bool(10)}")
print(f"bool(0): {bool(0)}")
print(f"bool(-5): {bool(-5)}")
print(f"bool(3.14): {bool(3.14)}")
print(f"bool(0.0): {bool(0.0)}")
print(f"bool('hello'): {bool('hello')}")
print(f"bool(''): {bool('')}")
print(f"bool([1, 2]): {bool([1, 2])}")
print(f"bool([]): {bool([])}")
print(f"bool({'a': 1}): {bool({'a': 1})}")
print(f"bool({}): {bool({})}")
print(f"bool(None): {bool(None)}")
print(f"bool(True): {bool(True)}")
print(f"bool(False): {bool(False)}")

Функція input()

Пояснення:

Функція input() використовується для зчитування рядка тексту зі стандартного пристрою введення (зазвичай з клавіатури). Коли викликається input(), програма зупиняє своє виконання та очікує, доки користувач не введе текст і не натисне клавішу Enter. Введений користувачем текст повертається функцією як рядок.

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

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

Приклад використання:

name = input("Будь ласка, введіть ваше ім'я: ")
print(f"Привіт, {name}!")

age_str = input("Будь ласка, введіть ваш вік: ")
try:
    age = int(age_str)
    print(f"Ваш вік: {age} років.")
except ValueError:
    print("Некоректний формат віку. Будь ласка, введіть ціле число.")

city = input()
print(f"Ви ввели місто: {city}")

Функція range()

Пояснення:

Функція range() використовується для створення незмінюваної послідовності чисел. Найчастіше вона застосовується у циклах for для ітерації певної кількості разів або для генерації послідовності індексів.

Функція range() може приймати від одного до трьох цілочисельних аргументів:

• range(stop): Створює послідовність чисел від 0 (включно) до stop (виключно) з кроком 1.

• range(start, stop): Створює послідовність чисел від start (включно) до stop (виключно) з кроком 1.

• range(start, stop, step): Створює послідовність чисел від start (включно) до stop (виключно) з кроком step. Крок може бути як позитивним, так і негативним.

Важливо зазначити, що range() не створює одразу список усіх чисел у пам'яті. Замість цього вона генерує числа по одному в міру потреби, що робить її дуже ефективною для роботи з великими послідовностями. Щоб отримати фактичний список чисел, можна перетворити результат range() на список за допомогою функції list().

Приклад використання:

# Ітерація від 0 до 4
for i in range(5):
    print(i)

# Ітерація від 2 до 5
for j in range(2, 6):
    print(j)

# Ітерація від 1 до 10 з кроком 2
for k in range(1, 11, 2):
    print(k)

# Ітерація у зворотному порядку
for l in range(10, 0, -1):
    print(l)

# Створення списку чисел за допомогою range()
numbers = list(range(3))
print(f"Список чисел: {numbers}")

Функція enumerate()

Пояснення:

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

Функція enumerate() приймає два аргументи:

• iterable: Ітерований об'єкт, по якому потрібно пройтися.

• start (необов'язковий): Ціле число, що вказує, з якого значення починати індексацію. За замовчуванням start дорівнює 0.

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

Приклад використання:

my_list = ["яблуко", "банан", "вишня"]

# Ітерація з індексами, починаючи з 0 (за замовчуванням)
for index, fruit in enumerate(my_list):
    print(f"Індекс: {index}, Фрукт: {fruit}")

print("-" * 20)

# Ітерація з індексами, починаючи з 1
for index, fruit in enumerate(my_list, start=1):
    print(f"Номер: {index}, Фрукт: {fruit}")

print("-" * 20)

my_string = "Python"
for index, char in enumerate(my_string):
    print(f"Індекс {index}: Символ '{char}'")

Функція zip()

Пояснення:

Функція zip() використовується для об'єднання елементів з кількох ітерованих об'єктів (таких як списки, кортежі) в один ітератор кортежів. Вона приймає довільну кількість ітерованих об'єктів як аргументи.

Ітератор, який повертає zip(), видає кортежі, де i-тий елемент кожного кортежу є i-тим елементом відповідного вхідного ітерованого об'єкта. Ітерація триває до тих пір, поки не буде вичерпано найкоротший з переданих ітерованих об'єктів. Елементи довших ітерованих об'єктів після цього ігноруються.

Функція zip() є корисною для паралельної обробки елементів з різних послідовностей, наприклад, для створення словників з двох списків (один для ключів, інший для значень) або для виконання поелементних операцій над кількома наборами даних.

Приклад використання:

names = ["Alice", "Bob", "Charlie"]
ages = [30, 25, 35]
cities = ["New York", "London", "Paris"]

# Об'єднання трьох списків
combined = zip(names, ages, cities)
for name, age, city in combined:
    print(f"{name} is {age} years old and lives in {city}.")

print("-" * 20)

# Об'єднання двох списків для створення словника
keys = ["a", "b", "c"]
values = [1, 2, 3]
my_dict = dict(zip(keys, values))
print(f"Створений словник: {my_dict}")

print("-" * 20)

# Випадок з різною довжиною списків
list1 = [1, 2, 3, 4]
list2 = ["one", "two", "three"]
zipped_short = zip(list1, list2)
for item1, item2 in zipped_short:
    print(f"Елемент 1: {item1}, Елемент 2: {item2}")

Функція iter()

Пояснення:

Функція iter() використовується для отримання об'єкта-ітератора з ітерованого об'єкта (такого як список, кортеж, рядок, словник, множина або будь-який об'єкт, що реалізує методи __iter__() або __getitem__()).

Вона має два можливі синтаксиси:

1. iter(object): Якщо передано один аргумент, який є ітерованим об'єктом, iter() повертає ітератор для цього об'єкта. Ітератор - це об'єкт, який дозволяє послідовно перебирати елементи ітерованого об'єкта за допомогою функції next().

2. iter(callable, sentinel): Якщо передано два аргументи, перший аргумент callable повинен бути об'єктом, який можна викликати (наприклад, функція або метод), а другий аргумент sentinel є "сторожовим" значенням. У цьому випадку iter() створює ітератор, який викликає callable без аргументів для кожного запиту на наступний елемент. Ітерація триває до тих пір, поки викликаний об'єкт не поверне значення, рівне sentinel. Коли це відбувається, виникає виняток StopIteration, і ітерація завершується.

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

Приклад використання (перша форма):

my_list = [10, 20, 30]
my_iterator = iter(my_list)

print(next(my_iterator))
print(next(my_iterator))
print(next(my_iterator))

# Спроба отримати наступний елемент після вичерпання ітератора призведе до StopIteration
# print(next(my_iterator))

Приклад використання (друга форма):

def counter():
    n = 0
    while n < 5:
        n += 1
        return n

my_iter = iter(counter, 3)

print(next(my_iter)) # поверне 1
print(next(my_iter)) # поверне 2
# наступний виклик counter() поверне 3, що дорівнює sentinel, тому виникне StopIteration
# print(next(my_iter))

Функція next()

Пояснення:

Функція next() використовується для отримання наступного елемента з об'єкта-ітератора. Вона приймає один або два аргументи:

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

2. next(iterator, default): Якщо передано два аргументи, перший аргумент є ітератором, а другий - значенням за замовчуванням (default). У цьому випадку next() намагається повернути наступний елемент з ітератора. Якщо ітератор вичерпано, замість виникнення винятку StopIteration, функція повертає значення default.

Функція next() є основним способом ручного отримання елементів з ітератора, який був створений за допомогою функції iter() або є результатом іншої операції, що повертає ітератор (наприклад, map(), filter(), zip()).

Приклад використання (один аргумент):

my_list = [100, 200, 300]
my_iterator = iter(my_list)

first_element = next(my_iterator)
print(f"Перший елемент: {first_element}")

second_element = next(my_iterator)
print(f"Другий елемент: {second_element}")

third_element = next(my_iterator)
print(f"Третій елемент: {third_element}")

# Спроба отримати наступний елемент призведе до StopIteration
# next(my_iterator)

Приклад використання (два аргументи):

my_list = [1, 2]
my_iterator = iter(my_list)

first = next(my_iterator, None)
print(f"Перший: {first}")

second = next(my_iterator, None)
print(f"Другий: {second}")

third = next(my_iterator, None)
print(f"Третій (за замовчуванням): {third}")

fourth = next(my_iterator, "Кінець ітерації")
print(f"Четвертий (за замовчуванням): {fourth}")

Функція id()

Пояснення:

Функція id() повертає унікальну ідентичність об'єкта. Це ціле число, яке гарантовано є унікальним для даного об'єкта протягом його існування. Однак, два об'єкти з непересічними періодами життя можуть мати однакове значення id().

По суті, id() повертає адресу об'єкта в пам'яті (хоча це залежить від конкретної реалізації Python і може не бути прямою фізичною адресою). Ви можете використовувати id() для перевірки, чи дві змінні посилаються на один і той самий об'єкт у пам'яті. Це відрізняється від перевірки на рівність значень (==).

Функція id() є корисною для розуміння того, як Python керує об'єктами в пам'яті, особливо при роботі зі змінними та присвоєннями.

Приклад використання:

x = [1, 2, 3]
y = x
z = [1, 2, 3]

print(f"id(x): {id(x)}")
print(f"id(y): {id(y)}")
print(f"id(z): {id(z)}")

# x та y посилаються на один і той самий об'єкт
print(f"x is y: {x is y}")

# x та z мають однакові значення, але є різними об'єктами
print(f"x == z: {x == z}")
print(f"x is z: {x is z}")

a = 10
b = 10
print(f"id(a): {id(a)}")
print(f"id(b): {id(b)}")
# Для невеликих незмінних об'єктів Python може використовувати оптимізацію
# і змусити кілька змінних посилатися на один і той самий об'єкт
print(f"a is b: {a is b}")

Функція isinstance()

Пояснення:

Функція isinstance() використовується для перевірки, чи є об'єкт екземпляром певного класу (або підкласу) чи одного з типів, зазначених у кортежі. Вона приймає два аргументи:

• object: Об'єкт, який потрібно перевірити.

• classinfo: Клас, кортеж класів або тип. Функція поверне True, якщо object є екземпляром classinfo або його підкласом, інакше - False.

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

Приклад використання:

x = 10
y = "hello"
z = [1, 2, 3]

print(f"isinstance(x, int): {isinstance(x, int)}")
print(f"isinstance(y, str): {isinstance(y, str)}")
print(f"isinstance(z, list): {isinstance(z, list)}")

print(f"isinstance(x, float): {isinstance(x, float)}")
print(f"isinstance(y, (int, float)): {isinstance(y, (int, float))}")
print(f"isinstance(z, (list, tuple)): {isinstance(z, (list, tuple))}")

class MyClass:
    pass

obj = MyClass()
print(f"isinstance(obj, MyClass): {isinstance(obj, MyClass)}")
print(f"isinstance(obj, object): {isinstance(obj, object)}") # Всі класи є підкласами object

Функція hasattr()

Пояснення:

Функція hasattr() використовується для перевірки, чи має об'єкт вказаний атрибут (метод або змінну-член). Вона приймає два аргументи:

• object: Об'єкт, який потрібно перевірити.

• name: Рядок, що представляє ім'я атрибута, існування якого потрібно перевірити.

Функція повертає True, якщо об'єкт має атрибут з вказаним ім'ям, і False в іншому випадку.

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

Приклад використання:

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def greet(self):
        print(f"Привіт, мене звати {self.name}")

person = Person("Alice", 30)

print(f"Чи має person атрибут 'name'? {hasattr(person, 'name')}")
print(f"Чи має person атрибут 'greet'? {hasattr(person, 'greet')}")
print(f"Чи має person атрибут 'city'? {hasattr(person, 'city')}")

my_list = [1, 2, 3]
print(f"Чи має my_list атрибут 'append'? {hasattr(my_list, 'append')}")
print(f"Чи має my_list атрибут 'size'? {hasattr(my_list, 'size')}")

Функція getattr()

Пояснення:

Функція getattr() використовується для отримання значення атрибута об'єкта за його ім'ям (яке передається у вигляді рядка). Вона приймає два або три аргументи:

• object: Об'єкт, атрибут якого потрібно отримати.

• name: Рядок, що представляє ім'я атрибута.

• default (необов'язковий): Значення, яке буде повернуто, якщо об'єкт не має атрибута з вказаним ім'ям. Якщо цей аргумент не вказано і атрибут не знайдено, виникає виняток AttributeError.

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

Приклад використання:

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def distance_from_origin(self):
        return (self.x**2 + self.y**2)**0.5

point = Point(3, 4)

print(f"Координата x: {getattr(point, 'x')}")
print(f"Метод distance_from_origin: {getattr(point, 'distance_from_origin')()}")

# Спроба отримати відсутній атрибут без default призведе до AttributeError
# print(getattr(point, 'z'))

# Отримання відсутнього атрибута з default значенням
color = getattr(point, 'color', 'black')
print(f"Колір точки: {color}")

Функція setattr()

Пояснення:

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

• object: Об'єкт, атрибут якого потрібно встановити або створити.

• name: Рядок, що представляє ім'я атрибута.

• value: Значення, яке потрібно присвоїти атрибуту.

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

Приклад використання:

class Person:
    def __init__(self, name):
        self.name = name

person = Person("Bob")
print(f"Ім'я до зміни: {person.name}")

# Встановлення існуючого атрибута
setattr(person, 'name', 'Charlie')
print(f"Ім'я після зміни: {person.name}")

# Створення нового атрибута
setattr(person, 'age', 25)
print(f"Вік: {person.age}")

# Створення нового методу (потрібно бути обережним)
def greet(self):
    print(f"Привіт від {self.name}!")

setattr(Person, 'greet', greet)
person.greet()

Функція delattr()

Пояснення:

Функція delattr() використовується для видалення існуючого атрибута (методу або змінної-члена) з об'єкта. Вона приймає два аргументи:

• object: Об'єкт, атрибут якого потрібно видалити.

• name: Рядок, що представляє ім'я атрибута, який потрібно видалити.

Якщо об'єкт не має атрибута з вказаним ім'ям, функція викликає виняток AttributeError.

delattr() дозволяє динамічно змінювати структуру об'єктів, видаляючи непотрібні атрибути під час виконання програми.

Приклад використання:

class Car:
    def __init__(self, model, color):
        self.model = model
        self.color = color
        self.engine_on = False

    def start_engine(self):
        self.engine_on = True

my_car = Car("Toyota", "red")
print(f"Модель: {my_car.model}, Колір: {my_car.color}, Двигун увімкнено: {my_car.engine_on}")

# Видалення атрибута color
delattr(my_car, 'color')
try:
    print(f"Колір: {my_car.color}")
except AttributeError:
    print("Атрибут 'color' був видалений.")

# Видалення методу (потрібно бути обережним)
delattr(Car, 'start_engine')
try:
    my_car.start_engine()
except AttributeError:
    print("Метод 'start_engine' був видалений з класу Car.")

Функція vars()

Пояснення:

Функція vars() повертає словник, що містить атрибути об'єкта та їхні значення. Вона приймає один необов'язковий аргумент:

• Якщо аргумент є об'єктом (наприклад, екземпляр класу, модуль), vars() повертає його атрибут __dict__. Цей атрибут є словником, що зберігає простір імен об'єкта.

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

Функція vars() є корисною для інтроспекції об'єктів, тобто для отримання інформації про їхню внутрішню структуру та стан під час виконання програми.

Приклад використання (з об'єктом):

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

person = Person("Charlie", 35)
person.city = "London"

attributes = vars(person)
print(f"Атрибути об'єкта person: {attributes}")
print(f"Ім'я: {attributes['name']}")
print(f"Вік: {attributes['age']}")
print(f"Місто: {attributes.get('city')}")

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

def my_function():
    local_var = 10
    result = local_var * 2
    local_vars = vars()
    print(f"Локальні змінні у функції: {local_vars}")

my_function()

global_var = "global value"
print(f"Глобальні змінні: {vars()}")

Функція dir()

Пояснення:

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

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

Функція dir() є потужним інструментом для дослідження об'єктів та розуміння їхнього вмісту та можливостей. Вона особливо корисна в інтерактивному режимі Python для швидкого огляду доступних атрибутів об'єкта.

Приклад використання (з об'єктом):

class MyClass:
    class_attribute = "class_value"

    def __init__(self, instance_attribute):
        self.instance_attribute = instance_attribute

    def my_method(self):
        pass

obj = MyClass("instance_value")

attributes = dir(obj)
print("Атрибути об'єкта obj:")
for attr in attributes:
    print(attr)

print("-" * 20)

list_attributes = dir([])
print("Атрибути об'єкта list:")
# Виведе багато вбудованих методів списку
# for attr in list_attributes:
#     print(attr)
print(f"Кількість атрибутів списку: {len(list_attributes)}")

Функція all()

Пояснення:

Функція all() приймає один аргумент, який має бути ітерованим об'єктом (наприклад, список, кортеж, множина). Вона повертає True, якщо всі елементи в переданому ітерованому об'єкті є істинними (або якщо ітерований об'єкт порожній).

Елемент вважається істинним, якщо його значення є істинним у булевому контексті (наприклад, будь-яке ненульове число, непорожній рядок або колекція). Якщо хоча б один елемент в ітерованому об'єкті є хибним (наприклад, False, None, 0, порожній рядок або колекція), функція all() поверне False.

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

Приклад використання:

list1 = [True, True, True]
print(f"all(list1): {all(list1)}")

list2 = [True, False, True]
print(f"all(list2): {all(list2)}")

list3 = [1, 2, 3]
print(f"all(list3): {all(list3)}") # Всі ненульові числа - істинні

list4 = [0, 1, 2]
print(f"all(list4): {all(list4)}") # 0 - хибне значення

list5 = ["hello", "world"]
print(f"all(list5): {all(list5)}") # Непорожні рядки - істинні

list6 = ["", "world"]
print(f"all(list6): {all(list6)}") # Порожній рядок - хибне значення

empty_list = []
print(f"all(empty_list): {all(empty_list)}") # Порожній ітерований об'єкт повертає True

Функція any()

Пояснення:

Функція any() приймає один аргумент, який також має бути ітерованим об'єктом. Вона повертає True, якщо хоча б один елемент у переданому ітерованому об'єкті є істинним. Якщо всі елементи в ітерованому об'єкті є хибними (або якщо ітерований об'єкт порожній), функція any() поверне False.

Подібно до all(), any() оцінює "істинність" кожного елемента в булевому контексті. Вона припиняє перевірку, як тільки знаходить перший істинний елемент.

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

Приклад використання:

list1 = [False, False, True]
print(f"any(list1): {any(list1)}")

list2 = [False, False, False]
print(f"any(list2): {any(list2)}")

list3 = [0, 0, 1]
print(f"any(list3): {any(list3)}") # 1 - істинне значення

list4 = [0, 0, 0]
print(f"any(list4): {any(list4)}") # Всі нулі - хибні значення

list5 = ["", "world"]
print(f"any(list5): {any(list5)}") # Непорожній рядок - істинне значення

list6 = ["", ""]
print(f"any(list6): {any(list6)}") # Всі порожні рядки - хибні значення

empty_list = []
print(f"any(empty_list): {any(empty_list)}") # Порожній ітерований об'єкт повертає False

Звісно! Переходимо до наступного розділу нашого плану:

III. Користувацькі функції: Створення власного коду

Пояснення:

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

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

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

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

Синтаксис визначення функції:

def ім'я_функції(параметр1, параметр2, ...):
    # Тіло функції (код, який виконується)
    return значення  # Необов'язково

Аргументи та параметри:

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

Існує кілька способів передачі аргументів у функцію:

• Позиційні аргументи: Аргументи передаються функції в тому ж порядку, в якому визначені відповідні параметри. Python зіставляє перший аргумент з першим параметром, другий аргумент з другим параметром і так далі.

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

• Аргументи за замовчуванням: Під час визначення функції можна задати для деяких параметрів значення за замовчуванням. Якщо при виклику функції для такого параметра не буде передано аргумент, буде використано значення за замовчуванням. Параметри зі значеннями за замовчуванням повинні йти після параметрів без значень за замовчуванням.

• Аргументи зі змінною кількістю (*args): Цей синтаксис дозволяє функції приймати довільну кількість позиційних аргументів. Усі передані позиційні аргументи збираються в кортеж, який стає значенням параметра args.

• Аргументи зі змінною кількістю (**kwargs): Цей синтаксис дозволяє функції приймати довільну кількість ключових аргументів. Усі передані ключові аргументи збираються в словник, де ключами є імена аргументів, а значеннями - їхні значення.

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

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

def greet(name, greeting="Привіт"):
    """Вітає користувача з заданим ім'ям та привітанням."""
    print(f"{greeting}, {name}!")

# Позиційні аргументи
greet("Іван")  # Виведе: Привіт, Іван!
greet("Марія", "Доброго ранку")  # Виведе: Доброго ранку, Марія!

# Ключові аргументи
greet(name="Петро")  # Виведе: Привіт, Петро!
greet(greeting="Вітаю", name="Ольга")  # Виведе: Вітаю, Ольга!

def sum_all(*args):
    """Повертає суму всіх переданих позиційних аргументів."""
    total = 0
    for num in args:
        total += num
    return total

print(f"Сума: {sum_all(1, 2, 3)}")  # Виведе: Сума: 6
print(f"Сума: {sum_all(10, 20, 30, 40)}")  # Виведе: Сума: 100

def print_info(**kwargs):
    """Виводить інформацію, передану як ключові аргументи."""
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info(name="Світлана", age=28, city="Київ")
# Виведе:
# name: Світлана
# age: 28
# city: Київ

Повернення значень за допомогою return:

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

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

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

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

Приклад використання return:

def add(x, y):
    """Повертає суму двох чисел."""
    result = x + y
    return result

sum_result = add(5, 3)
print(f"Сума: {sum_result}")  # Виведе: Сума: 8

def is_even(number):
    """Повертає True, якщо число парне, і False - якщо непарне."""
    if number % 2 == 0:
        return True
    else:
        return False

print(f"Чи 10 парне? {is_even(10)}")  # Виведе: Чи 10 парне? True
print(f"Чи 7 парне? {is_even(7)}")   # Виведе: Чи 7 парне? False

def get_name_and_age(name, age):
    """Повертає ім'я та вік у вигляді кортежу."""
    return name, age

person_info = get_name_and_age("Олена", 22)
print(f"Інформація про особу: {person_info}")  # Виведе: Інформація про особу: ('Олена', 22)
name, age = get_name_and_age("Віктор", 40)
print(f"Ім'я: {name}, Вік: {age}")  # Виведе: Ім'я: Віктор, Вік: 40

def no_return_value(message):
    """Виводить повідомлення на екран."""
    print(message)

result = no_return_value("Це повідомлення від функції.")
print(f"Результат функції без return: {result}")  # Виведе: Результат функції без return: None

Приклади створення та використання простих користувацьких функцій:

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

Приклад 1: Функція для обчислення площі прямокутника.

def calculate_rectangle_area(length, width):
    """Повертає площу прямокутника."""
    area = length * width
    return area

# Використання функції
rectangle_length = 5
rectangle_width = 10
rectangle_area = calculate_rectangle_area(rectangle_length, rectangle_width)
print(f"Площа прямокутника зі сторонами {rectangle_length} та {rectangle_width} дорівнює: {rectangle_area}")

У цьому прикладі ми визначили функцію calculate_rectangle_area, яка приймає два параметри (length та width) і повертає їхній добуток, що є площею прямокутника. Потім ми викликаємо цю функцію з конкретними значеннями сторін та виводимо результат.

Приклад 2: Функція для перевірки, чи є число простим.

def is_prime(number):
    """Повертає True, якщо число просте, і False - інакше."""
    if number <= 1:
        return False
    for i in range(2, int(number**0.5) + 1):
        if number % i == 0:
            return False
    return True

# Використання функції
print(f"Число 7 просте? {is_prime(7)}")
print(f"Число 10 просте? {is_prime(10)}")
print(f"Число 1 просте? {is_prime(1)}")

Тут ми створили функцію is_prime, яка приймає ціле число як аргумент і перевіряє, чи є воно простим, повертаючи відповідне булеве значення.

Приклад 3: Функція для створення привітального повідомлення.

def create_greeting(name, language="ukrainian"):
    """Повертає привітання заданою мовою."""
    if language.lower() == "ukrainian":
        return f"Привіт, {name}!"
    elif language.lower() == "english":
        return f"Hello, {name}!"
    else:
        return f"Привітання, {name}!"

# Використання функції з аргументом за замовчуванням
greeting_ukrainian = create_greeting("Олена")
print(greeting_ukrainian)

# Використання функції з явним вказанням мови
greeting_english = create_greeting("John", "english")
print(greeting_english)

greeting_default = create_greeting("Carlos", "spanish")
print(greeting_default)

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

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

IV. Область видимості (Scope) змінних:

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

У Python існують різні рівні області видимості:

• Локальна (Local): Змінні, визначені всередині функції, мають локальну область видимості. Вони доступні лише всередині цієї функції і перестають існувати після завершення її виконання.

• Область видимості функції, що охоплює (Enclosing function locals): Якщо одна функція вкладена в іншу, внутрішня функція може мати доступ до локальних змінних зовнішньої функції. Ці змінні знаходяться в області видимості функції, що охоплює.

• Глобальна (Global): Змінні, визначені на верхньому рівні модуля (поза будь-якими функціями чи класами), мають глобальну область видимості. Вони доступні з будь-якої частини коду програми.

• Вбудована (Built-in): Це область видимості, яка містить зарезервовані імена Python, такі як назви вбудованих функцій (print(), len()), винятків (TypeError, ValueError) та констант (True, False, None).

Порядок, в якому Python шукає ім'я змінної, визначається правилом LEGB:

1. L (Local): Спочатку Python шукає ім'я в поточній локальній області видимості (всередині поточної функції).

2. E (Enclosing function locals): Якщо ім'я не знайдено в локальній області видимості, Python шукає його в локальних областях видимості всіх охоплюючих функцій, починаючи з найближчої.

3. G (Global): Якщо ім'я не знайдено в локальних областях видимості охоплюючих функцій, Python шукає його в глобальній області видимості (на рівні модуля).

4. B (Built-in): Нарешті, якщо ім'я не знайдено в глобальній області видимості, Python шукає його у вбудованій області видимості.

Використання ключових слів global та nonlocal:

• global: Використовується всередині функції для оголошення, що певна змінна є глобальною. Це дозволяє змінювати значення глобальної змінної зсередини функції. Без оголошення global, присвоєння значення імені всередині функції створить нову локальну змінну з тим самим ім'ям, приховуючи глобальну змінну.

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

Розуміння області видимості та правильне використання global і nonlocal є важливими для керування станом програми та уникнення неочікуваних побічних ефектів.

(Далі ми можемо навести приклади, що ілюструють різні області видимості та використання global і nonlocal)

Також читайте: Інвестування: основні терміни та поняття