В чем разница между функциями и процедурами?

# Функции vs Процедуры в программировании

Процедура (Procedure)

Процедура — это блок кода, который выполняет действие (побочный эффект), но не возвращает значение.

Процедуры ориентированы на действие, а не на результат.

Характеристики процедур:

• Выполняет действие (изменяет состояние, печатает, записывает в БД)
• Не возвращает значение (или возвращает None/void)
• Результат — побочный эффект
• Вызывается для действия, не для получения результата

# ❌ Примеры процедур (не рекомендуется в современном Python)

def print_hello():
    """Процедура — выполняет действие, ничего не возвращает"""
    print("Hello, World!")
    # Возвращает None

def save_to_database(user_data):
    """Процедура — сохраняет в БД, ничего не возвращает"""
    db.insert('users', user_data)
    # Возвращает None

def clear_cache():
    """Процедура — очищает кэш, ничего не возвращает"""
    cache.clear()
    # Побочный эффект — изменение состояния

def update_user_status(user_id, status):
    """Процедура — обновляет статус пользователя"""
    user = db.find_user(user_id)
    user.status = status
    db.save(user)
    # Возвращает None, побочный эффект в БД

# Использование:
print_hello()  # Вызываем для действия, не для результата
save_to_database({"name": "Alice"})
update_user_status("123", "active")

Функция (Function)

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

Функции ориентированы на преобразование входа в выход.

Характеристики функций:

• Вычисляет результат из входных данных
• Возвращает значение (не None)
• Результат — это возвращаемое значение
• Вызывается для получения результата
• Идеально: без побочных эффектов (чистая функция)

# ✅ Примеры функций (рекомендуется)

def add(a: int, b: int) -> int:
    """Функция — вычисляет сумму и возвращает результат"""
    return a + b

def calculate_age(birth_year: int, current_year: int = 2026) -> int:
    """Функция — вычисляет возраст"""
    return current_year - birth_year

def format_user_name(first_name: str, last_name: str) -> str:
    """Функция — форматирует имя"""
    return f"{first_name} {last_name}"

def is_valid_email(email: str) -> bool:
    """Функция — проверяет валидность email"""
    return '@' in email and '.' in email

def get_user_from_database(user_id: str) -> dict:
    """Функция — получает пользователя из БД и возвращает"""
    user = db.find_user(user_id)
    return user.to_dict()

# Использование — результат используется:
result = add(5, 3)  # 8
age = calculate_age(1990)  # 36
full_name = format_user_name("John", "Doe")  # "John Doe"
valid = is_valid_email("test@example.com")  # True
user = get_user_from_database("123")  # {"id": "123", "name": "Alice"}

Таблица сравнения

Чистые функции (Pure Functions) vs Процедуры

Чистая функция:

def calculate_discount(price: float, discount_percent: float) -> float:
    """Чистая функция:
    - Зависит только от входных параметров
    - Возвращает результат
    - Нет побочных эффектов
    """
    return price * (1 - discount_percent / 100)

# Использование:
final_price = calculate_discount(100, 20)  # 80.0
# Вызвали дважды с одинаковыми параметрами — одинаковый результат
assert calculate_discount(100, 20) == calculate_discount(100, 20)

Процедура с побочными эффектами:

class ShoppingCart:
    def __init__(self):
        self.items = []
    
    def add_item(self, item: str):
        """Процедура — изменяет состояние корзины"""
        self.items.append(item)
        # Побочный эффект: изменение self.items
        # Возвращает None
    
    def apply_discount(self, discount_percent: float):
        """Процедура — применяет скидку, изменяет цены"""
        for item in self.items:
            item.price *= (1 - discount_percent / 100)
        # Побочный эффект: изменение цен в self.items

# Использование:
cart = ShoppingCart()
cart.add_item(Item("Book", 100))
cart.apply_discount(20)  # Результат — изменённое состояние корзины
print(cart.items[0].price)  # 80.0

Лучший подход: функции, а не процедуры

В современном Python рекомендуется функциональный стиль (FP — Functional Programming):

# ❌ Плохо: процедура с побочными эффектами
class UserManager:
    def process_user_registration(self, form_data):
        """Процедура с множественными побочными эффектами"""
        # Валидация
        if not form_data.get('email'):
            print("Invalid email")  # Побочный эффект
            return
        
        # Хеширование пароля
        hashed = hash_password(form_data['password'])  # Побочный эффект
        
        # Сохранение в БД
        db.insert('users', {'email': form_data['email'], 'password': hashed})  # Побочный эффект
        
        # Отправка email
        send_email(form_data['email'], "Welcome!")  # Побочный эффект

# ✅ Хорошо: разделение на функции
def validate_email(email: str) -> bool:
    """Чистая функция"""
    return '@' in email and '.' in email

def hash_password(password: str) -> str:
    """Чистая функция"""
    import hashlib
    return hashlib.sha256(password.encode()).hexdigest()

def create_user(email: str, password: str) -> dict:
    """Функция с минимальными побочными эффектами"""
    if not validate_email(email):
        raise ValueError("Invalid email")
    
    hashed_pw = hash_password(password)
    user = {"email": email, "password": hashed_pw}
    return user

def save_user_to_db(user: dict) -> None:
    """Процедура — сохранение в БД (побочный эффект контролирован)"""
    db.insert('users', user)

def send_welcome_email(email: str) -> None:
    """Процедура — отправка email (побочный эффект контролирован)"""
    send_email(email, "Welcome!")

def register_user(email: str, password: str) -> dict:
    """Оркестратор — собирает функции и процедуры вместе"""
    user = create_user(email, password)  # Функция
    save_user_to_db(user)  # Процедура с побочным эффектом
    send_welcome_email(email)  # Процедура с побочным эффектом
    return user

# Использование:
user = register_user("alice@example.com", "secret123")
print(user)  # {"email": "alice@example.com", "password": "...хеш..."}

Принципы функционального программирования

# 1. Максимум чистых функций
def multiply(a: int, b: int) -> int:
    return a * b

# 2. Минимум побочных эффектов
def log_result(result: int) -> None:
    """Побочный эффект явно отделён"""
    print(f"Result: {result}")

# 3. Композиция функций
def square(x: int) -> int:
    return x * x

def add_one(x: int) -> int:
    return x + 1

def compose(f, g):
    """Композиция функций: (f ∘ g)(x) = f(g(x))"""
    return lambda x: f(g(x))

# (square ∘ add_one)(5) = square(add_one(5)) = square(6) = 36
result = compose(square, add_one)(5)  # 36

# 4. Higher-order функции
def apply_twice(func, value):
    """Функция, принимающая функцию"""
    return func(func(value))

apply_twice(add_one, 5)  # 7 (5 + 1 + 1)

# 5. Map, Filter, Reduce
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x ** 2, numbers))  # [1, 4, 9, 16, 25]
evens = list(filter(lambda x: x % 2 == 0, numbers))  # [2, 4]

from functools import reduce
product = reduce(lambda a, b: a * b, numbers)  # 120 (1*2*3*4*5)

Заключение

• Процедуры — выполняют действия, ничего не возвращают
• Функции — вычисляют результаты, возвращают значения
• В современном Python предпочитаются функции
• Чистые функции (без побочных эффектов) — лучше для тестирования и понимания кода
• Побочные эффекты (БД, файлы, email) разделяй явно
• Используй функциональное программирование для более надёжного и тестируемого кода