■ Exercices Python
Niveau Débutant — 110 Exercices
Thèmes couverts Niveaux
Variables, types, opérateurs ■ Débutant absolu (1–30)
Conditions et boucles ■■ Débutant (31–70)
Fonctions et portée ■■■ Débutant avancé (71–110)
Listes, tuples, dictionnaires
Chaînes de caractères
Fichiers et modules
POO introductive
Algorithmes simples
Utilise un IDE comme VS Code, PyCharm ou simplement IDLE pour pratiquer ces exercices. Installe Python sur
[Link] si ce n'est pas encore fait.
Chapitre 1 — Variables et types de données
■ Niveau 1 — Exercices 1 à 15
Exercice 1 — Bonjour le monde
Affiche le message 'Bonjour, Python !' à l'écran.
Indice : Utilise la fonction print().
Exercice 2 — Présentation personnelle
Crée trois variables : ton prénom, ton âge et ta ville. Affiche une phrase de présentation avec ces trois
variables.
Indice : Ex : 'Je m'appelle Alice, j'ai 20 ans et j'habite à Paris.'
Exercice 3 — Types de variables
Crée une variable de chaque type : int, float, str et bool. Affiche leur valeur ET leur type avec la fonction
type().
x = 42 print(type(x)) # affiche: <class 'int'>
Exercice 4 — Saisie utilisateur
Demande le prénom de l'utilisateur avec input() puis affiche 'Bonjour, [prénom] !'.
Indice : input() retourne toujours une chaîne de caractères.
Exercice 5 — Conversion de types
Demande un nombre à l'utilisateur (avec input()), convertis-le en entier avec int() et affiche son double.
age = input('Ton âge : ') age = int(age) print(age * 2)
Exercice 6 — Opérations de base
Demande deux nombres entiers à l'utilisateur et affiche leur somme, différence, produit, quotient (/) et
quotient entier (//).
Exercice 7 — Modulo et division entière
Écris un programme qui demande un nombre et affiche s'il est exactement divisible par 7.
Indice : Utilise l'opérateur % : si n % 7 == 0, c'est divisible.
Exercice 8 — Échange de variables
Crée deux variables a = 5 et b = 10. Échange leurs valeurs sans utiliser de variable temporaire.
a, b = b, a # Python permet ceci !
Exercice 9 — Constantes
Déclare une constante PI = 3.14159 et calcule la surface d'un cercle de rayon 5. Affiche le résultat arrondi
à 2 décimales avec round().
Exercice 10 — Concatenation vs f-string
Crée les variables nom = 'Python' et version = 3. Affiche 'Langage : Python 3' en utilisant d'abord la
concaténation (+), puis une f-string.
# f-string: print(f"Langage : {nom} {version}")
Exercice 11 — Opérateurs de comparaison
Demande deux nombres et affiche les résultats de ==, !=, <, >, <=, >= entre les deux nombres.
Exercice 12 — Opérateurs logiques
Demande l'âge de l'utilisateur. Affiche True s'il a entre 18 et 65 ans (inclus), False sinon.
Indice : Utilise and : age >= 18 and age <= 65
Exercice 13 — Valeurs par défaut
Demande le prénom de l'utilisateur. S'il n'entre rien (chaîne vide), utilise 'Inconnu' comme prénom par
défaut.
prenom = input("Prénom : ") or "Inconnu"
Exercice 14 — Affectation augmentée
Initialise une variable compteur = 0. Utilise +=, -=, *=, //= pour la modifier et affiche la valeur après chaque
opération.
Exercice 15 — Conversion Celsius/Fahrenheit
Demande une température en Celsius et convertis-la en Fahrenheit avec la formule : F = C * 9/5 + 32.
Chapitre 2 — Conditions (if / elif / else)
■ Niveau 1–2 — Exercices 16 à 30
Exercice 16 — Majeur ou mineur
Demande l'âge de l'utilisateur et affiche s'il est majeur (18 ans ou plus) ou mineur.
Exercice 17 — Note scolaire
Demande une note entre 0 et 20 et affiche la mention : Très bien (>=16), Bien (>=14), Assez bien (>=12),
Passable (>=10), Insuffisant (<10).
Exercice 18 — Saison de l'année
Demande un numéro de mois (1-12) et affiche la saison correspondante (Hiver, Printemps, Été, Automne).
Indice : Décembre, Janvier, Février → Hiver ; etc.
Exercice 19 — Calculatrice avec choix
Demande deux nombres et une opération (+, -, *, /). Effectue le calcul et affiche le résultat. Gère la division
par zéro.
Exercice 20 — Valeur absolue sans abs()
Demande un nombre et affiche sa valeur absolue sans utiliser la fonction abs() de Python.
Exercice 21 — Maximum de trois nombres
Demande trois nombres et affiche le plus grand sans utiliser max().
Indice : Compare a > b and a > c, etc.
Exercice 22 — Triangle valide
Demande les longueurs de trois côtés et vérifie si elles peuvent former un triangle (la somme de deux
côtés doit être supérieure au troisième).
Exercice 23 — Année bissextile
Demande une année et affiche si elle est bissextile. Une année est bissextile si elle est divisible par 4, sauf
les centenaires non divisibles par 400.
# (an % 4 == 0 and an % 100 != 0) or (an % 400 == 0)
Exercice 24 — Jour de la semaine
Demande un numéro (1 à 7) et affiche le nom du jour correspondant. Affiche une erreur si le numéro est
hors plage.
Exercice 25 — IMC (Indice de Masse Corporelle)
Demande le poids (kg) et la taille (m). Calcule l'IMC = poids / taille². Affiche la catégorie : Sous-poids
(<18.5), Normal (18.5-25), Surpoids (25-30), Obésité (>30).
Exercice 26 — Jeu de devinette simple
Le programme a un nombre secret fixe (ex: 42). L'utilisateur fait une seule tentative et le programme dit si
c'est exact, trop grand ou trop petit.
Exercice 27 — Voyelle ou consonne
Demande une lettre et affiche si c'est une voyelle (a, e, i, o, u, y) ou une consonne.
Indice : Utilise lower() pour ignorer la casse : [Link]() in 'aeiouy'
Exercice 28 — Frais de livraison
Une commande est gratuite si elle dépasse 50€, sinon 4.99€ de frais. Demande le montant et affiche le
total.
Exercice 29 — Tarif cinéma
Tarif normal : 10€. Réductions : -2€ pour les moins de 18 ans, -3€ pour les plus de 60 ans, -1€ le mercredi.
Demande l'âge et le jour, affiche le prix.
Exercice 30 — Nombre de jours dans un mois
Demande un mois (1-12) et une année. Affiche le nombre de jours dans ce mois (en tenant compte des
années bissextiles pour février).
Chapitre 3 — Boucles (for / while)
■■ Niveau 2 — Exercices 31 à 50
Exercice 31 — Compter jusqu'à 10
Affiche les nombres de 1 à 10 avec une boucle for.
for i in range(1, 11): print(i)
Exercice 32 — Table de multiplication
Demande un nombre et affiche sa table de multiplication de 1 à 10.
Exercice 33 — Somme des entiers
Calcule et affiche la somme de tous les entiers de 1 à N, où N est demandé à l'utilisateur. Vérifie avec la
formule N*(N+1)/2.
Exercice 34 — FizzBuzz
Affiche les nombres de 1 à 50. Pour les multiples de 3 affiche 'Fizz', pour les multiples de 5 affiche 'Buzz',
pour les deux affiche 'FizzBuzz'.
Exercice 35 — Compteur avec while
Affiche un compte à rebours de 10 à 1 avec une boucle while, puis affiche 'Décollage !'.
Exercice 36 — Devinette avec boucle
Le programme choisit un nombre aléatoire entre 1 et 100. L'utilisateur a 7 tentatives pour le trouver.
Affiche 'Trop grand', 'Trop petit' ou 'Bravo !'.
Indice : Utilise import random, puis [Link](1, 100)
Exercice 37 — Somme des chiffres
Demande un entier et calcule la somme de ses chiffres. Ex : 1234 → 1+2+3+4 = 10.
Indice : Convertis en str et parcoure les caractères : for c in str(n)
Exercice 38 — Factorielle
Calcule la factorielle de N (N!) sans utiliser [Link]. Ex : 5! = 5×4×3×2×1 = 120.
Exercice 39 — Nombres premiers
Affiche tous les nombres premiers entre 2 et 50.
Indice : Un nombre est premier s'il n'est divisible que par 1 et lui-même.
Exercice 40 — Suite de Fibonacci
Affiche les 15 premiers termes de la suite de Fibonacci : 0, 1, 1, 2, 3, 5, 8, 13…
Indice : Chaque terme est la somme des deux précédents.
Exercice 41 — Triangle d'étoiles
Affiche un triangle d'étoiles de hauteur N (demandée à l'utilisateur).
# Pour N=4 : * ** *** ****
Exercice 42 — Triangle inversé
Affiche un triangle d'étoiles inversé (la base en haut, la pointe en bas).
Exercice 43 — Pyramide centrée
Affiche une pyramide centrée d'étoiles de hauteur N.
# Pour N=3 : * *** *****
Exercice 44 — Multiplication des impairs
Calcule le produit de tous les nombres impairs de 1 à 19.
Exercice 45 — Collatz (3n+1)
Prends un nombre N. Si pair, divise par 2. Si impair, multiplie par 3 et ajoute 1. Répète jusqu'à arriver à 1.
Affiche tous les termes et compte les étapes.
Note : C'est une conjecture mathématique célèbre : on croit que ça finit toujours à 1, mais ce n'est pas encore
prouvé !
Exercice 46 — Puissance sans **
Calcule a puissance b en utilisant une boucle, sans l'opérateur ** ni pow().
Exercice 47 — PGCD (Euclide)
Calcule le Plus Grand Commun Diviseur de deux nombres avec l'algorithme d'Euclide.
# Algorithme : tant que b != 0, a, b = b, a % b
Exercice 48 — Nombre parfait
Un nombre parfait est égal à la somme de ses diviseurs propres. Ex : 6 = 1+2+3. Affiche tous les nombres
parfaits inférieurs à 1000.
Exercice 49 — Palindrome numérique
Demande un entier et vérifie s'il est palindrome (se lit pareil dans les deux sens). Ex : 12321 → oui.
Exercice 50 — Jeu de Pierre-Feuille-Ciseaux
Crée un jeu contre l'ordinateur. L'ordinateur choisit aléatoirement. Affiche le résultat (victoire, défaite,
égalité).
Indice : Utilise [Link](['pierre', 'feuille', 'ciseaux'])
Chapitre 4 — Chaînes de caractères
■■ Niveau 2 — Exercices 51 à 65
Exercice 51 — Inversion de chaîne
Écris une fonction inverser(mot) qui retourne le mot à l'envers sans utiliser [::-1].
# Ex : inverser('python') → 'nohtyp'
Exercice 52 — Palindrome texte
Vérifie si une phrase est un palindrome (en ignorant espaces et majuscules). Ex : 'Kayak' → oui.
Exercice 53 — Compter les voyelles
Écris une fonction qui compte le nombre de voyelles dans une phrase.
Exercice 54 — Compter les mots
Compte le nombre de mots dans une phrase saisie par l'utilisateur sans utiliser len(split()).
Indice : Compte les espaces + 1.
Exercice 55 — Majuscule première lettre
Mets la première lettre de chaque mot en majuscule sans utiliser title() ou capitalize().
Exercice 56 — Coder par décalage (César)
Implémente un chiffrement de César : décale chaque lettre de N positions dans l'alphabet. Ex : 'abc' avec
décalage 2 → 'cde'.
Exercice 57 — Compter les occurrences
Compte combien de fois chaque lettre apparaît dans une chaîne (sans utiliser count()).
Exercice 58 — Supprimer les doublons
Supprime les caractères en double d'une chaîne tout en gardant l'ordre. Ex : 'aabbcc' → 'abc'.
Exercice 59 — Trouver tous les e-mails
Vérifie si une chaîne ressemble à une adresse email valide : elle doit contenir exactement un '@' et au
moins un '.' après le '@'.
Exercice 60 — Formater un nombre de téléphone
Demande un numéro de téléphone de 10 chiffres et affiche-le au format XX XX XX XX XX.
# Ex : '0612345678' → '06 12 34 56 78'
Exercice 61 — Anagramme
Vérifie si deux mots sont des anagrammes l'un de l'autre (mêmes lettres, ordre différent). Ex : 'chien' et
'niche'.
Exercice 62 — ROT13
Implémente le chiffrement ROT13 : décalage de 13 positions. ROT13 appliqué deux fois redonne le texte
original.
Exercice 63 — Compresser une chaîne
Compresse une chaîne en remplaçant les répétitions. Ex : 'aaabbc' → 'a3b2c1'.
Exercice 64 — Extraire les chiffres
Extrait tous les chiffres d'une chaîne mixte et retourne leur somme. Ex : 'a1b2c3' → 6.
Exercice 65 — Inverser les mots
Inverse l'ordre des mots dans une phrase. Ex : 'Bonjour tout le monde' → 'monde le tout Bonjour'.
Chapitre 5 — Listes et tuples
■■ Niveau 2 — Exercices 66 à 80
Exercice 66 — Création de liste
Crée une liste de 5 fruits. Affiche le premier, le dernier, et la liste complète.
Exercice 67 — Somme et moyenne
Calcule la somme et la moyenne d'une liste de nombres sans utiliser sum().
Exercice 68 — Min et max manuels
Trouve le minimum et le maximum d'une liste sans utiliser min() ou max().
Exercice 69 — Supprimer les doublons d'une liste
Supprime les doublons d'une liste en préservant l'ordre.
# Ex : [1, 2, 2, 3, 1] → [1, 2, 3]
Exercice 70 — Trier par tri à bulles
Implémente le tri à bulles (bubble sort) pour trier une liste de nombres.
Indice : Compare et échange les éléments adjacents.
Exercice 71 — Aplatir une liste imbriquée
Transforme une liste de listes en une liste simple.
# Ex : [[1,2],[3,4],[5]] → [1, 2, 3, 4, 5]
Exercice 72 — Compréhension de liste
Utilise une compréhension de liste pour créer : la liste des carrés de 1 à 10, puis la liste des nombres pairs
de 1 à 20.
carres = [x**2 for x in range(1, 11)]
Exercice 73 — Rotation de liste
Effectue une rotation vers la gauche de k positions.
# Ex : [1,2,3,4,5], k=2 → [3,4,5,1,2]
Exercice 74 — Intersection de deux listes
Trouve les éléments communs à deux listes sans utiliser set().
Exercice 75 — Fusion de listes triées
Fusionne deux listes déjà triées en une seule liste triée sans utiliser sort().
Exercice 76 — Fréquence des éléments
Compte combien de fois chaque élément apparaît dans une liste et affiche le résultat.
Exercice 77 — Matrice (liste de listes)
Crée une matrice 3x3 (liste de listes) et affiche-la sous forme de grille. Calcule la somme de la diagonale
principale.
Exercice 78 — Transposée d'une matrice
Calcule la transposée d'une matrice (échange lignes et colonnes).
Exercice 79 — Séparation pair/impair
Sépare une liste de nombres en deux listes : une avec les pairs, une avec les impairs.
Exercice 80 — Tuples : coordonnées
Crée une liste de tuples représentant des coordonnées (x, y). Calcule la distance de chaque point à
l'origine avec la formule sqrt(x²+y²).
Indice : import math puis [Link]()
Chapitre 6 — Dictionnaires
■■■ Niveau 3 — Exercices 81 à 95
Exercice 81 — Premier dictionnaire
Crée un dictionnaire représentant une personne (nom, âge, ville). Accède à chaque valeur et affiche-les.
personne = {'nom': 'Alice', 'age': 25, 'ville': 'Lyon'}
Exercice 82 — Carnet de contacts
Crée un programme qui permet d'ajouter, rechercher et supprimer des contacts (nom → téléphone) dans
un dictionnaire.
Exercice 83 — Fréquence des mots
Compte la fréquence de chaque mot dans une phrase. Affiche les mots par ordre de fréquence
décroissante.
Exercice 84 — Inverser un dictionnaire
Crée un dictionnaire {clé: valeur} et retourne un nouveau dictionnaire {valeur: clé}.
Exercice 85 — Fusionner deux dictionnaires
Fusionne deux dictionnaires. En cas de clé identique, additionne les valeurs.
Exercice 86 — Traduction
Crée un mini dictionnaire de traduction (fr → en pour 10 mots). L'utilisateur entre un mot français et obtient
la traduction.
Exercice 87 — Carnet de notes
Stocke les notes de plusieurs étudiants dans un dictionnaire {nom: [notes]}. Calcule et affiche la moyenne
de chacun.
Exercice 88 — Dictionnaire imbriqué
Crée un dictionnaire représentant 3 pays avec leurs capitales et populations. Affiche les pays par ordre de
population.
Exercice 89 — Compte des caractères
Crée un dictionnaire comptant chaque caractère dans une chaîne. Affiche uniquement les lettres (pas les
espaces).
Exercice 90 — Groupement par catégorie
Donne une liste de mots. Regroupe-les dans un dictionnaire selon leur première lettre.
# Ex : ['apple','avocado','banana'] → {'a':['apple','avocado'], 'b':['banana']}
Chapitre 7 — Fonctions
■■■ Niveau 3 — Exercices 91 à 105
Exercice 91 — Fonctions de base
Écris une fonction saluer(prenom) qui retourne 'Bonjour, [prenom] !' et une fonction adieu(prenom) qui
retourne 'Au revoir, [prenom] !'.
Exercice 92 — Paramètres par défaut
Écris une fonction puissance(base, exposant=2) qui retourne base^exposant. Teste avec un et deux
arguments.
Exercice 93 — Retourner plusieurs valeurs
Écris une fonction min_max(liste) qui retourne à la fois le minimum et le maximum d'une liste.
def min_max(lst): return min_val, max_val mi, ma = min_max([3,1,4,1,5])
Exercice 94 — Fonction récursive — Factorielle
Réimplémente la factorielle de manière récursive.
def factorielle(n): if n <= 1: return 1 return n * factorielle(n-1)
Exercice 95 — Fonction récursive — Fibonacci
Calcule le N-ième terme de Fibonacci de manière récursive. Compare la vitesse pour N=30 vs. la version
itérative.
Exercice 96 — Arguments variables (*args)
Écris une fonction somme(*args) qui accepte un nombre variable d'arguments et retourne leur somme.
def somme(*args): return sum(args) somme(1, 2, 3, 4, 5) # → 15
Exercice 97 — Arguments nommés (**kwargs)
Écris une fonction creer_profil(**kwargs) qui affiche chaque clé et valeur passée en argument.
Exercice 98 — Fonctions lambda
Crée une liste de tuples (nom, age). Trie-la par âge en utilisant une fonction lambda.
[Link](key=lambda x: x[1])
Exercice 99 — Décorateur simple
Crée un décorateur @chrono qui mesure et affiche le temps d'exécution d'une fonction.
Indice : Utilise import time et [Link]()
Exercice 100 — Fermeture (closure)
Crée une fonction créer_compteur() qui retourne une fonction qui incrémente et affiche un compteur à
chaque appel.
compteur = creer_compteur() compteur() # 1 compteur() # 2
Chapitre 8 — Fichiers, Modules et POO
■■■ Niveau 3 — Exercices 101 à 110
Exercice 101 — Lire et écrire un fichier
Écris un programme qui demande du texte à l'utilisateur et le sauvegarde dans un fichier '[Link]'. Lis et
affiche ensuite le contenu.
with open('[Link]', 'w') as f: [Link](texte)
Exercice 102 — Compter les lignes d'un fichier
Lit un fichier texte et affiche le nombre de lignes, de mots et de caractères qu'il contient.
Exercice 103 — Journal de bord
Crée un programme qui ajoute (mode 'a') une entrée datée au fichier '[Link]' à chaque exécution.
Affiche tout le journal à la fin.
Indice : Utilise datetime : from datetime import datetime
Exercice 104 — Module random — Loto
Simule un tirage loto : génère 6 numéros uniques entre 1 et 49, triés en ordre croissant.
import random tirage = [Link](range(1, 50), 6)
Exercice 105 — Module math
Utilise le module math pour : calculer la racine carrée, le log base 10, le cosinus de 45° et la constante pi.
Exercice 106 — Module os — Explorer des fichiers
Utilise [Link]() pour lister tous les fichiers du répertoire courant et affiche leur nom et taille.
Exercice 107 — Classe Voiture
Crée une classe Voiture avec les attributs marque, modele, annee et une méthode description() qui affiche
ces infos.
class Voiture: def __init__(self, marque, modele, annee): ...
Exercice 108 — Classe Compte bancaire
Crée une classe CompteBancaire avec un solde, et les méthodes deposer(montant), retirer(montant) et
afficher_solde(). Empêche le solde négatif.
Exercice 109 — Héritage — Animaux
Crée une classe Animal avec nom et son, une méthode parler(). Crée les sous-classes Chien et Chat qui
héritent de Animal.
class Chien(Animal): def __init__(self, nom): super().__init__(nom, 'Wouf')
Exercice 110 — Mini projet — Gestionnaire de tâches
Crée un petit programme en ligne de commande avec un menu : 1) Ajouter une tâche, 2) Afficher les
tâches, 3) Marquer comme faite, 4) Supprimer, 5) Quitter. Sauvegarde dans un fichier.
Note : C'est ton mini-projet final ! Combine tout ce que tu as appris : listes, dictionnaires, fichiers, fonctions et
boucles.
Félicitations !
Tu as parcouru les 110 exercices !
Ressource URL Description
Docs Python FR [Link]/fr/3/ Documentation officielle en français
Python Tutor [Link] Visualise l'exécution pas à pas
Exercism [Link]/tracks/python Exercices avec mentors
Codewars [Link] Défis progressifs en Python
Replit [Link] IDE en ligne, sans installation
OpenClassrooms [Link] Cours Python en français
Continue à pratiquer chaque jour — même 30 minutes suffisent pour progresser rapidement. Bonne chance ! ■