300 Solutions Python

Solutions — 300 Exercices Python

Chaque solution est fournie sous forme de fonction Python, accompagnée d’un exemple
d’utilisation avec son résultat attendu en commentaire.

Variables, Types et Conversions

Exercice 1. Écrire une fonction convertir_en_entier(valeur) qui tente de convertir

valeur en entier et retourne None si c’est impossible.

def convertir_en_entier(valeur):
try:
return int(valeur)
except (ValueError, TypeError):
return None

print(convertir_en_entier("42")) # 42
print(convertir_en_entier("abc")) # None

Exercice 2. Écrire une fonction type_de_variable(valeur) qui retourne le nom du type

de valeur sous forme de chaîne (ex: “int”, “str”).

def type_de_variable(valeur):
return type(valeur).__name__

print(type_de_variable(10)) # int
print(type_de_variable("abc")) # str

Exercice 3. Écrire une fonction est_numerique(chaine) qui vérifie si une chaîne

représente un nombre (entier ou décimal).

def est_numerique(chaine):
try:
float(chaine)
return True
except ValueError:
return False

print(est_numerique("3.14")) # True
print(est_numerique("abc")) # False

Exercice 4. Écrire une fonction echanger(a, b) qui retourne le tuple (b, a).

def echanger(a, b):

return (b, a)

print(echanger(1, 2)) # (2, 1)

Exercice 5. Écrire une fonction moyenne_ponderee(valeurs, poids) qui calcule la

moyenne pondérée d’une liste de valeurs.
 def moyenne_ponderee(valeurs, poids):
total = sum(v * p for v, p in zip(valeurs, poids))
return total / sum(poids)

print(moyenne_ponderee([12, 15, 18], [1, 2, 3])) # 16.0

Exercice 6. Écrire une fonction convertir_kg_en_lb(kg) qui convertit des kilogrammes

en livres (1 kg = 2.20462 lb).

def convertir_kg_en_lb(kg):
return kg * 2.20462

print(convertir_kg_en_lb(10)) # 22.0462

Exercice 7. Écrire une fonction convertir_lb_en_kg(lb) qui convertit des livres en

kilogrammes.

def convertir_lb_en_kg(lb):
return lb / 2.20462

print(round(convertir_lb_en_kg(22.0462), 2)) # 10.0

Exercice 8. Écrire une fonction convertir_km_en_miles(km) qui convertit des

kilomètres en miles (1 km = 0.621371 miles).

def convertir_km_en_miles(km):
return km * 0.621371

print(convertir_km_en_miles(10)) # 6.21371

Exercice 9. Écrire une fonction convertir_secondes(s) qui retourne un tuple (heures,

minutes, secondes) à partir d’un nombre de secondes.

def convertir_secondes(s):
h = s // 3600
m = (s % 3600) // 60
sec = s % 60
return (h, m, sec)

print(convertir_secondes(3665)) # (1, 1, 5)

Exercice 10. Écrire une fonction calculer_imc(poids, taille) qui calcule l’IMC (poids
/ taille²).

def calculer_imc(poids, taille):

return poids / (taille ** 2)

print(round(calculer_imc(70, 1.75), 2)) # 22.86

Exercice 11. Écrire une fonction arrondir_a(valeur, n) qui arrondit valeur à n

décimales.

def arrondir_a(valeur, n):

return round(valeur, n)

print(arrondir_a(3.14159, 2)) # 3.14

Exercice 12. Écrire une fonction est_pair(n) qui retourne True si n est pair.
 def est_pair(n):
return n % 2 == 0

print(est_pair(4)) # True

Exercice 13. Écrire une fonction est_multiple(n, m) qui vérifie si n est un multiple de
m.

def est_multiple(n, m):

return n % m == 0

print(est_multiple(15, 5)) # True

Exercice 14. Écrire une fonction pgcd(a, b) qui calcule le plus grand commun diviseur.

def pgcd(a, b):

while b:
a, b = b, a % b
return a

print(pgcd(24, 36)) # 12

Exercice 15. Écrire une fonction ppcm(a, b) qui calcule le plus petit commun multiple.

def pgcd(a, b):

while b:
a, b = b, a % b
return a

def ppcm(a, b):

return abs(a * b) // pgcd(a, b)

print(ppcm(4, 6)) # 12

Exercice 16. Écrire une fonction somme_chiffres(n) qui retourne la somme des chiffres
d’un nombre entier.

def somme_chiffres(n):
return sum(int(c) for c in str(abs(n)))

print(somme_chiffres(1234)) # 10

Exercice 17. Écrire une fonction inverser_nombre(n) qui retourne l’entier inversé (ex:
123 -> 321).

def inverser_nombre(n):
return int(str(abs(n))[::-1]) * (1 if n >= 0 else -1)

print(inverser_nombre(123)) # 321

Exercice 18. Écrire une fonction est_nombre_parfait(n) qui vérifie si n est égal à la
somme de ses diviseurs propres (ex: 28).

def est_nombre_parfait(n):
diviseurs = [i for i in range(1, n) if n % i == 0]
return sum(diviseurs) == n

print(est_nombre_parfait(28)) # True
Exercice 19. Écrire une fonction est_nombre_premier(n) qui vérifie si n est un nombre
premier.

def est_nombre_premier(n):
if n < 2:
return False
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0:
return False
return True

print(est_nombre_premier(17)) # True

Exercice 20. Écrire une fonction convertir_base(n, base) qui convertit un entier n en
binaire, octal ou hexadécimal selon base (2, 8, ou 16).

def convertir_base(n, base):

if base == 2:
return bin(n)[2:]
elif base == 8:
return oct(n)[2:]
elif base == 16:
return hex(n)[2:]
else:
raise ValueError("Base non supportée")

print(convertir_base(10, 2)) # 1010

print(convertir_base(255, 16)) # ff

Opérateurs et Calculs Mathématiques

Exercice 21. Écrire une fonction calculer_aire_cercle(rayon) qui retourne l’aire d’un
cercle.

import math
def calculer_aire_cercle(rayon):
return [Link] * rayon ** 2

print(round(calculer_aire_cercle(5), 2)) # 78.54

Exercice 22. Écrire une fonction calculer_perimetre_cercle(rayon) qui retourne le

périmètre d’un cercle.

import math
def calculer_perimetre_cercle(rayon):
return 2 * [Link] * rayon

print(round(calculer_perimetre_cercle(5), 2)) # 31.42

Exercice 23. Écrire une fonction calculer_aire_rectangle(l, h) qui retourne l’aire

d’un rectangle.

def calculer_aire_rectangle(l, h):

return l * h

print(calculer_aire_rectangle(4, 5)) # 20

Exercice 24. Écrire une fonction calculer_aire_triangle(b, h) qui retourne l’aire

d’un triangle.

def calculer_aire_triangle(b, h):

return (b * h) / 2

print(calculer_aire_triangle(6, 4)) # 12.0

Exercice 25. Écrire une fonction calculer_hypotenuse(a, b) qui retourne l’hypoténuse

d’un triangle rectangle.

import math
def calculer_hypotenuse(a, b):
return [Link](a ** 2 + b ** 2)

print(calculer_hypotenuse(3, 4)) # 5.0

Exercice 26. Écrire une fonction resoudre_equation_second_degre(a, b, c) qui

retourne les racines réelles de ax²+bx+c=0 (ou None si pas de solution réelle).

import math
def resoudre_equation_second_degre(a, b, c):
delta = b ** 2 - 4 * a * c
if delta < 0:
return None
elif delta == 0:
return (-b / (2 * a),)
else:
x1 = (-b + [Link](delta)) / (2 * a)
x2 = (-b - [Link](delta)) / (2 * a)
return (x1, x2)

print(resoudre_equation_second_degre(1, -3, 2)) # (2.0, 1.0)

Exercice 27. Écrire une fonction interet_compose(capital, taux, annees) qui

calcule le montant final avec intérêts composés.

def interet_compose(capital, taux, annees):

return capital * (1 + taux) ** annees

print(round(interet_compose(1000, 0.05, 3), 2)) # 1157.63

Exercice 28. Écrire une fonction convertir_devise(montant, taux) qui convertit un

montant selon un taux de change.

def convertir_devise(montant, taux):

return montant * taux

print(convertir_devise(100, 0.92)) # 92.0

Exercice 29. Écrire une fonction calculer_moyenne(notes) qui retourne la moyenne

d’une liste de notes.

def calculer_moyenne(notes):
return sum(notes) / len(notes)

print(calculer_moyenne([12, 15, 18])) # 15.0

Exercice 30. Écrire une fonction calculer_ecart_type(valeurs) qui calcule l’écart-

type d’une liste de nombres.
 def calculer_ecart_type(valeurs):
m = sum(valeurs) / len(valeurs)
variance = sum((x - m) ** 2 for x in valeurs) / len(valeurs)
return variance ** 0.5

print(round(calculer_ecart_type([2, 4, 4, 4, 5, 5, 7, 9]), 2)) # 2.0

Exercice 31. Écrire une fonction calculer_mediane(valeurs) qui retourne la médiane

d’une liste de nombres.

def calculer_mediane(valeurs):
v = sorted(valeurs)
n = len(v)
milieu = n // 2
if n % 2 == 0:
return (v[milieu - 1] + v[milieu]) / 2
return v[milieu]

print(calculer_mediane([3, 1, 4, 1, 5])) # 3

Exercice 32. Écrire une fonction distance_points(x1, y1, x2, y2) qui calcule la
distance euclidienne entre deux points.

import math
def distance_points(x1, y1, x2, y2):
return [Link]((x2 - x1) ** 2 + (y2 - y1) ** 2)

print(distance_points(0, 0, 3, 4)) # 5.0

Exercice 33. Écrire une fonction calculer_tva(prix_ht, taux) qui retourne le prix
TTC.

def calculer_tva(prix_ht, taux):

return prix_ht * (1 + taux)

print(calculer_tva(100, 0.2)) # 120.0

Exercice 34. Écrire une fonction calculer_remise(prix, pourcentage) qui retourne le

prix après remise.

def calculer_remise(prix, pourcentage):

return prix * (1 - pourcentage / 100)

print(calculer_remise(200, 15)) # 170.0

Exercice 35. Écrire une fonction convertir_pourcentage(valeur, total) qui retourne

le pourcentage que représente valeur par rapport à total.

def convertir_pourcentage(valeur, total):

return (valeur / total) * 100

print(convertir_pourcentage(25, 200)) # 12.5

Exercice 36. Écrire une fonction puissance_iterative(base, exposant) qui calcule

une puissance sans utiliser l’opérateur **.

def puissance_iterative(base, exposant):

resultat = 1
for _ in range(exposant):
 resultat *= base
return resultat

print(puissance_iterative(2, 10)) # 1024

Exercice 37. Écrire une fonction racine_carree_newton(n) qui calcule la racine carrée
par la méthode de Newton (sans [Link]).

def racine_carree_newton(n, precision=1e-10):

x = n
while True:
nouveau_x = (x + n / x) / 2
if abs(nouveau_x - x) < precision:
return nouveau_x
x = nouveau_x

print(round(racine_carree_newton(25), 5)) # 5.0

Exercice 38. Écrire une fonction factorielle_iterative(n) qui calcule n! avec une
boucle.

def factorielle_iterative(n):
resultat = 1
for i in range(2, n + 1):
resultat *= i
return resultat

print(factorielle_iterative(5)) # 120

Exercice 39. Écrire une fonction fibonacci_iteratif(n) qui retourne le n-ième terme
de Fibonacci avec une boucle.

def fibonacci_iteratif(n):
a, b = 0, 1
for _ in range(n):
a, b = b, a + b
return a

print(fibonacci_iteratif(10)) # 55

Exercice 40. Écrire une fonction somme_serie_harmonique(n) qui calcule 1 + 1/2 + 1/3
+ … + 1/n.

def somme_serie_harmonique(n):
return sum(1 / i for i in range(1, n + 1))

print(round(somme_serie_harmonique(4), 4)) # 2.0833

Chaînes de Caractères

Exercice 41. Écrire une fonction inverser_mots(phrase) qui inverse l’ordre des mots
d’une phrase.

def inverser_mots(phrase):
return " ".join([Link]()[::-1])

print(inverser_mots("Python est génial")) # génial est Python

Exercice 42. Écrire une fonction compter_mots(phrase) qui compte le nombre de mots
dans une phrase.

def compter_mots(phrase):
return len([Link]())

print(compter_mots("Bonjour le monde")) # 3

Exercice 43. Écrire une fonction capitaliser_chaque_mot(phrase) qui met en

majuscule la première lettre de chaque mot.

def capitaliser_chaque_mot(phrase):
return " ".join([Link]() for mot in [Link]())

print(capitaliser_chaque_mot("bonjour le monde")) # Bonjour Le Monde

Exercice 44. Écrire une fonction supprimer_espaces(phrase) qui supprime tous les
espaces d’une chaîne.

def supprimer_espaces(phrase):
return [Link](" ", "")

print(supprimer_espaces("Bon jour")) # Bonjour

Exercice 45. Écrire une fonction compter_occurrences(mot, lettre) qui compte le

nombre d’occurrences d’une lettre dans un mot.

def compter_occurrences(mot, lettre):

return [Link](lettre)

print(compter_occurrences("anticonstitutionnellement", "n")) # 4

Exercice 46. Écrire une fonction est_anagramme(mot1, mot2) qui vérifie si deux mots
sont des anagrammes.

def est_anagramme(mot1, mot2):

return sorted([Link]()) == sorted([Link]())

print(est_anagramme("chien", "niche")) # True

Exercice 47. Écrire une fonction remplacer_voyelles(mot, car) qui remplace toutes
les voyelles d’un mot par un caractère donné.

def remplacer_voyelles(mot, car):

voyelles = "aeiouAEIOU"
return "".join(car if c in voyelles else c for c in mot)

print(remplacer_voyelles("Bonjour", "*")) # B*nj**r

Exercice 48. Écrire une fonction extraire_nombres(chaine) qui extrait tous les chiffres
présents dans une chaîne sous forme de liste d’entiers.

def extraire_nombres(chaine):
return [int(c) for c in chaine if [Link]()]

print(extraire_nombres("a1b22c3")) # [1, 2, 2, 3]

Exercice 49. Écrire une fonction formater_telephone(numero) qui formate une suite de
10 chiffres en “XX XX XX XX XX”.

def formater_telephone(numero):
return " ".join(numero[i:i+2] for i in range(0, len(numero), 2))

print(formater_telephone("0612345678")) # 06 12 34 56 78

Exercice 50. Écrire une fonction verifier_email(adresse) qui vérifie qu’une adresse
contient un @ et un . après le @.

def verifier_email(adresse):
if "@" not in adresse:
return False
utilisateur, domaine = [Link]("@", 1)
return "." in domaine and len(utilisateur) > 0

print(verifier_email("test@[Link]")) # True

Exercice 51. Écrire une fonction chiffrement_cesar(texte, decalage) qui applique

un chiffrement de César.

def chiffrement_cesar(texte, decalage):

resultat = ""
for c in texte:
if [Link]():
base = ord('A') if [Link]() else ord('a')
resultat += chr((ord(c) - base + decalage) % 26 + base)
else:
resultat += c
return resultat

print(chiffrement_cesar("abc", 3)) # def

