← Retour au programme
Module 01

Les fondamentaux de la programmation

Apprenez à raisonner comme un développeur en maîttrisant les bases universelles avec Python.

Ce premier module vous enseigne les bases universelles de la programmation : variables, types de données, conditions, boucles et fonctions. Python est choisi pour sa syntaxe lisible qui vous permet de vous concentrer sur la logique plutôt que sur la complexité du langage. À la fin de ce module, vous serez capable d’écrire des programmes complets et structurés.

Module suivant →

Philosophie

L’objectif n’est pas la vitesse, mais la compréhension profonde de chaque concept. Prenez le temps nécessaire pour que chaque ligne de code devienne limpide. La programmation est un art qui se construit brique par brique.

Prérequis & Outils

  • Aucun prérequis technique. Seule la curiosité est nécessaire.
  • Un ordinateur avec Python 3 installé (ou accès à un éditeur en ligne comme Replit).
PythonAlgorithmesPseudo-code

Objectifs du module

  • Comprendre ce qu’est un programme et comment il transforme des données
  • Maîtriser les variables, les types de données et les opérations de base
  • Écrire des conditions pour contrôler le flux d’exécution
  • Utiliser les boucles pour répéter des actions efficacement
  • Organiser votre code en fonctions réutilisables

Ressource complémentaire

Python pour les débutants — Cours complet

Ressource complémentaire pour découvrir Python à votre rythme.

Contenu du module

Progression pas à pas.

Chaque leçon s'appuie sur la précédente avec un rythme pensé pour laisser de l'espace à la compréhension, à la pratique et à la révision.

Leçon 1

Variables, types et entrées/sorties

Comprendre qu’un programme est une suite d’instructions qui transforme des données d’entrée en résultats de sortie, et maîtriser les briques fondamentales que sont les variables et les types.

Un programme informatique est, dans sa forme la plus simple, une séquence d’instructions qui transforme des données d’entrée (input) en résultats de sortie (output). Imaginez une recette de cuisine : les ingrédients sont les entrées, les étapes sont les instructions, et le plat final est la sortie. En programmation, c’est exactement le même principe. Par exemple, un programme de calcul de prix TTC prend en entrée un prix hors taxe, applique une formule (l’instruction), et produit le prix TTC (la sortie). Cette vision entrée → traitement → sortie est le fondement de toute la programmation.

Une variable est un espace de stockage nommé dans la mémoire de l’ordinateur. Pensez-y comme une boîte étiquetée : l’étiquette est le nom de la variable, et le contenu de la boîte est sa valeur. En Python, on crée une variable simplement en lui assignant une valeur avec le signe égal : age = 25. Python détecte automatiquement le type de la donnée. Les quatre types fondamentaux sont : int (nombres entiers comme 42), float (nombres décimaux comme 3.14), str (chaînes de caractères comme “Bonjour”), et bool (valeurs booléennes True ou False). Comprendre les types est crucial car chaque type détermine les opérations possibles sur la donnée.

Pour interagir avec l’utilisateur, Python offre deux fonctions essentielles : input() pour lire une saisie clavier (qui retourne toujours une chaîne de caractères), et print() pour afficher un résultat à l’écran. Attention : comme input() retourne toujours du texte, il faut convertir la valeur si on veut faire des calculs numériques. On utilise int() pour convertir en entier et float() pour convertir en décimal. Par exemple : prix = float(input(“Entrez le prix : ”)). Cette conversion de type (appelée “casting”) est une opération fréquente que vous utiliserez dans presque tous vos programmes interactifs.

Calcul d’un prix TTC à partir d’un prix hors taxe saisi par l’utilisateur.python
prix_ht = float(input("Entrez le prix HT : "))
taux_tva = 0.20
montant_tva = prix_ht * taux_tva
prix_ttc = prix_ht + montant_tva

print("Prix HT :", prix_ht, "€")
print("TVA (20%) :", montant_tva, "€")
print("Prix TTC :", prix_ttc, "€")

Exercice pratique

Calculateur d’addition au restaurant

