Exercice 1 : Questions de cours – Généralités (4pts)
1. Typage dynamique en Python
Correction : Le typage dynamique signifie que le type d'une variable est déterminé à l'exécution et peut changer pendant la vie du programme. Contrairement au typage statique, on n'a pas besoin de déclarer le type d'une variable.
Exemple :
x = 10 # x est un entier
print(type(x)) # <class 'int'>
x = "Genius" # Maintenant x est une chaîne de caractères
print(type(x)) # <class 'str'>
Explication : La variable x change de type sans erreur, ce qui illustre la flexibilité du typage dynamique.
2. Fonction en Python
Correction : Une fonction est un bloc de code réutilisable qui effectue une tâche spécifique. Elle est définie avec le mot-clé def.
Intérêt d'utiliser des fonctions :
- Réutilisabilité : Évite la duplication de code
- Modularité : Divise un problème complexe en sous-problèmes
- Lisibilité : Rend le code plus clair et organisé
- Maintenance : Facilite les modifications
Exemple :
def carre(x):
return x * x
print(carre(5)) # 25
3. Fonction sans instruction return
Correction : Quand une fonction ne contient pas d'instruction return, elle retourne implicitement None.
Exemple :
def saluer(nom):
print(f"Bonjour {nom}")
resultat = saluer("Mr Joel Yankam")
print(resultat) # Affiche : Mr Joel Yankam
# Puis : None
Implicitement veut dire directement effectué par le compilateur ……….
4. Fonction anonyme (lambda)
Correction : Une fonction lambda est une petite fonction anonyme définie avec le mot-clé lambda. Elle peut prendre plusieurs arguments mais ne contient qu'une seule expression.
Exemple d'utilisation :
# Avec sorted() pour trier par le deuxième élément
points = [(1, 5), (3, 2), (2, 8)]
triés = sorted(points, key=lambda x: x[1])
print(triés) # [(3, 2), (1, 5), (2, 8)]
# Avec map() pour transformer
nombres = [1, 2, 3]
f = list(map(lambda a: a * a, nombres))
print(f) # résultat [1, 4, 6]
5. Portée des variables (scope)
Le concept de portée (scope) définit la manière dont les variables et les noms sont recherchés dans votre code. En Python, il existe 4 portées principales :
- Locale (local) : Variable définie dans une fonction
- Enclosing(Enclosed) : Variable dans une fonction englobante
- Globale (Global) : Variable définie au niveau du module
- Built-in : Noms prédéfinis (comme print, len)
Exemple :
# PORTÉE GLOBALE (Global Scope)
# Ces variables sont accessibles partout dans le module
x = 10 # Variable globale x
y = 20 # Variable globale y
def outer():
# PORTÉE ENCLOSED (Enclosed Scope)
# Cette variable est définie dans outer() et accessible dans inner()
z = 30 # Variable enclosed z - accessible dans inner() mais pas globalement
#Retrouvez plus d'exercice corrigé sur www.pandacodeur.com
def inner():
# PORTÉE LOCALE (Local Scope)
# Cette variable n'existe que dans inner()
x = 30 # Variable locale x - masque la variable globale x
# Accès aux différentes portées :
print(f'x is {x}') # Affiche la variable LOCALE x (30)
print(f'z is {z}') # Affiche la variable ENCLOSED z (30)
print(f'y is {y}') # Affiche la variable GLOBALE y (20)
# PORTÉE BUILT-IN (Built-in Scope)
# len() est une fonction intégrée de Python
print(len("abc")) # Utilise la fonction BUILT-IN len()
# Appel de la fonction intérieure
inner()
# Appel de la fonction extérieure
outer()
Exercice 2 : Liste imbriquée – filtrage avancé (2pts)
Énoncé : À partir d'une liste de listes de nombres, créer une nouvelle liste ne contenant que les sous-listes dont la somme est supérieure à la moyenne globale.
Correction :
def filtrer_sous_listes(liste_imbriquee):
# Étape 1 : Calculer la moyenne globale
tous_nombres = []
for sous_liste in liste_imbriquee:
tous_nombres.extend(sous_liste)
moyenne_globale = sum(tous_nombres) / len(tous_nombres) if tous_nombres else 0
# Étape 2 : Filtrer les sous-listes
resultat = []
for sous_liste in liste_imbriquee:
if sum(sous_liste) > moyenne_globale:
resultat.append(sous_liste)
return resultat
# Exemple d'utilisation
liste_Genius = [[1, 2, 3], [4, 5, 6], [7, 8, 78], [40]]
filtree = filtrer_sous_listes(liste_Genius)
print(filtree)
Explication :
- On combine d'abord tous les nombres pour calculer la moyenne globale
- On parcourt chaque sous-liste et on compare sa somme avec la moyenne
- On garde seulement les sous-listes dont la somme est supérieure
Exercice 3 : Compression et décompression (2pts)
Énoncé : Écrire un programme python qui transforme une liste d'entier en tuple ([1,1,1,2,2,3,3,3]) → [(1,3),(2,2),(3,3)] et écrire la fonction qui effectue l'opération inverse.
Correction :
Partie 1 : Compression
def compresser(liste):
if not liste:
return []
resultat = []
valeur_courante = liste[0]
compteur = 1
for i in range(1, len(liste)):
if liste[i] == valeur_courante:
compteur += 1
else:
resultat.append((valeur_courante, compteur))
valeur_courante = liste[i]
compteur = 1
# Ajouter la dernière valeur
resultat.append((valeur_courante, compteur))
return resultat
# Test
liste_origine = [1, 1, 1, 2, 2, 3, 3, 3]
compressee = compresser(liste_origine)
print(compressee) # [(1, 3), (2, 2), (3, 3)]
Partie 2 : Décompression
def decompresser(liste_compressee):
resultat = []
for valeur, compteur in liste_compressee:
resultat.extend([valeur] * compteur)
return resultat
# Test
decompressee = decompresser(compressee)
print(decompressee) # [1, 1, 1, 2, 2, 3, 3, 3]
# Vérification
print(decompressee == liste_origine) # True
L'instant Genius :
- Compression : On compte les occurrences consécutives de chaque valeur
- Décompression : On recrée la liste originale à partir des paires (valeur, compteur)
Exercice 4 : Les Fonctions - Compter de caractères (2pts)
Énoncé : Écrire une fonction en python, qui reçoit une chaîne et retourne un dictionnaire {caractère : fréquence} contenant le nombre d'occurrences de chaque caractère, ainsi que le caractère le plus fréquent (utiliser une fonction lambda).
Correction :
def compter_caracteres(chaine):
# Créer le dictionnaire de fréquences
frequences = { }
for caractere in chaine:
if caractere in frequences:
frequences[caractere] += 1
else:
frequences[caractere] = 1
# Trouver le caractère le plus fréquent avec lambda
if frequences:
caractere_max = max(frequences.items(), key=lambda x: x[1])
# caractere_max est un tuple (caractere, frequence)
return frequences, caractere_max[0], caractere_max[1]
else:
return frequences, None, 0
# Exemple d'utilisation
genius_test = "programmation"
freq, char_max, freq_max = compter_caracteres(genius_test)
print("Fréquences :", freq)
print(f"Caractère le plus fréquent : '{char_max}' avec {freq_max} occurrences")
#Plus d'exercice corrigé pandacodeur.com !
L'instant Genius :
- On parcourt chaque caractère de la chaîne
- On incrémente le compteur dans le dictionnaire
- On utilise max() avec une lambda pour trouver le caractère ayant la valeur maximale
- La lambda key=lambda x: x[1] spécifie qu'on compare par la fréquence (deuxième élément du tuple)
Problème : Manipulation des Listes, tuples et Dictionnaires
Partie A : Manipulation des listes et des tuples (5 pts)
Données :
Etudiants = [
("Alice", [12, 14, 15]),
("Bob", [8, 9, 10]),
("Charlie", [16, 15, 17]),
("Diane", [11, 10, 12]),
("Eric", [9, 10, 13])
]
1. Afficher le nom de chaque étudiant suivi de sa moyenne
print("1. Noms et moyennes des étudiants:")
for nom, notes in Etudiants:
moyenne = sum(notes) / len(notes)
print(f"{nom}: {moyenne:.2f}")
2. Liste des étudiants admis (moyenne ≥ 10)
print("\n2. Étudiants admis (moyenne ≥ 10):")
etudiants_admis = []
for nom, notes in Etudiants:
moyenne = sum(notes) / len(notes)
if moyenne >= 10:
etudiants_admis.append((nom, moyenne))
print(etudiants_admis)
# [('Alice', 13.666...), ('Charlie', 16.0), ('Diane', 11.0), ('Eric', 10.666...)]
3. Trouver l'étudiant ayant la meilleure moyenne sans max()
print("\n3. Meilleur étudiant (sans max()):")
meilleur_nom = None
meilleure_moyenne = -1
for nom, notes in Etudiants:
moyenne = sum(notes) / len(notes)
if moyenne > meilleure_moyenne:
meilleure_moyenne = moyenne
meilleur_nom = nom
print(f"{meilleur_nom} avec {meilleure_moyenne:.2f}")
# Charlie avec 16.00
4. Trier les étudiants par moyenne décroissante
print("\n4. Étudiants triés par moyenne décroissante:")
# Créer une liste avec les moyennes
etudiants_avec_moyennes = []
for nom, notes in Etudiants:
moyenne = sum(notes) / len(notes)
etudiants_avec_moyennes.append((nom, moyenne))
# Trier par moyenne décroissante
etudiants_tries = sorted(etudiants_avec_moyennes, key=lambda x: x[1], reverse=True)
for nom, moyenne in etudiants_tries:
print(f"{nom}: {moyenne:.2f}")
5. Tuple des étudiants avec note > moyenne de classe
print("\n5. Étudiants avec note > moyenne de classe:")
# Calculer la moyenne générale
toutes_notes = []
for nom, notes in Etudiants:
toutes_notes.extend(notes)
moyenne_classe = sum(toutes_notes) / len(toutes_notes)
# Filtrer les étudiants
etudiants_superieurs = []
for nom, notes in Etudiants:
moyenne_etudiant = sum(notes) / len(notes)
if moyenne_etudiant > moyenne_classe:
etudiants_superieurs.append(nom)
resultat_tuple = tuple(etudiants_superieurs)
print(f"Moyenne de classe: {moyenne_classe:.2f}")
print("Étudiants au-dessus:", resultat_tuple)
Partie B : Fonctions et manipulation des dictionnaires (5 pts)
Données :
Notes_etudiants = {
"Alice": {"math": 14, "info": 15, "physique": 13},
"Bob": {"math": 9, "info": 10, "physique": 8},
"Charlie": {"math": 17, "info": 16, "physique": 15},
"Diane": {"math": 11, "info": 12, "physique": 10}
}
1. Fonction moyenne(liste)
print("\n1. Fonction moyenne():")
def moyenne(liste):
if not liste: # Liste vide
return 0
return sum(liste) / len(liste)
# Test
test_liste = [10, 12, 14, 16]
print(f"Moyenne de {test_liste}: {moyenne(test_liste)}") # 13.0
2. Fonction moyenne_etudiant()
print("\n2. Fonction moyenne_etudiant():")
def moyenne_etudiant(notes_etudiants, nom):
if nom not in notes_etudiants:
return {nom: 0}
notes = list(notes_etudiants[nom].values())
moy = moyenne(notes)
return {nom: moy}
# Test
resultat = moyenne_etudiant(Notes_etudiants, "Alice")
print(f"Moyenne d'Alice: {resultat}") # {'Alice': 14.0}
3. Étudiants admissibles
print("\n3. Liste des étudiants admissibles (moyenne ≥ 10):")
def etudiants_admissibles(notes_etudiants):
admis = []
for nom, matieres in notes_etudiants.items():
notes = list(matieres.values())
moy = moyenne(notes)
if moy >= 10:
admis.append(nom)
return admis
admis = etudiants_admissibles(Notes_etudiants)
print("Étudiants admis:", admis) # ['Alice', 'Charlie', 'Diane']
4. Matière avec moyenne générale la plus faible
print("\n4. Matière avec moyenne la plus faible:")
def matiere_faible(notes_etudiants):
# Calculer les moyennes par matière
moyennes_matieres = {}
# Initialiser
for matiere in next(iter(notes_etudiants.values())).keys():
moyennes_matieres[matiere] = []
# Collecter les notes
for matieres in notes_etudiants.values():
for matiere, note in matieres.items():
moyennes_matieres[matiere].append(note)
# Calculer les moyennes
moyennes_calculees = {}
for matiere, notes in moyennes_matieres.items():
moyennes_calculees[matiere] = moyenne(notes)
# Trouver la plus faible
matiere_min = min(moyennes_calculees.items(), key=lambda x: x[1])
return matiere_min[0], matiere_min[1]
mat_faible, moy_faible = matiere_faible(Notes_etudiants)
print(f"Matière: {mat_faible}, Moyenne: {moy_faible:.2f}")
5. Étudiant avec la meilleure moyenne
print("\n5. Meilleur étudiant:")
def meilleur_etudiant(notes_etudiants):
meilleur_nom = None
meilleure_moyenne = -1
for nom, matieres in notes_etudiants.items():
notes = list(matieres.values())
moy = moyenne(notes)
if moy > meilleure_moyenne:
meilleure_moyenne = moy
meilleur_nom = nom
return meilleur_nom, meilleure_moyenne
nom_meilleur, moy_meilleur = meilleur_etudiant(Notes_etudiants)
print(f"Meilleur étudiant: {nom_meilleur} avec {moy_meilleur:.2f}")
# Charlie avec 16.00
"La persévérance, c'est ce qui rend l'impossible possible, le possible probable et le probable réalisé."
Contact WhatsApp : +237 652027193 | Réalisé Par Mr Joël_Yk