Exercice 52. Écrire une fonction decrypter_cesar(texte, decalage) qui déchiffre un

texte chiffré par César.

def chiffrement_cesar(texte, decalage):

resultat = ""
for c in texte:
if [Link]():
base = ord('A') if [Link]() else ord('a')
resultat += chr((ord(c) - base + decalage) % 26 + base)
else:
resultat += c
return resultat

def decrypter_cesar(texte, decalage):

return chiffrement_cesar(texte, -decalage)

print(decrypter_cesar("def", 3)) # abc

Exercice 53. Écrire une fonction compter_consonnes(mot) qui compte le nombre de

consonnes dans un mot.

def compter_consonnes(mot):
voyelles = "aeiouAEIOU"
return sum(1 for c in mot if [Link]() and c not in voyelles)

print(compter_consonnes("Bonjour")) # 4
Exercice 54. Écrire une fonction mot_le_plus_long(phrase) qui retourne le mot le plus
long d’une phrase.

def mot_le_plus_long(phrase):
mots = [Link]()
return max(mots, key=len)

print(mot_le_plus_long("Le chat mange rapidement")) # rapidement

Exercice 55. Écrire une fonction mot_le_plus_court(phrase) qui retourne le mot le

plus court d’une phrase.

def mot_le_plus_court(phrase):
mots = [Link]()
return min(mots, key=len)

print(mot_le_plus_court("Le chat mange rapidement")) # Le

Exercice 56. Écrire une fonction supprimer_doublons_chaine(chaine) qui supprime

les lettres dupliquées en conservant l’ordre.

def supprimer_doublons_chaine(chaine):
vus = set()
resultat = ""
for c in chaine:
if c not in vus:
[Link](c)
resultat += c
return resultat

print(supprimer_doublons_chaine("programmation")) # progamti

Exercice 57. Écrire une fonction est_palindrome_phrase(phrase) qui vérifie si une

phrase est un palindrome (en ignorant espaces et casse).

def est_palindrome_phrase(phrase):
nettoye = "".join([Link]() for c in phrase if [Link]())
return nettoye == nettoye[::-1]

print(est_palindrome_phrase("Esope reste ici et se repose")) # True

Exercice 58. Écrire une fonction compresser_chaine(chaine) qui compresse une

chaîne par comptage de caractères consécutifs (ex: “aaabbc” -> “a3b2c1”).

def compresser_chaine(chaine):
if not chaine:
return ""
resultat = ""
compte = 1
for i in range(1, len(chaine)):
if chaine[i] == chaine[i - 1]:
compte += 1
else:
resultat += chaine[i - 1] + str(compte)
compte = 1
resultat += chaine[-1] + str(compte)
return resultat

print(compresser_chaine("aaabbc")) # a3b2c1
Exercice 59. Écrire une fonction decompresser_chaine(chaine) qui inverse la
compression (ex: “a3b2c1” -> “aaabbc”).

def decompresser_chaine(chaine):
resultat = ""
i = 0
while i < len(chaine):
lettre = chaine[i]
j = i + 1
nombre = ""
while j < len(chaine) and chaine[j].isdigit():
nombre += chaine[j]
j += 1
resultat += lettre * int(nombre)
i = j
return resultat

print(decompresser_chaine("a3b2c1")) # aaabbc

Exercice 60. Écrire une fonction premiere_lettre_non_repetee(chaine) qui retourne

la première lettre non répétée d’une chaîne.

def premiere_lettre_non_repetee(chaine):
for c in chaine:
if [Link](c) == 1:
return c
return None

print(premiere_lettre_non_repetee("swiss")) # w

Exercice 61. Écrire une fonction vers_camel_case(chaine) qui convertit une chaîne
snake_case en camelCase.

def vers_camel_case(chaine):
mots = [Link]("_")
return mots[0] + "".join([Link]() for m in mots[1:])

print(vers_camel_case("nom_de_variable")) # nomDeVariable

Exercice 62. Écrire une fonction vers_snake_case(chaine) qui convertit une chaîne
camelCase en snake_case.

def vers_snake_case(chaine):
resultat = ""
for c in chaine:
if [Link]():
resultat += "_" + [Link]()
else:
resultat += c
return resultat

print(vers_snake_case("nomDeVariable")) # nom_de_variable

Exercice 63. Écrire une fonction compter_maj_min(chaine) qui retourne un tuple

(nb_majuscules, nb_minuscules).

def compter_maj_min(chaine):
maj = sum(1 for c in chaine if [Link]())
minu = sum(1 for c in chaine if [Link]())
return (maj, minu)
 print(compter_maj_min("Bonjour Le Monde")) # (3, 11)

Exercice 64. Écrire une fonction verifier_mdp_fort(mdp) qui vérifie qu’un mot de
passe contient au moins 8 caractères, une majuscule, un chiffre et un caractère spécial.

def verifier_mdp_fort(mdp):
if len(mdp) < 8:
return False
a_maj = any([Link]() for c in mdp)
a_chiffre = any([Link]() for c in mdp)
a_special = any(not [Link]() for c in mdp)
return a_maj and a_chiffre and a_special

print(verifier_mdp_fort("Python123!")) # True

Exercice 65. Écrire une fonction generer_acronyme(phrase) qui retourne l’acronyme en

majuscules formé des premières lettres de chaque mot.

def generer_acronyme(phrase):
return "".join(mot[0].upper() for mot in [Link]())

print(generer_acronyme("Organisation des Nations Unies")) # ONNU

Conditions

Exercice 66. Écrire une fonction classer_age(age) qui retourne “enfant”, “adolescent”,
“adulte” ou “senior” selon l’âge.

def classer_age(age):
if age < 13:
return "enfant"
elif age < 18:
return "adolescent"
elif age < 65:
return "adulte"
else:
return "senior"

print(classer_age(30)) # adulte

Exercice 67. Écrire une fonction verifier_triangle(a, b, c) qui vérifie si trois

longueurs peuvent former un triangle.

def verifier_triangle(a, b, c):

return a + b > c and a + c > b and b + c > a

print(verifier_triangle(3, 4, 5)) # True

Exercice 68. Écrire une fonction type_triangle(a, b, c) qui retourne “équilatéral”,

“isocèle” ou “scalène”.

def type_triangle(a, b, c):

if a == b == c:
return "équilatéral"
elif a == b or b == c or a == c:
return "isocèle"
else:
return "scalène"
 print(type_triangle(3, 3, 5)) # isocèle

Exercice 69. Écrire une fonction est_bissextile(annee) qui vérifie si une année est
bissextile.

def est_bissextile(annee):
return annee % 4 == 0 and (annee % 100 != 0 or annee % 400 == 0)

print(est_bissextile(2024)) # True

Exercice 70. Écrire une fonction categorie_imc(imc) qui retourne “Maigreur”,

“Normal”, “Surpoids” ou “Obésité” selon l’IMC.

def categorie_imc(imc):
if imc < 18.5:
return "Maigreur"
elif imc < 25:
return "Normal"
elif imc < 30:
return "Surpoids"
else:
return "Obésité"

print(categorie_imc(24)) # Normal

Exercice 71. Écrire une fonction determiner_saison(mois) qui retourne la saison

(hiver, printemps, été, automne) selon un numéro de mois (1-12).

def determiner_saison(mois):
if mois in (12, 1, 2):
return "hiver"
elif mois in (3, 4, 5):
return "printemps"
elif mois in (6, 7, 8):
return "été"
else:
return "automne"

print(determiner_saison(7)) # été

Exercice 72. Écrire une fonction verifier_code_postal(code) qui vérifie qu’un code
postal est composé de 5 chiffres.

def verifier_code_postal(code):
return [Link]() and len(code) == 5

print(verifier_code_postal("75001")) # True

Exercice 73. Écrire une fonction peut_voter(age, nationalite) qui vérifie si une
personne peut voter (majeur et nationalité “française”).

def peut_voter(age, nationalite):

return age >= 18 and nationalite == "française"

print(peut_voter(20, "française")) # True

Exercice 74. Écrire une fonction tarif_cinema(age) qui retourne le tarif : 5€ si <12
ans, 8€ si <65 ans, 6€ sinon.
 def tarif_cinema(age):
if age < 12:
return 5
elif age < 65:
return 8
else:
return 6

print(tarif_cinema(70)) # 6

Exercice 75. Écrire une fonction signe_astrologique(jour, mois) qui retourne le

signe astrologique correspondant (simplifié par mois).

def signe_astrologique(jour, mois):

signes = {1: "Capricorne", 2: "Verseau", 3: "Poissons", 4: "Bélier",
5: "Taureau", 6: "Gémeaux", 7: "Cancer", 8: "Lion",
9: "Vierge", 10: "Balance", 11: "Scorpion", 12: "Sagittaire"}
return signes[mois]

print(signe_astrologique(15, 8)) # Lion

Exercice 76. Écrire une fonction qualite_signal(force) qui retourne “Excellent”,

“Bon”, “Faible” ou “Aucun” selon la force du signal wifi (0-100).

def qualite_signal(force):
if force >= 80:
return "Excellent"
elif force >= 50:
return "Bon"
elif force > 0:
return "Faible"
else:
return "Aucun"

print(qualite_signal(65)) # Bon

Exercice 77. Écrire une fonction type_triangle_angle(a, b, c) (angles en degrés) qui

retourne “rectangle”, “obtus” ou “aigu”.

def type_triangle_angle(a, b, c):

angles = [a, b, c]
if 90 in angles:
return "rectangle"
elif any(angle > 90 for angle in angles):
return "obtus"
else:
return "aigu"

print(type_triangle_angle(90, 45, 45)) # rectangle

Exercice 78. Écrire une fonction jour_semaine(numero) qui retourne le nom du jour
(1=Lundi … 7=Dimanche).

def jour_semaine(numero):
jours = ["Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi",
"Dimanche"]
if 1 <= numero <= 7:
return jours[numero - 1]
return "Numéro invalide"

print(jour_semaine(3)) # Mercredi
Exercice 79. Écrire une fonction mdp_valide(mdp) qui vérifie qu’un mot de passe a au
moins 6 caractères et contient un chiffre.

def mdp_valide(mdp):
return len(mdp) >= 6 and any([Link]() for c in mdp)

print(mdp_valide("abc123")) # True

Exercice 80. Écrire une fonction note_finale(cc, examen) qui calcule 30% du contrôle
continu + 70% de l’examen, et retourne aussi la mention.

def note_finale(cc, examen):

note = cc * 0.3 + examen * 0.7
if note >= 16:
mention = "Très bien"
elif note >= 14:
mention = "Bien"
elif note >= 12:
mention = "Assez bien"
elif note >= 10:
mention = "Passable"
else:
mention = "Ajourné"
return (round(note, 2), mention)

print(note_finale(15, 12)) # (12.9, 'Assez bien')

Exercice 81. Écrire une fonction type_nombre(n) qui retourne “positif”, “négatif” ou
“nul”.

def type_nombre(n):
if n > 0:
return "positif"
elif n < 0:
return "négatif"
else:
return "nul"

print(type_nombre(-5)) # négatif

Exercice 82. Écrire une fonction est_chaine_vide(chaine) qui vérifie si une chaîne est
vide ou ne contient que des espaces.

def est_chaine_vide(chaine):
return len([Link]()) == 0

print(est_chaine_vide(" ")) # True

Exercice 83. Écrire une fonction classer_vitesse(vitesse) qui retourne “lente” (<50),
“normale” (50-90) ou “rapide” (>90).

def classer_vitesse(vitesse):
if vitesse < 50:
return "lente"
elif vitesse <= 90:
return "normale"
else:
return "rapide"
 print(classer_vitesse(100)) # rapide

Exercice 84. Écrire une fonction eligible_pret(salaire, dettes) qui vérifie

l’éligibilité à un prêt (salaire > 1500 et dettes < 30% du salaire).

def eligible_pret(salaire, dettes):

return salaire > 1500 and dettes < 0.3 * salaire

print(eligible_pret(2000, 400)) # True

Exercice 85. Écrire une fonction code_promo_valide(code, liste_valides) qui vérifie

si un code promo existe dans une liste (insensible à la casse).

def code_promo_valide(code, liste_valides):

return [Link]() in [[Link]() for c in liste_valides]

print(code_promo_valide("promo10", ["PROMO10", "SOLDE20"])) # True

Boucles

Exercice 86. Écrire une fonction somme_pairs(n) qui retourne la somme des nombres
pairs de 1 à n.

def somme_pairs(n):
total = 0
for i in range(1, n + 1):
if i % 2 == 0:
total += i
return total

print(somme_pairs(10)) # 30

Exercice 87. Écrire une fonction somme_impairs(n) qui retourne la somme des nombres
impairs de 1 à n.

def somme_impairs(n):
total = 0
for i in range(1, n + 1):
if i % 2 != 0:
total += i
return total

print(somme_impairs(10)) # 25

Exercice 88. Écrire une fonction produit_1_a_n(n) qui retourne le produit des nombres
de 1 à n.

def produit_1_a_n(n):
produit = 1
for i in range(1, n + 1):
produit *= i
return produit

print(produit_1_a_n(5)) # 120

Exercice 89. Écrire une fonction triangle_etoiles(n) qui retourne une chaîne
représentant un triangle de n lignes d’étoiles.
 def triangle_etoiles(n):
lignes = []
for i in range(1, n + 1):
[Link]("*" * i)
return "\n".join(lignes)

print(triangle_etoiles(4))
# *
# **
# ***
# ****

Exercice 90. Écrire une fonction triangle_inverse(n) qui retourne un triangle d’étoiles
inversé.

def triangle_inverse(n):
lignes = []
for i in range(n, 0, -1):
[Link]("*" * i)
return "\n".join(lignes)

print(triangle_inverse(4))
# ****
# ***
# **
# *

Exercice 91. Écrire une fonction pyramide(n) qui retourne une pyramide d’étoiles
centrée de n lignes.

def pyramide(n):
lignes = []
for i in range(1, n + 1):
[Link](" " * (n - i) + "*" * (2 * i - 1))
return "\n".join(lignes)

print(pyramide(3))
# *
# ***
# *****

Exercice 92. Écrire une fonction compter_diviseurs(n) qui compte le nombre de

diviseurs d’un nombre.

def compter_diviseurs(n):
compte = 0
for i in range(1, n + 1):
if n % i == 0:
compte += 1
return compte

print(compter_diviseurs(12)) # 6

Exercice 93. Écrire une fonction lister_diviseurs(n) qui retourne la liste des
diviseurs d’un nombre.

def lister_diviseurs(n):
return [i for i in range(1, n + 1) if n % i == 0]

print(lister_diviseurs(12)) # [1, 2, 3, 4, 6, 12]

Exercice 94. Écrire une fonction nombres_premiers_jusqua(n) qui retourne la liste des
nombres premiers jusqu’à n.

def nombres_premiers_jusqua(n):
premiers = []
for nombre in range(2, n + 1):
est_premier = True
for i in range(2, int(nombre ** 0.5) + 1):
if nombre % i == 0:
est_premier = False
break
if est_premier:
[Link](nombre)
return premiers

print(nombres_premiers_jusqua(20)) # [2, 3, 5, 7, 11, 13, 17, 19]

Exercice 95. Écrire une fonction suite_syracuse(n) qui retourne la longueur de la suite
de Syracuse (Collatz) partant de n.

