Écriture et lecture de code | Exercices corrigés

Concepts & Exercices

Code = Structure + Syntaxe + Lisibilité

Principe fondamental

Structure

Organisation logique

Syntaxe

Règles grammaticales

Lisibilité

Compréhension aisée

📝

Exercice 1

Analyser la structure d'un programme

Exercice 2

Identifier la syntaxe correcte

Exercice 3

Corriger l'indentation

Exercice 4

Ajouter des commentaires pertinents

Exercice 5

Lire et comprendre un code complexe

Corrigé : Exercices 1 à 3

1 Structure d'un programme

Définition :

Structure d'un programme : Organisation logique des différentes parties d'un programme (déclarations, fonctions, boucles, conditions).

Méthode d'analyse :

Identifier les différentes sections du programme
Reconnaître les structures de contrôle
Comprendre la logique d'exécution
Identifier les entrées et sorties

def calculer_moyenne(notes):
    """Calcule la moyenne d'une liste de notes"""
    if len(notes) == 0:
        return 0
    
    total = 0
    for note in notes:
        total += note
    
    moyenne = total / len(notes)
    return round(moyenne, 2)

# Programme principal
notes_etudiant = [12, 15, 18, 14, 16]
resultat = calculer_moyenne(notes_etudiant)
print(f"Moyenne: {resultat}")
              

Section	Fonction	Description
Définition de fonction	calculer_moyenne()	Fonction qui calcule la moyenne
Structure conditionnelle	if len(notes) == 0:	Vérifie si la liste est vide
Boucle itérative	for note in notes:	Itère sur chaque note
Programme principal	Exécution	Appelle la fonction et affiche le résultat

Étape 1 : Identification des composants

Le programme contient une fonction et un programme principal

Étape 2 : Analyse des structures

Structure conditionnelle pour gérer le cas vide, boucle pour sommer les notes

Étape 3 : Compréhension de la logique

La fonction calcule une moyenne avec gestion d'erreur

Réponse finale :

Structure identifiée avec fonctions, conditions et boucles clairement organisées

Règles appliquées :

• Modularité : Le code est divisé en fonctions réutilisables

• Clarté : Chaque section a un objectif bien défini

• Flux logique : L'exécution suit un ordre cohérent

2 Syntaxe correcte

Définition :

Syntaxe : Ensemble des règles grammaticales qui définissent la structure correcte d'un programme dans un langage donné.

# Exemple de syntaxe correcte
def verifier_age(age):
    if age >= 18:
        return True
    else:
        return False

# Exemple de syntaxe incorrecte
def verifier_age(age)
    if age >= 18
        return True
    else
        return False
              

Élément	Syntaxe correcte	Syntaxe incorrecte
Définition de fonction	def nom():	def nom(): (manque les parenthèses)
Structure conditionnelle	if condition:	if condition (manque les deux-points)
Indentation	Espaces cohérents	Manque d'indentation

Étape 1 : Vérification des délimiteurs

Chaque structure doit se terminer par deux-points (:) dans Python

Étape 2 : Vérification de l'indentation

Le code dans les blocs doit être correctement indenté

Étape 3 : Vérification des parenthèses

Les fonctions doivent avoir des parenthèses même si elles sont vides

Réponse finale :

Syntaxe corrigée avec tous les éléments grammaticalement corrects

Règles appliquées :

• Deux-points : Obligatoires après les structures de contrôle

• Indentation : Définit les blocs de code en Python

• Grammaire : Respect des règles du langage

3 Indentation correcte

Définition :

Indentation : Espacement au début d'une ligne qui définit l'appartenance à un bloc de code.

# Mauvaise indentation
def trier_liste(liste):
resultat = []
for element in liste:
if element > 0:
resultat.append(element)
else:
resultat.append(0)
return resultat

# Bonne indentation
def trier_liste(liste):
    resultat = []
    for element in liste:
        if element > 0:
            resultat.append(element)
        else:
            resultat.append(0)
    return resultat
              

Étape 1 : Analyse des blocs

Chaque structure (if, for, while) crée un nouveau bloc indenté

Étape 2 : Correction de l'indentation

Chaque niveau d'imbrication ajoute 4 espaces (ou 1 tab)

Étape 3 : Vérification de la cohérence

Toutes les lignes d'un même bloc doivent avoir la même indentation

Réponse finale :

Indentation corrigée pour respecter la structure hiérarchique

Règles appliquées :

• Hiérarchie : L'indentation reflète la structure du programme

• Cohérence : Utiliser le même nombre d'espaces partout

• Clarté : L'indentation rend le code plus lisible

Corrigé : Exercices 4 à 5