Créez un programme qui demande à l’utilisateur le nombre de convives, le prix du plat principal et le prix du dessert, puis affiche le total par personne et le total général avec un pourboire de 10%.

  1. Utilisez input() et float() pour demander le nombre de convives, le prix du plat et le prix du dessert.
  2. Calculez le sous-total (plat + dessert) multiplié par le nombre de convives.
  3. Calculez le pourboire (10% du sous-total) et le total général.
  4. Affichez le détail : sous-total, pourboire, total général et montant par personne.

Le programme demande correctement les trois valeurs, calcule le pourboire et affiche tous les montants. Testez avec 3 convives, un plat à 15€ et un dessert à 7€ : le total général doit être 72.6€.

Leçon 2

Conditions et flux de contrôle

Maîtriser les structures conditionnelles pour permettre à un programme de prendre des décisions en fonction des données.

Jusqu’ici, nos programmes s’exécutaient ligne par ligne, de haut en bas, sans déviation. Mais dans la vie réelle, les décisions sont omniprésentes : “S’il pleut, je prends un parapluie ; sinon, je mets des lunettes de soleil.” En programmation, les structures conditionnelles (if, elif, else) permettent au programme de choisir quel bloc de code exécuter en fonction d’une condition. La syntaxe Python est particulièrement lisible : le mot-clé if est suivi d’une condition, puis de deux-points, et le bloc de code indenté en dessous ne s’exécute que si la condition est vraie (True).

Pour exprimer des conditions, Python offre les opérateurs de comparaison : égalité (==), différence (!=), inférieur (<), supérieur (>), inférieur ou égal (<=), supérieur ou égal (>=). Attention à ne pas confondre = (affectation) avec == (comparaison). On peut aussi combiner plusieurs conditions grâce aux opérateurs logiques : and (les deux conditions doivent être vraies), or (au moins une condition doit être vraie), et not (inverse la condition). Par exemple : if age >= 18 and age < 65 vérifie que l’âge se situe entre 18 et 64 ans inclus.

Lorsque vous avez plus de deux cas possibles, utilisez elif (contraction de “else if”) pour chaîner les conditions. Python évalue les conditions de haut en bas et exécute le premier bloc dont la condition est vraie, puis ignore tous les autres. Le bloc else final est optionnel et sert de “filet de sécurité” : il s’exécute si aucune des conditions précédentes n’est vraie. Une bonne pratique est de toujours penser aux cas limites : que se passe-t-il si l’utilisateur entre une valeur inattendue ? Anticiper ces cas rend votre programme robuste et fiable.

Système de notation : convertit une note sur 20 en appréciation.python
note = float(input("Entrez la note sur 20 : "))

if note < 0 or note > 20:
    print("Erreur : la note doit être entre 0 et 20.")
elif note >= 16:
    print("Très bien ! Félicitations.")
elif note >= 14:
    print("Bien. Continuez ainsi.")
elif note >= 10:
    print("Assez bien. Vous pouvez progresser.")
elif note >= 8:
    print("Insuffisant. Des efforts sont nécessaires.")
else:
    print("Très insuffisant. Revoyez les bases.")

Exercice pratique

Contrôle d’accès par âge

Créez un programme qui demande l’âge de l’utilisateur et détermine son accès à différentes zones d’un parc d’attractions : zone enfant (< 12 ans), zone ado (12-17 ans), zone adulte (18-64 ans), zone senior (65+ ans). Si l’âge est négatif, affichez une erreur.

  1. Demandez l’âge avec input() et convertissez-le en int().
  2. Vérifiez d’abord si l’âge est invalide (négatif) et affichez un message d’erreur.
  3. Utilisez elif pour tester chaque tranche d’âge et afficher la zone correspondante.
  4. Ajoutez un message personnalisé pour chaque zone avec le prix du billet associé.

Testez avec au moins 5 valeurs : -1 (erreur), 8 (enfant), 15 (ado), 30 (adulte), 70 (senior). Chaque cas doit afficher la bonne zone et le bon tarif.

Leçon 3

Boucles et fonctions

Automatiser les tâches répétitives avec les boucles et structurer le code en fonctions réutilisables.

