Что такое функция в Python?

Функции в Python

Функция - это переиспользуемый блок кода, который выполняет конкретную задачу. Функции в Python - это объекты первого класса, что позволяет передавать их как аргументы, возвращать из других функций и присваивать переменным.

Базовое определение и вызов

def greet(name):
    """Функция приветствует человека"""
    return f"Hello, {name}!"

result = greet("Alice")
print(result)  # Hello, Alice!

Компоненты функции:

1. def - ключевое слово определения
2. greet - имя функции
3. name - параметр функции
4. """..""" - docstring (документация)
5. return - возвращаемое значение

Параметры и аргументы

# Позиционные аргументы
def add(a, b):
    return a + b

print(add(5, 3))  # 8

# Именованные аргументы (по имени параметра)
print(add(b=3, a=5))  # 8

# Значения по умолчанию
def power(x, exponent=2):
    return x ** exponent

print(power(5))      # 25 (используется exponent=2)
print(power(5, 3))   # 125 (используется exponent=3)

# *args - переменное количество позиционных аргументов
def sum_all(*args):
    total = 0
    for num in args:
        total += num
    return total

print(sum_all(1, 2, 3, 4))  # 10

# **kwargs - переменное количество именованных аргументов
def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info(name="Alice", age=30, city="NYC")
# name: Alice
# age: 30
# city: NYC

# Комбинация всего
def full_example(a, b=2, *args, **kwargs):
    print(f"a={a}, b={b}")
    print(f"args={args}")
    print(f"kwargs={kwargs}")

full_example(1, 3, 4, 5, name="Bob", age=25)
# a=1, b=3
# args=(4, 5)
# kwargs={name: Bob, age: 25}

Возвращение значений

# Одно значение
def get_square(x):
    return x ** 2

# Несколько значений (возвращается кортеж)
def divide_with_remainder(a, b):
    return a // b, a % b

quotient, remainder = divide_with_remainder(10, 3)
print(quotient, remainder)  # 3 1

# None (функция без явного return возвращает None)
def greet_without_return(name):
    print(f"Hello, {name}!")

result = greet_without_return("Bob")
print(result)  # None

Функции как объекты первого класса

# Присваивание переменной
def add(a, b):
    return a + b

my_function = add
print(my_function(5, 3))  # 8

# Передача в другую функцию
def apply_operation(x, y, operation):
    return operation(x, y)

result = apply_operation(10, 5, add)
print(result)  # 15

# Возвращение функции из функции
def create_multiplier(factor):
    def multiply(x):
        return x * factor
    return multiply

multiply_by_3 = create_multiplier(3)
print(multiply_by_3(10))  # 30

# Хранение в структурах
operations = {
    add: lambda x, y: x + y,
    subtract: lambda x, y: x - y,
    multiply: lambda x, y: x * y,
}

print(operations[add](10, 5))  # 15

Лямбда функции

# Лямбда - функция в одну строку
square = lambda x: x ** 2
print(square(5))  # 25

# Часто используются с map, filter, sorted
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x ** 2, numbers))
print(squared)  # [1, 4, 9, 16, 25]

even = list(filter(lambda x: x % 2 == 0, numbers))
print(even)  # [2, 4]

words = [apple, pie, zoo, cat]
sorted_by_length = sorted(words, key=lambda w: len(w))
print(sorted_by_length)  # [pie, zoo, cat, apple]

Декораторы (функции над функциями)

# Декоратор - функция, которая модифицирует другую функцию
def timer(func):
    def wrapper(*args, **kwargs):
        import time
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"Функция {func.__name__} выполнена за {end - start:.4f} сек")
        return result
    return wrapper

@timer  # Применяем декоратор
def slow_function():
    import time
    time.sleep(0.1)
    return "Done"

result = slow_function()
# Функция slow_function выполнена за 0.1001 сек

# Декоратор с параметрами
def repeat(times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            results = []
            for _ in range(times):
                results.append(func(*args, **kwargs))
            return results
        return wrapper
    return decorator

@repeat(times=3)
def say_hello():
    return "Hello"

print(say_hello())  # [Hello, Hello, Hello]

Область видимости (Scope)

global_var = 100  # Глобальная переменная

def outer():
    outer_var = 50  # Переменная функции outer
    
    def inner():
        inner_var = 10  # Локальная переменная
        print(inner_var)    # 10 - локальная
        print(outer_var)    # 50 - nonlocal scope
        print(global_var)   # 100 - глобальная
    
    inner()

outer()

# Модификация переменных из внешней области
def counter():
    count = 0
    def increment():
        nonlocal count  # Модифицировать переменную из внешней области
        count += 1
        return count
    return increment

my_counter = counter()
print(my_counter())  # 1
print(my_counter())  # 2
print(my_counter())  # 3

Аннотация типов (Type hints)

def add(a: int, b: int) -> int:
    """Складывает два целых числа"""
    return a + b

def greet(name: str) -> None:
    """Приветствует человека, ничего не возвращает"""
    print(f"Hello, {name}!")

from typing import List, Dict, Optional

def process_items(items: List[int]) -> Dict[str, int]:
    """Обработать список чисел"""
    return {
        count: len(items),
        sum: sum(items),
        average: sum(items) / len(items) if items else 0
    }

def find_user(user_id: int) -> Optional[str]:
    """Найти пользователя, может вернуть None"""
    # ...
    return None

Лучшие практики

1. Одна ответственность - функция должна делать одно
2. Понятные имена - calculate_total_price() лучше, чем calc()
3. Документация - используй docstrings
4. Типы - аннотируй параметры и возвращаемое значение
5. DRY - не повторяй код, выноси в функции
6. Небольшой размер - если функция > 20 строк, разбей на части
7. Чистые функции - не меняй глобальное состояние
8. Обработка ошибок - используй try/except если нужно