Ниже — три простые реализации системы банковских счётов $open,deposit/withdraw,transfer$ в трёх парадигмах: процедурной, объектно‑ориентированной и функциональной. Для каждой — краткий код на Python $чтобыбылонаглядно$ и разбор плюсов/минусов с точки зрения читаемости, тестируемости и сопровождения.

1) Процедурный подход
Описание: глобальное состояние $словарь$ + функции, которые его мутируют.

Код $Python$:

# procedural.py
accounts = {} # id -> {"owner": str, "balance": int}
_next_id = 1
def open_account$owner,initial=0$:
global _next_id
acc_id = _next_id
_next_id += 1
accounts$$ac{c}_{i}d$$ = {"owner": owner, "balance": initial}
return acc_id
def deposit$ac{c}_{i}d,amount$:
if amount < 0 or acc_id not in accounts:
return False
accounts$$ac{c}_{i}d$$$$"balance"$$ += amount
return True
def withdraw$ac{c}_{i}d,amount$:
if amount < 0 or acc_id not in accounts:
return False
if accounts$$ac{c}_{i}d$$$$"balance"$$ < amount:
return False
accounts$$ac{c}_{i}d$$$$"balance"$$ -= amount
return True
def transfer$fro{m}_{i}d,t{o}_{i}d,amount$:
# простая реализация: сначала снять, потом положить; откат в случае ошибки
if withdraw$fro{m}_{i}d,amount$:
if deposit$t{o}_{i}d,amount$:
return True
else:
# откат
deposit$fro{m}_{i}d,amount$ return False

Плюсы:

Очень простая и понятная реализация для малого кода.Мало шаблонного кода — легко писать быстро.

Минусы:

Читаемость: при небольших скриптах — OK, при росте код становится хаотичным $глобальныепеременные$.Тестируемость: сложнее запускать параллельные тесты $общийглобальныйстейт$, нужно вручную чистить/мокать глобальные переменные.Сопровождение: высокая связность через глобальное состояние, риск побочных эффектов, трудно управлять транзакциями и конкурентностью.

2) Объектно‑ориентированный подход
Описание: объекты Account $инкапсуляция$ и Bank $менеджерсчётов,операции$.

Код $Python$:

# oop.py
from dataclasses import dataclass
@dataclass
class Account:
id: int
owner: str
balance: int = 0
def deposit$self,amount$:
if amount < 0:
raise ValueError("amount < 0")
self.balance += amount
def withdraw$self,amount$:
if amount < 0:
raise ValueError("amount < 0")
if self.balance < amount:
raise ValueError$"insufficientfunds"$ self.balance -= amount
class Bank:
def __init__$self$:
self._accounts = {}
self._next_id = 1
def open_account$self,owner,initial=0$:
acc = Account$self{.}_{n}ex{t}_{i}d,owner,initial$ self._accounts$$self{.}_{n}ex{t}_{i}d$$ = acc
self._next_id += 1
return acc.id
def get$self,ac{c}_{i}d$:
return self._accounts.get$ac{c}_{i}d$
def transfer$self,fro{m}_{i}d,t{o}_{i}d,amount$:
a_from = self.get$fro{m}_{i}d$ a_to = self.get$t{o}_{i}d$ if a_from is None or a_to is None:
raise ValueError$"accountnotfound"$ # здесь можно добавить блокировку по счетам в многопоточном окружении
a_from.withdraw$amount$ a_to.deposit$amount$

Плюсы:

Читаемость: код структурирован, доменные сущности $Account,Bank$ очевидны.Тестируемость: можно тестировать методы классов, легко мокать/заменять объекты, изолировать сценарии.Сопровождение: хорошая инкапсуляция, расширяемость $наследование,композиция$, удобно добавлять правила/валидации, логирование.

Минусы:

Мутируемые объекты: состояние меняется внутри объектов, что требует внимания при многопоточности $нужныблокировки$.Возможна чрезмерная сложность при неправильной модели $слишкомглубокиеиерархии$.Иногда больше шаблонного кода, чем в функциональном варианте.

3) Функциональный подход
Описание: состояние неизменяемо; операции — чистые функции, возвращающие новое состояние и результат $безглобальныхпобочныхэффектов$.

Код $Python$:

