Exercices Python pour débutants : guide pratique avec corrigés

La meilleure façon d'apprendre Python consiste à créer des automatismes grâce à la répétition, l'expérimentation et la résolution de problèmes. C'est pourquoi l'approche « apprendre en faisant » est au cœur de la formation des bons programmeurs. 

Écrire du code, se tromper, puis corriger ses erreurs : c'est ainsi que vous développez de vraies compétences.

Dans cet article, nous allons parcourir une série d'exercices Python structurés, spécialement conçus pour les débutants. On commence par des variables simples, puis on monte en puissance avec les fonctions, les structures de données et de petits projets data.

Avant d'aller plus loin, voici un défi : essayez de résoudre immédiatement les trois premiers exercices de cet article, sans lire les explications. Même si vous bloquez, c'est l'effort d'essayer qui vous fera le plus progresser.

Si vous préférez un accompagnement pas à pas, les cours DataCamp vérifient automatiquement votre syntaxe et votre logique à chaque étape. Cela évite que de petites erreurs ne bloquent vos progrès et c'est particulièrement utile au début. Un bon point de départ est le cours Introduction to Python.

Bien démarrer avec les exercices Python

Avant de vous lancer, il vous faut un environnement simple pour écrire et exécuter du code Python. Bonne nouvelle : c'est plus facile que jamais.

Préparation

Pour exécuter Python en local, installez un éditeur de code adapté aux débutants comme Visual Studio Code.

Une configuration type ressemble à ceci :

• Installer Python depuis le site officiel

• Installer Visual Studio Code

• Ajouter l'extension Python dans VS Code

• Créer un nouveau fichier .py et commencer à coder

VS Code est un bon point de départ : il est open source et gratuit. Rendez-vous sur leur page de téléchargement pour récupérer le logiciel, puis installez‑le.

Si vous préférez ne rien installer, utilisez DataLab, un environnement dans le navigateur qui exécute instantanément du code Python (et SQL). Idéal pour suivre des tutoriels, tester des extraits et expérimenter sans vous soucier de la configuration.

Comment utiliser ces exercices

Pour maximiser vos apprentissages, chaque exercice est conçu pour être tenté avant de lire la solution ou l'explication.

Voici la meilleure façon d'en tirer tout le bénéfice :

• Consacrer au moins 15 minutes à chercher une solution par vous‑même
• Écrire le programme en entier, même si cela paraît répétitif
• Ne consulter le corrigé qu'après avoir essayé

Un corrigé complet de tous les exercices est disponible dans un cahier DataLab lié ici. Vous pourrez comparer votre approche à une solution fonctionnelle et découvrir d'autres façons de résoudre le même problème.

Exercices Python sur les variables, l'entrée et la sortie

Commençons par quelques exercices basiques sur les fondamentaux : stocker des valeurs, lire une saisie utilisateur et afficher un résultat à l'écran.

La salutation personnalisée

Pour démarrer, voici un exercice simple qui affiche un message personnalisé.

Exercice

Écrivez un programme qui :

• Demande le nom de l'utilisateur avec input()

• Demande l'âge de l'utilisateur avec input()

• Affiche un message de bienvenue en utilisant une f‑string

• Calcule l'année où l'utilisateur aura 100 ans

Avant d'écrire le moindre code, réfléchissez au cheminement de l'information dans un programme : l'utilisateur fournit un texte brut, Python le stocke dans des variables, puis vous transformez ces valeurs en quelque chose de pertinent. 

Cet exercice reflète de nombreux programmes réels, où la saisie n'est presque jamais exploitable telle quelle : il faut d'abord la valider ou la convertir.

Code de départ

Voici un squelette pour vous guider :

# Task: Ask for the user's name
name = input("Enter your name: ")

# Task: Ask for the user's age (note: input() returns a string)
age_str = input("Enter your age: ")

# Task: Convert age_str to an int
# age = ...

# Task: Calculate the year the user turns 100
# Tip: you'll need the current year
# current_year = ...
# year_turn_100 = ...

# Task: Print a personalized message using an f-string
# print(...)

Notions clés travaillées

• input() renvoie toujours une chaîne de caractères

• Conversion des chaînes en entiers avec int()

• Arithmétique de base

