Bonnes pratiques Python¶

# Longueur de ligne : 88 caracteres (standard ruff/black)
# PEP 8 recommande 79, mais 88-100 est la norme moderne

# Imports : stdlib, tiers, local — separes par une ligne vide
import os
import sys
from pathlib import Path

import fastapi
from sqlalchemy.orm import Session

from monpaquet.models import Item

# Espaces autour des operateurs
x = 10 + 2 * (5 - 1)

# Pas d'espace avant les parentheses d'appel
result = ma_fonction(arg1, arg2)

# Virgule finale dans les structures multi-lignes
config = {
    "host": "localhost",
    "port": 8000,
    "debug": False,  # virgule finale = diff plus propre en git
}

# Liste de carres des nombres pairs
carres_pairs = [x**2 for x in range(20) if x % 2 == 0]

# Dictionnaire inverse (valeur -> cle)
original = {"a": 1, "b": 2, "c": 3}
inverse = {v: k for k, v in original.items()}

# Set de mots uniques en minuscules
texte = "Python est Simple Python est Lisible"
mots_uniques = {mot.lower() for mot in texte.split()}

# Expression generatrice (evaluee paresseusement)
total = sum(x**2 for x in range(1000))  # Ne cree pas de liste intermediaire

# Ouverture de fichier — fermeture garantie
with open("donnees.csv", encoding="utf-8") as f:
    contenu = f.read()

# Plusieurs ressources simultanees
with open("source.txt") as src, open("dest.txt", "w") as dst:
    dst.write(src.read())

# Context manager personnalise avec contextlib
from contextlib import contextmanager
import time


@contextmanager
def chronometre(nom: str):
    debut = time.perf_counter()
    try:
        yield
    finally:
        duree = time.perf_counter() - debut
        print(f"{nom}: {duree:.3f}s")


with chronometre("traitement"):
    result = sum(range(1_000_000))

# Unpacking de sequences
premier, *reste = [1, 2, 3, 4, 5]
# premier = 1, reste = [2, 3, 4, 5]

*debut, dernier = [1, 2, 3, 4, 5]
# debut = [1, 2, 3, 4], dernier = 5

# Echange de variables sans temporaire
a, b = 1, 2
a, b = b, a  # a=2, b=1

# Merge de dictionnaires (Python 3.9+)
defaults = {"timeout": 30, "retries": 3}
overrides = {"timeout": 60}
config = {**defaults, **overrides}   # Python 3.5+
config = defaults | overrides        # Python 3.9+

def lire_lignes_csv_par_batch(chemin: str, taille: int = 1000):
    """
    Lit un CSV volumineux par lots sans tout charger en memoire.
    Utilise un generateur pour une empreinte memoire constante.
    """
    import csv

    batch: list[dict] = []
    with open(chemin, encoding="utf-8") as f:
        reader = csv.DictReader(f)
        for ligne in reader:
            batch.append(ligne)
            if len(batch) >= taille:
                yield batch
                batch = []
    if batch:  # Dernier lot (possiblement incomplet)
        yield batch


# Usage
for lot in lire_lignes_csv_par_batch("ventes.csv", taille=500):
    traiter_lot(lot)

# MAUVAIS : la liste est partagee entre tous les appels
def ajouter_item(item: str, liste: list = []) -> list:
    liste.append(item)
    return liste

ajouter_item("a")  # ["a"]
ajouter_item("b")  # ["a", "b"] — surprenant !

# CORRECT : utiliser None comme sentinel
def ajouter_item(item: str, liste: list | None = None) -> list:
    if liste is None:
        liste = []
    liste.append(item)
    return liste

# MAUVAIS : capture toutes les exceptions, y compris KeyboardInterrupt
try:
    faire_quelque_chose()
except:
    pass

# CORRECT : capter uniquement les exceptions prevues
try:
    faire_quelque_chose()
except ValueError as e:
    logger.warning("Valeur invalide : %s", e)
except (ConnectionError, TimeoutError) as e:
    logger.error("Erreur reseau : %s", e)
    raise

# MAUVAIS : etat global difficile a tester et a raisonner
_cache = {}

def obtenir_config(cle: str) -> str:
    return _cache.get(cle, "")

# CORRECT : encapsuler dans une classe ou utiliser l'injection de dependances
from functools import lru_cache


class ConfigService:
    def __init__(self) -> None:
        self._cache: dict[str, str] = {}

    def obtenir(self, cle: str) -> str:
        return self._cache.get(cle, "")

    def definir(self, cle: str, valeur: str) -> None:
        self._cache[cle] = valeur

# MAUVAIS
if x == None:
    pass
if x == True:
    pass
if type(x) == list:
    pass

# CORRECT
if x is None:
    pass
if x is True:
    pass
if isinstance(x, list):
    pass

# LBYL (style C/Java) — verifier avant d'agir
if "cle" in dictionnaire and isinstance(dictionnaire["cle"], int):
    valeur = dictionnaire["cle"]
else:
    valeur = 0

# EAFP (style pythonique) — essayer et gerer l'echec
try:
    valeur = dictionnaire["cle"]
except (KeyError, TypeError):
    valeur = 0

# Encore plus pythonique avec .get()
valeur = dictionnaire.get("cle", 0)

class ErreurApplication(Exception):
    """Classe de base pour les erreurs de l'application."""
    pass


class ErreurValidation(ErreurApplication):
    """Donnee invalide soumise a l'application."""

    def __init__(self, champ: str, message: str) -> None:
        self.champ = champ
        self.message = message
        super().__init__(f"Champ '{champ}': {message}")


class ErreurRessourceIntrouvable(ErreurApplication):
    """Ressource demandee inexistante."""

    def __init__(self, type_ressource: str, identifiant: int | str) -> None:
        self.type_ressource = type_ressource
        self.identifiant = identifiant
        super().__init__(f"{type_ressource} {identifiant!r} introuvable")


# Usage
def obtenir_utilisateur(user_id: int) -> dict:
    resultat = db.find(user_id)
    if resultat is None:
        raise ErreurRessourceIntrouvable("Utilisateur", user_id)
    return resultat

from functools import lru_cache, cache
from dataclasses import dataclass


# __slots__ : reduit la memoire des instances (pas de __dict__)
class PointOptimise:
    __slots__ = ("x", "y")

    def __init__(self, x: float, y: float) -> None:
        self.x = x
        self.y = y


# @dataclass avec slots (Python 3.10+)
@dataclass(slots=True, frozen=True)
class Coordonnee:
    latitude: float
    longitude: float


# Memoisation des appels couteux
@lru_cache(maxsize=128)
def fibonacci(n: int) -> int:
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)


# @cache = @lru_cache(maxsize=None) — sans limite
@cache
def calculer_factorielle(n: int) -> int:
    if n == 0:
        return 1
    return n * calculer_factorielle(n - 1)