def suite_syracuse(n):
compte = 0
while n != 1:
if n % 2 == 0:
n = n // 2
else:
n = 3 * n + 1
compte += 1
return compte

print(suite_syracuse(27)) # 111

Exercice 96. Écrire une fonction somme_carres(n) qui retourne la somme des carrés de
1 à n.

def somme_carres(n):
total = 0
for i in range(1, n + 1):
total += i ** 2
return total

print(somme_carres(5)) # 55

Exercice 97. Écrire une fonction somme_cubes(n) qui retourne la somme des cubes de 1
à n.

def somme_cubes(n):
total = 0
for i in range(1, n + 1):
total += i ** 3
return total

print(somme_cubes(3)) # 36

Exercice 98. Écrire une fonction damier(n) qui retourne une chaîne représentant un
damier n x n de ‘X’ et ‘O’.

def damier(n):
lignes = []
for i in range(n):
ligne = ""
 for j in range(n):
ligne += "X" if (i + j) % 2 == 0 else "O"
[Link](ligne)
return "\n".join(lignes)

print(damier(4))
# XOXO
# OXOX
# XOXO
# OXOX

Exercice 99. Écrire une fonction pgcd_boucle(a, b) qui calcule le PGCD par
soustractions successives.

def pgcd_boucle(a, b):

while a != b:
if a > b:
a -= b
else:
b -= a
return a

print(pgcd_boucle(48, 18)) # 6

Exercice 100. Écrire une fonction moyenne_geometrique(valeurs) qui calcule la

moyenne géométrique d’une liste de nombres.

def moyenne_geometrique(valeurs):
produit = 1
for v in valeurs:
produit *= v
return produit ** (1 / len(valeurs))

print(round(moyenne_geometrique([4, 9]), 2)) # 6.0

Exercice 101. Écrire une fonction compter_lettres_boucle(mot) qui retourne un

dictionnaire {lettre: nombre_occurrences} en utilisant une boucle.

def compter_lettres_boucle(mot):
compteur = {}
for lettre in mot:
if lettre in compteur:
compteur[lettre] += 1
else:
compteur[lettre] = 1
return compteur

print(compter_lettres_boucle("abracadabra"))

Exercice 102. Écrire une fonction inverser_liste_boucle(liste) qui inverse une liste
sans utiliser reverse() ni le slicing.

def inverser_liste_boucle(liste):
resultat = []
for i in range(len(liste) - 1, -1, -1):
[Link](liste[i])
return resultat

print(inverser_liste_boucle([1, 2, 3, 4])) # [4, 3, 2, 1]

Exercice 103. Écrire une fonction rechercher_element_boucle(liste, element) qui

retourne l’index d’un élément (ou -1) sans utiliser .index().

def rechercher_element_boucle(liste, element):

for i in range(len(liste)):
if liste[i] == element:
return i
return -1

print(rechercher_element_boucle([5, 3, 8, 1], 8)) # 2

Exercice 104. Écrire une fonction trouver_min_max_boucle(liste) qui retourne un

tuple (min, max) sans utiliser min() ni max().

def trouver_min_max_boucle(liste):
minimum = maximum = liste[0]
for element in liste[1:]:
if element < minimum:
minimum = element
if element > maximum:
maximum = element
return (minimum, maximum)

print(trouver_min_max_boucle([4, 7, 2, 9, 1])) # (1, 9)

Exercice 105. Écrire une fonction somme_multiples_3_5(limite) qui retourne la

somme de tous les multiples de 3 ou 5 en dessous de limite.

def somme_multiples_3_5(limite):
total = 0
for i in range(limite):
if i % 3 == 0 or i % 5 == 0:
total += i
return total

print(somme_multiples_3_5(1000)) # 233168

Exercice 106. Écrire une fonction compter_voyelles_boucle(texte) qui compte les

voyelles avec une boucle.

def compter_voyelles_boucle(texte):
voyelles = "aeiouAEIOU"
compte = 0
for c in texte:
if c in voyelles:
compte += 1
return compte

print(compter_voyelles_boucle("Bonjour tout le monde")) # 7

Exercice 107. Écrire une fonction table_addition(n) qui retourne une liste des
sommes i+n pour i de 1 à 10.

def table_addition(n):
return [i + n for i in range(1, 11)]

print(table_addition(5)) # [6, 7, 8, ..., 15]

Exercice 108. Écrire une fonction premiers_dans_intervalle(debut, fin) qui

retourne les nombres premiers entre debut et fin.
 def est_premier(n):
if n < 2:
return False
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0:
return False
return True

def premiers_dans_intervalle(debut, fin):

return [n for n in range(debut, fin + 1) if est_premier(n)]

print(premiers_dans_intervalle(10, 30)) # [11, 13, 17, 19, 23, 29]

Exercice 109. Écrire une fonction moyenne_ponderee_boucle(notes, coefficients)

qui calcule une moyenne pondérée avec une boucle explicite.

def moyenne_ponderee_boucle(notes, coefficients):

somme_notes = 0
somme_coeffs = 0
for i in range(len(notes)):
somme_notes += notes[i] * coefficients[i]
somme_coeffs += coefficients[i]
return somme_notes / somme_coeffs

print(moyenne_ponderee_boucle([10, 15, 12], [2, 3, 1])) # 12.83...

Exercice 110. Écrire une fonction simuler_compte_bancaire(solde, operations) qui

applique une liste d’opérations (+dépôt / -retrait) à un solde et retourne le solde final
(refuse les retraits qui rendraient le solde négatif).

def simuler_compte_bancaire(solde, operations):

for operation in operations:
if solde + operation >= 0:
solde += operation
else:
print(f"Opération refusée : {operation}")
return solde

print(simuler_compte_bancaire(100, [50, -30, -200, -20])) # 100

Listes

Exercice 111. Écrire une fonction fusionner_listes_triees(l1, l2) qui fusionne

deux listes déjà triées en une seule liste triée.

def fusionner_listes_triees(l1, l2):

resultat = []
i = j = 0
while i < len(l1) and j < len(l2):
if l1[i] <= l2[j]:
[Link](l1[i]); i += 1
else:
[Link](l2[j]); j += 1
[Link](l1[i:])
[Link](l2[j:])
return resultat

print(fusionner_listes_triees([1, 3, 5], [2, 4, 6])) # [1, 2, 3, 4, 5, 6]

Exercice 112. Écrire une fonction supprimer_doublons_liste(liste) qui supprime les
doublons d’une liste en conservant l’ordre.

def supprimer_doublons_liste(liste):
vus = set()
resultat = []
for element in liste:
if element not in vus:
[Link](element)
[Link](element)
return resultat

print(supprimer_doublons_liste([1, 2, 2, 3, 1, 4])) # [1, 2, 3, 4]

Exercice 113. Écrire une fonction aplatir_liste(liste_de_listes) qui aplatit une

liste de listes en une seule liste.

def aplatir_liste(liste_de_listes):
resultat = []
for sous_liste in liste_de_listes:
[Link](sous_liste)
return resultat

print(aplatir_liste([[1, 2], [3, 4], [5]])) # [1, 2, 3, 4, 5]

Exercice 114. Écrire une fonction rotation_liste(liste, n) qui décale les éléments
d’une liste de n positions vers la droite.

def rotation_liste(liste, n):

n = n % len(liste)
return liste[-n:] + liste[:-n]

print(rotation_liste([1, 2, 3, 4, 5], 2)) # [4, 5, 1, 2, 3]

Exercice 115. Écrire une fonction deuxieme_max(liste) qui retourne la deuxième plus
grande valeur d’une liste.

def deuxieme_max(liste):
uniques = sorted(set(liste), reverse=True)
return uniques[1]

print(deuxieme_max([4, 7, 2, 9, 9, 1])) # 7

Exercice 116. Écrire une fonction compter_occurrences_liste(liste, element) qui

compte les occurrences d’un élément dans une liste.

def compter_occurrences_liste(liste, element):

return [Link](element)

print(compter_occurrences_liste([1, 2, 2, 3, 2], 2)) # 3

Exercice 117. Écrire une fonction diviser_en_groupes(liste, taille) qui découpe

une liste en sous-listes de taille donnée.

def diviser_en_groupes(liste, taille):

return [liste[i:i + taille] for i in range(0, len(liste), taille)]

print(diviser_en_groupes([1,2,3,4,5,6,7], 3)) # [[1,2,3],[4,5,6],[7]]

Exercice 118. Écrire une fonction liste_intersection(l1, l2) qui retourne les
éléments communs entre deux listes.

def liste_intersection(l1, l2):

return [element for element in l1 if element in l2]

print(liste_intersection([1,2,3,4], [3,4,5,6])) # [3, 4]

Exercice 119. Écrire une fonction liste_difference(l1, l2) qui retourne les éléments
de l1 absents de l2.

def liste_difference(l1, l2):

return [element for element in l1 if element not in l2]

print(liste_difference([1,2,3,4], [3,4,5,6])) # [1, 2]

Exercice 120. Écrire une fonction permuter_elements(liste, i, j) qui échange deux

éléments d’une liste (retourne une nouvelle liste).

def permuter_elements(liste, i, j):

nouvelle = liste[:]
nouvelle[i], nouvelle[j] = nouvelle[j], nouvelle[i]
return nouvelle

print(permuter_elements([1,2,3,4], 0, 3)) # [4, 2, 3, 1]

Exercice 121. Écrire une fonction tri_insertion(liste) qui trie une liste en
implémentant l’algorithme de tri par insertion.

def tri_insertion(liste):
liste = liste[:]
for i in range(1, len(liste)):
cle = liste[i]
j = i - 1
while j >= 0 and liste[j] > cle:
liste[j + 1] = liste[j]
j -= 1
liste[j + 1] = cle
return liste

print(tri_insertion([5, 2, 4, 6, 1, 3])) # [1, 2, 3, 4, 5, 6]

Exercice 122. Écrire une fonction tri_selection(liste) qui trie une liste en
implémentant l’algorithme de tri par sélection.

def tri_selection(liste):
liste = liste[:]
n = len(liste)
for i in range(n):
idx_min = i
for j in range(i + 1, n):
if liste[j] < liste[idx_min]:
idx_min = j
liste[i], liste[idx_min] = liste[idx_min], liste[i]
return liste

print(tri_selection([64, 25, 12, 22, 11])) # [11, 12, 22, 25, 64]

Exercice 123. Écrire une fonction recherche_dichotomique(liste_triee, cible) qui

retourne l’index d’un élément dans une liste triée (ou -1).
 def recherche_dichotomique(liste_triee, cible):
gauche, droite = 0, len(liste_triee) - 1
while gauche <= droite:
milieu = (gauche + droite) // 2
if liste_triee[milieu] == cible:
return milieu
elif liste_triee[milieu] < cible:
gauche = milieu + 1
else:
droite = milieu - 1
return -1

print(recherche_dichotomique([1,3,5,7,9,11], 7)) # 3

Exercice 124. Écrire une fonction liste_est_triee(liste) qui vérifie si une liste est
triée en ordre croissant.

def liste_est_triee(liste):
for i in range(len(liste) - 1):
if liste[i] > liste[i + 1]:
return False
return True

print(liste_est_triee([1, 2, 3, 4])) # True

Exercice 125. Écrire une fonction fusionner_et_trier(l1, l2) qui fusionne deux
listes quelconques puis les trie.

def fusionner_et_trier(l1, l2):

return sorted(l1 + l2)

print(fusionner_et_trier([5,1,3], [4,2])) # [1, 2, 3, 4, 5]

Exercice 126. Écrire une fonction moyenne_liste(liste) qui calcule la moyenne des
éléments d’une liste.

def moyenne_liste(liste):
return sum(liste) / len(liste)

print(moyenne_liste([10, 20, 30])) # 20.0

Exercice 127. Écrire une fonction produit_liste(liste) qui calcule le produit des
éléments d’une liste.

def produit_liste(liste):
produit = 1
for element in liste:
produit *= element
return produit

print(produit_liste([1, 2, 3, 4])) # 24

Exercice 128. Écrire une fonction filtrer_pairs(liste) qui retourne uniquement les
nombres pairs d’une liste.

def filtrer_pairs(liste):
return [x for x in liste if x % 2 == 0]

print(filtrer_pairs([1,2,3,4,5,6])) # [2, 4, 6]
Exercice 129. Écrire une fonction filtrer_positifs(liste) qui retourne uniquement
les nombres positifs d’une liste.

def filtrer_positifs(liste):
return [x for x in liste if x > 0]

print(filtrer_positifs([-3, 5, -1, 8, 0])) # [5, 8]

Exercice 130. Écrire une fonction transformer_carre(liste) qui retourne une liste
avec le carré de chaque élément.

def transformer_carre(liste):
return [x ** 2 for x in liste]

print(transformer_carre([1,2,3,4])) # [1, 4, 9, 16]

Exercice 131. Écrire une fonction zip_listes(l1, l2) qui combine deux listes en une
liste de tuples (sans utiliser zip).

def zip_listes(l1, l2):

resultat = []
for i in range(min(len(l1), len(l2))):
[Link]((l1[i], l2[i]))
return resultat

print(zip_listes([1,2,3], ["a","b","c"])) # [(1,'a'),(2,'b'),(3,'c')]

Exercice 132. Écrire une fonction liste_cumulative(liste) qui retourne la somme

cumulative d’une liste.

def liste_cumulative(liste):
resultat = []
total = 0
for x in liste:
total += x
[Link](total)
return resultat

print(liste_cumulative([1,2,3,4])) # [1, 3, 6, 10]

Exercice 133. Écrire une fonction sous_liste_somme_max(liste) qui retourne la

somme maximale d’une sous-liste contiguë (algorithme de Kadane).

def sous_liste_somme_max(liste):
max_actuel = max_global = liste[0]
for x in liste[1:]:
max_actuel = max(x, max_actuel + x)
max_global = max(max_global, max_actuel)
return max_global

print(sous_liste_somme_max([-2,1,-3,4,-1,2,1,-5,4])) # 6

Exercice 134. Écrire une fonction transposer_matrice(matrice) qui retourne la

transposée d’une matrice (liste de listes).

def transposer_matrice(matrice):
return [[ligne[i] for ligne in matrice] for i in range(len(matrice[0]))]

print(transposer_matrice([[1,2,3],[4,5,6]])) # [[1,4],[2,5],[3,6]]
Exercice 135. Écrire une fonction addition_matrices(m1, m2) qui additionne deux
matrices de même taille.

def addition_matrices(m1, m2):

return [[m1[i][j] + m2[i][j] for j in range(len(m1[0]))] for i in
range(len(m1))]

print(addition_matrices([[1,2],[3,4]], [[5,6],[7,8]])) # [[6,8],[10,12]]

Exercice 136. Écrire une fonction multiplication_matrices(m1, m2) qui multiplie

deux matrices compatibles.

def multiplication_matrices(m1, m2):

lignes_m1 = len(m1)
colonnes_m1 = len(m1[0])
colonnes_m2 = len(m2[0])
resultat = [[0] * colonnes_m2 for _ in range(lignes_m1)]
for i in range(lignes_m1):
for j in range(colonnes_m2):
for k in range(colonnes_m1):
resultat[i][j] += m1[i][k] * m2[k][j]
return resultat

