Приведи пример, когда не нужно ООП

# Приведи пример, когда не нужно ООП

Хотя Python поддерживает ООП (объектно-ориентированное программирование), это не всегда лучший выбор. Есть много случаев, когда функциональное программирование, процедурный подход или просто функции намного проще и понятнее.

Когда ООП не нужно

1. Простые одноразовые скрипты

# ❌ ПЕРЕУСЛОЖНЕНО с ООП
class DataProcessor:
    def __init__(self, filename):
        self.filename = filename
    
    def process(self):
        with open(self.filename, 'r') as f:
            lines = f.readlines()
        return [line.strip() for line in lines]

processor = DataProcessor('data.txt')
result = processor.process()

# ✅ ПРОСТО И ПОНЯТНО
def process_file(filename):
    with open(filename, 'r') as f:
        return [line.strip() for line in f.readlines()]

result = process_file('data.txt')

2. Математические вычисления и обработка данных

# ❌ ИЗЛИШНЕЕ ООП
class Calculator:
    def add(self, a, b):
        return a + b
    
    def multiply(self, a, b):
        return a * b

calc = Calculator()
result = calc.add(5, 3) + calc.multiply(4, 2)

# ✅ ФУНКЦИОНАЛЬНЫЙ ПОДХОД
def add(a, b):
    return a + b

def multiply(a, b):
    return a * b

result = add(5, 3) + multiply(4, 2)

# ✅ ЕЩЕ ЛУЧШЕ — использовать встроенные функции
result = (5 + 3) + (4 * 2)

3. Конвейеры обработки данных (pipeline)

# ❌ С ООП (слишком сложно)
class DataPipeline:
    def __init__(self, data):
        self.data = data
    
    def filter_positive(self):
        self.data = [x for x in self.data if x > 0]
        return self
    
    def multiply_by_two(self):
        self.data = [x * 2 for x in self.data]
        return self
    
    def get_result(self):
        return self.data

pipeline = DataPipeline([1, -2, 3, -4, 5])
result = pipeline.filter_positive().multiply_by_two().get_result()

# ✅ ФУНКЦИОНАЛЬНЫЙ ПОДХОД (чище)
from functools import reduce

def filter_positive(data):
    return [x for x in data if x > 0]

def multiply_by_two(data):
    return [x * 2 for x in data]

def compose(*functions):
    """Композиция функций"""
    def composed(x):
        return reduce(lambda a, f: f(a), functions, x)
    return composed

pipeline = compose(filter_positive, multiply_by_two)
result = pipeline([1, -2, 3, -4, 5])

4. Утилиты и хелперы

# ❌ ООП заломка для утилит
class StringUtils:
    @staticmethod
    def capitalize(s):
        return s.capitalize()
    
    @staticmethod
    def reverse(s):
        return s[::-1]
    
    @staticmethod
    def to_uppercase(s):
        return s.upper()

utils = StringUtils()
result = utils.capitalize("hello")

# ✅ ПРОСТО ФУНКЦИИ
def capitalize(s):
    return s.capitalize()

def reverse(s):
    return s[::-1]

def to_uppercase(s):
    return s.upper()

result = capitalize("hello")

# ✅ ИЛИ ИСПОЛЬЗУЙ ВСТРОЕННЫЕ МЕТОДЫ
result = "hello".capitalize()

5. Обработка команд в CLI

# ❌ ИЗЛИШНЕЕ ООП
class Command:
    def execute(self):
        raise NotImplementedError

class ListCommand(Command):
    def execute(self):
        return "Список файлов"

class CopyCommand(Command):
    def execute(self):
        return "Копирование файла"

# ✅ ПРОСТО СЛОВАРЬ С ФУНКЦИЯМИ
commands = {
    'list': lambda: "Список файлов",
    'copy': lambda: "Копирование файла",
    'delete': lambda: "Удаление файла"
}

cmd = input("Команда: ")
result = commands.get(cmd, lambda: "Неизвестная команда")()

Практические примеры, где нужны функции, не ООП

1. Обработка логов

# ✅ ФУНКЦИОНАЛЬНЫЙ ПОДХОД идеален для логов
import re
from typing import Iterator

def read_log_file(filename: str) -> Iterator[str]:
    """Читать лог построчно"""
    with open(filename, 'r') as f:
        yield from f

def filter_errors(lines: Iterator[str]) -> Iterator[str]:
    """Оставить только ошибки"""
    return (line for line in lines if 'ERROR' in line)

def extract_timestamps(lines: Iterator[str]) -> list[str]:
    """Извлечь временные метки"""
    pattern = r'^\[(.*?)\]'
    return [re.match(pattern, line).group(1) for line in lines if re.match(pattern, line)]

# Использование
errors = read_log_file('app.log')
error_lines = filter_errors(errors)
timestamps = extract_timestamps(error_lines)
print(timestamps)

2. Преобразование данных между форматами