• Mise en forme de chaînes avec les f‑strings

Cet exercice montre que les entrées utilisateur doivent souvent être transformées avant de pouvoir être utilisées dans des calculs.

Le convertisseur de température

Appliquons vos compétences à une conversion d'unités simple.

Exercice

Écrivez un programme qui :

• Demande une température en degrés Celsius

• La convertit en Fahrenheit avec la formule : F = (C × 9/5) + 32

• Affiche la température convertie

Code de départ

Voici un squelette pour vous guider :

# Task: Ask the user for a Celsius temperature
celsius_str = input("Temperature in Celsius: ")

# Task: Convert the input to a float
# celsius = ...

# Task: Apply the conversion formula
# fahrenheit = ...

# Task: Print the result (consider formatting to 1–2 decimal places)
# print(...)

Notions clés travaillées

• Nombres à virgule flottante

• Expressions arithmétiques

• Conversion de type avec float()

Cet exercice rappelle que toutes les entrées numériques ne sont pas des entiers et que Python gère naturellement les décimales.

L'énigme de l'échange de valeurs

Cet exercice paraît trivial, mais beaucoup de débutants imaginent les variables comme des boîtes à vider puis à remplir étape par étape. Voyons comment échanger des valeurs en Python.

Exercice

On vous donne deux variables : a = 5 et b = 10. Échangez leurs valeurs sans les réaffecter manuellement valeur par valeur.

Python permet une affectation plus expressive : on peut dépaqueter et réaffecter en une seule opération.

Code de départ

Voici un squelette pour vous guider :

a = 5
b = 10

# Task: Swap a and b
# Hint: Try a temporary variable first.
# Then try the Pythonic approach (tuple unpacking).

# Task: Print the swapped values to verify
# print("a:", a)
# print("b:", b)

Notions clés travaillées

• Affectation de variables
• Variable temporaire vs dépaquetage de tuple

Cela introduit le dépaquetage de tuples, une fonctionnalité qui rend Python à la fois concis et expressif.

Pour approfondir les bases, consultez notre Python Cheat Sheet.

Exercices Python sur le contrôle de flux et la logique

Le contrôle de flux permet à vos programmes de prendre des décisions et de répéter des actions selon des conditions.

Le test pair ou impair

Un cas d'usage courant de l'opérateur modulo est de vérifier la parité. Essayons‑le.

Exercice

Écrivez un programme qui :

• Demande un nombre à l'utilisateur

• Utilise l'opérateur modulo %

• Indique si le nombre est pair ou impair

Code de départ

Voici un squelette pour vous guider :

# Task: Ask the user for a number
num_str = input("Enter a whole number: ")

# Task: Convert to int
# num = ...

# Task: Use modulo (%) to decide even vs odd
# if ...:
#     print("Even")
# else:
#     print("Odd")

Notions clés travaillées

• Opérateur modulo

• Instructions if / else

• Logique booléenne

C'est souvent le premier exemple où l'on voit comment les conditions pilotent le comportement d'un programme.

Le fameux défi FizzBuzz

Un classique largement pratiqué par les programmeurs : FizzBuzz. Voyons les règles.

Exercice

Affichez les nombres de 1 à 100 selon les règles suivantes :

• Les multiples de 3 affichent Fizz

• Les multiples de 5 affichent Buzz

• Les multiples des deux affichent FizzBuzz

Cet exercice vous entraîne à raisonner sur les arbres de décision et les cas limites, une compétence clé en programmation.

Code de départ

Voici un squelette pour vous guider :

# Task: Loop from 1 to 100
for n in range(1, 101):
    # Task: Check multiples of 3 AND 5 first
    # if ...:
    #     print("FizzBuzz")

    # Task: Then multiples of 3
    # elif ...:
    #     print("Fizz")

    # Task: Then multiples of 5
    # elif ...:
    #     print("Buzz")

    # Task: Otherwise, print the number
    # else:
    #     print(n)
    pass

Notions clés travaillées

• Boucles for

• Ordre des conditions

• Opérateurs logiques

Cet exercice est un rite de passage, souvent utilisé pour enseigner une pensée structurée autour du contrôle de flux. Pour en savoir plus sur les boucles, consultez notre tutoriel sur les boucles en Python.

Le jeu de devinette