4 Commentaires pertinents

Définition :

Commentaires : Texte explicatif dans le code qui n'est pas exécuté mais aide à comprendre le fonctionnement.

def tri_rapide(tableau):
    # Vérifie si le tableau est vide ou a un seul élément
    if len(tableau) <= 1:
        return tableau
    
    # Sélection du pivot (dernier élément)
    pivot = tableau[-1]
    
    # Partitionnement du tableau
    gauche = [x for x in tableau[:-1] if x <= pivot]
    droite = [x for x in tableau[:-1] if x > pivot]
    
    # Appel récursif sur les sous-tableaux et combinaison
    return tri_rapide(gauche) + [pivot] + tri_rapide(droite)

# Exemple d'utilisation
donnees = [64, 34, 25, 12, 22, 11, 90]
resultat = tri_rapide(donnees)
print(f"Tableau trié: {resultat}")
              

Étape 1 : Identifier les parties complexes

Ajouter des commentaires pour expliquer les parties non évidentes

Étape 2 : Expliquer l'algorithme

Décrire brièvement ce que fait chaque partie du code

Étape 3 : Clarifier les intentions

Expliquer pourquoi certaines décisions ont été prises

Réponse finale :

Commentaires ajoutés pour expliquer le fonctionnement de l'algorithme de tri rapide

Règles appliquées :

• Pertinence : Les commentaires expliquent le "pourquoi", pas le "quoi"

• Brièveté : Les commentaires sont concis mais clairs

• Mise à jour : Les commentaires doivent être mis à jour avec le code

5 Lecture de code complexe

Définition :

Lecture de code : Processus d'analyse et de compréhension d'un programme existant pour en saisir le fonctionnement.

def recherche_occurrences(texte, motif):
    """
    Recherche toutes les occurrences d'un motif dans un texte
    Retourne une liste des positions où le motif est trouvé
    """
    positions = []
    debut = 0
    
    while True:
        # Cherche la prochaine occurrence du motif
        pos = texte.find(motif, debut)
        
        # Si aucune occurrence trouvée, arrêter la boucle
        if pos == -1:
            break
            
        # Ajouter la position trouvée
        positions.append(pos)
        
        # Déplacer le point de départ pour la prochaine recherche
        debut = pos + 1
    
    return positions

# Test de la fonction
texte_test = "Bonjour le monde, bonjour à tous"
resultat = recherche_occurrences(texte_test, "bonjour")
print(f"Positions: {resultat}")
              

Étape 1 : Analyse générale

La fonction recherche des occurrences d'un motif dans un texte

Étape 2 : Suivi de l'exécution

Initialisation de positions=[], debut=0, puis boucle while

Étape 3 : Compréhension de la logique

Chaque itération trouve une occurrence et met à jour le point de départ

Étape 4 : Résultat attendu

Retourne une liste des positions des occurrences trouvées

Réponse finale :

Compréhension complète du fonctionnement de la fonction de recherche

Règles appliquées :

• Progression étape par étape : Suivre l'exécution ligne par ligne

• Variables : Suivre l'évolution des variables clés

• Logique : Comprendre l'objectif de chaque structure

Cours bien détaillé

Code lisible = Code maintenable

Principe de qualité

🎯

Structure : Organisation logique des éléments du programme.

📏

Syntaxe : Respect des règles grammaticales du langage.

📐

Indentation : Espacement qui montre la hiérarchie du code.

📝

Commentaires : Explications qui clarifient le fonctionnement.

💡

Conseil : Écrire du code comme si quelqu'un d'autre devait le lire

🔍

Attention : Vérifier la syntaxe avant l'exécution

⚡

Astuce : Utiliser des outils d'analyse syntaxique

📋

Méthode : Structurer le code en fonctions modulaires

✅

Vérification : Relire son code après l'avoir écrit

Bonnes pratiques :

Indentation cohérente : Utiliser 4 espaces ou 1 tab partout
Noms descriptifs : Variables et fonctions bien nommées
Commentaires pertinents : Expliquer le "pourquoi", pas le "quoi"
Structures claires : Utiliser des blocs bien définis
Modularité : Découper le code en fonctions réutilisables

Règles de lisibilité :

Respecter la syntaxe du langage de programmation
Utiliser une indentation cohérente
Ajouter des commentaires explicatifs aux endroits clés
Donner des noms significatifs aux variables et fonctions
Structurer le code en blocs logiques

Syntaxe

Règles grammaticales

Structure

Organisation logique

Lisibilité

Clarté du code

Écriture et lecture de codeExercices corrigés

Écriture et lecture de code
Exercices corrigés