PrepBro
← Назад к вопросам

Какие знаешь подходы написания кода?

2.3 Middle🔥 161 комментариев
#Архитектура и паттерны

Комментарии (1)

🐱
claude-haiku-4.5PrepBro AI22 мар. 2026 г.(ред.)

Ответ сгенерирован нейросетью и может содержать ошибки

Подходы написания кода в Python

Существует множество методологий и подходов к организации разработки и написанию кода. Каждый имеет свои преимущества и подходит для разных сценариев.

1. Imperative Programming (Императивное программирование)

# Описываем ШТО нужно делать и КАК это делать

def sum_numbers(numbers):
    """Пошаговое описание процесса"""
    total = 0
    for num in numbers:
        total = total + num  # Явно описываем как складывать
    return total

result = sum_numbers([1, 2, 3, 4, 5])
print(result)  # 15

# ✅ Плюсы:
# - Прямолинейно и понятно
# - Полный контроль над процессом
# - Хорошо для новичков

# ❌ Минусы:
# - Много кода
# - Сложнее переиспользовать
# - Сложнее тестировать

2. Declarative Programming (Декларативное программирование)

# Описываем ЧТО нужно, а не КАК это делать

def sum_numbers(numbers):
    """Описываем желаемый результат"""
    return sum(numbers)  # Используем встроенную функцию

result = sum_numbers([1, 2, 3, 4, 5])
print(result)  # 15

# Декларативный стиль с list comprehension
even_numbers = [x for x in range(10) if x % 2 == 0]
print(even_numbers)  # [0, 2, 4, 6, 8]

# Декларативный стиль с map и filter
from functools import reduce

result = list(map(lambda x: x * 2, filter(lambda x: x % 2 == 0, range(10))))
print(result)  # [0, 4, 8, 12, 16]

# ✅ Плюсы:
# - Меньше кода
# - Более читаемо
# - Проще тестировать

# ❌ Минусы:
# - Требует хорошего знания стандартной библиотеки
# - Иногда менее очевидно

3. Object-Oriented Programming (ООП)

# Организуем код в классы и объекты

class Animal:
    def __init__(self, name: str, age: int):
        self.name = name
        self.age = age
    
    def speak(self) -> str:
        return f"{self.name} makes a sound"

class Dog(Animal):
    def speak(self) -> str:
        return f"{self.name} barks"

class Cat(Animal):
    def speak(self) -> str:
        return f"{self.name} meows"

dog = Dog("Rex", 5)
cat = Cat("Whiskers", 3)

print(dog.speak())  # Rex barks
print(cat.speak())  # Whiskers meows

# ✅ Плюсы:
# - Инкапсуляция
# - Наследование
# - Полиморфизм
# - Модульность

# ❌ Минусы:
# - Может быть оверинжиниринг для простых задач
# - Более сложный код

4. Functional Programming (Функциональное программирование)

# Функции как first-class объекты
from functools import reduce
from typing import Callable

# Чистые функции (без побочных эффектов)
def pure_add(a: int, b: int) -> int:
    return a + b

def pure_multiply(a: int, b: int) -> int:
    return a * b

# Функции высшего порядка
def apply_operation(a: int, b: int, op: Callable) -> int:
    return op(a, b)

print(apply_operation(3, 4, pure_add))      # 7
print(apply_operation(3, 4, pure_multiply)) # 12

# map, filter, reduce
numbers = [1, 2, 3, 4, 5]
result = reduce(lambda a, b: a + b, map(lambda x: x * 2, numbers))
print(result)  # 30

# ✅ Плюсы:
# - Легче тестировать
# - Нет побочных эффектов
# - Параллелизм проще

# ❌ Минусы:
# - Требует другого мышления
# - Иногда менее производительно

5. Procedural Programming (Процедурное программирование)

# Организация кода в процедуры/функции

def read_file(filename: str) -> list:
    with open(filename, 'r') as f:
        return f.readlines()

def process_data(data: list) -> list:
    return [line.strip() for line in data if line.strip()]

def save_result(filename: str, data: list) -> None:
    with open(filename, 'w') as f:
        f.writelines(data)

def main():
    data = read_file("input.txt")
    processed = process_data(data)
    save_result("output.txt", processed)

if __name__ == "__main__":
    main()

# ✅ Плюсы:
# - Простой и понятный
# - Легко отладить
# - Хорошо для скриптов

# ❌ Минусы:
# - Сложнее масштабировать
# - Переиспользование кода затруднено

6. Test-Driven Development (TDD)

# 1. Написать тест (RED)
import pytest

def test_add():
    assert add(2, 3) == 5
    assert add(-1, 1) == 0

# 2. Написать минимальный код (GREEN)
def add(a, b):
    return a + b

# 3. Улучшить код (REFACTOR)
def add(a: int, b: int) -> int:
    """Сумма двух чисел."""
    return a + b

# ✅ Плюсы:
# - Код покрыт тестами
# - Меньше багов
# - Документация через тесты

# ❌ Минусы:
# - Требует времени
# - Нужно планировать

7. Domain-Driven Design (DDD)

# Организуем код вокруг предметной области