Cet exercice introduit des programmes interactifs qui réagissent dynamiquement à la saisie utilisateur.

Exercice

Écrivez un programme qui :

• Génère un nombre aléatoire (en important random)

• Utilise une boucle while pour demander des propositions

• Affiche un retour "Too high" ou "Too low" après chaque essai

• S'arrête lorsque le nombre est trouvé

C'est souvent le premier exercice où l'on perçoit un programme interactif plutôt que linéaire. Contrairement aux scripts précédents, celui‑ci tourne jusqu'à ce qu'une condition soit remplie.

La clé ici est de bien comprendre la condition d'arrêt de la boucle.

Code de départ

Voici un squelette pour vous guider :

import random

# Task: Pick a random number in a reasonable range
# target = random.randint(1, 100)

# Task: Use a while loop to keep asking until correct
# while ...:
#     guess_str = input("Your guess (1–100): ")
#     # guess = ...
#     # if guess > target:
#     #     print("Too high")
#     # elif guess < target:
#     #     print("Too low")
#     # else:
#     #     print("Correct!")
#     #     break

Notions clés travaillées

• Import de modules (random)

• Boucles while

• Conditions d'arrêt

Exercices Python sur les listes, les boucles et l'itération

Les listes permettent de manipuler des collections de valeurs, et les boucles de les traiter efficacement.

La somme d'une liste

Ce schéma revient fréquemment dans les flux de traitement et d'analyse de données.

Exercice

Écrivez un programme qui additionne tous les nombres d'une liste sans utiliser la fonction intégrée sum(). Le programme doit implémenter explicitement la logique d'addition dans une boucle, sans recourir à d'autres aides d'agrégation.

Code de départ

Voici un squelette pour vous guider :

numbers = [3, 7, 2, 9, 4]

# Task: Create an accumulator variable
# total = ...

# Task: Loop through numbers and add each value to total
# for ...:
#     ...

# Task: Print the final total
# print(total)

Notions clés travaillées

• Initialisation d'un accumulateur

• Itération avec des boucles for

• Mise à jour incrémentale de valeurs

Pour d'autres exemples sur les listes, consultez notre guide des questions Python les plus fréquentes sur les listes.

Trouver le nombre maximum

L'exercice suivant ressemble au précédent mais adopte une autre logique dans la boucle. Il renforce la réflexion algorithmique et illustre le fonctionnement interne des fonctions intégrées.

Exercice

Mettez au défi l'utilisateur de trouver le plus grand nombre d'une liste sans utiliser max().

Code de départ

Voici un squelette pour vous guider :

numbers = [12, 5, 27, 3, 19]

# Task: Initialize current_max using the first element
# current_max = numbers[0]

# Task: Loop through the remaining elements and update current_max
# for ...:
#     if ...:
#         current_max = ...

# Task: Print the largest number
# print(current_max)

Notions clés travaillées

• Logique de comparaison
• Suivi d'un état pendant l'itération

Supprimer les doublons

Les données réelles sont rarement propres, et cela implique souvent des doublons. L'exercice suivant vous prépare aux tâches de nettoyage des données.

Exercice

Transformez une liste contenant des doublons en une nouvelle liste ne comportant que des éléments uniques.

À première vue, le problème paraît simple, mais il introduit l'idée de suivre ce que vous avez déjà vu. Un concept fondamental en traitement de données, où l'identification et la suppression des enregistrements en double sont courantes.

Code de départ

Voici un squelette pour vous guider :

data = ["apple", "banana", "apple", "orange", "banana", "kiwi"]

# Task: Create a new list for unique items
# unique = []

# Task: Loop through data and append items you haven't seen yet
# for item in data:
#     if ...:
#         ...

# Task: Print or return the unique list
# print(unique)

Notions clés travaillées

• Tests d'appartenance avec in

• Construction de nouvelles listes

• Compréhension de l'unicité des données

Exercices Python sur les dictionnaires et la manipulation de chaînes

Les dictionnaires et les chaînes sont essentiels pour organiser et transformer des données textuelles. Voyons comment les manipuler.

Le compteur de fréquence des caractères

Cet exercice vous apprend à construire des tables de fréquences, fréquentes en analyse de données.

Exercice

