Décomposer un problème complexe
Exercices corrigés

"Concevoir un système de gestion pour une maison intelligente qui contrôle l'éclairage, le chauffage, la sécurité, la musique et l'automatisation des volets."

"Créer une plateforme e-commerce permettant aux clients de naviguer, rechercher, commander, payer et suivre leurs commandes, tout en gérant les stocks et les ventes pour les vendeurs."

# Structure du système e-commerce
class SystemeEcommerce:
    def __init__(self):
        self.utilisateurs = GestionUtilisateurs()
        self.catalogue = GestionCatalogue()
        self.panier = GestionPanier()
        self.commandes = GestionCommandes()
        self.paiements = GestionPaiements()
        self.stocks = GestionStocks()
        self.livraisons = GestionLivraisons()

class GestionUtilisateurs:
    def __init__(self):
        self.profiles = []
        self.permissions = {}
    
    def creer_compte(self, utilisateur):
        # Gère l'inscription et la création de compte
        pass

class GestionCatalogue:
    def __init__(self):
        self.produits = []
        self.categories = []
    
    def rechercher_produit(self, critere):
        # Gère la recherche de produits
        pass

class GestionPanier:
    def __init__(self):
        self.articles = []
        self.total = 0
    
    def ajouter_article(self, produit, quantite):
        # Gère l'ajout d'un article au panier
        pass

# Autres classes similaires pour chaque module...

• Chaque module peut être développé indépendamment
• Facilité de maintenance et de mise à jour
• Meilleure réutilisabilité du code
• Testabilité séparée de chaque module
• Meilleure collaboration entre développeurs

"Développer un système de gestion scolaire qui permet aux administrateurs de gérer les inscriptions, aux enseignants de suivre les performances des élèves, et aux parents de consulter les résultats et absences."

# Modèle de gestion scolaire décomposé
class Ecole:
    def __init__(self):
        self.personnes = PersonnesManager()
        self.cours = CoursManager()
        self.notes = NotesManager()
        self.absences = AbsencesManager()
        self.planning = PlanningManager()

class PersonnesManager:
    def __init__(self):
        self.eleves = []
        self.enseignants = []
        self.administrateurs = []
    
    def ajouter_eleve(self, eleve):
        # Gestion des inscriptions élèves
        pass

class CoursManager:
    def __init__(self):
        self.matieres = []
        self.niveaux = []
        self.classes = []
    
    def affecter_cours(self, enseignant, matiere, classe):
        # Attribution des cours
        pass

class NotesManager:
    def __init__(self):
        self.bulletins = {}
        self.moyennes = {}
    
    def saisir_note(self, eleve, matiere, note, periode):
        # Saisie des notes
        pass

# Continuation pour les autres modules...

"Développer un jeu de plateforme 2D où le joueur contrôle un personnage qui doit atteindre la fin du niveau en évitant des obstacles et en collectant des objets."

# Structure modulaire d'un jeu
class Jeu:
    def __init__(self):
        self.ecran = Ecran()
        self.joueur = Joueur()
        self.entites = EntitesManager()
        self.rendu = RenduManager(self.ecran)
        self.audio = AudioManager()
        self.etat_jeu = EtatJeu()
        
    def boucle_principale(self):
        while self.etat_jeu.en_cours:
            # Gestion des événements
            self.gerer_evenements()
            
            # Mise à jour de la logique
            self.mettre_a_jour()
            
            # Rendu graphique
            self.rendre()
    
    def gerer_evenements(self):
        # Gestion des entrées utilisateur
        pass
    
    def mettre_a_jour(self):
        # Mise à jour de la logique de jeu
        self.joueur.mettre_a_jour()
        self.entites.mettre_a_jour()
        self.verifier_collisions()
    
    def rendre(self):
        # Affichage des éléments
        self.rendu.dessiner_fond()
        self.rendu.dessiner_entites()
        self.rendu.dessiner_ui()

class Joueur:
    def __init__(self):
        self.x = 0
        self.y = 0
        self.vie = 3
        self.score = 0
    
    def deplacer(self, dx, dy):
        # Logique de déplacement
        pass
    
    def subir_degats(self, degats):
        # Gestion des dégâts
        self.vie -= degats

class EntitesManager:
    def __init__(self):
        self.ennemis = []
        self.objets = []
        self.obstacles = []
    
    def verifier_collisions(self):
        # Gestion des collisions
        pass

• Chaque module peut être testé indépendamment
• Meilleure lisibilité et maintenabilité du code
• Facilité d'extension avec de nouvelles fonctionnalités
• Parallélisation possible du développement
• Réutilisation potentielle des modules

"Créer un système de suivi financier personnel qui permet d'enregistrer les revenus et dépenses, de suivre les budgets, de gérer les investissements et de produire des rapports graphiques."

# Modèle financier décomposé
class SuiviFinancier:
    def __init__(self):
        self.comptes = GestionComptes()
        self.transactions = GestionTransactions()
        self.budgets = GestionBudgets()
        self.investissements = GestionInvestissements()
        self.rapports = GestionRapports()
        self.synchronisation = GestionSync()
    
    def mettre_a_jour_solde(self):
        # Met à jour les soldes de tous les comptes
        for compte in self.comptes.get_all():
            compte.solde = self.transactions.calculer_solde(compte.id)

class GestionComptes:
    def __init__(self):
        self.comptes = []
    
    def ajouter_compte(self, type_compte, nom, solde_initial=0):
        # Ajoute un nouveau compte
        compte = Compte(type_compte, nom, solde_initial)
        self.comptes.append(compte)
        return compte

class GestionTransactions:
    def __init__(self):
        self.transactions = []
    
    def enregistrer_transaction(self, montant, categorie, compte, date):
        # Enregistre une nouvelle transaction
        transaction = Transaction(montant, categorie, compte, date)
        self.transactions.append(transaction)
        return transaction
    
    def calculer_solde(self, compte_id):
        # Calcule le solde d'un compte
        solde = 0
        for t in self.transactions:
            if t.compte_id == compte_id:
                solde += t.montant
        return solde

class Transaction:
    def __init__(self, montant, categorie, compte_id, date):
        self.montant = montant  # positif pour revenus, négatif pour dépenses
        self.categorie = categorie
        self.compte_id = compte_id
        self.date = date

class Compte:
    def __init__(self, type_compte, nom, solde_initial=0):
        self.type = type_compte
        self.nom = nom
        self.solde = solde_initial
        self.numero = self.generer_numero()

    def generer_numero(self):
        # Génère un numéro de compte unique
        import random
        return f"ACC-{random.randint(10000, 99999)}"

# Module de budget
class GestionBudgets:
    def __init__(self):
        self.budgets = []
        self.depenses_par_categorie = {}
    
    def definir_budget_mensuel(self, categorie, montant_max):
        # Définit un budget mensuel pour une catégorie
        budget = Budget(categorie, montant_max)
        self.budgets.append(budget)
        return budget
    
    def verifier_depassement(self, categorie, montant):
        # Vérifie si le budget est dépassé
        depenses = self.depenses_par_categorie.get(categorie, 0)
        total = depenses + montant
        
        for budget in self.budgets:
            if budget.categorie == categorie:
                if total > budget.montant_max:
                    return True
        return False

Chaque module contribue à la cohérence globale du système financier.