Techniques de vérification visuelle | Exercices corrigés

Concepts & Exercices

\(\text{Qualité} = \text{Inspection} + \text{Revues} + \text{Bonnes Pratiques}\)

Vérification visuelle

Inspection

Vérification systématique

Examen détaillé

Revues

Collaboration

Travail d'équipe

Pratiques

Normes

Guidelines

🔍

Inspection de code : Examen systématique du code source pour détecter les erreurs.

👥

Revues de conception : Examen collaboratif des décisions architecturales.

✅

Bonnes pratiques : Règles et standards pour améliorer la qualité du code.

Exercice 1

Inspecter un code pour identifier les erreurs de logique

Exercice 2

Passer en revue une fonction pour améliorer sa lisibilité

Exercice 3

Identifier les problèmes de structure dans un algorithme

Exercice 4

Détecter les erreurs de style et de documentation

Exercice 5

Vérifier la cohérence d'un ensemble de fonctions

Corrigé : Exercices 1 à 3

1 Inspection de logique

Définition :

Inspection de logique : Technique systématique d'examen du code pour identifier les erreurs de raisonnement ou de traitement.

Méthode d'inspection :

Lire le code de manière méthodique
Identifier les structures de contrôle (boucles, conditions)
Vérifier la logique d'exécution
Identifier les erreurs potentielles

def verifier_age(age): if age > 18: # ERREUR ICI return "Majeur" else: return "Mineur" # Problème : 18 ans est considéré comme mineur print(verifier_age(18)) # Affiche "Mineur" - devrait être "Majeur"

Étape 1 : Analyser la condition

La condition age > 18 exclut les 18 ans

Étape 2 : Identifier l'erreur

Les 18 ans devraient être considérés comme majeurs

Étape 3 : Corriger la logique

Changer age > 18 en age >= 18

def verifier_age_corrige(age): if age >= 18: # CORRIGÉ return "Majeur" else: return "Mineur" print(verifier_age_corrige(18)) # Affiche "Majeur" - correct

Erreur identifiée :

Condition incorrecte qui exclut les 18 ans de la catégorie "majeur"

Règles appliquées :

• Conditions : Vérifier les bornes incluses/exclues

• Frontières : Tester les valeurs limites

• Logique : S'assurer que la logique correspond au besoin

2 Revue de lisibilité

Définition :

Revue de lisibilité : Examen collaboratif du code pour améliorer sa clarté et sa compréhension.

def f(x, y, z): r = [] for i in range(len(x)): if x[i] > y: t = x[i] * z r.append(t) return r # Code difficile à comprendre à cause des noms non descriptifs liste = [1, 5, 3, 8, 2] resultat = f(liste, 3, 2)

Étape 1 : Identifier les noms non descriptifs

Variables x, y, z, r, i, t ne disent rien sur leur utilité

Étape 2 : Analyser la logique

La fonction filtre les éléments > y et les multiplie par z

Étape 3 : Améliorer la lisibilité

Utiliser des noms de variables descriptifs

def filtrer_et_multiplier(valeurs, seuil, multiplicateur): """Filtre les valeurs supérieures au seuil et les multiplie par un facteur""" resultat = [] for valeur in valeurs: if valeur > seuil: valeur_transformee = valeur * multiplicateur resultat.append(valeur_transformee) return resultat liste_nombres = [1, 5, 3, 8, 2] resultat_final = filtrer_et_multiplier(liste_nombres, 3, 2)

Lisibilité améliorée :

Noms de variables et de fonctions descriptifs qui clarifient le but du code

Règles appliquées :

• Nom descriptif : Utiliser des noms qui décrivent la fonction

• Commentaires : Ajouter des commentaires pour expliquer la logique

• Structure : Organiser le code pour faciliter la lecture

3 Structure algorithmique

Définition :

Structure algorithmique : Organisation logique des instructions pour résoudre un problème.

def trouver_maximum(liste): max_val = 0 # Problème : initialisation incorrecte for i in range(len(liste)): if liste[i] > max_val: max_val = liste[i] return max_val # Problème : ne fonctionne pas avec des listes de nombres négatifs print(trouver_maximum([-5, -2, -8, -1])) # Retourne 0 au lieu de -1

Étape 1 : Identifier le problème d'initialisation

Initialiser max_val à 0 ne fonctionne pas avec des nombres négatifs

Étape 2 : Analyser les cas limites

Que se passe-t-il avec des listes contenant uniquement des nombres négatifs ?

Étape 3 : Corriger la structure

Initialiser avec le premier élément de la liste

def trouver_maximum_corrige(liste): if not liste: # Gestion du cas vide return None max_val = liste[0] # Initialisation correcte for valeur in liste[1:]: # Commencer à l'indice 1 if valeur > max_val: max_val = valeur return max_val print(trouver_maximum_corrige([-5, -2, -8, -1])) # Retourne -1 - correct

Structure améliorée :

Initialisation correcte et gestion des cas limites pour une structure plus robuste

Règles appliquées :

• Initialisation : Choisir des valeurs initiales appropriées

• Cas limites : Gérer les cas vides et extrêmes

• Itération : Optimiser les boucles pour éviter les répétitions