Prenez une chaîne en entrée et retournez un dictionnaire comptant le nombre d'occurrences de chaque caractère.

Il s'agit d'une étape conceptuelle majeure : construire dynamiquement une structure de données pendant l'exécution. Plutôt que de travailler avec une liste ou un dictionnaire prédéfinis, vous créez et mettez à jour des entrées selon les données rencontrées.

Code de départ

Voici un squelette pour vous guider :

text = input("Enter some text: ")

# Task: Create an empty dictionary
# counts = {}

# Task: Loop over each character and update counts
# for ch in text:
#     # Option A: counts[ch] = counts.get(ch, 0) + 1
#     # Option B: if ch in counts: ... else: ...
#     pass

# Task: Print the frequency table
# print(counts)

Notions clés travaillées

• Dictionnaires

• Méthode .get()

• Initialisation conditionnelle

Le mini-annuaire

Cet exercice touche à la logique des dictionnaires, base de la compréhension des structures de données tabulaires ensuite.

Exercice

Créez un programme qui stocke des noms et des numéros dans un dictionnaire et permet une recherche par nom.

Il s'agit d'utiliser un programme comme outil de consultation persistant plutôt que pour un calcul ponctuel. Vous modélisez une version simplifiée de la manière dont de nombreuses applications stockent et récupèrent des informations.

Code de départ

Voici un squelette pour vous guider :

phonebook = {
    # "Alice": "9123 4567",
    # "Ben": "9876 5432",
}

# Task: (Optional) add entries via input()
# name = input("Name to add: ")
# number = input("Number to add: ")
# phonebook[name] = number

# Task: Search loop (one lookup is fine for a start)
query = input("Search name: ")

# Task: Print the number if found, otherwise print a friendly message
# if ...:
#     print(...)
# else:
#     print("Not found")

Notions clés travaillées

• Recherches dans un dictionnaire
• Relations clé‑valeur

Pour aller plus loin sur les dictionnaires, lisez notre guide complet sur les méthodes des dictionnaires Python.

Vérificateur de palindrome

Cet exercice combine traitement de texte et comparaison logique autour des palindromes.

Exercice

Un palindrome est un mot, une phrase, un nombre ou une séquence de caractères qui se lit de la même façon dans les deux sens. Créez un script qui vérifie si une chaîne est un palindrome (en ignorant la casse et les espaces).

Code de départ

Voici un squelette pour vous guider :

text = input("Enter a word or phrase: ")

# Task: Normalize (lowercase + remove spaces)
# normalized = ...

# Task: Reverse using slicing
# reversed_text = ...

# Task: Compare and print a result message
# if ...:
#     print("Palindrome")
# else:
#     print("Not a palindrome")

Notions clés travaillées

• Méthodes de chaîne (lower(), replace())

• Tranchage de chaîne ([::-1])

Exercices Python sur les fonctions et la modularité

Les fonctions permettent d'écrire du code réutilisable et structuré, au lieu de répéter la même logique.

Le calculateur de factorielle

Cet exercice vous aide à comprendre la notion de valeur de retour, essentielle pour construire des programmes plus ambitieux.

Exercice

Définissez une fonction qui prend un entier et renvoie sa factorielle à l'aide d'une boucle.

La différence entre afficher une valeur et la retourner est cruciale. Le retour de résultats permet de composer votre fonction avec d'autres éléments, indispensable quand un projet dépasse un seul fichier.

Code de départ

Voici un squelette pour vous guider :

def factorial(n: int) -> int:
    """Return n! (factorial of n) using a loop."""
    # Task: Decide how to handle n < 0

    # Task: Initialize result
    # result = ...

    # Task: Multiply result by each integer from 1 to n
    # for ...:
    #     ...

    # Task: Return the computed factorial
    # return result
    pass

# Optional quick test
# print(factorial(5))  # expected: 120

Notions clés travaillées

• Définition de fonctions
• Calculs itératifs
• Retourner des valeurs vs afficher

Pour en savoir plus, lisez notre tutoriel sur les fonctions Python.

Validateur de nombre premier

Voyons ensuite une fonction qui vérifie si un nombre est premier. Vous apprendrez à écrire une fonction réutilisable.

Exercice

Écrivez une fonction qui renvoie True si un nombre est premier, et False sinon.

