Какие знаешь принципы программирования?

Принципы программирования

SOLID

Это 5 основных принципов объектно-ориентированного дизайна.

1. Single Responsibility Principle (SRP)

Каждый класс или функция должна иметь одну ответственность.

# Плохо - класс имеет несколько ответственностей
class User:
    def __init__(self, name, email):
        self.name = name
        self.email = email
    
    def save_to_database(self):
        pass
    
    def send_email_notification(self):
        pass
    
    def generate_report(self):
        pass

# Хорошо - разделяем ответственность
class User:
    def __init__(self, name, email):
        self.name = name
        self.email = email

class UserRepository:
    def save(self, user):
        pass

class EmailService:
    def send_notification(self, user):
        pass

2. Open/Closed Principle (OCP)

Класс открыт для расширения, но закрыт для модификации.

from abc import ABC, abstractmethod

class PaymentMethod(ABC):
    @abstractmethod
    def process(self, amount: float) -> bool:
        pass

class CreditCardPayment(PaymentMethod):
    def process(self, amount: float) -> bool:
        return True

class PayPalPayment(PaymentMethod):
    def process(self, amount: float) -> bool:
        return True

class PaymentProcessor:
    def process(self, payment: PaymentMethod, amount: float):
        return payment.process(amount)

3. Liskov Substitution Principle (LSP)

Объекты подтипов должны корректно заменять объекты базовых типов.

class Bird:
    def eat(self):
        pass

class FlyingBird(Bird):
    def fly(self):
        pass

class Eagle(FlyingBird):
    def fly(self):
        return "Eagle is flying"

class Penguin(Bird):
    def swim(self):
        return "Penguin is swimming"

4. Interface Segregation Principle (ISP)

Интерфейсы должны быть специфичными для клиентов.

from abc import ABC, abstractmethod

class Workable(ABC):
    @abstractmethod
    def work(self):
        pass

class Eatable(ABC):
    @abstractmethod
    def eat_lunch(self):
        pass

class Developer(Workable, Eatable):
    def work(self):
        return "Writing code"
    def eat_lunch(self):
        return "Eating"

5. Dependency Inversion Principle (DIP)

Зависимости должны быть на абстракции.

from abc import ABC, abstractmethod

class DatabaseInterface(ABC):
    @abstractmethod
    def save(self, data):
        pass

class UserService:
    def __init__(self, db: DatabaseInterface):
        self.db = db
    
    def create_user(self, name):
        self.db.save({"name": name})

DRY (Dont Repeat Yourself)

Не повторяй код - выноси в функции и классы.

def get_full_name(first: str, last: str) -> str:
    return f"{first} {last}"

def get_user_full_name(user_id):
    user = database.get_user(user_id)
    return get_full_name(user["first_name"], user["last_name"]) if user else ""

KISS (Keep It Simple, Stupid)

Простое решение лучше сложного.

class DataProcessor:
    def process(self, data: list) -> list:
        return [item * 2 for item in data]

YAGNI (You Arent Gonna Need It)

Не добавляй функционал на будущее.

class User:
    def __init__(self, name: str):
        self.name = name

Composition over Inheritance

Предпочитай композицию наследованию.

class MovementBehavior:
    def move(self):
        pass

class Bird:
    def __init__(self, behavior: MovementBehavior):
        self.behavior = behavior
    
    def move(self):
        return self.behavior.move()

Explicit is Better Than Implicit

Явное лучше скрытого.

def process_numbers(numbers) -> list:
    return [num * 2 for num in numbers if num != 0]

Принцип единственной ответственности в функциях

Каждая функция должна делать одно и делать это хорошо.

def validate_user_data(data: dict) -> tuple:
    if not data.get("email"):
        return False, "Email required"
    return True, ""

def create_user(data: dict):
    return User(name=data["name"], email=data["email"])

def handle_user_signup(data: dict) -> dict:
    is_valid, error = validate_user_data(data)
    if not is_valid:
        return {"error": error}
    user = create_user(data)
    return {"success": True}

Главное — пиши код, который:

1. Читаем
2. Поддерживаем
3. Тестируем
4. Масштабируем
5. Простой