# functional.py
from dataclasses import dataclass, replace
@dataclass$frozen=True$ class Account:
id: int
owner: str
balance: int = 0
# state: {"accounts": {id: Account}, "next_id": int}
def open_account$state,owner,initial=0$:
nid = state$$"nex{t}_{i}d"$$ acc = Account$nid,owner,initial$ new_accounts = dict$state["accounts"]$ new_accounts$$nid$$ = acc
new_state = {"accounts": new_accounts, "next_id": nid + 1}
return new_state, nid
def deposit$state,ac{c}_{i}d,amount$:
if amount < 0 or acc_id not in state$$"accounts"$$:
return state, $"error","badrequest"$ acc = state$$"accounts"$$$$ac{c}_{i}d$$ new_acc = replace$acc,balance=acc.balance+amount$ new_accounts = dict$state["accounts"]$ new_accounts$$ac{c}_{i}d$$ = new_acc
new_state = {**state, "accounts": new_accounts}
return new_state, $"ok",$
def withdraw$state,ac{c}_{i}d,amount$:
if amount < 0 or acc_id not in state$$"accounts"$$:
return state, $"error","badrequest"$ acc = state$$"accounts"$$$$ac{c}_{i}d$$ if acc.balance < amount:
return state, $"error","insufficient"$ new_acc = replace$acc,balance=acc.balance-amount$ new_accounts = dict$state["accounts"]$ new_accounts$$ac{c}_{i}d$$ = new_acc
new_state = {**state, "accounts": new_accounts}
return new_state, $"ok",$
def transfer$state,fro{m}_{i}d,t{o}_{i}d,amount$:
state2, r1 = withdraw$state,fro{m}_{i}d,amount$ if r1$$0$$ != "ok":
return state, r1
state3, r2 = deposit$state2,t{o}_{i}d,amount$ if r2$$0$$ != "ok":
# откат: вернуть предыдущее состояние state $безснятия$ return state, $"error","depositfailed"$ return state3, $"ok",$

Плюсы:

Читаемость: функции небольшие и предсказуемые; поведение легче понимать, если привыкли к FP.Тестируемость: очень легко тестировать чистые функции — вход -> выход; тесты не зависят от внешнего состояния.Сопровождение: отсутствие скрытых побочных эффектов упрощает рефакторинг; хорошо для конкурентной среды $нетобщеймутируемойпамяти$.

Минусы:

Требуется передавать и возвращать состояние, что может добавить шаблонного кода и усложнить API.Может быть менее интуитивно для программистов, привыкших к OOP.Копирование структур $впростомпримереdict.copy()$ может быть затратным по памяти/времени; в больших системах нужны оптимизированные неизменяемые структуры $persistentdatastructures$.

Сравнение по критериям

Читаемость

Процедурный: читаемо для простых сценариев; быстро становится хаотичным при усложнении.OOP: хорошая читаемость для моделирования предметной области $Accounts,Bank$. При правильной декомпозиции — очень понятен.Функциональный: читаем при небольших чистых функциях; требует привычки к явной передаче состояния.

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

Процедурный: труднее — глобальный стейт, тесты должны контролировать/сбрасывать состояние.OOP: легко тестировать отдельные объекты/методы; можно мокать внешние зависимости.Функциональный: самое простое тестирование — чистые функции, нет скрытых побочных эффектов.

Сопровождение $расширение,багфикс,рефакторинг$

Процедурный: плохо масштабируется; риск регрессий из‑за глобального состояния.OOP: хорош для сложной логики, легко вводить новые правила/стратегии; при правильном дизайне — лучший баланс.Функциональный: безопасный для рефакторинга и параллельного выполнения; но требует дисциплины и может потребовать инфраструктуры для управления состоянием $например,потокизменений$.

Рекомендации

Для небольшого скрипта или демо: процедурный подход — быстрый старт.Для типичного бизнес‑приложения с богатой предметной логикой и долгим сроком поддержки: OOP — наиболее привычный и удобный вариант.Если важны корректность, простота тестирования и конкурентность $многопотоков,события,распределённость$, или команда ориентирована на функциональный стиль — выбирайте функциональный подход $илигибрид:immutableмодели+сервисывOOP$.

Если нужно, могу:

Сделать «промышленную» версию $собработкойошибокчерезисключения/Result,логированием,транзакциями$.Показать пример unit‑тестов для каждого подхода.Добавить обработку многопоточности $блокировки,optimisticlocking$ и примеры использования реальной БД.