La vérification de primalité illustre comment encapsuler proprement une logique. Une fois écrite, la fonction peut être réutilisée partout sans avoir à en comprendre le détail interne.

Code de départ

Voici un squelette pour vous guider :

def is_prime(n: int) -> bool:
    """Return True if n is prime, otherwise False."""
    # Task: Handle small cases (n <= 1)

    # Task: Check divisibility from 2 up to an appropriate limit
    # for ...:
    #     if ...:
    #         return False

    # Task: If no divisors found, return True
    # return True
    pass

# Optional quick tests
# print(is_prime(2))   # expected: True
# print(is_prime(15))  # expected: False

Notions clés travaillées

• Itération
• Retours anticipés
• Efficacité logique

Afficheur d'arguments flexible

Cela introduit des signatures de fonctions avancées, courantes dans de nombreuses bibliothèques Python.

Exercice

Créez une fonction qui accepte un nombre quelconque d'arguments avec *args et les affiche un par un.

Cet exercice vous expose à une fonctionnalité très flexible de Python : les arguments de longueur variable. Il vous fait passer d'entrées figées à des fonctions capables de s'adapter à différents usages.

Comprendre *args facilite la lecture et l'utilisation de bibliothèques Python réelles, où les fonctions acceptent souvent un nombre flexible de paramètres pour plus de commodité et d'extensibilité.

Code de départ

Voici un squelette pour vous guider :

def print_args(*args) -> None:
    """Print each positional argument on its own line."""
    # Task: Loop over args and print each one
    # for ...:
    #     print(...)
    pass

# Optional quick test
# print_args("hello", 42, True)

Notions clés travaillées

• Arguments de longueur variable
• Flexibilité des fonctions

Mettre en pratique avec des projets guidés

Les exercices développent les compétences, mais les projets transforment ces compétences en confiance.

Enquêter sur les films Netflix

Le projet guidé Investigating Netflix Movies pose une question en apparence simple : les films raccourcissent‑ils avec le temps ? Pour y répondre, vous travaillerez sur un jeu de données réel de titres Netflix et transformerez progressivement des lignes brutes en un aperçu visuel clair.

La force de ce projet est de faire le pont entre les fondamentaux Python pour débutants et l'analyse de données appliquée. Vous voyez comment une logique simple change d'échelle avec les bons outils, sans rien installer en local.

Le Dr Semmelweis et la découverte du lavage des mains

Le projet Dr. Semmelweis and the Importance of Handwashing vous place dans la peau d'un analyste explorant un problème historique réel. Au milieu du XIX^e siècle, le Dr Ignaz Semmelweis observa des taux de mortalité anormalement élevés dans un service par rapport à un autre, sans disposer des outils de calcul pour en apporter la preuve.

À partir de registres historiques, vous analyserez des données de mortalité avant et après l'introduction du lavage des mains. Le projet se concentre sur la manipulation de données tabulaires avec pandas, le calcul de taux et la comparaison de moyennes sur différentes périodes. 

Explorer le marché Airbnb de New York

Dans le projet Exploring Airbnb Market Trends, vous vous retrouvez dans une situation très proche du travail analytique réel : des données brouillonnes et incohérentes, à nettoyer en profondeur avant toute analyse utile. 

Le jeu de données contient des annonces avec des prix stockés en chaînes de caractères, des notes manquantes et des formats hétérogènes.

Votre mission principale est de nettoyer et standardiser les données. Le projet rappelle que la préparation des données n'est pas une corvée préliminaire, mais une compétence analytique centrale. Souvent, la majeure partie du temps des praticiens est consacrée au nettoyage, et ce projet constitue un excellent jalon pratique pour cette compétence.

Conclusion

Vous avez démarré avec de simples variables et des entrées utilisateur, puis progressé vers le contrôle de flux, les structures de données, les fonctions, avant d'appliquer le tout dans des projets guidés. Ces exercices vous ont donné un bon aperçu de l'usage de Python en contexte réel.

La suite naturelle est un apprentissage structuré. Une pratique régulière, associée à un accompagnement méthodique, est le moyen le plus rapide de transformer des exercices en expertise. Nous vous recommandons de vous inscrire à notre parcours Python Programming ou Data Scientist pour vous lancer.