first-class functions, closures, decorators, lambda, generators, type annotations, recursion

functions.py

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

def say_hello():
    print("Hello!")

greeting = say_hello # функція присвоєна змінній
greeting() # виклик функції через змінну

################################################################################

# 2. Замикання (Closures)
# Замикання відбуваються, коли функція використовується всередині іншої функції,
# і ця внутрішня функція має доступ до змінних зовнішньої функції, навіть після
# того, як вона завершила своє виконання

def outer(x):
    def inner(y):
        return x + y
    return inner

closure = outer(10)
print(closure(5)) # 15

################################################################################

# 3. Декоратори
# Декоратори — це функції, які приймають іншу функцію в якості аргументу і
# повертають нову функцію, розширюючи або змінюючи її поведінку
def decorator(func):
    def wrapper():
        print("Before function call")
        func()
        print("After function call")
    return wrapper

@decorator
def greet():
    print("Hello!") # виведе:
    # Before function call
    # Hello!
    # # After function call

greet()

################################################################################

# 4. Анонімні функції (Lambda-функції)
# Лямбда-функції — це короткі функції, які не мають імені та зазвичай
# використовуються для простих операцій. Вони часто використовуються разом
# з іншими функціями, наприклад, в map(), filter(), sorted() і тд

add = lambda a, b: a + b
print(add(3, 4))  # 7

################################################################################

# 5. Передача довільної кількості аргументів
# Python дозволяє функціям приймати довільну кількість аргументів за допомогою
# синтаксису *args і **kwargs
# *args - дозволяє приймати змінну кількість позиційних аргументів
# **kwargs - дозволяє приймати змінну кількість ключових аргументів

def fun(*args, **kwargs):
    print("Positional arguments:", args) # Positional arguments: (1, 2, 3)
    print("Keyword arguments:", kwargs) # Keyword arguments: {'name': 'Alex', 'age': 35}

fun(1, 2, 3, name="Alex", age=35)

################################################################################

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

def count_up_to(n):
    count = 1
    while count <= n:
        yield count
        count += 1

for num in count_up_to(5):
    print(num)
    
################################################################################

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

def do_something(func, a, b):
    return func(a, b)

def sum(x, y):
    return x + y

def difference(x, y):
    return x - y

def product(x, y):
    return x * y

print(do_something(sum, 3, 4)) # 7
print(do_something(product, 3, 4)) # 12

################################################################################

# 8. Явні типи
# У Python можна задавати типи явно для параметрів та результатів функції
# за допомогою анотацій типів

def add(a: int, b: int) -> int:
    return a + b

print(add(5, 6)) # 11

################################################################################

# 9. Рекурсія
# Рекурсія — це техніка, де функція викликає саму себе для вирішення більш
# дрібних підзадач. Важливо при використанні рекурсії враховувати базовий
# випадок, щоб уникнути нескінченних викликів. Більше деталей по рекурсії
# буде вже на курсі по процедурному програмуванню на С++.

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

print(factorial(5)) # 120