print(multiplication_matrices([[1,2],[3,4]], [[5,6],[7,8]])) # [[19,22],[43,50]]

Exercice 137. Écrire une fonction liste_vers_dictionnaire(liste) qui transforme

une liste en dictionnaire {index: valeur}.

def liste_vers_dictionnaire(liste):
return {i: valeur for i, valeur in enumerate(liste)}

print(liste_vers_dictionnaire(["a","b","c"])) # {0:'a',1:'b',2:'c'}

Exercice 138. Écrire une fonction melanger_liste(liste) qui retourne une copie
mélangée d’une liste (module random).

import random
def melanger_liste(liste):
copie = liste[:]
[Link](copie)
return copie

print(melanger_liste([1,2,3,4,5])) # ordre aléatoire

Exercice 139. Écrire une fonction partitionner_pair_impair(liste) qui retourne un

tuple (liste_des_pairs, liste_des_impairs).

def partitionner_pair_impair(liste):
pairs = [x for x in liste if x % 2 == 0]
impairs = [x for x in liste if x % 2 != 0]
return (pairs, impairs)

print(partitionner_pair_impair([1,2,3,4,5,6])) # ([2,4,6],[1,3,5])

Exercice 140. Écrire une fonction trouver_triplets_somme(liste, cible) qui

retourne tous les triplets de la liste dont la somme est égale à cible.

def trouver_triplets_somme(liste, cible):

liste = sorted(liste)
 resultats = []
n = len(liste)
for i in range(n - 2):
gauche, droite = i + 1, n - 1
while gauche < droite:
s = liste[i] + liste[gauche] + liste[droite]
if s == cible:
[Link]((liste[i], liste[gauche], liste[droite]))
gauche += 1
droite -= 1
elif s < cible:
gauche += 1
else:
droite -= 1
return resultats

print(trouver_triplets_somme([1,0,-1,2,-1,-4], 0)) # [(-1,-1,2),(-1,0,1)]

Tuples

Exercice 141. Écrire une fonction tuple_vers_dict(cles, valeurs) qui construit un

dictionnaire à partir de deux tuples.

def tuple_vers_dict(cles, valeurs):

return dict(zip(cles, valeurs))

print(tuple_vers_dict(("a","b","c"), (1,2,3))) # {'a':1,'b':2,'c':3}

Exercice 142. Écrire une fonction inverser_tuple(tup) qui retourne un tuple inversé.

def inverser_tuple(tup):
return tup[::-1]

print(inverser_tuple((1,2,3,4))) # (4, 3, 2, 1)

Exercice 143. Écrire une fonction concatener_tuples(*tuples) qui concatène un

nombre variable de tuples.

def concatener_tuples(*tuples):
resultat = ()
for t in tuples:
resultat += t
return resultat

print(concatener_tuples((1,2), (3,4), (5,))) # (1, 2, 3, 4, 5)

Exercice 144. Écrire une fonction tuple_le_plus_long(liste_de_tuples) qui retourne

le tuple le plus long d’une liste.

def tuple_le_plus_long(liste_de_tuples):
return max(liste_de_tuples, key=len)

print(tuple_le_plus_long([(1,2), (1,2,3), (1,)])) # (1, 2, 3)

Exercice 145. Écrire une fonction comparer_tuples(t1, t2) qui retourne les éléments
qui diffèrent entre deux tuples de même taille.

def comparer_tuples(t1, t2):

 return [(a, b) for a, b in zip(t1, t2) if a != b]

print(comparer_tuples((1,2,3), (1,5,3))) # [(2, 5)]

Exercice 146. Écrire une fonction tuple_sans_doublons(tup) qui retourne un tuple

sans doublons (ordre préservé).

def tuple_sans_doublons(tup):
vus = set()
resultat = []
for x in tup:
if x not in vus:
[Link](x)
[Link](x)
return tuple(resultat)

print(tuple_sans_doublons((1,2,2,3,1))) # (1, 2, 3)

Exercice 147. Écrire une fonction somme_tuple(tup) qui retourne la somme des
éléments d’un tuple de nombres.

def somme_tuple(tup):
return sum(tup)

print(somme_tuple((1,2,3,4))) # 10

Exercice 148. Écrire une fonction tuple_pair_impair(tup) qui retourne un tuple des
éléments pairs et un tuple des éléments impairs.

def tuple_pair_impair(tup):
pairs = tuple(x for x in tup if x % 2 == 0)
impairs = tuple(x for x in tup if x % 2 != 0)
return (pairs, impairs)

print(tuple_pair_impair((1,2,3,4,5))) # ((2, 4), (1, 3, 5))

Exercice 149. Écrire une fonction trier_tuples_par_element(liste_tuples, index)

qui trie une liste de tuples selon la valeur à un index donné.

def trier_tuples_par_element(liste_tuples, index):

return sorted(liste_tuples, key=lambda t: t[index])

print(trier_tuples_par_element([(1,"b"),(2,"a")], 1)) # [(2,'a'), (1,'b')]

Exercice 150. Écrire une fonction tuple_min_max(tup) qui retourne un tuple (min, max)
d’un tuple de nombres.

def tuple_min_max(tup):
return (min(tup), max(tup))

print(tuple_min_max((4,7,2,9,1))) # (1, 9)

Exercice 151. Écrire une fonction additionner_tuples(t1, t2) qui additionne deux
tuples élément par élément.

def additionner_tuples(t1, t2):

return tuple(a + b for a, b in zip(t1, t2))

print(additionner_tuples((1,2,3), (4,5,6))) # (5, 7, 9)

Exercice 152. Écrire une fonction tuple_est_sous_ensemble(t1, t2) qui vérifie si tous
les éléments de t1 sont présents dans t2.

def tuple_est_sous_ensemble(t1, t2):

return all(x in t2 for x in t1)

print(tuple_est_sous_ensemble((1,2), (1,2,3,4))) # True

Exercice 153. Écrire une fonction compter_elements_communs(t1, t2) qui compte le

nombre d’éléments communs entre deux tuples.

def compter_elements_communs(t1, t2):

return len(set(t1) & set(t2))

print(compter_elements_communs((1,2,3), (2,3,4))) # 2

Exercice 154. Écrire une fonction tuple_vers_liste_triee(tup) qui convertit un tuple

en liste triée.

def tuple_vers_liste_triee(tup):
return sorted(list(tup))

print(tuple_vers_liste_triee((3,1,4,1,5))) # [1, 1, 3, 4, 5]

Exercice 155. Écrire une fonction extraire_positions_paires(tup) qui retourne un

tuple des éléments situés aux positions paires.

def extraire_positions_paires(tup):
return tup[::2]

print(extraire_positions_paires((10,20,30,40,50))) # (10, 30, 50)

Ensembles

Exercice 156. Écrire une fonction elements_uniques(l1, l2) qui retourne les éléments
qui n’apparaissent que dans une seule des deux listes.

def elements_uniques(l1, l2):

return set(l1) ^ set(l2)

print(elements_uniques([1,2,3], [2,3,4])) # {1, 4}

Exercice 157. Écrire une fonction est_sous_ensemble(a, b) qui vérifie si l’ensemble a

est un sous-ensemble de b.

def est_sous_ensemble(a, b):

return set(a).issubset(set(b))

print(est_sous_ensemble({1,2}, {1,2,3})) # True

Exercice 158. Écrire une fonction caracteres_uniques(chaine) qui retourne

l’ensemble des caractères uniques d’une chaîne.

def caracteres_uniques(chaine):
return set(chaine)

print(caracteres_uniques("mississippi")) # {'m','i','s','p'}
Exercice 159. Écrire une fonction intersection_multiple(*ensembles) qui retourne
l’intersection de plusieurs ensembles.

def intersection_multiple(*ensembles):
resultat = set(ensembles[0])
for e in ensembles[1:]:
resultat &= set(e)
return resultat

print(intersection_multiple({1,2,3}, {2,3,4}, {2,3,5})) # {2, 3}

Exercice 160. Écrire une fonction union_multiple(*ensembles) qui retourne l’union de

plusieurs ensembles.

def union_multiple(*ensembles):
resultat = set()
for e in ensembles:
resultat |= set(e)
return resultat

print(union_multiple({1,2}, {2,3}, {3,4})) # {1, 2, 3, 4}

Exercice 161. Écrire une fonction difference_symetrique(a, b) qui retourne la

différence symétrique entre deux ensembles.

def difference_symetrique(a, b):

return set(a).symmetric_difference(set(b))

print(difference_symetrique({1,2,3}, {2,3,4})) # {1, 4}

Exercice 162. Écrire une fonction sont_disjoints(a, b) qui vérifie si deux ensembles
n’ont aucun élément en commun.

def sont_disjoints(a, b):

return set(a).isdisjoint(set(b))

print(sont_disjoints({1,2}, {3,4})) # True

Exercice 163. Écrire une fonction lettres_uniques_communes(mot1, mot2) qui

retourne les lettres communes entre deux mots.

def lettres_uniques_communes(mot1, mot2):

return set(mot1) & set(mot2)

print(lettres_uniques_communes("python", "typhon")) # {'p','y','t','h','o','n'}

Exercice 164. Écrire une fonction ensembles_egaux(a, b) qui vérifie si deux ensembles
contiennent les mêmes éléments.

def ensembles_egaux(a, b):

return set(a) == set(b)

print(ensembles_egaux([1,2,3], [3,2,1])) # True

Exercice 165. Écrire une fonction ajouter_si_absent(ensemble, element) qui ajoute

un élément à un ensemble s’il n’y est pas déjà, et retourne le nouvel ensemble.
 def ajouter_si_absent(ensemble, element):
nouvel_ensemble = set(ensemble)
nouvel_ensemble.add(element)
return nouvel_ensemble

print(ajouter_si_absent({1,2,3}, 4)) # {1, 2, 3, 4}

Exercice 166. Écrire une fonction fusionner_sans_doublons(*listes) qui fusionne

plusieurs listes en supprimant les doublons.

def fusionner_sans_doublons(*listes):
resultat = set()
for liste in listes:
resultat |= set(liste)
return resultat

print(fusionner_sans_doublons([1,2], [2,3], [3,4])) # {1, 2, 3, 4}

Exercice 167. Écrire une fonction ensemble_carres(ensemble) qui retourne l’ensemble

des carrés des éléments.

def ensemble_carres(ensemble):
return {x ** 2 for x in ensemble}

print(ensemble_carres({1,2,3})) # {1, 4, 9}

Exercice 168. Écrire une fonction produit_cartesien(a, b) qui retourne l’ensemble

des paires (x, y) possibles.

def produit_cartesien(a, b):

return {(x, y) for x in a for y in b}

print(produit_cartesien({1,2}, {"a","b"})) # {(1,'a'),(1,'b'),(2,'a'),(2,'b')}

Exercice 169. Écrire une fonction ensemble_premiers(limite) qui retourne l’ensemble

des nombres premiers jusqu’à limite.

def ensemble_premiers(limite):
premiers = set()
for n in range(2, limite + 1):
est_premier = True
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0:
est_premier = False
break
if est_premier:
[Link](n)
return premiers

print(ensemble_premiers(20)) # {2,3,5,7,11,13,17,19}

Exercice 170. Écrire une fonction comparer_trois_ensembles(a, b, c) qui retourne

un dictionnaire avec l’union, l’intersection et les éléments communs aux trois.

def comparer_trois_ensembles(a, b, c):

a, b, c = set(a), set(b), set(c)
return {
"union": a | b | c,
"intersection_totale": a & b & c,
"seulement_a": a - b - c
 }

print(comparer_trois_ensembles({1,2,3}, {2,3,4}, {3,4,5}))

Dictionnaires

Exercice 171. Écrire une fonction compter_frequence_mots(texte) qui retourne un

dictionnaire {mot: fréquence}.

def compter_frequence_mots(texte):
mots = [Link]().split()
frequence = {}
for mot in mots:
frequence[mot] = [Link](mot, 0) + 1
return frequence

print(compter_frequence_mots("le chat mange le poisson le chat dort"))

Exercice 172. Écrire une fonction fusionner_dictionnaires(d1, d2) qui fusionne

deux dictionnaires (d2 prioritaire en cas de conflit).

def fusionner_dictionnaires(d1, d2):

return {**d1, **d2}

print(fusionner_dictionnaires({"a":1,"b":2}, {"b":3,"c":4})) # {'a':1,'b':3,'c':4}

Exercice 173. Écrire une fonction inverser_dictionnaire(d) qui inverse les clés et les
valeurs d’un dictionnaire.

def inverser_dictionnaire(d):
return {valeur: cle for cle, valeur in [Link]()}

print(inverser_dictionnaire({"a":1,"b":2})) # {1: 'a', 2: 'b'}

Exercice 174. Écrire une fonction trier_dict_par_valeur(d) qui retourne une liste de
tuples (clé, valeur) triée par valeur.

def trier_dict_par_valeur(d):
return sorted([Link](), key=lambda item: item[1])

print(trier_dict_par_valeur({"a":3,"b":1,"c":2})) # [('b',1),('c',2),('a',3)]

Exercice 175. Écrire une fonction trier_dict_par_cle(d) qui retourne une liste de
tuples (clé, valeur) triée par clé.

def trier_dict_par_cle(d):
return sorted([Link]())

print(trier_dict_par_cle({"c":3,"a":1,"b":2})) # [('a',1),('b',2),('c',3)]

Exercice 176. Écrire une fonction dict_vers_liste_tuples(d) qui convertit un

dictionnaire en liste de tuples (clé, valeur).

def dict_vers_liste_tuples(d):
return list([Link]())

print(dict_vers_liste_tuples({"a":1,"b":2})) # [('a',1),('b',2)]
Exercice 177. Écrire une fonction filtrer_dictionnaire(d, seuil) qui retourne un
dictionnaire ne gardant que les valeurs supérieures au seuil.

def filtrer_dictionnaire(d, seuil):

return {cle: valeur for cle, valeur in [Link]() if valeur > seuil}

print(filtrer_dictionnaire({"a":5,"b":15,"c":25}, 10)) # {'b':15,'c':25}

Exercice 178. Écrire une fonction cle_valeur_max(d) qui retourne la clé associée à la
plus grande valeur.

def cle_valeur_max(d):
return max(d, key=[Link])

print(cle_valeur_max({"a":5,"b":15,"c":25})) # c

Exercice 179. Écrire une fonction sommer_valeurs_dict(d) qui retourne la somme de

toutes les valeurs d’un dictionnaire.

def sommer_valeurs_dict(d):
return sum([Link]())

print(sommer_valeurs_dict({"a":5,"b":15,"c":25})) # 45

Exercice 180. Écrire une fonction compter_caracteres_dict(mot) qui retourne un

dictionnaire {caractère: nombre_occurrences}.

def compter_caracteres_dict(mot):
resultat = {}
for c in mot:
resultat[c] = [Link](c, 0) + 1
return resultat

print(compter_caracteres_dict("banane")) # {'b':1,'a':2,'n':2,'e':1}

Exercice 181. Écrire une fonction grouper_par_longueur(liste_mots) qui regroupe les

mots par leur longueur dans un dictionnaire.

def grouper_par_longueur(liste_mots):
resultat = {}
for mot in liste_mots:
longueur = len(mot)
[Link](longueur, []).append(mot)
return resultat