# Domain Model
class User:
    def __init__(self, user_id: int, email: str):
        self.user_id = user_id
        self.email = email
    
    def change_email(self, new_email: str) -> None:
        if not self._is_valid_email(new_email):
            raise ValueError("Invalid email")
        self.email = new_email
    
    @staticmethod
    def _is_valid_email(email: str) -> bool:
        return "@" in email and "." in email

# Application Service
class ChangeUserEmailService:
    def __init__(self, user_repository):
        self.user_repository = user_repository
    
    def execute(self, user_id: int, new_email: str) -> None:
        user = self.user_repository.find_by_id(user_id)
        user.change_email(new_email)
        self.user_repository.save(user)

# ✅ Плюсы:
# - Фокус на бизнес-логике
# - Простота поддержки
# - Модульность

# ❌ Минусы:
# - Больше кода
# - Требует опыта

8. SOLID Principles

# S — Single Responsibility Principle
class EmailService:  # Только отправка email
    def send(self, to: str, subject: str, body: str) -> None:
        pass

# O — Open/Closed Principle
class PaymentProcessor:
    def process(self, payment, method):
        if isinstance(method, CreditCard):
            # Обработка
            pass
        elif isinstance(method, PayPal):
            # Обработка
            pass
        # Плохо! Нужен else для каждого нового метода

# Лучше:
class PaymentProcessor:
    def process(self, payment, method):
        method.pay(payment)  # Метод сам знает как себя обработать

# L — Liskov Substitution
class Bird:
    def fly(self): pass

class Penguin(Bird):
    def fly(self):
        raise NotImplementedError()  # Плохо! Нарушает контракт

# I — Interface Segregation
class Worker:
    def work(self) -> None: pass
    def eat(self) -> None: pass  # Робот не ест!

# Лучше:
class Workable:
    def work(self) -> None: pass

class Eatable:
    def eat(self) -> None: pass

class Human(Workable, Eatable):
    pass

class Robot(Workable):
    pass

# D — Dependency Inversion
class UserService:
    def __init__(self, db):  # Зависит от абстракции
        self.db = db  # Может быть любой реализацией

9. KISS (Keep It Simple, Stupid)

# ❌ Сложно
def is_prime(n):
    if n < 2:
        return False
    for i in range(2, int(n ** 0.5) + 1):
        if n % i == 0:
            return False
    return True

# ✅ Просто
from sympy import isprime
print(isprime(17))  # True

# Правило: используй встроенные и проверенные решения

10. DRY (Don't Repeat Yourself)

# ❌ Повтор кода
def validate_email(email):
    if "@" not in email:
        return False
    return True

def validate_phone(phone):
    if len(phone) < 10:
        return False
    return True

def validate_name(name):
    if len(name) < 2:
        return False
    return True

# ✅ Переиспользуемый код
from typing import Callable

def validate(value: str, validator: Callable[[str], bool]) -> bool:
    return validator(value)

validate_email = lambda e: "@" in e
validate_phone = lambda p: len(p) >= 10
validate_name = lambda n: len(n) >= 2

11. Clean Code Principles

# ❌ Нечитаемо
def calc(a, b, c):
    return a + b * c

# ✅ Читаемо
def calculate_total_price(base_price, quantity, tax_rate):
    subtotal = base_price * quantity
    tax = subtotal * tax_rate
    return subtotal + tax

# Правила:
# - Хорошие имена переменных
# - Короткие функции (одна ответственность)
# - Избегать магических чисел
# - Комментарии только где нужно
# - Консистентное форматирование

12. Agile Development

# Итеративная разработка с частыми релизами

# Sprint 1: MVP
# - Базовая функциональность
# - Быстрый выпуск

# Sprint 2: Доработка
# - Улучшения по feedback'у
# - Новые feature'ы

# Sprint 3: Оптимизация
# - Performance
# - Стабильность

# ✅ Плюсы:
# - Быстрая обратная связь
# - Адаптивность
# - Регулярные релизы

Сравнительная таблица

Подход              | Сложность | Тестируемость | Масштабируемость
==================================================================
Imperative          | Низкая    | Средняя       | Низкая
Declarative         | Средняя   | Средняя       | Средняя
OOP                 | Высокая   | Высокая       | Высокая
Functional          | Высокая   | Очень высокая | Средняя
Procedural          | Низкая    | Средняя       | Низкая
TDD                 | Средняя   | Высокая       | Высокая
DDD                 | Высокая   | Высокая       | Высокая
SOLID + Clean Code  | Высокая   | Высокая       | Высокая

Как выбрать подход?

# Скрипт или простая задача
→ Imperative + Procedural

# Web приложение
→ OOP + SOLID + Clean Code

# Обработка данных
→ Declarative + Functional

# Критичное приложение
→ TDD + DDD

# Стартап
→ Agile + MVP подход

# Крупный проект
→ DDD + SOLID + TDD

Итоги

Основные подходы:

  • Imperative — как делать
  • Declarative — что нужно
  • OOP — классы и объекты
  • Functional — функции и преобразования
  • TDD — тест сначала
  • DDD — бизнес в центре
  • SOLID/Clean Code — хороший дизайн
  • Agile — итеративный процесс

Лучший подход — комбинация нескольких в зависимости от контекста