Les boucles sont l’un des outils les plus puissants de la programmation : elles permettent de répéter un bloc de code autant de fois que nécessaire sans le réécrire. Python propose deux types de boucles. La boucle for parcourt une séquence (liste, chaîne, plage de nombres) : for i in range(5) répète le bloc 5 fois avec i allant de 0 à 4. La fonction range(début, fin, pas) génère une séquence de nombres. La boucle while, elle, répète tant qu’une condition est vraie : elle est idéale quand on ne connaît pas à l’avance le nombre d’itérations (par exemple, demander une saisie jusqu’à ce qu’elle soit valide).

Les fonctions sont des blocs de code nommés et réutilisables. On les définit avec le mot-clé def, suivi du nom de la fonction et de ses paramètres entre parenthèses. Une fonction peut recevoir des données (les paramètres) et renvoyer un résultat (avec return). Par exemple : def calculer_ttc(prix_ht, taux): définit une fonction qui prend deux paramètres. L’appel calculer_ttc(100, 0.20) exécute le code de la fonction avec ces valeurs. Les fonctions évitent la répétition de code : au lieu de copier-coller le même calcul à dix endroits, vous l’écrivez une seule fois dans une fonction.

Le principe DRY (Don’t Repeat Yourself — Ne vous répétez pas) est un pilier de la programmation de qualité. Chaque fois que vous écrivez du code similaire à deux endroits, c’est le signal qu’une fonction est nécessaire. Les fonctions rendent votre code plus lisible (chaque fonction a un nom descriptif), plus facile à maintenir (un seul endroit à modifier en cas de bug), et plus facile à tester (on peut vérifier chaque fonction indépendamment). Combiner boucles et fonctions vous donne déjà une puissance considérable pour résoudre des problèmes complexes de manière élégante.

Fonction qui génère et affiche la table de multiplication d’un nombre donné.python
def table_multiplication(nombre, limite=10):
    """Affiche la table de multiplication d'un nombre."""
    print(f"--- Table de {nombre} ---")
    for i in range(1, limite + 1):
        resultat = nombre * i
        print(f"{nombre} x {i} = {resultat}")

# Utilisation
table_multiplication(7)
print()
table_multiplication(12, 15)

Exercice pratique

Vérificateur de nombres premiers

À partir du HTML fourni, créez une fonction `est_premier(n)` qui retourne True si n est un nombre premier, False sinon. Utilisez ensuite cette fonction dans une boucle pour afficher tous les nombres premiers entre 2 et 100.

  1. Définissez la fonction est_premier(n) qui prend un entier en paramètre.
  2. Dans la fonction, utilisez une boucle for pour tester si n est divisible par un nombre entre 2 et n-1. Si oui, retournez False.
  3. Si aucun diviseur n’est trouvé, retournez True. Gérez le cas spécial n < 2.
  4. Écrivez une boucle for qui parcourt range(2, 101) et affiche chaque nombre premier.

La fonction doit retourner True pour 2, 3, 5, 7, 11 et False pour 0, 1, 4, 6, 9. Le programme doit trouver 25 nombres premiers entre 2 et 100.

Projet final

Mini calculatrice multi-opérations

Construisez une calculatrice interactive en Python qui propose à l’utilisateur de choisir une opération (addition, soustraction, multiplication, division), saisir deux nombres, afficher le résultat, et recommencer tant qu’il le souhaite.

Critères de réussite

  • Le programme affiche un menu clair avec les opérations disponibles.
  • Chaque opération est implémentée dans une fonction dédiée.
  • La division par zéro est gérée avec un message d’erreur.
  • Le programme tourne en boucle jusqu’à ce que l’utilisateur choisisse de quitter.
  • Les entrées invalides sont gérées sans que le programme ne plante.

Guide de réalisation

  • 1Commencez par définir une fonction pour chaque opération (addition, soustraction, etc.).
  • 2Utilisez une boucle while True pour faire tourner le programme en continu.
  • 3Utilisez if/elif/else pour diriger l’utilisateur vers la bonne opération selon son choix.
  • 4Pensez à ajouter une option “5. Quitter” dans le menu avec un break pour sortir de la boucle.

Consolidez vos acquis avant de poursuivre.

Prenez le temps de revoir les concepts difficiles et de refaire les exercices qui méritent une seconde passe.