print(grouper_par_longueur(["chat","chien","rat","souris"]))

Exercice 182. Écrire une fonction acceder_dict_imbrique(d, chemin) qui accède à

une valeur dans un dictionnaire imbriqué à partir d’une liste de clés.

def acceder_dict_imbrique(d, chemin):

valeur = d
for cle in chemin:
valeur = valeur[cle]
return valeur

data = {"a": {"b": {"c": 42}}}

print(acceder_dict_imbrique(data, ["a","b","c"])) # 42
Exercice 183. Écrire une fonction mettre_a_jour_imbrique(d, chemin, valeur) qui
met à jour une valeur dans un dictionnaire imbriqué.

def mettre_a_jour_imbrique(d, chemin, valeur):

sous_dict = d
for cle in chemin[:-1]:
sous_dict = sous_dict.setdefault(cle, {})
sous_dict[chemin[-1]] = valeur
return d

data = {"a": {"b": {}}}

print(mettre_a_jour_imbrique(data, ["a","b","c"], 99)) # {'a': {'b': {'c': 99}}}

Exercice 184. Écrire une fonction fusionner_en_sommant(d1, d2) qui fusionne deux
dictionnaires en additionnant les valeurs des clés communes.

def fusionner_en_sommant(d1, d2):

resultat = dict(d1)
for cle, valeur in [Link]():
resultat[cle] = [Link](cle, 0) + valeur
return resultat

print(fusionner_en_sommant({"a":5,"b":3}, {"b":2,"c":4})) # {'a':5,'b':5,'c':4}

Exercice 185. Écrire une fonction dict_depuis_deux_listes(cles, valeurs) qui

construit un dictionnaire à partir de deux listes.

def dict_depuis_deux_listes(cles, valeurs):

return dict(zip(cles, valeurs))

print(dict_depuis_deux_listes(["nom","age"], ["Alice", 25])) #

{'nom':'Alice','age':25}

Exercice 186. Écrire une fonction cles_communes(d1, d2) qui retourne les clés
communes entre deux dictionnaires.

def cles_communes(d1, d2):

return set([Link]()) & set([Link]())

print(cles_communes({"a":1,"b":2}, {"b":3,"c":4})) # {'b'}

Exercice 187. Écrire une fonction compter_valeur(d, valeur) qui compte combien de
clés ont une valeur donnée.

def compter_valeur(d, valeur):

return sum(1 for v in [Link]() if v == valeur)

print(compter_valeur({"a":1,"b":2,"c":1}, 1)) # 2

Exercice 188. Écrire une fonction valeurs_uniques_dict(d) qui retourne l’ensemble

des valeurs uniques d’un dictionnaire.

def valeurs_uniques_dict(d):
return set([Link]())

print(valeurs_uniques_dict({"a":1,"b":2,"c":1})) # {1, 2}

Exercice 189. Écrire une fonction transformer_valeurs(d, fonction) qui applique

une fonction à toutes les valeurs d’un dictionnaire.
 def transformer_valeurs(d, fonction):
return {cle: fonction(valeur) for cle, valeur in [Link]()}

print(transformer_valeurs({"a":2,"b":3}, lambda x: x ** 2)) # {'a':4,'b':9}

Exercice 190. Écrire une fonction grouper_par_note(dict_notes) qui regroupe les

étudiants par mention (à partir d’un dict {nom: note}).

def grouper_par_note(dict_notes):
groupes = {"Très bien": [], "Bien": [], "Passable": [], "Échec": []}
for nom, note in dict_notes.items():
if note >= 16:
groupes["Très bien"].append(nom)
elif note >= 14:
groupes["Bien"].append(nom)
elif note >= 10:
groupes["Passable"].append(nom)
else:
groupes["Échec"].append(nom)
return groupes

print(grouper_par_note({"Alice":17, "Bob":12, "Charlie":8}))

Exercice 191. Écrire une fonction moyenne_dict(d) qui calcule la moyenne des valeurs
numériques d’un dictionnaire.

def moyenne_dict(d):
return sum([Link]()) / len(d)

print(moyenne_dict({"Alice":17,"Bob":12,"Charlie":8})) # 12.33...

Exercice 192. Écrire une fonction ajouter_contact(nom, numero, annuaire) qui

ajoute un contact à un annuaire (dictionnaire) et le retourne.

def ajouter_contact(nom, numero, annuaire):

annuaire[nom] = numero
return annuaire

print(ajouter_contact("Alice", "0601020304", {"Bob": "0605060708"}))

Exercice 193. Écrire une fonction rechercher_par_valeur(d, valeur) qui retourne la

liste des clés associées à une valeur donnée.

def rechercher_par_valeur(d, valeur):

return [cle for cle, v in [Link]() if v == valeur]

print(rechercher_par_valeur({"a":1,"b":2,"c":1}, 1)) # ['a', 'c']

Exercice 194. Écrire une fonction compteur_lettres_texte(texte) qui retourne un

dictionnaire trié par fréquence décroissante des lettres d’un texte.

def compteur_lettres_texte(texte):
compteur = {}
for c in [Link]():
if [Link]():
compteur[c] = [Link](c, 0) + 1
return dict(sorted([Link](), key=lambda x: x[1], reverse=True))

print(compteur_lettres_texte("mississippi"))
Exercice 195. Écrire une fonction fusion_profonde(d1, d2) qui fusionne
récursivement deux dictionnaires imbriqués.

def fusion_profonde(d1, d2):

resultat = dict(d1)
for cle, valeur in [Link]():
if cle in resultat and isinstance(resultat[cle], dict) and
isinstance(valeur, dict):
resultat[cle] = fusion_profonde(resultat[cle], valeur)
else:
resultat[cle] = valeur
return resultat

d1 = {"a": {"x": 1, "y": 2}}

d2 = {"a": {"y": 99, "z": 3}}
print(fusion_profonde(d1, d2)) # {'a': {'x':1,'y':99,'z':3}}

Fonctions Avancées (Récursivité, Lambda, *args,

Décorateurs)

Exercice 196. Écrire une fonction récursive fibonacci_recursif(n) qui retourne le n-

ième terme de Fibonacci.

def fibonacci_recursif(n):
if n <= 1:
return n
return fibonacci_recursif(n - 1) + fibonacci_recursif(n - 2)

print(fibonacci_recursif(10)) # 55

Exercice 197. Écrire une fonction récursive factorielle_recursive(n) qui calcule n!.

def factorielle_recursive(n):
if n <= 1:
return 1
return n * factorielle_recursive(n - 1)

print(factorielle_recursive(5)) # 120

Exercice 198. Écrire une fonction récursive somme_recursive(liste) qui calcule la

somme des éléments d’une liste.

def somme_recursive(liste):
if not liste:
return 0
return liste[0] + somme_recursive(liste[1:])

print(somme_recursive([1,2,3,4,5])) # 15

Exercice 199. Écrire une fonction récursive puissance_recursive(base, exposant)

qui calcule base^exposant.

def puissance_recursive(base, exposant):

if exposant == 0:
return 1
return base * puissance_recursive(base, exposant - 1)

print(puissance_recursive(2, 8)) # 256

Exercice 200. Écrire une fonction récursive pgcd_recursif(a, b) qui calcule le PGCD
de deux nombres.

def pgcd_recursif(a, b):

if b == 0:
return a
return pgcd_recursif(b, a % b)

print(pgcd_recursif(48, 18)) # 6

Exercice 201. Écrire une fonction récursive inverser_chaine_recursive(chaine) qui

inverse une chaîne.

def inverser_chaine_recursive(chaine):
if len(chaine) <= 1:
return chaine
return inverser_chaine_recursive(chaine[1:]) + chaine[0]

print(inverser_chaine_recursive("Python")) # nohtyP

Exercice 202. Écrire une fonction récursive est_palindrome_recursif(chaine) qui

vérifie si une chaîne est un palindrome.

def est_palindrome_recursif(chaine):
if len(chaine) <= 1:
return True
if chaine[0] != chaine[-1]:
return False
return est_palindrome_recursif(chaine[1:-1])

print(est_palindrome_recursif("radar")) # True

Exercice 203. Écrire une fonction récursive compter_occurrences_recursif(liste,

element) qui compte les occurrences d’un élément.

def compter_occurrences_recursif(liste, element):

if not liste:
return 0
return (1 if liste[0] == element else 0) +
compter_occurrences_recursif(liste[1:], element)

print(compter_occurrences_recursif([1,2,1,3,1], 1)) # 3

Exercice 204. Écrire une fonction récursive tours_de_hanoi(n, source, aux, dest)
qui résout les tours de Hanoï et retourne le nombre de déplacements.

def tours_de_hanoi(n, source, aux, dest):

if n == 0:
return 0
compte = tours_de_hanoi(n - 1, source, dest, aux)
print(f"Déplacer disque {n} de {source} vers {dest}")
compte += 1
compte += tours_de_hanoi(n - 1, aux, source, dest)
return compte

print(tours_de_hanoi(3, "A", "B", "C")) # 7 déplacements

Exercice 205. Écrire une fonction récursive

recherche_dichotomique_recursive(liste, cible, gauche=0, droite=None) qui
recherche un élément.
 def recherche_dichotomique_recursive(liste, cible, gauche=0, droite=None):
if droite is None:
droite = len(liste) - 1
if gauche > droite:
return -1
milieu = (gauche + droite) // 2
if liste[milieu] == cible:
return milieu
elif liste[milieu] < cible:
return recherche_dichotomique_recursive(liste, cible, milieu + 1, droite)
else:
return recherche_dichotomique_recursive(liste, cible, gauche, milieu - 1)

print(recherche_dichotomique_recursive([1,3,5,7,9], 7)) # 3

Exercice 206. Écrire une fonction récursive

aplatir_liste_recursive(liste_imbriquee) qui aplatit une liste imbriquée de
profondeur quelconque.

def aplatir_liste_recursive(liste_imbriquee):
resultat = []
for element in liste_imbriquee:
if isinstance(element, list):
[Link](aplatir_liste_recursive(element))
else:
[Link](element)
return resultat

print(aplatir_liste_recursive([1, [2, 3, [4, 5]], 6])) # [1,2,3,4,5,6]

Exercice 207. Écrire une fonction récursive somme_chiffres_recursive(n) qui calcule

la somme des chiffres d’un nombre.

def somme_chiffres_recursive(n):
if n < 10:
return n
return n % 10 + somme_chiffres_recursive(n // 10)

print(somme_chiffres_recursive(12345)) # 15

Exercice 208. Écrire une fonction multiplier_avec_lambda() qui retourne une lambda
multipliant deux nombres, puis l’utiliser.

def multiplier_avec_lambda():
return lambda a, b: a * b

multiplier = multiplier_avec_lambda()
print(multiplier(4, 5)) # 20

Exercice 209. Écrire une fonction trier_avec_lambda(liste_tuples, index) qui trie

une liste de tuples selon un index en utilisant une lambda.

def trier_avec_lambda(liste_tuples, index):

return sorted(liste_tuples, key=lambda t: t[index])

print(trier_avec_lambda([(3,"c"),(1,"a"),(2,"b")], 0)) # [(1,'a'),(2,'b'),(3,'c')]

Exercice 210. Écrire une fonction filtrer_avec_lambda(liste, condition) qui filtre

une liste selon une fonction lambda passée en paramètre.
 def filtrer_avec_lambda(liste, condition):
return list(filter(condition, liste))

print(filtrer_avec_lambda([1,2,3,4,5,6], lambda x: x % 2 == 0)) # [2, 4, 6]

Exercice 211. Écrire une fonction appliquer_fonction_a_liste(liste, fonction) qui

applique une fonction à chaque élément d’une liste (équivalent de map).

def appliquer_fonction_a_liste(liste, fonction):

return [fonction(x) for x in liste]

print(appliquer_fonction_a_liste([1,2,3], lambda x: x ** 2)) # [1, 4, 9]

Exercice 212. Écrire une fonction somme_args(*args) qui retourne la somme d’un
nombre variable d’arguments.

def somme_args(*args):
return sum(args)

print(somme_args(1, 2, 3, 4, 5)) # 15

Exercice 213. Écrire une fonction afficher_kwargs(**kwargs) qui affiche chaque paire
clé-valeur passée en argument nommé.

def afficher_kwargs(**kwargs):
for cle, valeur in [Link]():
print(f"{cle} : {valeur}")

afficher_kwargs(nom="Alice", age=25, ville="Paris")

Exercice 214. Écrire une fonction creer_multiplicateur(n) qui retourne une fonction
(closure) multipliant son argument par n.

def creer_multiplicateur(n):
def multiplicateur(x):
return x * n
return multiplicateur

double = creer_multiplicateur(2)
print(double(5)) # 10

Exercice 215. Écrire une fonction creer_compteur() qui retourne une fonction (closure)
comptant le nombre de ses appels.

def creer_compteur():
compte = [0]
def compteur():
compte[0] += 1
return compte[0]
return compteur

compter = creer_compteur()
print(compter()) # 1
print(compter()) # 2

Exercice 216. Écrire un décorateur mesurer_temps(fonction) qui affiche le temps

d’exécution d’une fonction.

import time
 def mesurer_temps(fonction):
def wrapper(*args, **kwargs):
debut = [Link]()
resultat = fonction(*args, **kwargs)
fin = [Link]()
print(f"Temps d'exécution : {fin - debut:.6f} s")
return resultat
return wrapper

@mesurer_temps
def calcul_long():
return sum(range(1000000))

calcul_long()

Exercice 217. Écrire un décorateur journaliser(fonction) qui affiche le nom de la

fonction et ses arguments à chaque appel.

def journaliser(fonction):
def wrapper(*args, **kwargs):
print(f"Appel de {fonction.__name__} avec args={args}, kwargs={kwargs}")
return fonction(*args, **kwargs)
return wrapper

@journaliser
def addition(a, b):
return a + b

print(addition(3, 4))

Exercice 218. Écrire un décorateur memoiser(fonction) qui met en cache les résultats
d’une fonction Fibonacci récursive.

def memoiser(fonction):
cache = {}
def wrapper(n):
if n not in cache:
cache[n] = fonction(n)
return cache[n]
return wrapper

@memoiser
def fibonacci(n):
if n <= 1:
return n
return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(30)) # 832040 (rapide grâce au cache)

Exercice 219. Écrire deux fonctions récursives mutuelles est_pair_mutuel(n) et

est_impair_mutuel(n).

def est_pair_mutuel(n):
if n == 0:
return True
return est_impair_mutuel(n - 1)

def est_impair_mutuel(n):
if n == 0:
return False
return est_pair_mutuel(n - 1)
 print(est_pair_mutuel(10)) # True
print(est_impair_mutuel(7)) # True

Exercice 220. Écrire une fonction récursive generer_permutations(liste) qui génère

toutes les permutations d’une liste.

def generer_permutations(liste):
if len(liste) <= 1:
return [liste]
permutations = []
for i in range(len(liste)):
reste = liste[:i] + liste[i+1:]
for p in generer_permutations(reste):
[Link]([liste[i]] + p)
return permutations

print(generer_permutations([1,2,3]))
# [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

Gestion des Exceptions

Exercice 221. Écrire une fonction diviser_securise(a, b) qui gère la division par zéro
et retourne None en cas d’erreur.

