Cours Clean Code Complet ✨

# ✅ Noms qui racontent une histoire
SECONDS_PER_DAY = 86400
def calculate_shipping_cost(weight, distance): …
users = get_active_users()
for user in users:
if user.is_active: …

# 1. Variables = noms (ce que c'est)
user_count = 42 # ✅ Nom descriptif
is_admin = True # ✅ Booléen = is_/has_/can_/should_
max_retries = 3 # ✅ Avec contexte

# 2. Fonctions = verbes (ce que ça fait)
def get_user_by_id(id): … # ✅ get/set/create/delete/validate/send
def is_valid_email(e): … # ✅ Booléen retourné = is_/has_/can_
def calculate_total(c): … # ✅ Verbe clair

# 3. Classes = noms (ce que c'est)
class UserRepository: … # ✅ PascalCase
class PaymentProcessor: … # ✅ Rôle clair

# 4. Constantes = UPPER_SNAKE_CASE
MAX_FILE_SIZE = 5_000_000 # ✅
API_BASE_URL = « https://… » # ✅

# 5. Éviter les abréviations sauf universelles
# ✅ OK : url, id, html, css, api, db, http, json
# ❌ NON : usr, cnt, mgr, proc, tmp, val, btn

# ✅ Fonctions petites et composables
def process_order(order: Order) -> Receipt:
validate_order(order)
total = calculate_total(order)
total = apply_discounts(total, order.coupons)
check_stock(order.items)
charge_payment(order.payment, total)
send_confirmation(order.user.email)
return generate_receipt(order, total)

# Chaque sous-fonction fait UNE chose, 5-15 lignes max
def calculate_total(order: Order) -> float:
return sum(item.price * item.quantity for item in order.items)

def apply_discounts(total: float, coupons: list[Coupon]) -> float:
for coupon in coupons:
total *= (1 – coupon.discount)
return round(total, 2)

# 1. Maximum 3 paramètres (idéal : 0-2)
# ❌
def create_user(name, email, age, role, team, dept, mgr): …

# ✅ Regrouper dans un objet
@dataclass
class UserInput:
name: str; email: str; age: int
role: str = « user »

def create_user(data: UserInput): …

# 2. Pas d'effets de bord surprenants
# ❌ get_user() qui modifie la BDD en secret
# ✅ Le nom dit EXACTEMENT ce que ça fait

# 3. Retourner tôt (early return)
# ❌ Imbrication profonde
def process(user):
if user:
if user.is_active:
if user.has_permission:
# code…

# ✅ Guard clauses (retour anticipé)
def process(user):
if not user: return
if not user.is_active: return
if not user.has_permission: return
# code principal — au même niveau

# ✅ Propre, aéré, structuré
def get_combined_data(base_value: int, offset: int) -> Data | None:
total = base_value + offset
if total <= 0:
return None

raw_data = fetch_data(total)
if not raw_data:
return None

return process_data(raw_data)

# ❌ Code dupliqué
def create_admin(name, email):
validate_email(email)
user = User(name, email, role=« admin »)
db.save(user)
send_welcome_email(email)

def create_editor(name, email):
validate_email(email)
user = User(name, email, role=« editor »)
db.save(user)
send_welcome_email(email)

# ✅ Une seule fonction paramétrable
def create_user(name: str, email: str, role: str = « user ») -> User:
validate_email(email)
user = User(name, email, role=role)
db.save(user)
send_welcome_email(email)
return user

# ❌ Trop malin
result = (
reduce(lambda a, b: a + b,
map(lambda x: x[« price »] * x[« qty »],
filter(lambda x: x[« active »], items)))
)

# ✅ Simple et lisible
total = sum(
item[« price »] * item[« qty »] for item in items
if item[« active »] )

# ❌ « Au cas où on en aura besoin un jour »
class UserService:
def export_to_csv(self): …
def export_to_xml(self): …
def export_to_pdf(self): …
def export_to_excel(self): …
# Personne n'utilise aucun de ces exports

