class CompteBancaire:
    # Attribut de classe : partage par toutes les instances
    taux_interet = 0.02

    def __init__(self, titulaire: str, solde_initial: float = 0):
        # Attributs d'instance : propres a chaque objet
        self.titulaire = titulaire
        self.solde = solde_initial
        self._historique = []          # convention "_" = usage interne

    def deposer(self, montant: float) -> None:
        if montant <= 0:
            raise ValueError("Le montant doit etre positif")
        self.solde += montant
        self._historique.append(("depot", montant))

    def retirer(self, montant: float) -> None:
        if montant > self.solde:
            raise ValueError("Solde insuffisant")
        self.solde -= montant
        self._historique.append(("retrait", montant))

    def appliquer_interets(self) -> None:
        self.solde *= (1 + self.taux_interet)

    def __str__(self):
        # Representation lisible pour l'utilisateur (print, str())
        return f"Compte de {self.titulaire} : {self.solde:.2f} EUR"

    def __repr__(self):
        # Representation non-ambigue pour le debogage (console, logs)
        return f"CompteBancaire(titulaire={self.titulaire!r}, solde={self.solde!r})"

compte = CompteBancaire("Alice", 1000)
compte.deposer(500)
compte.retirer(200)
print(compte)                      # utilise __str__
print(repr(compte))                # utilise __repr__

# Attribut de classe vs instance
print(CompteBancaire.taux_interet)     # 0.02, accessible sans instance
compte.taux_interet = 0.05             # cree un attribut D'INSTANCE qui masque celui de classe
print(compte.taux_interet, CompteBancaire.taux_interet)   # 0.05, 0.02 (inchange)

# Methodes de classe et methodes statiques
class Produit:
    devise_defaut = "EUR"

    def __init__(self, nom, prix):
        self.nom = nom
        self.prix = prix

    @classmethod
    def depuis_dict(cls, data: dict) -> "Produit":
        # constructeur alternatif : pattern tres courant
        return cls(data["nom"], data["prix"])

    @staticmethod
    def convertir_devise(montant: float, taux: float) -> float:
        # ne depend ni de l'instance ni de la classe : juste une fonction utilitaire logee ici
        return round(montant * taux, 2)

produit = Produit.depuis_dict({"nom": "Clavier", "prix": 49.99})
prix_usd = Produit.convertir_devise(produit.prix, 1.08)

# Encapsulation : conventions Python (pas d'imposition stricte comme Java)
class Exemple:
    def __init__(self):
        self.public = "visible partout"
        self._protege = "convention : usage interne, mais accessible"
        self.__prive = "name mangling : devient _Exemple__prive"

e = Exemple()
print(e._Exemple__prive)      # toujours accessible, mais decourage explicitement

# Attributs de classe mutables : piege similaire aux defauts de fonction
class Panier:
    def __init__(self):
        self.articles = []          # OK ici car defini dans __init__, pas au niveau classe

    # class Panier:
    #     articles = []             # BUG : partage entre toutes les instances !