Les questions théoriques nécessitent des explications précises
Exercice 1 : Questions de cours (8 points)
Question 1.1 (2 points)
Expliquer la différence entre une liste et un tuple en Python. Donner un exemple pour illustrer.
Différences principales : - Mutabilité : Les listes sont mutables (modifiables), les tuples sont immutables (non modifiables après création) - Syntaxe : Listes avec [] , Tuples avec () - Performance : Les tuples sont légèrement plus rapides - Utilisation : Listes pour données homogènes, tuples pour données hétérogènes Exemple : # Liste (modifiable) ma_liste = [1, 2, 3] ma_liste[0] = 10 # OK ma_liste.append(4) # OK print(ma_liste) # [10, 2, 3, 4] # Tuple (non modifiable) mon_tuple = (1, 2, 3) # mon_tuple[0] = 10 # Erreur ! # mon_tuple.append(4) # Erreur ! print(mon_tuple) # (1, 2, 3)
Question 1.2 (2 points)
Expliquer la différence entre une copie superficielle et une copie profonde. Donner un exemple pour illustrer.
Différence : - Copie superficielle (shallow copy) : Crée un nouvel objet mais les éléments imbriqués sont partagés - Copie profonde (deep copy) : Crée un nouvel objet et copie récursivement tous les éléments imbriqués Exemple : import copy # Liste originale avec une liste imbriquée original = [[1, 2, 3], [4, 5, 6]] # Copie superficielle shallow = copy.copy(original) shallow[0][0] = 99 # Modifie aussi l'original print(original) # [[99, 2, 3], [4, 5, 6]] # Copie profonde original = [[1, 2, 3], [4, 5, 6]] # Réinitialisation deep = copy.deepcopy(original) deep[0][0] = 99 # Ne modifie pas l'original print(original) # [[1, 2, 3], [4, 5, 6]]
Question 1.3 (1.5 points)
Qu'est-ce qu'une fonction récursive? Expliquer avec un exemple.
Une fonction récursive est une fonction qui s'appelle elle-même. Elle doit avoir : 1. Un cas de base (condition d'arrêt) 2. Un appel récursif qui se rapproche du cas de base Exemple - Calcul de factorielle : def factorielle(n): # Cas de base if n <= 1: return 1 # Appel récursif return n * factorielle(n - 1) print(factorielle(5)) # 120 (5*4*3*2*1)
Question 1.4 (1.5 points)
Qu'est-ce qu'un argument par défaut dans une fonction ? Expliquer le problème lié à l'utilisation d'une liste comme valeur par défaut.
Un argument par défaut prend une valeur si l'appelant ne fournit pas cet argument. Problème avec les listes : Les arguments par défaut sont créés une seule fois à la définition de la fonction, pas à chaque appel. Exemple du problème : def mauvais_ajout(element, liste=[]): liste.append(element) return liste print(mauvais_ajout(1)) # [1] print(mauvais_ajout(2)) # [1, 2] - Problème : la liste persiste ! Solution correcte : def bon_ajout(element, liste=None): if liste is None: liste = [] liste.append(element) return liste print(bon_ajout(1)) # [1] print(bon_ajout(2)) # [2] - Nouvelle liste à chaque appel
Question 1.5 (1 point)
Expliquer la différence entre une variable globale, locale, et nonlocale dans le cas des fonctions.
Différences : - Globale : Définie en dehors des fonctions, accessible partout - Locale : Définie dans une fonction, accessible uniquement dans cette fonction - Nonlocale : Utilisée dans les fonctions imbriquées pour modifier une variable de la fonction englobante Exemple : x = 10 # Globale def externe(): y = 20 # Locale à externe def interne(): nonlocal y # Pour modifier y de la fonction externe global x # Pour modifier x globale y += 5 x += 5 z = 30 # Locale à interne interne() print(y) # 25 (modifié par nonlocal) externe() print(x) # 15 (modifié par global)
Exercice 2 : Variables et affichage (2 points)
Déclare deux variables nom et age, puis affiche le message suivant : "Je m'appelle nom et j'ai age ans."
# Correction - Exercice 2 nom = "Jean" age = 25 print(f"Je m'appelle {nom} et j'ai {age} ans.") # Ou avec format() print("Je m'appelle {} et j'ai {} ans.".format(nom, age))
Exercice 3 : Conditions (2 points)
Écrire un programme qui demande à l'utilisateur un nombre et affiche :
"Positif" si le nombre est supérieur à 0
"Négatif" s'il est inférieur à 0
"Zéro" s'il est égal à 0
# Correction - Exercice 3 try: nombre = float(input("Entrez un nombre : ")) if nombre > 0: print("Positif") elif nombre < 0: print("Négatif") else: print("Zéro") except ValueError: print("Veuillez entrer un nombre valide.")
Exercice 4 : Boucles (2 points)
Écrire un programme qui affiche les nombres de 1 à 10 en utilisant une boucle for.
# Correction - Exercice 4 # Version 1 : avec range for i in range(1, 11): print(i, end=" ") # end=" " pour afficher sur une ligne print() # Retour à la ligne # Version 2 : plus explicite for nombre in range(1, 11): print(f"Nombre : {nombre}")
Exercice 5 : Fonctions (2 points)
Créer une fonction addition(a, b) qui retourne la somme de deux nombres, puis appeler cette fonction et afficher le résultat.
# Correction - Exercice 5 def addition(a, b): """Retourne la somme de a et b""" return a + b # Test de la fonction resultat = addition(5, 3) print(f"La somme de 5 et 3 est : {resultat}") # Autres tests print(addition(10, 20)) # 30 print(addition(-5, 8)) # 3
Exercice 6 : Tri avec lambda (4 points)
On considère une liste de tuples (nom, note), représentant la liste des étudiants et leurs notes respectives. Écrire un programme python qui trie la liste par ordre décroissant de note, en cas d'égalité, le tri se fait par ordre alphabétique du nom. Utilisez une fonction lambda.
# Correction - Exercice 6 # Liste d'étudiants (nom, note) etudiants = [ ("Alice", 15), ("Bob", 12), ("Charlie", 15), ("David", 14), ("Eve", 12), ("Frank", 15) ] print("Liste originale :") for nom, note in etudiants: print(f"{nom}: {note}") # Tri : d'abord par note décroissante, puis par nom alphabétique # Pour tri décroissant sur note, on utilise -note # En cas d'égalité, le nom en alphabétique (ordre normal) etudiants_tries = sorted(etudiants, key=lambda x: (-x[1], x[0])) print("\nListe triée (note décroissante, puis nom alphabétique) :") for nom, note in etudiants_tries: print(f"{nom}: {note}") # Version alternative avec tri en place # etudiants.sort(key=lambda x: (-x[1], x[0]))
Un jour, j’ai oublié un point-virgule…
et toute ma forêt a planté ?
Mais grâce à Pandacodeur, j’ai appris de mes erreurs !
? Sur Pandacodeur, tu peux :
✔ apprendre la programmation de façon pratique
✔ t’entraîner avec des quiz interactifs
✔ comprendre grâce à des exercices corrigés
✔ te préparer efficacement à l’examen