# ✅ Implémenter quand c'est nécessaire
class UserService:
def export_to_csv(self): … # Seul format demandé

# ✅ Un fichier = un module = une responsabilité
# project/
# models/
# user.py → Modèle User
# order.py → Modèle Order
# services/
# user_service.py → Logique métier User
# order_service.py → Logique métier Order
# repositories/
# user_repo.py → Accès BDD User
# routes/
# user_routes.py → Endpoints API User
# tests/
# test_user.py
# test_order.py

# ✅ Exceptions spécifiques, messages clairs
try:
user = get_user_by_id(user_id)
except UserNotFoundError as e:
logger.warning(f »User not found »)
raise HTTPException(status_code=404, detail=str(e))

# Créer des exceptions métier
class InsufficientStockError(Exception):
def __init__(self, product: str, requested: int, available: int):
self.product = product
super().__init__(
f » : demandés, disponibles »
)

# Valider tôt (fail fast)
def create_order(items: list, payment: Payment) -> Order:
if not items:
raise ValueError(« La commande doit contenir au moins un article »)
if not payment.is_valid():
raise PaymentError(« Moyen de paiement invalide »)
# … logique métier

def test_calculate_total_with_discount():
# Arrange — préparer les données
cart = Cart()
cart.add(Product(« Laptop », 1000), qty=1)
cart.add(Product(« Mouse », 50), qty=2)
coupon = Coupon(discount=0.10) # -10%

# Act — exécuter l'action
total = cart.calculate_total(coupon)

# Assert — vérifier le résultat
assert total == 990.0 # (1000 + 100) * 0.90

def test_withdraw_insufficient_funds_raises():
account = BankAccount(« Alice », balance=100)
with pytest.raises(ValueError, match=« insuffisant »):
account.withdraw(500)

def test_create_user_with_invalid_email():
with pytest.raises(ValidationError):
create_user(name=« Alice », email=« pas-un-email »)

# ❌ Commentaire qui masque du mauvais code
# Vérifier si l'utilisateur est éligible à la réduction
if u.a > 18 and u.t == « p » and u.d > 365: …

# ✅ Le code s'explique lui-même
if user.is_eligible_for_discount(): …

# ✅ Commentaire utile : POURQUOI, pas QUOI
# Stripe exige un montant en centimes, pas en euros
amount_cents = int(total * 100)

# ✅ Commentaire utile : avertissement
# ATTENTION : cet endpoint est rate-limité à 100 req/min par Stripe

# ✅ TODO/FIXME acceptables (temporaires)
# TODO: migrer vers le nouveau SDK Stripe v12
# FIXME: race condition si 2 paiements simultanés

# SMELL 1 : Magic numbers
# ❌
if age > 18 and score > 750:
approve_loan()
# ✅
LEGAL_AGE = 18
MIN_CREDIT_SCORE = 750
if age > LEGAL_AGE and score > MIN_CREDIT_SCORE:
approve_loan()

# SMELL 2 : Condition complexe → extraire en fonction
# ❌
if (user.age >= 18 and user.kyc_verified and
user.country in ALLOWED_COUNTRIES and
not user.is_banned and user.credit_score > 600):
# ✅
if user.is_eligible_for_trading():

# SMELL 3 : Nested if → guard clauses (vu ch.3)
# SMELL 4 : Long parameter list → objet
# SMELL 5 : God class → découper en services
# SMELL 6 : Feature envy → déplacer la méthode
# SMELL 7 : Primitive obsession → value objects

# 1. Linter + formatter passent ?
ruff check .
black –check .

# 2. Tests passent ?
pytest

# 3. Types corrects ?
mypy .

# 4. Relire son propre diff
git diff –staged

# 5. Commit message clair ?
# ✅ « fix: prevent duplicate charges on retry »
# ❌ « fix stuff »