Corrigé : Exercices 4 à 5

4 Style et documentation

Définition :

Style et documentation : Normes de codage et commentaires pour améliorer la maintenabilité.

# Calcul de la moyenne def moyenne(l): s=0 for e in l:s+=e return s/len(l) # Pas de docstring, indentation irrégulière, noms courts resultat=moyenne([10,15,20])

Étape 1 : Identifier les problèmes de style

Indentation irrégulière, absence de docstring, noms de variables courts

Étape 2 : Améliorer la documentation

Ajouter une docstring décrivant la fonction

Étape 3 : Normaliser le style

Appliquer des conventions de codage cohérentes

def calculer_moyenne(liste_notes): """ Calcule la moyenne d'une liste de notes. Args: liste_notes (list): Liste de nombres représentant les notes Returns: float: La moyenne des notes Raises: ValueError: Si la liste est vide """ if not liste_notes: raise ValueError("La liste des notes ne peut pas être vide") somme = sum(liste_notes) moyenne_resultat = somme / len(liste_notes) return moyenne_resultat resultat_final = calculer_moyenne([10, 15, 20])

Style amélioré :

Documentation complète, nommage clair, gestion des erreurs et style cohérent

Règles appliquées :

• Docstring : Documenter toutes les fonctions importantes

• Style : Suivre les conventions de codage (PEP 8 pour Python)

• Nom descriptif : Utiliser des noms qui reflètent la fonction

5 Cohérence de code

Définition :

Cohérence de code : Uniformité des styles, conventions et structures dans un ensemble de fonctions.

# Ensemble de fonctions non cohérentes def additionner(a, b): return a + b def soustraire(x, y): """Soustrait y de x""" return x - y def multiplication(c,d): # Manque d'espace, nom pas clair return c*d # Styles différents, noms inconsistants resultat1 = additionner(5, 3) resultat2 = soustraire(10, 4) resultat3 = multiplication(2, 6)

Étape 1 : Identifier les incohérences

Noms de fonctions différents, styles d'espacement variés, documentation absente

Étape 2 : Établir des conventions

Définir des règles de nommage, de documentation et de style

Étape 3 : Harmoniser l'ensemble

Appliquer les conventions à toutes les fonctions

def additionner_operandes(operande1, operande2): """ Additionne deux opérandes. Args: operande1 (float): Premier opérande operande2 (float): Deuxième opérande Returns: float: Résultat de l'addition """ return operande1 + operande2 def soustraire_operandes(operande1, operande2): """ Soustrait le deuxième opérande du premier. Args: operande1 (float): Premier opérande operande2 (float): Deuxième opérande Returns: float: Résultat de la soustraction """ return operande1 - operande2 def multiplier_operandes(operande1, operande2): """ Multiplie deux opérandes. Args: operande1 (float): Premier opérande operande2 (float): Deuxième opérande Returns: float: Résultat de la multiplication """ return operande1 * operande2 # Ensemble cohérent de fonctions resultat_addition = additionner_operandes(5, 3) resultat_soustraction = soustraire_operandes(10, 4) resultat_multiplication = multiplier_operandes(2, 6)

Cohérence atteinte :

Ensemble de fonctions avec style uniforme, noms cohérents et documentation complète

Règles appliquées :

• Uniformité : Maintenir le même style dans tout le code

• Conventions : Établir et suivre des conventions de nommage

• Documentation : Appliquer la même structure de documentation

Cours bien détaillé

\(\text{Qualité}_{visuelle} = \text{Clarté} + \text{Cohérence} + \text{Documentation}\)

Facteurs de qualité

🎯

Définition : La vérification visuelle est l'examen humain du code pour identifier les erreurs et améliorer la qualité.

📏

Objectif : Détecter les erreurs avant l'exécution et améliorer la lisibilité du code.

📐

Techniques : Inspection de code, revue par les pairs, walkthroughs, checklist.

📝

Avantages : Détection précoce des erreurs, amélioration de la compréhension, partage de connaissances.

💡

Conseil : Prendre du recul et relire le code comme si vous ne l'aviez pas écrit

🔍

Attention : Ne pas ignorer les petits détails - ils peuvent cacher des erreurs

⚡

Astuce : Faire relire le code par un collègue pour un regard neuf

📋

Méthode : Utiliser une checklist pour ne rien oublier

✅

Vérification : Vérifier la logique avant la syntaxe

Checklist de vérification :

✓ Syntaxe : Aucune erreur de grammaire ou d'indentation
✓ Logique : Conditions et boucles correctement formulées
✓ Nom descriptif : Variables et fonctions bien nommées
✓ Documentation : Commentaires et docstrings présents
✓ Cohérence : Style uniforme dans tout le code
✓ Structure : Organisé de manière logique

Règles importantes :

La vérification visuelle est complémentaire aux tests automatisés
Elle permet de détecter des erreurs de logique que les tests pourraient manquer
Elle améliore la lisibilité et la maintenabilité du code
Elle favorise le partage de connaissances entre développeurs
Elle contribue à l'amélioration continue des pratiques de codage

Techniques de vérification visuelleExercices corrigés

Techniques de vérification visuelle
Exercices corrigés