def diviser_securise(a, b):

try:
return a / b
except ZeroDivisionError:
print("Erreur : division par zéro")
return None

print(diviser_securise(10, 0)) # None

Exercice 222. Écrire une fonction acceder_liste_securise(liste, index) qui gère

les erreurs d’index hors limite.

def acceder_liste_securise(liste, index):

try:
return liste[index]
except IndexError:
print("Erreur : index hors limite")
return None

print(acceder_liste_securise([1,2,3], 10)) # None

Exercice 223. Écrire une fonction convertir_entier_securise(valeur) qui gère les

erreurs de conversion.

def convertir_entier_securise(valeur):
try:
return int(valeur)
except ValueError:
print(f"Erreur : '{valeur}' n'est pas convertible en entier")
return None

print(convertir_entier_securise("abc")) # None

Exercice 224. Écrire une fonction verifier_age_valide(age) qui lève une exception
ValueError si l’âge est négatif ou supérieur à 150.
 def verifier_age_valide(age):
if age < 0 or age > 150:
raise ValueError("Âge invalide")
return age

try:
verifier_age_valide(-5)
except ValueError as e:
print("Erreur :", e)

Exercice 225. Écrire une fonction lire_fichier_securise(nom_fichier) qui gère

l’absence du fichier.

def lire_fichier_securise(nom_fichier):
try:
with open(nom_fichier, "r", encoding="utf-8") as f:
return [Link]()
except FileNotFoundError:
print(f"Erreur : le fichier '{nom_fichier}' n'existe pas")
return None

print(lire_fichier_securise("[Link]")) # None

Exercice 226. Écrire une fonction racine_carree_securisee(n) qui lève une exception
si n est négatif.

