Зачем нужна функция?

Зачем нужна функция

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

Основные причины использования функций

1. Переиспользование кода (DRY — Don't Repeat Yourself)

Вместо повторения одного и того же кода, функция инкапсулирует логику:

# ❌ Без функции — код повторяется
name1 = "Alice"
age1 = 30
print(f"{name1} is {age1} years old")

name2 = "Bob"
age2 = 25
print(f"{name2} is {age2} years old")  # Повторение

name3 = "Charlie"
age3 = 35
print(f"{name3} is {age3} years old")  # Еще повторение

# ✅ С функцией — централизованная логика
def introduce(name, age):
    print(f"{name} is {age} years old")

introduce("Alice", 30)
introduce("Bob", 25)
introduce("Charlie", 35)

2. Организация и читаемость

Функции организуют код в логические блоки:

# Плохо: всё в одном месте
def process_user_data(data):
    # Валидация
    if not data.get('name'):
        return {"error": "Name required"}
    if not data.get('email'):
        return {"error": "Email required"}
    
    # Обработка
    name = data['name'].strip().title()
    email = data['email'].lower()
    
    # Сохранение
    db.save({'name': name, 'email': email})
    
    # Отправка письма
    send_email(email, f"Welcome {name}")
    
    return {"success": True}

# Хорошо: разделить на функции
def validate_user_input(data):
    if not data.get('name'):
        raise ValueError("Name required")
    if not data.get('email'):
        raise ValueError("Email required")
    return True

def normalize_user_data(data):
    return {
        'name': data['name'].strip().title(),
        'email': data['email'].lower()
    }

def save_user(user_data):
    return db.save(user_data)

def send_welcome_email(email, name):
    send_email(email, f"Welcome {name}")

def process_user_data(data):
    validate_user_input(data)
    user = normalize_user_data(data)
    save_user(user)
    send_welcome_email(user['email'], user['name'])
    return {"success": True}

3. Тестируемость

Функции легко тестировать:

# Функция
def calculate_discount(price, discount_percent):
    return price * (1 - discount_percent / 100)

# Тесты
def test_calculate_discount():
    assert calculate_discount(100, 10) == 90  # 10% скидка
    assert calculate_discount(50, 50) == 25  # 50% скидка
    assert calculate_discount(200, 0) == 200  # Без скидки

test_calculate_discount()  # Все тесты проходят

4. Модульность и поддерживаемость

Змена логики в одном месте:

# Было
def calculate_total_price(items):
    total = 0
    for item in items:
        total += item['price'] * item['quantity']
    return total

# Нужно добавить налог — меняем только функцию
def calculate_total_price(items, tax_rate=0.1):
    total = 0
    for item in items:
        total += item['price'] * item['quantity']
    return total * (1 + tax_rate)  # Добавили налог

# Все вызовы функции автоматически получают новую логику

5. Абстракция сложности

Скрывает детали реализации:

# Без функции — видны все детали
password = input("Enter password: ")
import hashlib
encrypted = hashlib.sha256(password.encode()).hexdigest()
db.save(encrypted)

# С функцией — простой интерфейс
def set_user_password(user_id, password):
    encrypted = hashlib.sha256(password.encode()).hexdigest()
    db.update_password(user_id, encrypted)

set_user_password(123, "secret123")  # Просто и понятно

6. Асинхронные операции

Функции помогают управлять асинхронностью:

# Асинхронные операции
async def fetch_user_data(user_id):
    user = await db.get_user(user_id)
    orders = await db.get_user_orders(user_id)
    return {"user": user, "orders": orders}

# Использование
data = await fetch_user_data(123)

Типы функций

Простая функция

def greet(name):
    return f"Hello, {name}!"

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

Функция с параметрами по умолчанию

def power(base, exponent=2):
    return base ** exponent

print(power(3))  # 9 (3^2)
print(power(3, 3))  # 27 (3^3)

Функция с переменным количеством аргументов

def sum_all(*args):
    return sum(args)

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

def print_kwargs(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

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

Анонимная функция (lambda)

# Lambda — функция без имени, для простых операций
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]

Вложенные функции (closure)

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

add_5 = outer(5)
print(add_5(3))  # 8 — 5 + 3

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

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

Декоратор (функция, которая оборачивает другую функцию)

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

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

slow_function()
# Execution time: 1.00s
# Done

Практические примеры

Пример 1: Валидация данных

def is_valid_email(email):
    """Проверить, является ли строка валидным email."""
    return '@' in email and '.' in email.split('@')[1]

def is_valid_password(password):
    """Пароль должен быть минимум 8 символов и содержать цифру."""
    return len(password) >= 8 and any(c.isdigit() for c in password)

# Использование
if is_valid_email("user@example.com") and is_valid_password("Pass1234"):
    print("All valid")

Пример 2: Обработка данных

def filter_active_users(users):
    return [u for u in users if u['status'] == 'active']

def sort_by_name(users):
    return sorted(users, key=lambda u: u['name'])

def get_user_emails(users):
    return [u['email'] for u in users]

# Pipeline обработки
users = load_users_from_db()
active_users = filter_active_users(users)
sorted_users = sort_by_name(active_users)
emails = get_user_emails(sorted_users)
print(emails)

Пример 3: Работа с БД

def get_user_by_id(user_id):
    query = "SELECT * FROM users WHERE id = ?"
    return db.query(query, (user_id,))

def create_user(name, email):
    query = "INSERT INTO users (name, email) VALUES (?, ?)"
    return db.execute(query, (name, email))

def delete_user(user_id):
    query = "DELETE FROM users WHERE id = ?"
    return db.execute(query, (user_id,))

def update_user_email(user_id, new_email):
    query = "UPDATE users SET email = ? WHERE id = ?"
    return db.execute(query, (new_email, user_id))

Best Practices

# 1. Однозначное имя функции
✅ def calculate_average_price(items):
❌ def calc(x):

# 2. Одна функция — одна ответственность
✅ def send_email(recipient, message):
❌ def send_email_and_log_and_update_stats(...):

# 3. Документация (docstring)
✅ def divide(a, b):
    """Разделить a на b. Вызывает ValueError если b == 0."""
    if b == 0:
        raise ValueError("Cannot divide by zero")
    return a / b

# 4. Чистые функции (без побочных эффектов)
✅ def add(a, b):
    return a + b

❌ def add(a, b):
    total = a + b
    print(total)  # Побочный эффект
    return total

# 5. Обработка исключений
✅ def get_config(key):
    try:
        return config[key]
    except KeyError:
        raise ValueError(f"Config key '{key}' not found")

Заключение

Функции — это:

• Основной строительный блок любой программы
• Инструмент переиспользования кода (DRY)
• Способ организации логики
• Средство тестирования и отладки
• Инструмент абстракции сложности

Хорошее использование функций делает код чистым, поддерживаемым и эффективным.