Examen Python 11

EXAMEN EN PYTHON SUJET 11

Examen de Programmation Python -pandacodeur

Durée : 2 heures

Exercice 1 : Questions de cours (5 points)

Questions sur les listes en Python

  1. Quelle est la différence entre une liste et un tuple ?

  2. Quelle structure de données permet de stocker des clés et des valeurs en Python ?

  3. Peut-on modifier une liste ? un tuple ?

  4. Quelle est la différence entre une liste vide et un dictionnaire vide ?

  5. Qu'est-ce qu'une fonction en Python ?

  6. C'est quoi l'inférence de type ?

Exercice 2 : Programme Python (4 points)

Écrire un programme PYTHON qui affiche les nombres pairs de 1 à N

Énoncé :

  • L'utilisateur doit entrer uniquement des nombres entiers positif N.
  • Le programme doit utiliser une boucle pour afficher tous les nombres pairs de 1 à N.

Exemple d'exécution :

Entrez un nombre entier positif : 10
Nombres pairs de 1 à 10 : 2 4 6 8 10

Exercice 3 : Matrices (6 points)

Écrire un programme qui lit les coefficients de deux matrices carrées

Énoncé :

Écrire un programme qui lit les coefficients de deux matrices carrées A et B d'ordre N=10 et affiche le nombre de coefficients égaux.

Problème : Manipulation des Listes en Python (15 points)

Contexte : CAN 2026 avec équipes africaines

En programmation, les listes sont des structures de données couramment utilisées pour stocker des collections d'éléments. En Python, les listes sont particulièrement puissantes en raison de leur flexibilité et de la variété d'opérations que l'on peut effectuer sur elles. Dans cet exercice, vous allez manipuler une liste d'équipes participantes à la CAN 2026 en utilisant différentes techniques de découpage et de sélection d'éléments.

Partie A : Manipulation d'une Liste d'Équipes

Nous avons la Liste Initiale: equipes_can = ["Cameroun", "Sénégal", "Maroc", "Égypte", "Côte d'Ivoire", "Nigeria", "Algérie", "Tunisie", "Mali", "Ghana"]

  1. Quelle sera la sortie de equipes_can[0:2] ?

  2. Quelle sera la sortie de equipes_can[0:3] ?

  3. Quelle sera la sortie de equipes_can[0:] ?

  4. Quelle sera la sortie de equipes_can[1:] ?

  5. Donne le bout de code pour ajouter l'équipe 'Afrique du Sud' dans la liste equipes_can.

  6. Convertissez la liste equipes_can en tuple et affichez le type.

  7. Utilisez range pour créer une liste d'indices correspondant aux équipes.

  8. Créez un dictionnaire où les clés sont les noms des équipes et les valeurs sont le nombre de lettres dans leur nom.

  9. Utilisez une fonction pour trouver l'équipe avec le plus grand nombre de lettres dans son nom.

  10. Écrivez le code pour vérifier si 'Cameroun' est dans la liste des équipes.

  11. Créez une nouvelle liste contenant uniquement les équipes dont le nom commence par la lettre 'C'.

Partie B : Manipulation des Scores

Nous avons la Liste Initiale des scores du Cameroun : scores_cameroun = [3, 2, 1, 0, 4, 2, 3, 1, 0, 2]

Questions :

  1. Triez et affichez la liste des scores.

  2. Ajoutez le score 3 à la liste et affichez la liste.

  3. Renversez et affichez la liste.

  4. Affichez l'indice du score 0.

  5. Enlevez le score 3 et affichez la liste.

  6. Affichez la sous-liste du 2ème au 3ème élément.

  7. Affichez la sous-liste du début au 2ème élément.

  8. Affichez la sous-liste du 3ème élément à la fin de la liste.

  9. Affichez la sous-liste complète de la liste.

  10. Utilisez range pour créer une liste d'indices correspondant à la liste scores_cameroun.

  11. Affichez le type de la liste scores_cameroun.

Partie C : Questions théoriques sur les listes

