Какие инструменты предоставляет функция?

Инструменты, предоставляемые функциями в Python

Функция — это один из основных строительных блоков программирования. Она предоставляет множество мощных инструментов для написания чистого и эффективного кода.

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

Позиционные аргументы

def greet(name, age):
    print(f"{name} is {age} years old")

greet("Alice", 30)  # Порядок важен

Именованные аргументы

def greet(name, age):
    print(f"{name} is {age} years old")

greet(age=30, name="Alice")  # Порядок не важен

Значения по умолчанию (Default parameters)

def greet(name="Guest", age=18):
    print(f"{name} is {age} years old")

greet()  # Guest is 18 years old
greet("Bob")  # Bob is 18 years old
greet("Charlie", 25)  # Charlie is 25 years old

2. Переменное количество аргументов

*args (позиционные аргументы переменной длины)

def sum_all(*args):
    print(f"Args type: {type(args)}")  # <class tuple>
    return sum(args)

result = sum_all(1, 2, 3, 4, 5)
print(result)  # 15

# Распаковка
values = [10, 20, 30]
print(sum_all(*values))  # 60

**kwargs (именованные аргументы переменной длины)

def print_info(**kwargs):
    print(f"Kwargs type: {type(kwargs)}")  # <class dict>
    for key, value in kwargs.items():
        print(f"{key}: {value}")

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

# Распаковка
params = {"name": "Bob", "age": 25}
print_info(**params)

Комбинация всех типов

def full_function(a, b, *args, default=10, **kwargs):
    print(f"a={a}, b={b}")
    print(f"args={args}")
    print(f"default={default}")
    print(f"kwargs={kwargs}")

full_function(1, 2, 3, 4, 5, default=20, x=100, y=200)
# a=1, b=2
# args=(3, 4, 5)
# default=20
# kwargs={x: 100, y: 200}

3. Возвращаемые значения

Одно значение

def square(x):
    return x ** 2

result = square(5)
print(result)  # 25

Несколько значений (кортеж)

def divide_and_remainder(a, b):
    return a // b, a % b

quotient, remainder = divide_and_remainder(17, 5)
print(quotient, remainder)  # 3 2

Возврат функции (замыкание)

def multiplier(factor):
    def multiply(x):
        return x * factor
    return multiply

triple = multiplier(3)
print(triple(10))  # 30

4. Декораторы (Decorators)

Декоратор — функция, которая изменяет поведение другой функции

Простой декоратор

def timer(func):
    import time
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"Execution time: {end - start:.4f}s")
        return result
    return wrapper

@timer
def slow_function():
    time.sleep(1)
    return "Done"

result = slow_function()  # Execution time: 1.0010s

Декоратор с параметрами

def repeat(times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(times):
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat(times=3)
def say_hello(name):
    print(f"Hello, {name}!")

say_hello("Alice")
# Hello, Alice!
# Hello, Alice!
# Hello, Alice!

Встроенные декораторы

class Calculator:
    def __init__(self, value):
        self.value = value
    
    @property  # Превращает метод в атрибут
    def squared(self):
        return self.value ** 2
    
    @staticmethod  # Метод без доступа к self
    def add(a, b):
        return a + b
    
    @classmethod  # Метод получает класс вместо self
    def from_string(cls, value_str):
        return cls(int(value_str))

calc = Calculator(5)
print(calc.squared)  # 25 (как атрибут, не вызов функции)
print(Calculator.add(3, 4))  # 7
calc2 = Calculator.from_string("10")

5. Замыкания (Closures)

Замыкание — функция, которая "помнит" переменные из внешней области видимости

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

add_5 = outer(5)
print(add_5(10))  # 15
print(add_5(20))  # 25

# Проверка замыкания
print(add_5.__closure__)  # Содержит переменную x
print(add_5.__closure__[0].cell_contents)  # 5

Практический пример: счётчик

def make_counter():
    count = 0
    
    def increment():
        nonlocal count  # Позволяет менять переменную из outer scope
        count += 1
        return count
    
    return increment

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

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

Правило LEGB:

global_var = "global"

def outer():
    enclosing_var = "enclosing"
    
    def inner():
        local_var = "local"
        
        print(local_var)  # LOCAL
        print(enclosing_var)  # ENCLOSING
        print(global_var)  # GLOBAL
    
    inner()

outer()

Изменение глобальных переменных

global_var = 10

def modify():
    global global_var
    global_var = 20

modify()
print(global_var)  # 20

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

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

def greet(name: str, age: int = 18) -> str:
    return f"{name} is {age}"

# Со сложными типами
from typing import List, Dict, Optional

def process_items(items: List[int]) -> Dict[str, int]:
    return {"count": len(items), "sum": sum(items)}

def find_user(user_id: int) -> Optional[Dict[str, str]]:
    return {"id": str(user_id)} if user_id > 0 else None

8. Docstring и документирование

def calculate_area(radius: float) -> float:
    """
    Calculate circle area given radius.
    
    Args:
        radius: Circle radius in cm
    
    Returns:
        Circle area in cm²
    
    Example:
        >>> calculate_area(5)
        78.5
    """
    import math
    return math.pi * radius ** 2

9. Lambda функции

Анонимные функции для простых операций

# Простая lambda
square = lambda x: x ** 2
print(square(5))  # 25

# С несколькими параметрами
add = lambda x, y: x + y
print(add(3, 4))  # 7

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

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

# Сортировка
people = [{name: Alice, age: 30}, {name: Bob, age: 25}]
sorted_people = sorted(people, key=lambda p: p[age])

10. Генераторы (Generators)

Функция, которая использует yield для возврата значений по одному

def count_up(max):
    current = 0
    while current < max:
        yield current
        current += 1

for num in count_up(5):
    print(num)  # 0 1 2 3 4

# Более эффективно, чем возвращать список
def fibonacci(n):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

print(list(fibonacci(10)))  # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

11. Встроенные функции высшего порядка

data = [1, 2, 3, 4, 5]

# map() — применить функцию ко всем элементам
squared = list(map(lambda x: x ** 2, data))
print(squared)  # [1, 4, 9, 16, 25]

# filter() — отобрать элементы по условию
evens = list(filter(lambda x: x % 2 == 0, data))
print(evens)  # [2, 4]

# reduce() — свернуть список в одно значение
from functools import reduce
product = reduce(lambda x, y: x * y, data)
print(product)  # 120

Практический пример: полноценная функция

from typing import List, Callable
from functools import wraps
import time

def timing_decorator(func):
    """Декоратор для замера времени выполнения."""
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        print(f"{func.__name__} took {time.time() - start:.4f}s")
        return result
    return wrapper

@timing_decorator
def process_numbers(numbers: List[int], multiplier: int = 2) -> int:
    """
    Process list of numbers with optional multiplier.
    
    Args:
        numbers: List of integers to process
        multiplier: Factor to multiply each number (default: 2)
    
    Returns:
        Sum of processed numbers
    """
    return sum(n * multiplier for n in numbers)

result = process_numbers([1, 2, 3, 4, 5], multiplier=3)
print(result)  # 45

Best Practices

1. Одна ответственность — функция должна делать одно
2. Понятное имя — название должно отражать то, что функция делает
3. Type hints — всегда аннотируй типы
4. Docstrings — документируй сложное поведение
5. Максимум 3-4 параметра — используй *args, **kwargs для большего количества
6. Избегай побочных эффектов — функция должна быть чистой (pure function)
7. Тестируй — покрывай функции unit тестами

Функции — это мощный инструмент для написания модульного, переиспользуемого и легкоподдерживаемого кода.