# ✅ ФУНКЦИИ идеальны для преобразований
import json
import csv

def csv_to_json(csv_file: str, json_file: str) -> None:
    """Преобразовать CSV в JSON"""
    data = []
    with open(csv_file, 'r') as f:
        reader = csv.DictReader(f)
        for row in reader:
            data.append(row)
    
    with open(json_file, 'w') as f:
        json.dump(data, f, indent=2)

def json_to_dict(json_file: str) -> dict:
    """Загрузить JSON в словарь"""
    with open(json_file, 'r') as f:
        return json.load(f)

# Простое использование
csv_to_json('data.csv', 'data.json')
config = json_to_dict('config.json')

3. Параллельная обработка массивов

# ✅ ФУНКЦИИ С map/filter идеальны
numbers = [1, 2, 3, 4, 5]

# Удвоить все числа
doubled = list(map(lambda x: x * 2, numbers))

# Оставить только четные
evens = list(filter(lambda x: x % 2 == 0, numbers))

# Комбинировать операции
result = list(map(lambda x: x * 2, filter(lambda x: x > 2, numbers)))
# [6, 8, 10]

# ✅ С list comprehension еще чище
result = [x * 2 for x in numbers if x > 2]

4. Работа с конфигурацией

# ✅ ПРОСТО СЛОВАРИ И ФУНКЦИИ
def load_config(filename: str) -> dict:
    """Загрузить конфигурацию"""
    import json
    with open(filename, 'r') as f:
        return json.load(f)

def get_config_value(config: dict, key: str, default=None):
    """Получить значение из конфига"""
    return config.get(key, default)

# Использование
config = load_config('config.json')
api_key = get_config_value(config, 'api_key', 'default_key')
timeout = get_config_value(config, 'timeout', 30)

5. Валидация данных

# ✅ ФУНКЦИИ ДЛЯ ВАЛИДАЦИИ НАМНОГО ПРОЩЕ
def validate_email(email: str) -> bool:
    """Проверить email"""
    import re
    return bool(re.match(r'^[\w\.-]+@[\w\.-]+\.\w+$', email))

def validate_phone(phone: str) -> bool:
    """Проверить номер телефона"""
    return bool(phone.replace('-', '').replace('+', '').isdigit())

def validate_age(age: int) -> bool:
    """Проверить возраст"""
    return 0 < age < 150

# Использование
if validate_email(user_email) and validate_age(user_age):
    save_user(user_data)

# ❌ ООП ПЕРЕУСЛОЖНИТ
class Validator:
    def validate_email(self, email):
        # ...
    def validate_phone(self, phone):
        # ...

Когда нужна простота вместо ООП

# ЗАДАЧА: парсинг и трансформация JSON

# ❌ ИЗЛИШНЯЯ АРХИТЕКТУРА
class JsonParser:
    def __init__(self, filename):
        self.filename = filename
        self.data = None
    
    def parse(self):
        import json
        with open(self.filename) as f:
            self.data = json.load(f)
        return self
    
    def transform(self):
        return [x.upper() for x in self.data]

parser = JsonParser('data.json')
result = parser.parse().transform()

# ✅ ПРОСТЫЕ ФУНКЦИИ
import json

def load_json(filename):
    with open(filename) as f:
        return json.load(f)

def transform_data(data):
    return [x.upper() for x in data]

result = transform_data(load_json('data.json'))

Правило KISS (Keep It Simple, Stupid)

# Не усложняй код без причины:

# ❌ ПЛОХО: создание класса для одной функции
class Adder:
    def add(self, a, b):
        return a + b

adder = Adder()
result = adder.add(5, 3)

# ✅ ХОРОШО: просто функция
def add(a, b):
    return a + b

result = add(5, 3)

# ✅ ИЛИ ПРЯМО ВЫЧИСЛИТЬ
result = 5 + 3

Когда ОО все-таки нужно

Классы действительно нужны, когда:

1. Состояние должно сохраняться между вызовами
2. Много методов работают с одними данными
3. Нужна иерархия и наследование
4. Используется полиморфизм
5. Нужна инкапсуляция

# ✅ ЗДЕСЬ КЛАССЫ ИМЕЮТ СМЫСЛ
class Database:
    def __init__(self, connection_string):
        self.conn = self._connect(connection_string)
    
    def _connect(self, conn_str):
        # подключиться к БД
        pass
    
    def execute(self, query):
        # выполнить запрос
        pass
    
    def close(self):
        # закрыть соединение
        self.conn.close()

Заключение

Не усложняй с ООП просто так:

• Простые скрипты — функции
• Математика и преобразования — функции
• Обработка данных — функции или map/filter
• Утилиты — функции
• Конфигурация — словари и функции

Используй ООП когда:

• Нужно состояние, которое сохраняется
• Логика связана с данными
• Нужна иерархия классов
• Несколько методов работают с одним состоянием

KISS правило: Выбирай самый простой способ решить проблему. Часто это функции, а не классы.