Pour resultats = [3, 2, 0, 1, 4, 2, 3, 1, 0, 2]

  1. Que renvoie resultats[0:2] ?

  2. Que renvoie resultats[0:3] ?

  3. Que renvoie resultats[0:] ?

  4. Que renvoie resultats[:] ?

  5. Que renvoie resultats[1:] ?

  6. Que renvoie resultats[1:-1] ?

  7. Que renvoie list(range(len(resultats))) ?

  8. Que renvoie type(resultats) ?

Total des points : 30 points

Bon courage !

 

CORRECTIONS Examen Python :

Examen Python - CAN 2026 avec Solutions

Examen de Programmation Python - CAN 2026

Durée : 2 heures

Exercice 1 : Questions de cours (5 points)

Questions sur les listes en Python

  1. Quelle est la différence entre une liste et un tuple ?

    Solution :

    Une liste est mutable (on peut modifier ses éléments) alors qu'un tuple est immuable (on ne peut pas le modifier après sa création).

    Syntaxe : liste = [1, 2, 3] | tuple = (1, 2, 3)

    Méthodes disponibles : Les listes ont plus de méthodes (append(), remove(), sort(), etc.) que les tuples.

  2. Quelle structure de données permet de stocker des clés et des valeurs en Python ?

    Solution : Le dictionnaire (dict)

    Syntaxe : d = {"clé1": "valeur1", "clé2": "valeur2"}

    Caractéristiques : Les clés doivent être uniques et immuables, les valeurs peuvent être de n'importe quel type.

  3. Peut-on modifier une liste ? un tuple ?

    Solution :

    Liste : OUI - On peut ajouter, supprimer, modifier des éléments

    Tuple : NON - Une fois créé, on ne peut pas modifier un tuple

    Exemple :

    liste = [1, 2, 3]
    liste[0] = 10  # ✓ Permis
    tuple = (1, 2, 3)
    tuple[0] = 10  # ✗ Erreur: 'tuple' object does not support item assignment
  4. Quelle est la différence entre une liste vide et un dictionnaire vide ?

    Solution :

    Liste vide : [] - Structure séquentielle indexée par des entiers

    Dictionnaire vide : {} - Structure de paires clé-valeur

    Différence principale : Une liste stocke des éléments accessibles par indice, un dictionnaire stocke des paires clé-valeur accessibles par clé.

  5. Qu'est-ce qu'une fonction en Python ?

    Solution : Une fonction est un bloc de code réutilisable qui effectue une tâche spécifique.

    Syntaxe :

    def nom_fonction(paramètres):
        """Docstring (optionnel)"""
        # Corps de la fonction
        return valeur_retour

    Caractéristiques : Réduit la duplication de code, améliore la lisibilité, facilite la maintenance.

  6. C'est quoi l'inférence de type ?

    Solution : L'inférence de type est la capacité d'un langage à déduire automatiquement le type des variables sans déclaration explicite.

    En Python : Python est à typage dynamique - le type est déterminé à l'exécution

    Exemple :

    x = 10      # Python infère que x est un int
    y = "hello" # Python infère que y est un str
    z = [1, 2]  # Python infère que z est une list

    Note : Python 3.6+ supporte les annotations de type optionnelles.

Exercice 2 : Programme Python (4 points)

Écrire un programme PYTHON qui affiche les nombres pairs de 1 à N

Énoncé :

  • L'utilisateur doit entrer uniquement des nombres entiers positif N.
  • Le programme doit utiliser une boucle pour afficher tous les nombres pairs de 1 à N.

Exemple d'exécution :

Entrez un nombre entier positif : 10
Nombres pairs de 1 à 10 : 2 4 6 8 10

Solution complète :

# Programme pour afficher les nombres pairs de 1 à N
# Méthode 1 : Boucle for avec range

# Demander à l'utilisateur d'entrer un nombre
n = int(input("Entrez un nombre entier positif : "))

print(f"Nombres pairs de 1 à {n} :", end=" ")

# Boucle for de 1 à n (inclus)
for i in range(1, n + 1):
    # Vérifier si le nombre est pair (divisible par 2)
    if i % 2 == 0:
        print(i, end=" ")

