Critères de qualité
Exercices corrigés

# Code peu lisible def f(x): s=0 for i in range(len(x)): if x[i]>0: s+=x[i]**2 return s # Code lisible def somme_carres_positifs(nombres): """ Calcule la somme des carrés des nombres positifs. Args: nombres (list): Liste de nombres Returns: int: Somme des carrés des nombres positifs """ somme = 0 for nombre in nombres: if nombre > 0: somme += nombre ** 2 return somme # Exemple d'utilisation donnees = [-2, 3, -1, 4, 0, 5] resultat = somme_carres_positifs(donnees) print(f"Somme des carrés positifs: {resultat}")

# Version inefficace - O(n²) def recherche_max_incorrect(tableau): """Recherche du maximum avec complexité quadratique.""" for i in range(len(tableau)): est_maximum = True for j in range(len(tableau)): if tableau[j] > tableau[i]: est_maximum = False break if est_maximum: return tableau[i] # Version efficace - O(n) def recherche_max_correct(tableau): """Recherche du maximum avec complexité linéaire.""" if not tableau: return None maximum = tableau[0] for element in tableau[1:]: if element > maximum: maximum = element return maximum # Analyse de performance import time import random tailles = [1000, 5000, 10000] for taille in tailles: donnees = [random.randint(1, 1000) for _ in range(taille)] # Version inefficace debut = time.time() resultat1 = recherche_max_incorrect(donnees) temps1 = time.time() - debut # Version efficace debut = time.time() resultat2 = recherche_max_correct(donnees) temps2 = time.time() - debut print(f"Taille: {taille}") print(f" Version O(n²): {temps1:.6f}s") print(f" Version O(n): {temps2:.6f}s") print(f" Gain: {temps1/temps2:.2f}x")

# Version non robuste def division_simple(a, b): return a / b # Version robuste def division_securisee(a, b): """ Effectue une division avec gestion des erreurs. Args: a (float): Numérateur b (float): Dénominateur Returns: float: Résultat de la division Raises: ZeroDivisionError: Si b est zéro TypeError: Si a ou b ne sont pas des nombres """ if not isinstance(a, (int, float)) or not isinstance(b, (int, float)): raise TypeError("Les arguments doivent être des nombres") if b == 0: raise ZeroDivisionError("Division par zéro impossible") return a / b # Tests de robustesse cas_tests = [ (10, 2), # Cas normal (10, 0), # Division par zéro (10, "2"), # Type incorrect ("10", 2), # Type incorrect (-5, 2), # Cas négatif (0, 5), # Zéro divisé ] for numerateur, denominateur in cas_tests: try: resultat = division_securisee(numerateur, denominateur) print(f"{numerateur} / {denominateur} = {resultat}") except Exception as e: print(f"Erreur avec {numerateur} / {denominateur}: {type(e).__name__} - {e}")

# Code non maintenable - tout dans une fonction def gestion_comptes_utilisateurs(operations): """Fonction complexe qui fait trop de choses.""" # Chargement des données with open("utilisateurs.txt", "r") as f: utilisateurs = f.read().splitlines() # Traitement des opérations for operation in operations: if operation.startswith("ajouter"): nom = operation.split()[1] utilisateurs.append(nom) elif operation.startswith("supprimer"): nom = operation.split()[1] utilisateurs.remove(nom) elif operation.startswith("rechercher"): nom = operation.split()[1] if nom in utilisateurs: print(f"{nom} trouvé") # Sauvegarde des données with open("utilisateurs.txt", "w") as f: f.write("\n".join(utilisateurs)) # Code maintenable - fonctions modulaires def charger_utilisateurs(fichier): """Charge la liste des utilisateurs depuis un fichier.""" with open(fichier, "r") as f: return f.read().splitlines() def sauvegarder_utilisateurs(fichier, utilisateurs): """Sauvegarde la liste des utilisateurs dans un fichier.""" with open(fichier, "w") as f: f.write("\n".join(utilisateurs)) def ajouter_utilisateur(utilisateurs, nom): """Ajoute un utilisateur à la liste.""" utilisateurs.append(nom) def supprimer_utilisateur(utilisateurs, nom): """Supprime un utilisateur de la liste.""" if nom in utilisateurs: utilisateurs.remove(nom) def rechercher_utilisateur(utilisateurs, nom): """Recherche un utilisateur dans la liste.""" return nom in utilisateurs def gerer_operations(operations, fichier="utilisateurs.txt"): """Gère les opérations sur les utilisateurs.""" utilisateurs = charger_utilisateurs(fichier) for operation in operations: if operation.startswith("ajouter"): nom = operation.split()[1] ajouter_utilisateur(utilisateurs, nom) elif operation.startswith("supprimer"): nom = operation.split()[1] supprimer_utilisateur(utilisateurs, nom) elif operation.startswith("rechercher"): nom = operation.split()[1] if rechercher_utilisateur(utilisateurs, nom): print(f"{nom} trouvé") sauvegarder_utilisateurs(fichier, utilisateurs)

def tri_fusion(tableau): """ Trie un tableau en utilisant l'algorithme du tri fusion (merge sort). Le tri fusion est un algorithme de tri stable qui fonctionne selon le principe de diviser pour régner. Il divise récursivement le tableau en deux moitiés jusqu'à ce que chaque sous-tableau contienne un seul élément, puis fusionne les sous-tableaux triés. Args: tableau (list): Liste d'éléments comparables à trier Returns: list: Nouvelle liste triée en ordre croissant Time Complexity: - Best case: O(n log n) - Average case: O(n log n) - Worst case: O(n log n) Space Complexity: O(n) Example: >>> tri_fusion([3, 1, 4, 1, 5]) [1, 1, 3, 4, 5] >>> tri_fusion([]) [] >>> tri_fusion([42]) [42] """ # Cas de base : tableau vide ou avec un élément if len(tableau) <= 1: return tableau # Division du tableau en deux moitiés milieu = len(tableau) // 2 gauche = tableau[:milieu] droite = tableau[milieu:] # Tri récursif des deux moitiés gauche_triee = tri_fusion(gauche) droite_triee = tri_fusion(droite) # Fusion des deux moitiés triées return fusionner(gauche_triee, droite_triee) def fusionner(gauche, droite): """ Fusionne deux listes triées en une seule liste triée. Args: gauche (list): Première liste triée droite (list): Deuxième liste triée Returns: list: Liste fusionnée et triée """ resultat = [] i = j = 0 # Comparer les éléments des deux listes et les fusionner while i < len(gauche) and j < len(droite): if gauche[i] <= droite[j]: resultat.append(gauche[i]) i += 1 else: resultat.append(droite[j]) j += 1 # Ajouter les éléments restants resultat.extend(gauche[i:]) resultat.extend(droite[j:]) return resultat # Documentation du module """ Module de tri fusion (Merge Sort) Ce module implémente l'algorithme de tri fusion, un algorithme de tri stable avec une complexité garantie de O(n log n). Fonctions principales: - tri_fusion(): Trie un tableau - fusionner(): Fusionne deux sous-tableaux triés """