def racine_carree_securisee(n):
if n < 0:
raise ValueError("Impossible de calculer la racine carrée d'un nombre
négatif")
return n ** 0.5

try:
racine_carree_securisee(-9)
except ValueError as e:
print("Erreur :", e)

Exercice 227. Écrire une fonction verifier_stock(stock, quantite) qui lève une
exception si la quantité demandée dépasse le stock.

def verifier_stock(stock, quantite):

if quantite > stock:
raise ValueError("Stock insuffisant")
return stock - quantite

try:
verifier_stock(5, 10)
except ValueError as e:
print("Erreur :", e)

Exercice 228. Créer une exception personnalisée SoldeInsuffisantError et une

fonction retirer_argent(solde, montant) qui la lève si nécessaire.

class SoldeInsuffisantError(Exception):
pass

def retirer_argent(solde, montant):

if montant > solde:
raise SoldeInsuffisantError("Solde insuffisant pour ce retrait")
return solde - montant
 try:
retirer_argent(100, 150)
except SoldeInsuffisantError as e:
print("Erreur :", e)

Exercice 229. Écrire une fonction valider_email_ou_lever(email) qui lève une

exception ValueError si l’email est invalide.

def valider_email_ou_lever(email):
if "@" not in email or "." not in [Link]("@")[-1]:
raise ValueError("Email invalide")
return True

try:
valider_email_ou_lever("pas_un_email")
except ValueError as e:
print("Erreur :", e)

Exercice 230. Écrire une fonction calculatrice(a, b, operation) qui gère plusieurs
exceptions possibles (ZeroDivisionError, TypeError, ValueError).

def calculatrice(a, b, operation):

try:
if operation == "+":
return a + b
elif operation == "-":
return a - b
elif operation == "*":
return a * b
elif operation == "/":
return a / b
else:
raise ValueError("Opération non reconnue")
except ZeroDivisionError:
return "Erreur : division par zéro"
except TypeError:
return "Erreur : types incompatibles"
except ValueError as e:
return f"Erreur : {e}"

print(calculatrice(10, 0, "/")) # Erreur : division par zéro

Exercice 231. Écrire une fonction verifier_liste_non_vide(liste) qui lève une

exception si la liste est vide.

def verifier_liste_non_vide(liste):
if not liste:
raise ValueError("La liste est vide")
return liste

try:
verifier_liste_non_vide([])
except ValueError as e:
print("Erreur :", e)

Exercice 232. Créer une exception personnalisée MotDePasseFaibleError et une

fonction verifier_force_mdp(mdp) qui la lève si le mot de passe fait moins de 8
caractères.

class MotDePasseFaibleError(Exception):
pass
 def verifier_force_mdp(mdp):
if len(mdp) < 8:
raise MotDePasseFaibleError("Le mot de passe doit contenir au moins 8
caractères")
return True

try:
verifier_force_mdp("abc")
except MotDePasseFaibleError as e:
print("Erreur :", e)

Exercice 233. Écrire une fonction acceder_dict_securise(d, cle) qui gère l’absence
d’une clé dans un dictionnaire.

def acceder_dict_securise(d, cle):

try:
return d[cle]
except KeyError:
print(f"Erreur : la clé '{cle}' n'existe pas")
return None

print(acceder_dict_securise({"a": 1}, "b")) # None

Exercice 234. Écrire une fonction verifier_type(valeur, type_attendu) qui lève une
exception TypeError si le type ne correspond pas.

def verifier_type(valeur, type_attendu):

if not isinstance(valeur, type_attendu):
raise TypeError(f"Type attendu : {type_attendu.__name__}, reçu :
{type(valeur).__name__}")
return True

try:
verifier_type("texte", int)
except TypeError as e:
print("Erreur :", e)

Exercice 235. Écrire une fonction moyenne_securisee(notes) qui gère le cas d’une liste
vide.

def moyenne_securisee(notes):
try:
return sum(notes) / len(notes)
except ZeroDivisionError:
print("Erreur : liste de notes vide")
return None

print(moyenne_securisee([])) # None

Exercice 236. Créer une exception personnalisée ElementNonTrouveError et une

fonction rechercher_ou_lever(liste, element) qui la lève si l’élément est absent.

class ElementNonTrouveError(Exception):
pass

def rechercher_ou_lever(liste, element):

if element not in liste:
raise ElementNonTrouveError(f"'{element}' non trouvé dans la liste")
return [Link](element)
 try:
rechercher_ou_lever([1,2,3], 5)
except ElementNonTrouveError as e:
print("Erreur :", e)

Exercice 237. Écrire une fonction convertir_liste_en_entiers(liste_valeurs) qui

convertit chaque élément en entier, ignore les erreurs et retourne la liste des conversions
réussies.

def convertir_liste_en_entiers(liste_valeurs):
resultats = []
for valeur in liste_valeurs:
try:
[Link](int(valeur))
except (ValueError, TypeError):
print(f"Ignoré : '{valeur}' n'est pas convertible")
return resultats

print(convertir_liste_en_entiers(["1", "abc", "3", None, "5"])) # [1, 3, 5]

Exercice 238. Écrire une fonction verifier_plage(valeur, minimum, maximum) qui

lève une exception si la valeur est hors de la plage donnée.

def verifier_plage(valeur, minimum, maximum):

if not (minimum <= valeur <= maximum):
raise ValueError(f"La valeur doit être entre {minimum} et {maximum}")
return valeur

try:
verifier_plage(150, 0, 100)
except ValueError as e:
print("Erreur :", e)

Exercice 239. Créer une exception personnalisée StockEpuiseError et une fonction

commander(catalogue, produit, quantite) qui la lève si le stock est insuffisant.

class StockEpuiseError(Exception):
pass

def commander(catalogue, produit, quantite):

if [Link](produit, 0) < quantite:
raise StockEpuiseError(f"Stock épuisé pour '{produit}'")
catalogue[produit] -= quantite
return catalogue

try:
commander({"pomme": 3}, "pomme", 5)
except StockEpuiseError as e:
print("Erreur :", e)

Exercice 240. Écrire une fonction calculatrice_complete(a, b, operateur) gérant

toutes les exceptions courantes avec un bloc finally.

def calculatrice_complete(a, b, operateur):

resultat = None
try:
a, b = float(a), float(b)
if operateur == "+":
resultat = a + b
elif operateur == "-":
resultat = a - b
 elif operateur == "*":
resultat = a * b
elif operateur == "/":
resultat = a / b
else:
raise ValueError("Opérateur invalide")
except ValueError as e:
print("Erreur de valeur :", e)
except ZeroDivisionError:
print("Erreur : division par zéro")
finally:
print("Calcul terminé")
return resultat

print(calculatrice_complete("10", "0", "/"))

Fichiers (.txt et JSON)

Exercice 241. Écrire une fonction ecrire_liste_dans_fichier(nom_fichier, liste)

qui écrit chaque élément d’une liste sur une ligne d’un fichier texte.

def ecrire_liste_dans_fichier(nom_fichier, liste):

with open(nom_fichier, "w", encoding="utf-8") as f:
for element in liste:
[Link](str(element) + "\n")

ecrire_liste_dans_fichier("[Link]", [1, 2, 3, 4, 5])

Exercice 242. Écrire une fonction lire_fichier_vers_liste(nom_fichier) qui

retourne les lignes d’un fichier sous forme de liste (sans le saut de ligne).

def lire_fichier_vers_liste(nom_fichier):
with open(nom_fichier, "r", encoding="utf-8") as f:
return [[Link]() for ligne in [Link]()]

print(lire_fichier_vers_liste("[Link]"))

Exercice 243. Écrire une fonction compter_lignes_fichier(nom_fichier) qui compte

le nombre de lignes d’un fichier.

def compter_lignes_fichier(nom_fichier):
with open(nom_fichier, "r", encoding="utf-8") as f:
return len([Link]())

print(compter_lignes_fichier("[Link]"))

Exercice 244. Écrire une fonction compter_mots_fichier(nom_fichier) qui compte le

nombre total de mots dans un fichier.

def compter_mots_fichier(nom_fichier):
with open(nom_fichier, "r", encoding="utf-8") as f:
contenu = [Link]()
return len([Link]())

print(compter_mots_fichier("[Link]"))

Exercice 245. Écrire une fonction rechercher_mot_dans_fichier(nom_fichier, mot)

qui retourne les numéros de lignes contenant un mot donné.
 def rechercher_mot_dans_fichier(nom_fichier, mot):
lignes_trouvees = []
with open(nom_fichier, "r", encoding="utf-8") as f:
for i, ligne in enumerate(f, start=1):
if mot in ligne:
lignes_trouvees.append(i)
return lignes_trouvees

with open("[Link]", "w", encoding="utf-8") as f:

[Link]("Alice : 17\nBob : 12\n")
print(rechercher_mot_dans_fichier("[Link]", "Alice"))

Exercice 246. Écrire une fonction copier_fichier(source, destination) qui copie le

contenu d’un fichier vers un autre.

def copier_fichier(source, destination):

with open(source, "r", encoding="utf-8") as f_src:
contenu = f_src.read()
with open(destination, "w", encoding="utf-8") as f_dst:
f_dst.write(contenu)

copier_fichier("[Link]", "copie_nombres.txt")

Exercice 247. Écrire une fonction fusionner_fichiers(fichier1, fichier2,

resultat) qui fusionne le contenu de deux fichiers dans un troisième.

def fusionner_fichiers(fichier1, fichier2, resultat):

with open(resultat, "w", encoding="utf-8") as f_out:
for fichier in (fichier1, fichier2):
with open(fichier, "r", encoding="utf-8") as f_in:
f_out.write(f_in.read())

with open("[Link]", "w", encoding="utf-8") as f: [Link]("Contenu A\n")

with open("[Link]", "w", encoding="utf-8") as f: [Link]("Contenu B\n")
fusionner_fichiers("[Link]", "[Link]", "[Link]")

Exercice 248. Écrire une fonction supprimer_ligne_fichier(nom_fichier,

texte_a_supprimer) qui supprime toutes les lignes contenant un texte donné.

def supprimer_ligne_fichier(nom_fichier, texte_a_supprimer):

with open(nom_fichier, "r", encoding="utf-8") as f:
lignes = [Link]()
lignes_conservees = [l for l in lignes if texte_a_supprimer not in l]
with open(nom_fichier, "w", encoding="utf-8") as f:
[Link](lignes_conservees)

with open("[Link]", "w", encoding="utf-8") as f:

[Link]("Alice : 17\nCharlie : 9\nBob : 12\n")
supprimer_ligne_fichier("[Link]", "Charlie")

Exercice 249. Écrire une fonction ajouter_ligne_fichier(nom_fichier, texte) qui

ajoute une ligne à la fin d’un fichier.

def ajouter_ligne_fichier(nom_fichier, texte):

with open(nom_fichier, "a", encoding="utf-8") as f:
[Link](texte + "\n")

ajouter_ligne_fichier("[Link]", "David : 18")

Exercice 250. Écrire une fonction compter_caracteres_fichier(nom_fichier) qui

compte le nombre total de caractères d’un fichier.

def compter_caracteres_fichier(nom_fichier):
with open(nom_fichier, "r", encoding="utf-8") as f:
return len([Link]())

print(compter_caracteres_fichier("[Link]"))

Exercice 251. Écrire une fonction sauvegarder_dict_json(nom_fichier,

dictionnaire) qui sauvegarde un dictionnaire dans un fichier JSON.

import json
def sauvegarder_dict_json(nom_fichier, dictionnaire):
with open(nom_fichier, "w", encoding="utf-8") as f:
[Link](dictionnaire, f, indent=4, ensure_ascii=False)

sauvegarder_dict_json("[Link]", {"nom": "Alice", "age": 22})

Exercice 252. Écrire une fonction charger_dict_json(nom_fichier) qui charge un

dictionnaire depuis un fichier JSON.

import json
def charger_dict_json(nom_fichier):
with open(nom_fichier, "r", encoding="utf-8") as f:
return [Link](f)

print(charger_dict_json("[Link]"))

Exercice 253. Écrire une fonction ajouter_entree_json(nom_fichier, cle, valeur)

qui ajoute une entrée à un fichier JSON existant.

import json
def ajouter_entree_json(nom_fichier, cle, valeur):
with open(nom_fichier, "r", encoding="utf-8") as f:
data = [Link](f)
data[cle] = valeur
with open(nom_fichier, "w", encoding="utf-8") as f:
[Link](data, f, indent=4, ensure_ascii=False)

ajouter_entree_json("[Link]", "ville", "Paris")

Exercice 254. Écrire une fonction supprimer_entree_json(nom_fichier, cle) qui

supprime une entrée d’un fichier JSON.

import json
def supprimer_entree_json(nom_fichier, cle):
with open(nom_fichier, "r", encoding="utf-8") as f:
data = [Link](f)
if cle in data:
del data[cle]
with open(nom_fichier, "w", encoding="utf-8") as f:
[Link](data, f, indent=4, ensure_ascii=False)

supprimer_entree_json("[Link]", "ville")

Exercice 255. Écrire une fonction filtrer_json_par_condition(nom_fichier,

condition) qui retourne les éléments d’une liste JSON respectant une condition (fonction
lambda).
 import json
def filtrer_json_par_condition(nom_fichier, condition):
with open(nom_fichier, "r", encoding="utf-8") as f:
data = [Link](f)
return [item for item in data if condition(item)]

# Exemple avec [Link] contenant une liste de dicts avec "stock"

# resultat = filtrer_json_par_condition("[Link]", lambda p: p["stock"] == 0)

Exercice 256. Écrire une fonction fusionner_fichiers_json(fichier1, fichier2,

resultat) qui fusionne deux fichiers JSON contenant des listes.

import json
def fusionner_fichiers_json(fichier1, fichier2, resultat):
with open(fichier1, "r", encoding="utf-8") as f:
data1 = [Link](f)
with open(fichier2, "r", encoding="utf-8") as f:
data2 = [Link](f)
fusion = data1 + data2
with open(resultat, "w", encoding="utf-8") as f:
[Link](fusion, f, indent=4, ensure_ascii=False)

with open("[Link]", "w", encoding="utf-8") as f: [Link]([1,2,3], f)

with open("[Link]", "w", encoding="utf-8") as f: [Link]([4,5,6], f)
fusionner_fichiers_json("[Link]", "[Link]", "[Link]")

Exercice 257. Écrire une fonction convertir_txt_en_json(fichier_txt,

fichier_json) qui convertit les lignes d’un fichier texte en liste JSON.

import json
def convertir_txt_en_json(fichier_txt, fichier_json):
with open(fichier_txt, "r", encoding="utf-8") as f:
lignes = [[Link]() for ligne in [Link]()]
with open(fichier_json, "w", encoding="utf-8") as f:
[Link](lignes, f, indent=4, ensure_ascii=False)

convertir_txt_en_json("[Link]", "[Link]")

Exercice 258. Écrire une fonction convertir_json_en_txt(fichier_json,

fichier_txt) qui convertit une liste JSON en fichier texte (une ligne par élément).

import json
def convertir_json_en_txt(fichier_json, fichier_txt):
with open(fichier_json, "r", encoding="utf-8") as f:
data = [Link](f)
with open(fichier_txt, "w", encoding="utf-8") as f:
for element in data:
[Link](str(element) + "\n")

convertir_json_en_txt("[Link]", "[Link]")

Exercice 259. Écrire une fonction sauvegarder_etudiants_json(nom_fichier,

etudiants) qui sauvegarde une liste de dictionnaires étudiants dans un fichier JSON.

import json
def sauvegarder_etudiants_json(nom_fichier, etudiants):
with open(nom_fichier, "w", encoding="utf-8") as f:
[Link](etudiants, f, indent=4, ensure_ascii=False)

etudiants = [{"nom": "Alice", "note": 17}, {"nom": "Bob", "note": 12}]

sauvegarder_etudiants_json("[Link]", etudiants)
Exercice 260. Écrire une fonction statistiques_notes_fichier(nom_fichier) qui lit
un fichier JSON de notes et retourne moyenne, min et max.

import json
def statistiques_notes_fichier(nom_fichier):
with open(nom_fichier, "r", encoding="utf-8") as f:
etudiants = [Link](f)
notes = [e["note"] for e in etudiants]
return {
"moyenne": sum(notes) / len(notes),
"min": min(notes),
"max": max(notes)
}

print(statistiques_notes_fichier("[Link]"))

Exercices Complexes et Algorithmes Avancés

Exercice 261. Écrire une fonction récursive tri_rapide(liste) implémentant

l’algorithme de tri rapide (quicksort).

def tri_rapide(liste):
if len(liste) <= 1:
return liste
pivot = liste[len(liste) // 2]
gauche = [x for x in liste if x < pivot]
milieu = [x for x in liste if x == pivot]
droite = [x for x in liste if x > pivot]
return tri_rapide(gauche) + milieu + tri_rapide(droite)

print(tri_rapide([5, 3, 8, 1, 9, 2])) # [1, 2, 3, 5, 8, 9]

Exercice 262. Écrire une fonction récursive tri_fusion(liste) implémentant

l’algorithme de tri fusion (merge sort).

def tri_fusion(liste):
if len(liste) <= 1:
return liste
milieu = len(liste) // 2
gauche = tri_fusion(liste[:milieu])
droite = tri_fusion(liste[milieu:])
resultat = []
i = j = 0
while i < len(gauche) and j < len(droite):
if gauche[i] <= droite[j]:
[Link](gauche[i]); i += 1
else:
[Link](droite[j]); j += 1
[Link](gauche[i:])
[Link](droite[j:])
return resultat

print(tri_fusion([5, 3, 8, 1, 9, 2])) # [1, 2, 3, 5, 8, 9]

Exercice 263. Écrire une fonction calculer_expression_rpn(tokens) qui évalue une

expression en notation polonaise inversée (ex: [‘2’,‘3’,‘+’]) à l’aide d’une pile.

def calculer_expression_rpn(tokens):
pile = []
 for token in tokens:
if token in ("+", "-", "*", "/"):
b = [Link]()
a = [Link]()
if token == "+": [Link](a + b)
elif token == "-": [Link](a - b)
elif token == "*": [Link](a * b)
elif token == "/": [Link](a / b)
else:
[Link](float(token))
return pile[0]

print(calculer_expression_rpn(["2", "3", "+", "4", "*"])) # 20.0

Exercice 264. Écrire une fonction parentheses_equilibrees(expression) qui vérifie, à

l’aide d’une pile, que les parenthèses/crochets/accolades sont bien équilibrés.

def parentheses_equilibrees(expression):
pile = []
paires = {")": "(", "]": "[", "}": "{"}
for c in expression:
if c in "([{":
[Link](c)
elif c in ")]}":
if not pile or [Link]() != paires[c]:
return False
return len(pile) == 0

print(parentheses_equilibrees("{[a+(b*c)]-d}")) # True
print(parentheses_equilibrees("(]")) # False

Exercice 265. Écrire une fonction infixe_vers_postfixe(expression) qui convertit

une expression infixe en notation postfixe (algorithme shunting-yard simplifié).

def infixe_vers_postfixe(expression):
priorite = {"+": 1, "-": 1, "*": 2, "/": 2}
sortie = []
pile = []
for token in [Link]():
if [Link]():
[Link](token)
elif token == "(":
[Link](token)
elif token == ")":
while pile and pile[-1] != "(":
[Link]([Link]())
[Link]()
else:
while pile and pile[-1] != "(" and [Link](pile[-1], 0) >=
priorite[token]:
[Link]([Link]())
[Link](token)
while pile:
[Link]([Link]())
return " ".join(sortie)

print(infixe_vers_postfixe("3 + 4 * 2")) # "3 4 2 * +"

Exercice 266. Écrire une fonction bfs_labyrinthe(grille, depart, arrivee) qui

trouve le plus court chemin dans une grille (0=libre, 1=mur) avec un parcours en largeur
(BFS).
 from collections import deque
def bfs_labyrinthe(grille, depart, arrivee):
lignes, colonnes = len(grille), len(grille[0])
file = deque([(depart, [depart])])
visites = {depart}
while file:
(x, y), chemin = [Link]()
if (x, y) == arrivee:
return chemin
for dx, dy in [(0,1),(0,-1),(1,0),(-1,0)]:
nx, ny = x + dx, y + dy
if 0 <= nx < lignes and 0 <= ny < colonnes and (nx, ny) not in visites
and grille[nx][ny] == 0:
[Link]((nx, ny))
[Link](((nx, ny), chemin + [(nx, ny)]))
return None

grille = [[0,0,1],[1,0,1],[0,0,0]]
print(bfs_labyrinthe(grille, (0,0), (2,2)))

Exercice 267. Écrire une fonction dijkstra(graphe, depart) qui calcule les distances
les plus courtes depuis un sommet dans un graphe pondéré (dictionnaire {sommet:
{voisin: poids}}).

import heapq
def dijkstra(graphe, depart):
distances = {sommet: float("inf") for sommet in graphe}
distances[depart] = 0
file_priorite = [(0, depart)]
while file_priorite:
dist_actuelle, sommet = [Link](file_priorite)
if dist_actuelle > distances[sommet]:
continue
for voisin, poids in graphe[sommet].items():
distance = dist_actuelle + poids
if distance < distances[voisin]:
distances[voisin] = distance
[Link](file_priorite, (distance, voisin))
return distances

graphe = {"A": {"B": 1, "C": 4}, "B": {"C": 2, "D": 5}, "C": {"D": 1}, "D": {}}
print(dijkstra(graphe, "A")) # {'A':0,'B':1,'C':3,'D':4}

Exercice 268. Écrire une fonction detecter_cycle(graphe_suivant, depart) qui

détecte s’il existe un cycle dans une séquence de type liste chaînée représentée par un
dictionnaire {noeud: noeud_suivant} (algorithme de Floyd).

def detecter_cycle(graphe_suivant, depart):

lent = depart
rapide = depart
while rapide is not None and graphe_suivant.get(rapide) is not None:
lent = graphe_suivant[lent]
rapide = graphe_suivant.get(graphe_suivant.get(rapide))
if lent == rapide:
return True
return False

g = {"A": "B", "B": "C", "C": "D", "D": "B"} # cycle B->C->D->B
print(detecter_cycle(g, "A")) # True

Exercice 269. Écrire une fonction récursive permutations_chaine(chaine) qui génère

toutes les permutations d’une chaîne de caractères.
 def permutations_chaine(chaine):
if len(chaine) <= 1:
return [chaine]
resultat = []
for i, c in enumerate(chaine):
reste = chaine[:i] + chaine[i+1:]
for p in permutations_chaine(reste):
[Link](c + p)
return resultat

print(permutations_chaine("abc")) # ['abc','acb','bac','bca','cab','cba']

Exercice 270. Écrire une fonction récursive combinaisons(liste, k) qui génère toutes
les combinaisons de k éléments d’une liste.

def combinaisons(liste, k):

if k == 0:
return [[]]
if not liste:
return []
avec_premier = [[liste[0]] + c for c in combinaisons(liste[1:], k - 1)]
sans_premier = combinaisons(liste[1:], k)
return avec_premier + sans_premier

print(combinaisons([1,2,3,4], 2)) # [[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]]

Exercice 271. Écrire une fonction sac_a_dos(objets, capacite) qui résout le

problème du sac à dos 0/1 par programmation dynamique. objets est une liste de tuples
(poids, valeur).

def sac_a_dos(objets, capacite):

n = len(objets)
dp = [[0] * (capacite + 1) for _ in range(n + 1)]
for i in range(1, n + 1):
poids, valeur = objets[i - 1]
for c in range(capacite + 1):
if poids <= c:
dp[i][c] = max(dp[i-1][c], dp[i-1][c-poids] + valeur)
else:
dp[i][c] = dp[i-1][c]
return dp[n][capacite]

objets = [(2, 3), (3, 4), (4, 5), (5, 6)]

print(sac_a_dos(objets, 5)) # 7

Exercice 272. Écrire une fonction plus_longue_sous_sequence_commune(s1, s2) (LCS)

qui calcule la longueur de la plus longue sous-séquence commune entre deux chaînes.

def plus_longue_sous_sequence_commune(s1, s2):

m, n = len(s1), len(s2)
dp = [[0] * (n + 1) for _ in range(m + 1)]
for i in range(1, m + 1):
for j in range(1, n + 1):
if s1[i-1] == s2[j-1]:
dp[i][j] = dp[i-1][j-1] + 1
else:
dp[i][j] = max(dp[i-1][j], dp[i][j-1])
return dp[m][n]

print(plus_longue_sous_sequence_commune("ABCBDAB", "BDCABA")) # 4
Exercice 273. Écrire une fonction distance_levenshtein(s1, s2) qui calcule la
distance d’édition entre deux chaînes.

def distance_levenshtein(s1, s2):

m, n = len(s1), len(s2)
dp = [[0] * (n + 1) for _ in range(m + 1)]
for i in range(m + 1):
dp[i][0] = i
for j in range(n + 1):
dp[0][j] = j
for i in range(1, m + 1):
for j in range(1, n + 1):
if s1[i-1] == s2[j-1]:
dp[i][j] = dp[i-1][j-1]
else:
dp[i][j] = 1 + min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1])
return dp[m][n]

print(distance_levenshtein("kitten", "sitting")) # 3

Exercice 274. Écrire une fonction plus_longue_sous_sequence_croissante(liste)

(LIS) qui retourne la longueur de la plus longue sous-suite strictement croissante.

def plus_longue_sous_sequence_croissante(liste):
if not liste:
return 0
dp = [1] * len(liste)
for i in range(1, len(liste)):
for j in range(i):
if liste[j] < liste[i]:
dp[i] = max(dp[i], dp[j] + 1)
return max(dp)

print(plus_longue_sous_sequence_croissante([10,9,2,5,3,7,101,18])) # 4

Exercice 275. Écrire une fonction rendu_monnaie(montant, pieces) qui calcule le

nombre minimum de pièces pour atteindre un montant (programmation dynamique).

def rendu_monnaie(montant, pieces):

dp = [float("inf")] * (montant + 1)
dp[0] = 0
for m in range(1, montant + 1):
for piece in pieces:
if piece <= m:
dp[m] = min(dp[m], dp[m - piece] + 1)
return dp[montant] if dp[montant] != float("inf") else -1

print(rendu_monnaie(11, [1, 2, 5])) # 3 (5+5+1)

Exercice 276. Écrire une fonction verifier_sudoku_valide(grille) qui vérifie qu’une

grille de sudoku 9x9 respecte les règles (lignes, colonnes, blocs 3x3).

def verifier_sudoku_valide(grille):
def valide(sequence):
chiffres = [x for x in sequence if x != 0]
return len(chiffres) == len(set(chiffres))

for ligne in grille:

if not valide(ligne):
return False
for col in range(9):
if not valide([grille[l][col] for l in range(9)]):
 return False
for bloc_l in range(0, 9, 3):
for bloc_c in range(0, 9, 3):
bloc = [grille[bloc_l+i][bloc_c+j] for i in range(3) for j in range(3
if not valide(bloc):
return False
return True

# print(verifier_sudoku_valide(grille_9x9))

Exercice 277. Écrire une fonction n_reines(n) qui compte le nombre de solutions au
problème des n-reines par backtracking.

def n_reines(n):
solutions = [0]
def peut_placer(colonnes, ligne, col):
for l in range(ligne):
c = colonnes[l]
if c == col or abs(c - col) == abs(l - ligne):
return False
return True

def resoudre(colonnes, ligne):

if ligne == n:
solutions[0] += 1
return
for col in range(n):
if peut_placer(colonnes, ligne, col):
colonnes[ligne] = col
resoudre(colonnes, ligne + 1)

resoudre([0] * n, 0)
return solutions[0]

print(n_reines(8)) # 92

Exercice 278. Écrire une fonction crible_eratosthene(limite) qui génère la liste des
nombres premiers jusqu’à limite grâce au crible d’Ératosthène.

def crible_eratosthene(limite):
est_premier = [True] * (limite + 1)
est_premier[0] = est_premier[1] = False
for i in range(2, int(limite ** 0.5) + 1):
if est_premier[i]:
for multiple in range(i * i, limite + 1, i):
est_premier[multiple] = False
return [i for i, premier in enumerate(est_premier) if premier]

print(crible_eratosthene(50))

Exercice 279. Écrire une fonction pgcd_liste(liste_nombres) qui calcule le PGCD

d’une liste de nombres.

import math
from functools import reduce
def pgcd_liste(liste_nombres):
return reduce([Link], liste_nombres)

print(pgcd_liste([24, 36, 48])) # 12

Exercice 280. Écrire une fonction ppcm_liste(liste_nombres) qui calcule le PPCM

d’une liste de nombres.
 import math
from functools import reduce
def ppcm_liste(liste_nombres):
def ppcm(a, b):
return abs(a * b) // [Link](a, b)
return reduce(ppcm, liste_nombres)

print(ppcm_liste([4, 6, 8])) # 24

Exercice 281. Écrire une fonction est_matrice_magique(matrice) qui vérifie si une

matrice carrée est un carré magique (mêmes sommes lignes/colonnes/diagonales).

def est_matrice_magique(matrice):
n = len(matrice)
somme_reference = sum(matrice[0])
for ligne in matrice:
if sum(ligne) != somme_reference:
return False
for col in range(n):
if sum(matrice[l][col] for l in range(n)) != somme_reference:
return False
diag1 = sum(matrice[i][i] for i in range(n))
diag2 = sum(matrice[i][n-1-i] for i in range(n))
return diag1 == somme_reference and diag2 == somme_reference

print(est_matrice_magique([[2,7,6],[9,5,1],[4,3,8]])) # True

Exercice 282. Écrire une fonction plus_court_chemin_grille(grille) qui calcule la

longueur du plus court chemin du coin haut-gauche au coin bas-droit d’une grille avec
obstacles (BFS).

from collections import deque

def plus_court_chemin_grille(grille):
lignes, colonnes = len(grille), len(grille[0])
if grille[0][0] == 1 or grille[lignes-1][colonnes-1] == 1:
return -1
file = deque([(0, 0, 1)])
visites = {(0, 0)}
while file:
x, y, distance = [Link]()
if (x, y) == (lignes - 1, colonnes - 1):
return distance
for dx, dy in [(0,1),(0,-1),(1,0),(-1,0)]:
nx, ny = x + dx, y + dy
if 0 <= nx < lignes and 0 <= ny < colonnes and (nx, ny) not in visites
and grille[nx][ny] == 0:
[Link]((nx, ny))
[Link]((nx, ny, distance + 1))
return -1

print(plus_court_chemin_grille([[0,0,0],[1,1,0],[0,0,0]])) # 5

Exercice 283. Écrire une fonction compresser_rle(chaine) qui compresse une chaîne
par Run-Length Encoding et ne conserve la version compressée que si elle est plus
courte.

def compresser_rle(chaine):
if not chaine:
return chaine
resultat = ""
compte = 1
 for i in range(1, len(chaine) + 1):
if i < len(chaine) and chaine[i] == chaine[i-1]:
compte += 1
else:
resultat += chaine[i-1] + str(compte)
compte = 1
return resultat if len(resultat) < len(chaine) else chaine

print(compresser_rle("aaaaabbbccd")) # a5b3c2d1

Exercice 284. Écrire une fonction decoder_rle(chaine) qui décode une chaîne
compressée par Run-Length Encoding.

def decoder_rle(chaine):
resultat = ""
i = 0
while i < len(chaine):
lettre = chaine[i]
j = i + 1
nombre = ""
while j < len(chaine) and chaine[j].isdigit():
nombre += chaine[j]
j += 1
resultat += lettre * int(nombre)
i = j
return resultat

print(decoder_rle("a5b3c2d1")) # aaaaabbbccd

Exercice 285. Écrire une fonction evaluer_expression(chaine) qui évalue une

expression mathématique simple (+, -, *, /) sans utiliser eval(), en respectant les
priorités.

def evaluer_expression(chaine):
tokens = [Link]()
pile = [float(tokens[0])]
i = 1
while i < len(tokens):
op = tokens[i]
valeur = float(tokens[i + 1])
if op == "*":
pile[-1] *= valeur
elif op == "/":
pile[-1] /= valeur
elif op == "+":
[Link](valeur)
elif op == "-":
[Link](-valeur)
i += 2
return sum(pile)

print(evaluer_expression("3 + 4 * 2 - 6 / 3")) # 9.0

Exercice 286. Écrire une fonction grouper_anagrammes(liste_mots) qui regroupe les

mots qui sont des anagrammes les uns des autres.

def grouper_anagrammes(liste_mots):
groupes = {}
for mot in liste_mots:
cle = "".join(sorted(mot))
[Link](cle, []).append(mot)
return list([Link]())
 print(grouper_anagrammes(["eat","tea","tan","ate","nat","bat"]))
# [['eat','tea','ate'], ['tan','nat'], ['bat']]

Exercice 287. Écrire une fonction paires_somme_cible(liste, cible) qui retourne

toutes les paires d’une liste dont la somme vaut cible (en O(n)).

def paires_somme_cible(liste, cible):

vus = set()
paires = []
for nombre in liste:
complement = cible - nombre
if complement in vus:
[Link]((complement, nombre))
[Link](nombre)
return paires

print(paires_somme_cible([2,7,11,15,-2,9], 9)) # [(2,7),(-2,11)]

Exercice 288. Écrire des fonctions inserer_abr(arbre, valeur) et

parcours_infixe(arbre) simulant un arbre binaire de recherche à l’aide de
dictionnaires imbriqués {valeur, gauche, droite}.

def inserer_abr(arbre, valeur):

if arbre is None:
return {"valeur": valeur, "gauche": None, "droite": None}
if valeur < arbre["valeur"]:
arbre["gauche"] = inserer_abr(arbre["gauche"], valeur)
else:
arbre["droite"] = inserer_abr(arbre["droite"], valeur)
return arbre

def parcours_infixe(arbre):
if arbre is None:
return []
return parcours_infixe(arbre["gauche"]) + [arbre["valeur"]] +
parcours_infixe(arbre["droite"])

arbre = None
for v in [5, 3, 8, 1, 4, 7, 9]:
arbre = inserer_abr(arbre, v)
print(parcours_infixe(arbre)) # [1, 3, 4, 5, 7, 8, 9]

Exercice 289. Écrire une fonction hauteur_arbre(arbre) qui calcule la hauteur d’un
arbre binaire représenté par des dictionnaires imbriqués {valeur, gauche, droite}.

def hauteur_arbre(arbre):
if arbre is None:
return 0
return 1 + max(hauteur_arbre(arbre["gauche"]), hauteur_arbre(arbre["droite"]))

arbre = {"valeur": 5, "gauche": {"valeur": 3, "gauche": None, "droite": None},

"droite": None}
print(hauteur_arbre(arbre)) # 2

Exercice 290. Écrire une fonction verifier_abr_valide(arbre) qui vérifie qu’un arbre
binaire respecte la propriété d’arbre binaire de recherche.

def verifier_abr_valide(arbre, minimum=float("-inf"), maximum=float("inf")):

if arbre is None:
return True
 if not (minimum < arbre["valeur"] < maximum):
return False
return (verifier_abr_valide(arbre["gauche"], minimum, arbre["valeur"]) and
verifier_abr_valide(arbre["droite"], arbre["valeur"], maximum))

arbre = {"valeur": 5, "gauche": {"valeur": 3, "gauche": None, "droite": None},

"droite": {"valeur": 8, "gauche": None, "droite": None}}
print(verifier_abr_valide(arbre)) # True

Exercice 291. Écrire une fonction simuler_pile(operations) qui simule une pile
(push/pop/peek) à partir d’une liste d’opérations et retourne l’état final.

def simuler_pile(operations):
pile = []
resultats = []
for operation in operations:
action = operation[0]
if action == "push":
[Link](operation[1])
elif action == "pop":
[Link]([Link]() if pile else None)
elif action == "peek":
[Link](pile[-1] if pile else None)
return pile, resultats

print(simuler_pile([("push",1),("push",2),("peek",),("pop",),("push",3)]))
# ([1, 3], [2, 2])

Exercice 292. Écrire une fonction simuler_file(operations) qui simule une file
(enfiler/défiler) à partir d’une liste d’opérations.

from collections import deque

def simuler_file(operations):
file = deque()
resultats = []
for operation in operations:
action = operation[0]
if action == "enfiler":
[Link](operation[1])
elif action == "defiler":
[Link]([Link]() if file else None)
return list(file), resultats

print(simuler_file([("enfiler",1),("enfiler",2),("defiler",),("enfiler",3)]))
# ([2, 3], [1])

Exercice 293. Écrire une fonction doublons_avec_positions(liste) qui retourne un

dictionnaire {élément dupliqué: [positions]} pour tous les éléments apparaissant plus
d’une fois.

def doublons_avec_positions(liste):
positions = {}
for i, element in enumerate(liste):
[Link](element, []).append(i)
return {element: pos for element, pos in [Link]() if len(pos) > 1}

print(doublons_avec_positions([1,2,3,2,4,1,5])) # {1:[0,5], 2:[1,3]}

Exercice 294. Écrire une fonction statistiques_completes(liste_nombres) qui

calcule en une seule fonction : moyenne, médiane, mode, variance et écart-type.
 def statistiques_completes(liste_nombres):
n = len(liste_nombres)
moyenne = sum(liste_nombres) / n
trie = sorted(liste_nombres)
milieu = n // 2
mediane = (trie[milieu] if n % 2 else (trie[milieu-1] + trie[milieu]) / 2)
frequences = {}
for x in liste_nombres:
frequences[x] = [Link](x, 0) + 1
mode = max(frequences, key=[Link])
variance = sum((x - moyenne) ** 2 for x in liste_nombres) / n
ecart_type = variance ** 0.5
return {
"moyenne": moyenne, "mediane": mediane, "mode": mode,
"variance": variance, "ecart_type": ecart_type
}

print(statistiques_completes([2,4,4,4,5,5,7,9]))

Exercice 295. Écrire une fonction generer_mdp_securise(longueur) qui génère un mot

de passe aléatoire contenant majuscules, minuscules, chiffres et caractères spéciaux.

import random
import string
def generer_mdp_securise(longueur=12):
if longueur < 4:
raise ValueError("Longueur minimale de 4 requise")
categories = [string.ascii_uppercase, string.ascii_lowercase, [Link],
"!@#$%^&*"]
mdp = [[Link](cat) for cat in categories]
tous_caracteres = "".join(categories)
mdp += [[Link](tous_caracteres) for _ in range(longueur - 4)]
[Link](mdp)
return "".join(mdp)

print(generer_mdp_securise(12))

Exercice 296. Écrire une fonction evaluer_force_mdp(mdp) qui attribue un score de

robustesse (0 à 5) à un mot de passe selon plusieurs critères.

def evaluer_force_mdp(mdp):
score = 0
if len(mdp) >= 8: score += 1
if len(mdp) >= 12: score += 1
if any([Link]() for c in mdp): score += 1
if any([Link]() for c in mdp): score += 1
if any(not [Link]() for c in mdp): score += 1
niveaux = {0: "Très faible", 1: "Faible", 2: "Moyen", 3: "Bon", 4: "Fort", 5:
"Excellent"}
return score, niveaux[score]

print(evaluer_force_mdp("Python2026!")) # (5, 'Excellent')

Exercice 297. Écrire une fonction traiter_file_capacite(taches, capacite) qui

simule une file de traitement de tâches limitée en capacité et retourne l’ordre de
traitement et les tâches rejetées.

def traiter_file_capacite(taches, capacite):

file = []
traitees = []
rejetees = []
for tache in taches:
 if len(file) < capacite:
[Link](tache)
else:
[Link](tache)
if len(file) == capacite:
[Link]([Link](0))
[Link](file)
return traitees, rejetees

print(traiter_file_capacite(["t1","t2","t3","t4","t5"], 3))

Exercice 298. Écrire une fonction analyser_texte_complet(texte) qui retourne en une

seule passe : nombre de mots, phrases, caractères, mot le plus fréquent et longueur
moyenne des mots.

def analyser_texte_complet(texte):
phrases = [p for p in [Link](".") if [Link]()]
mots = [Link]().split()
mots_nettoyes = ["".join(c for c in m if [Link]()) for m in mots]
mots_nettoyes = [m for m in mots_nettoyes if m]
frequences = {}
for m in mots_nettoyes:
frequences[m] = [Link](m, 0) + 1
mot_frequent = max(frequences, key=[Link]) if frequences else None
longueur_moyenne = sum(len(m) for m in mots_nettoyes) / len(mots_nettoyes) if
mots_nettoyes else 0
return {
"nb_mots": len(mots_nettoyes),
"nb_phrases": len(phrases),
"nb_caracteres": len(texte),
"mot_frequent": mot_frequent,
"longueur_moyenne_mots": round(longueur_moyenne, 2)
}

print(analyser_texte_complet("Python est génial. Python est simple et puissant."))

Exercice 299. Écrire une fonction correspond_motif(motif, texte) qui implémente

un mini moteur de correspondance supportant . (un caractère quelconque) et * (zéro ou
plusieurs répétitions du caractère précédent), sans utiliser le module re.

def correspond_motif(motif, texte):

if not motif:
return not texte
premier_correspond = bool(texte) and (motif[0] == texte[0] or motif[0] == "."
if len(motif) >= 2 and motif[1] == "*":
return (correspond_motif(motif[2:], texte) or
(premier_correspond and correspond_motif(motif, texte[1:])))
else:
return premier_correspond and correspond_motif(motif[1:], texte[1:])

print(correspond_motif("a*b", "aaab")) # True

print(correspond_motif("a.c", "abc")) # True

Exercice 300. Système complet : écrire un mini gestionnaire de bibliothèque

gerer_bibliotheque(catalogue, operation, **kwargs) gérant l’ajout, l’emprunt et le
retour de livres, avec exceptions personnalisées et persistance JSON.

import json

class LivreIndisponibleError(Exception):
pass
 class LivreInexistantError(Exception):
pass

def gerer_bibliotheque(catalogue, operation, **kwargs):

if operation == "ajouter":
titre = kwargs["titre"]
exemplaires = [Link]("exemplaires", 1)
if titre in catalogue:
catalogue[titre]["exemplaires"] += exemplaires
else:
catalogue[titre] = {"exemplaires": exemplaires, "empruntes": 0}

elif operation == "emprunter":

titre = kwargs["titre"]
if titre not in catalogue:
raise LivreInexistantError(f"'{titre}' n'existe pas dans le catalogue"
disponibles = catalogue[titre]["exemplaires"] - catalogue[titre]
["empruntes"]
if disponibles <= 0:
raise LivreIndisponibleError(f"'{titre}' n'a plus d'exemplaire
disponible")
catalogue[titre]["empruntes"] += 1

elif operation == "retourner":

titre = kwargs["titre"]
if titre not in catalogue or catalogue[titre]["empruntes"] == 0:
raise LivreInexistantError(f"Aucun emprunt actif pour '{titre}'")
catalogue[titre]["empruntes"] -= 1

elif operation == "sauvegarder":

with open(kwargs["fichier"], "w", encoding="utf-8") as f:
[Link](catalogue, f, indent=4, ensure_ascii=False)

elif operation == "charger":

with open(kwargs["fichier"], "r", encoding="utf-8") as f:
[Link]()
[Link]([Link](f))

else:
raise ValueError("Opération non reconnue")

return catalogue

biblio = {}
gerer_bibliotheque(biblio, "ajouter", titre="1984", exemplaires=2)
gerer_bibliotheque(biblio, "emprunter", titre="1984")
try:
gerer_bibliotheque(biblio, "emprunter", titre="Le Petit Prince")
except LivreInexistantError as e:
print("Erreur :", e)
print(biblio) # {'1984': {'exemplaires': 2, 'empruntes': 1}}