# Méthode alternative avec range qui saute directement les nombres pairs
print("\n\nMéthode alternative :")
print(f"Nombres pairs de 1 à {n} :", end=" ")
for i in range(2, n + 1, 2):  # Commence à 2, va jusqu'à n, pas de 2
    print(i, end=" ")

Explication détaillée :

  1. input() : Fonction pour lire l'entrée utilisateur (retourne une chaîne)
  2. int() : Conversion de la chaîne en entier
  3. range(1, n+1) : Génère les nombres de 1 à n inclus
  4. % (modulo) : Opérateur qui donne le reste de la division. i % 2 == 0 vérifie si i est pair
  5. print(i, end=" ") : Affiche i suivi d'un espace (au lieu d'un saut de ligne)
  6. range(2, n+1, 2) : Version optimisée qui génère directement 2, 4, 6, ...

Exercice 3 : Matrices (6 points)

Écrire un programme qui lit les coefficients de deux matrices carrées

Énoncé :

Écrire un programme qui lit les coefficients de deux matrices carrées A et B d'ordre N=10 et affiche le nombre de coefficients égaux.

Solution complète :

# Programme pour comparer deux matrices carrées d'ordre 10

# Définir la taille des matrices
N = 10

# Initialiser les matrices avec des listes de listes
# Méthode 1 : Matrices pré-définies (pour test)
A = [
    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
    [11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
    # ... (compléter avec 8 autres lignes)
]

B = [
    [1, 0, 3, 0, 5, 0, 7, 0, 9, 0],
    [0, 12, 0, 14, 0, 16, 0, 18, 0, 20],
    # ... (compléter avec 8 autres lignes)
]

# Méthode 2 : Lecture des matrices depuis l'entrée utilisateur
print("Entrez les coefficients de la matrice A (10x10) :")
A = []
for i in range(N):
    ligne = list(map(int, input(f"Ligne {i+1} (10 nombres séparés par des espaces) : ").split()))
    A.append(ligne)

print("\nEntrez les coefficients de la matrice B (10x10) :")
B = []
for i in range(N):
    ligne = list(map(int, input(f"Ligne {i+1} (10 nombres séparés par des espaces) : ").split()))
    B.append(ligne)

# Compter les coefficients égaux
compteur = 0

# Parcourir chaque élément des matrices
for i in range(N):  # Pour chaque ligne
    for j in range(N):  # Pour chaque colonne
        if A[i][j] == B[i][j]:
            compteur += 1

# Afficher le résultat
print(f"\nNombre de coefficients égaux entre A et B : {compteur}")
print(f"Pourcentage de similarité : {(compteur/(N*N))*100:.2f}%")

# Version alternative avec liste en compréhension
compteur_v2 = sum(1 for i in range(N) for j in range(N) if A[i][j] == B[i][j])
print(f"\nVérification (méthode alternative) : {compteur_v2}")

Explication détaillée :

  1. Matrice en Python : Représentée comme une liste de listes
  2. map(int, ...) : Convertit chaque élément de la liste en entier
  3. split() : Divise la chaîne d'entrée en liste de sous-chaînes
  4. Boucles imbriquées : i pour les lignes, j pour les colonnes
  5. Comparaison A[i][j] == B[i][j] : Vérifie l'égalité élément par élément
  6. Liste en compréhension : Méthode Pythonique pour compter

Problème : Manipulation des Listes en Python (15 points)

Contexte : CAN 2026 avec équipes africaines

En programmation, les listes sont des structures de données couramment utilisées pour stocker des collections d'éléments. En Python, les listes sont particulièrement puissantes en raison de leur flexibilité et de la variété d'opérations que l'on peut effectuer sur elles. Dans cet exercice, vous allez manipuler une liste d'équipes participantes à la CAN 2026 en utilisant différentes techniques de découpage et de sélection d'éléments.

Partie A : Manipulation d'une Liste d'Équipes

Nous avons la Liste Initiale: equipes_can = ["Cameroun", "Sénégal", "Maroc", "Égypte", "Côte d'Ivoire", "Nigeria", "Algérie", "Tunisie", "Mali", "Ghana"]

  1. Quelle sera la sortie de equipes_can[0:2] ?

    Solution : ['Cameroun', 'Sénégal']

    Explication : Le slicing [0:2] prend les éléments de l'indice 0 inclus à l'indice 2 exclus.

    Rappel : En Python, les indices commencent à 0.

  2. Quelle sera la sortie de equipes_can[0:3] ?

    Solution : ['Cameroun', 'Sénégal', 'Maroc']

  3. Quelle sera la sortie de equipes_can[0:] ?

    Solution : La liste complète depuis le début

    Sortie : ['Cameroun', 'Sénégal', 'Maroc', 'Égypte', 'Côte d'Ivoire', 'Nigeria', 'Algérie', 'Tunisie', 'Mali', 'Ghana']

    Explication : Quand le second indice est omis, on va jusqu'à la fin de la liste.

  4. Quelle sera la sortie de equipes_can[1:] ?

    Solution : ['Sénégal', 'Maroc', 'Égypte', 'Côte d'Ivoire', 'Nigeria', 'Algérie', 'Tunisie', 'Mali', 'Ghana']

    Explication : Omettre le premier indice signifie "depuis le début".

  5. Donne le bout de code pour ajouter l'équipe 'Afrique du Sud' dans la liste equipes_can.

    Solution :

    # Méthode 1 : append() - ajoute à la fin
    equipes_can.append('Afrique du Sud')
    
    # Méthode 2 : insert() - ajoute à une position spécifique
    equipes_can.insert(3, 'Afrique du Sud')  # Ajoute à l'indice 3
    
    # Méthode 3 : extend() - ajoute plusieurs éléments
    equipes_can.extend(['Afrique du Sud'])

    Différence entre append() et extend() :

    • append(x) : Ajoute x comme un seul élément
    • extend(iterable) : Ajoute tous les éléments de l'itérable
  6. Convertissez la liste equipes_can en tuple et affichez le type.

    Solution :

    # Conversion de liste à tuple
    equipes_tuple = tuple(equipes_can)
    
    # Affichage du type
    print(type(equipes_tuple))  # Affiche: <class 'tuple'>
    
    # Affichage du tuple
    print(equipes_tuple)

    Rappel : tuple() est un constructeur qui convertit n'importe quel itérable en tuple.

  7. Utilisez range pour créer une liste d'indices correspondant aux équipes.

    Solution :

    # Méthode 1 : range() avec conversion en liste
    indices = list(range(len(equipes_can)))
    print(indices)  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    
    # Méthode 2 : List comprehension
    indices = [i for i in range(len(equipes_can))]
    
    # Pour afficher les équipes avec leurs indices
    for i, equipe in enumerate(equipes_can):
        print(f"Indice {i}: {equipe}")

    Fonctions utilisées :

    • len(liste) : Retourne le nombre d'éléments
    • range(n) : Génère les nombres de 0 à n-1
    • enumerate(liste) : Retourne à la fois l'indice et la valeur
  8. Créez un dictionnaire où les clés sont les noms des équipes et les valeurs sont le nombre de lettres dans leur nom.

    Solution :

    # Méthode 1 : Boucle for classique
    dictionnaire_equipes = {}
    for equipe in equipes_can:
        dictionnaire_equipes[equipe] = len(equipe)
    
    print(dictionnaire_equipes)
    
    # Méthode 2 : Dictionary comprehension (plus pythonique)
    dictionnaire_equipes = {equipe: len(equipe) for equipe in equipes_can}
    
    # Méthode 3 : Avec enumerate pour avoir aussi les indices
    dictionnaire_complet = {i: {"equipe": equipe, "longueur": len(equipe)} 
                            for i, equipe in enumerate(equipes_can)}
    
    # Affichage formaté
    for equipe, longueur in dictionnaire_equipes.items():
        print(f"{equipe}: {longueur} lettres")

    Résultat attendu :

    {
        'Cameroun': 8,
        'Sénégal': 7,
        'Maroc': 5,
        'Égypte': 7,
        'Côte d\'Ivoire': 13,
        'Nigeria': 7,
        'Algérie': 7,
        'Tunisie': 7,
        'Mali': 4,
        'Ghana': 5
    }
  9. Utilisez une fonction pour trouver l'équipe avec le plus grand nombre de lettres dans son nom.

    Solution :

    # Méthode 1 : Fonction personnalisée
    def equipe_plus_longue(liste_equipes):
        """Retourne l'équipe avec le nom le plus long"""
        equipe_max = liste_equipes[0]  # Initialiser avec la première équipe
        for equipe in liste_equipes:
            if len(equipe) > len(equipe_max):
                equipe_max = equipe
        return equipe_max
    
    # Utilisation
    resultat = equipe_plus_longue(equipes_can)
    print(f"Équipe avec le nom le plus long: {resultat} ({len(resultat)} lettres)")
    
    # Méthode 2 : Utilisation de max() avec une fonction key
    resultat = max(equipes_can, key=len)
    print(f"Avec max(): {resultat}")
    
    # Méthode 3 : Tri décroissant par longueur
    equipes_triees = sorted(equipes_can, key=len, reverse=True)
    print(f"Top 3 des noms les plus longs: {equipes_triees[:3]}")

    Fonctions importantes :

    • max(iterable, key=func) : Retourne l'élément maximum selon la fonction key
    • sorted(iterable, key=func, reverse=True) : Trie par ordre décroissant
    • len(string) : Retourne le nombre de caractères

Partie B : Manipulation des Scores

Nous avons la Liste Initiale des scores du Cameroun : scores_cameroun = [3, 2, 1, 0, 4, 2, 3, 1, 0, 2]

  1. Triez et affichez la liste des scores.

    Solution :

    # Méthode 1 : sort() modifie la liste originale
    scores_cameroun.sort()
    print("Liste triée:", scores_cameroun)  # [0, 0, 1, 1, 2, 2, 2, 3, 3, 4]
    
    # Méthode 2 : sorted() retourne une nouvelle liste
    scores_tries = sorted(scores_cameroun)
    print("Nouvelle liste triée:", scores_tries)

    Différence cruciale :

    • sort() : Méthode de liste, modifie sur place, retourne None
    • sorted() : Fonction built-in, retourne nouvelle liste, original inchangé
  2. Ajoutez le score 3 à la liste et affichez la liste.

    scores_cameroun.append(3)
    print("Liste après ajout:", scores_cameroun)
  3. Renversez et affichez la liste.

    # Méthode 1 : reverse() modifie sur place
    scores_cameroun.reverse()
    print("Liste renversée:", scores_cameroun)
    
    # Méthode 2 : Slicing [::-1] crée une nouvelle liste
    liste_inverse = scores_cameroun[::-1]
    print("Avec slicing:", liste_inverse)

    Astuce : Le slicing [::-1] est très utile pour inverser n'importe quelle séquence.

  4. Affichez l'indice du score 0.

    # Méthode 1 : index() trouve le premier indice
    indice = scores_cameroun.index(0)
    print(f"Première occurrence de 0: indice {indice}")
    
    # Méthode 2 : Trouver tous les indices des 0
    indices_zeros = [i for i, score in enumerate(scores_cameroun) if score == 0]
    print(f"Tous les indices des 0: {indices_zeros}")

    Attention : index() lève une exception ValueError si l'élément n'est pas trouvé.

  5. Enlevez le score 3 et affichez la liste.

    # Méthode 1 : remove() enlève la première occurrence
    scores_cameroun.remove(3)
    print("Après remove(3):", scores_cameroun)
    
    # Méthode 2 : List comprehension pour enlever toutes les occurrences
    scores_sans_3 = [score for score in scores_cameroun if score != 3]
    
    # Méthode 3 : filter() avec fonction lambda
    scores_filtres = list(filter(lambda x: x != 3, scores_cameroun))
  6. Affichez la sous-liste du 2ème au 3ème élément.

    Solution : scores_cameroun[1:3]

    Explication : En Python, l'indexation commence à 0, donc :

    • 2ème élément = indice 1
    • 3ème élément = indice 2
    • [1:3] prend les indices 1 et 2 (3 exclu)
  7. Affichez la sous-liste du début au 2ème élément.

    Solution : scores_cameroun[:2]

    Équivalent à scores_cameroun[0:2]

  8. Affichez la sous-liste du 3ème élément à la fin de la liste.

    Solution : scores_cameroun[2:]

    3ème élément = indice 2

  9. Affichez la sous-liste complète de la liste.

    Solution : scores_cameroun[:] ou simplement scores_cameroun

    Utilité : Créer une copie superficielle (shallow copy) de la liste.

  10. Utilisez range pour créer une liste d'indices correspondant à la liste scores_cameroun.

    indices = list(range(len(scores_cameroun)))
    print("Indices:", indices)
    
    # Avec les valeurs correspondantes
    for i in range(len(scores_cameroun)):
        print(f"Indice {i}: score = {scores_cameroun[i]}")
  11. Affichez le type de la liste scores_cameroun.

    print(type(scores_cameroun))  # 
    
    # Pour vérifier le type de chaque élément
    for score in scores_cameroun:
        print(f"Score: {score}, Type: {type(score)}")

Partie C : Questions théoriques sur les listes

Pour resultats = [3, 2, 0, 1, 4, 2, 3, 1, 0, 2]

  1. Que renvoie resultats[0:2] ?

    Solution : [3, 2]

  2. Que renvoie resultats[0:3] ?

    Solution : [3, 2, 0]

  3. Que renvoie resultats[0:] ?

    Solution : La liste complète [3, 2, 0, 1, 4, 2, 3, 1, 0, 2]

  4. Que renvoie resultats[:] ?

    Solution : Une copie de la liste complète

    Utilité : Créer une nouvelle liste identique (shallow copy).

  5. Que renvoie resultats[1:] ?

    Solution : [2, 0, 1, 4, 2, 3, 1, 0, 2]

    Tous les éléments sauf le premier.

  6. Que renvoie resultats[1:-1] ?

    Solution : [2, 0, 1, 4, 2, 3, 1, 0]

    Explication : -1 représente le dernier élément (exclu).

  7. Que renvoie list(range(len(resultats))) ?

    Solution : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

    Explication étape par étape :

    1. len(resultats) → 10
    2. range(10) → génère 0, 1, 2, ..., 9
    3. list(range(10)) → convertit en liste
  8. Que renvoie type(resultats) ?

    Solution : <class 'list'>

    Rappel : type() est essentiel pour déboguer et comprendre la structure des données.

Résumé des Méthodes et Fonctions importantes :

Méthodes des listes :

  • append(x) : Ajoute x à la fin
  • extend(iterable) : Ajoute tous les éléments d'un itérable
  • insert(i, x) : Insère x à la position i
  • remove(x) : Supprime la première occurrence de x
  • pop([i]) : Supprime et retourne l'élément à la position i
  • clear() : Supprime tous les éléments
  • index(x) : Retourne l'indice de la première occurrence de x
  • count(x) : Compte le nombre d'occurrences de x
  • sort(key=None, reverse=False) : Trie la liste sur place
  • reverse() : Inverse la liste sur place
  • copy() : Retourne une copie superficielle

Fonctions built-in importantes :

  • len(iterable) : Longueur/nombre d'éléments
  • sorted(iterable, key=None, reverse=False) : Retourne nouvelle liste triée
  • max(iterable, key=None) / min(iterable, key=None) : Maximum/Minimum
  • sum(iterable) : Somme des éléments
  • enumerate(iterable) : Retourne (index, valeur)
  • zip(*iterables) : Agence plusieurs itérables ensemble
  • map(function, iterable) : Applique fonction à chaque élément
  • filter(function, iterable) : Filtre les éléments
  • list(iterable) : Convertit en liste
  • tuple(iterable) : Convertit en tuple
  • dict(iterable) : Convertit en dictionnaire

Opérations de slicing :

  • liste[start:stop] : Éléments de start à stop-1
  • liste[start:] : Éléments de start à la fin
  • liste[:stop] : Éléments du début à stop-1
  • liste[:] : Copie de toute la liste
  • liste[start:stop:step] : Éléments de start à stop-1 avec pas
  • liste[::-1] : Inverse la liste

Total des points : 30 points

Bon courage !

Questions / Réponses

Aucune question. Soyez le premier à poser une question.
Aucune note. Soyez le premier à attribuer une note !

Ajouter un commentaire

Anti-spam