Introduction à Python
Découvrez Python, son histoire, son installation et votre premier programme.
Python · Programmation procédurale
Python
Bases
Variables, types, structures de contrôle, fonctions, structures de données, fichiers et gestion d'erreurs — 15 chapitres avec exemples et quiz.
Chap. 01–04
Fondamentaux
Variables, types, opérateurs, I/O
Chap. 05–06
Contrôle
Conditions, boucles for & while
Chap. 07–10
Structures de données
Listes, dicts, tuples, strings
Chap. 11–12
Fonctions
Def, portée, modules
Chap. 13–15
Avancé
Fichiers, erreurs, PEP 8
01 — Python procédural
Introduction à Python
Qu'est-ce que Python ?
Python est un langage de programmation interprété, créé par Guido van Rossum en 1991. Il est reconnu pour sa syntaxe claire et lisible, ce qui en fait un excellent choix pour débuter en programmation.
- Interprété : le code est exécuté ligne par ligne, sans compilation préalable.
- Multiparadigme : supporte la programmation procédurale, orientée objet et fonctionnelle.
- Portable : fonctionne sur Windows, macOS, Linux.
- Très utilisé : data science, web, automatisation, intelligence artificielle.
La programmation procédurale
Le paradigme procédural organise le code en une séquence d'instructions et de fonctions réutilisables. C'est le style naturel pour débuter : le programme s'exécute de haut en bas, étape par étape.
💡 Procédural vs Orienté Objet
En procédural, on pense en termes d'actions et d'étapes. En orienté objet, on pense en termes d'objets et de leurs comportements. Ce guide couvre entièrement l'approche procédurale.
Installation de Python
- Télécharger Python sur python.org (version 3.x recommandée)
- Lors de l'installation Windows : cocher "Add Python to PATH"
- Vérifier dans un terminal :
python --version
Votre premier programme
python
# Mon premier programme Python print("Bonjour, le monde !") # On peut aussi calculer directement print(2 + 3) # Affiche : 5 print("La réponse est :", 42)
L'interpréteur interactif
Python dispose d'un mode interactif (REPL) lancé avec la commande python dans un terminal. Idéal pour tester des expressions rapidement :
terminal
>>> 2 + 2 4 >>> print("Hello") Hello >>> exit() # pour quitter
🧠 Quiz
Quelle commande affiche du texte dans la console en Python ?
La fonction print() est la fonction standard pour afficher du texte en Python.
Variables & Types de données
Apprenez à stocker et manipuler des données avec les types fondamentaux de Python.
Les variables
Une variable est un espace mémoire nommé qui stocke une valeur. En Python, on n'a pas besoin de déclarer le type : Python le déduit automatiquement.
python
# Affectation de variables age = 20 nom = "Alice" taille = 1.68 etudiant = True # Affectation multiple x, y, z = 1, 2, 3 # Afficher le type print(type(age)) # <class 'int'> print(type(taille)) # <class 'float'>
Types fondamentaux
| Type | Mot-clé | Exemple | Description |
|---|---|---|---|
| Entier | int | 42, -7 | Nombre entier |
| Flottant | float | 3.14, -0.5 | Nombre décimal |
| Chaîne | str | "bonjour" | Texte |
| Booléen | bool | True, False | Vrai ou Faux |
| Nul | NoneType | None | Absence de valeur |
Conversion de types (casting)
python
# Convertir entre les types x = int("42") # str → int → 42 y = float(7) # int → float → 7.0 z = str(3.14) # float → str → "3.14" b = bool(0) # int → bool → False b2 = bool(1) # int → bool → True # Erreur possible ! # int("bonjour") → ValueError
Nommage des variables
✅ Bonnes pratiques de nommage
Utilisez le style snake_case :
mon_age, nombre_etudiants. Les noms doivent être explicites. Évitez a, x1 sauf pour les compteurs temporaires.
⚠️ Mots réservés
Ces mots ne peuvent pas être des noms de variables : ifelseforwhiledefclassimportreturnTrueFalseNone
🧠 Quiz
Quel est le type de la valeur
3.14 en Python ?float (virgule flottante) est le type des nombres décimaux. Python n'a pas de type
double.Opérateurs
Arithmétiques, comparaison, logiques — maîtrisez toutes les opérations Python.
Opérateurs arithmétiques
| Opérateur | Nom | Exemple | Résultat |
|---|---|---|---|
+ | Addition | 5 + 3 | 8 |
- | Soustraction | 10 - 4 | 6 |
* | Multiplication | 3 * 4 | 12 |
/ | Division (float) | 7 / 2 | 3.5 |
// | Division entière | 7 // 2 | 3 |
% | Modulo (reste) | 7 % 2 | 1 |
** | Puissance | 2 ** 8 | 256 |
python
a, b = 17, 5 print(a / b) # 3.4 (division réelle) print(a // b) # 3 (quotient entier) print(a % b) # 2 (reste) print(2 ** 10) # 1024
Opérateurs de comparaison
Ils retournent toujours True ou False.
python
print(5 == 5) # True — égal print(5 != 3) # True — différent print(5 > 3) # True — supérieur print(5 <= 5) # True — inférieur ou égal
Opérateurs logiques
python
x = 15 print(x > 10 and x < 20) # True — ET logique print(x < 5 or x > 10) # True — OU logique print(not (x == 15)) # False — NON logique # Opérateur d'appartenance print("a" in "banane") # True print(3 not in [1, 2, 4]) # True
Opérateurs d'affectation
python
n = 10 n += 3 # n = n + 3 → 13 n -= 2 # n = n - 2 → 11 n *= 2 # n = n * 2 → 22 n //= 4 # n = n // 4 → 5 n **= 2 # n = n ** 2 → 25
🧠 Quiz
Quel est le résultat de
17 % 5 ?2 — Le modulo (%) donne le reste de la division entière. 17 = 5×3 + 2.
Entrées & Sorties
Communiquez avec l'utilisateur via print() et input().
La fonction print()
La signature complète de print() est : print(*objets, sep=' ', end='\n'). Les paramètres sep et end sont optionnels et ont des valeurs par défaut.
| Paramètre | Rôle | Valeur par défaut |
|---|---|---|
sep | Séparateur inséré entre les arguments | ' ' (espace) |
end | Caractère ajouté à la fin de l'affichage | '\n' (retour à la ligne) |
python
# Par défaut : sep=" " et end="\n" print("Nom :", "Alice", "Age :", 20) # → Nom : Alice Age : 20 # sep — changer le séparateur entre les arguments print("a", "b", "c", sep="-") # → a-b-c print("2026", "03", "04", sep="/") # → 2026/03/04 print("a", "b", "c", sep="") # → abc (sans séparateur) # end — changer la fin de ligne print("Chargement", end="...") # pas de retour à la ligne print("OK") # → Chargement...OK print("Ligne 1", end=" | ") print("Ligne 2", end=" | ") print("Ligne 3") # → Ligne 1 | Ligne 2 | Ligne 3 # Combiner sep et end print("x", "y", "z", sep=", ", end=".\n") # → x, y, z. # f-strings (Python 3.6+) — recommandé prenom = "Bob" note = 18.5 print(f"Bonjour {prenom}, ta note est {note:.1f}/20") # Formatage de nombres dans f-strings print(f"Pi ≈ {3.14159:.2f}") # Pi ≈ 3.14 print(f"{'Titre':^20}") # centré sur 20 chars print(f"{1000000:,}") # 1,000,000
💡 Astuce : afficher sans retour à la ligne
end="" est très utile pour afficher plusieurs éléments sur la même ligne dans une boucle :for i in range(5): print(i, end=" ") → 0 1 2 3 4
La fonction input() et le cast
input() retourne toujours une chaîne de caractères (str), quelle que soit la valeur tapée. Pour utiliser la valeur dans des calculs, il faut la convertir (caster) explicitement.
⚠️ Piège classique — input() retourne toujours un str !
Si l'utilisateur tape
20, Python reçoit la chaîne "20", pas le nombre 20."20" + 5 → TypeError | int("20") + 5 → 25 ✅
python
# ── Sans cast : problème ! ────────────────────── age = input("Votre âge : ") # age = "20" (str !) # print(age + 1) → TypeError: can only concatenate str # ── Avec cast int() : entier ───────────────────── age = int(input("Votre âge : ")) # age = 20 (int ✅) print(f"Dans 10 ans : {age + 10} ans") # ── Avec cast float() : décimal ────────────────── taille = float(input("Taille (m) : ")) # "1.75" → 1.75 poids = float(input("Poids (kg) : ")) imc = poids / (taille ** 2) print(f"IMC : {imc:.1f}") # ── Vérifier le type avec type() ───────────────── val = input("Nombre : ") print(type(val)) # <class 'str'> val = int(val) print(type(val)) # <class 'int'> # ── Cast sécurisé avec try/except ──────────────── try: n = int(input("Entier : ")) except ValueError: print("Ce n'est pas un entier valide !")
Programme interactif complet
python
# Calculateur d'IMC print("=== Calculateur d'IMC ===") poids = float(input("Poids (kg) : ")) taille = float(input("Taille (m) : ")) imc = poids / (taille ** 2) print(f"Votre IMC est : {imc:.1f}")
Structures conditionnelles
Prenez des décisions dans vos programmes avec if/elif/else et le pattern matching (match/case).
La structure if / elif / else
python
note = int(input("Note sur 20 : ")) if note >= 16: print("Très bien !") elif note >= 14: print("Bien") elif note >= 10: print("Passable") else: print("Insuffisant")
🐍 L'indentation est obligatoire
En Python, l'indentation (4 espaces) définit les blocs de code. Il n'y a pas d'accolades comme en C ou Java. Une mauvaise indentation provoque une
IndentationError.
Conditions imbriquées
python
age = 25 permis = True if age >= 18: if permis: print("Peut conduire") else: print("Majeur mais sans permis") else: print("Mineur") # Équivalent plus concis : if age >= 18 and permis: print("Peut conduire")
Expression conditionnelle (ternaire)
python
# valeur_si_vrai if condition else valeur_si_faux age = 20 statut = "majeur" if age >= 18 else "mineur" print(statut) # majeur # Maximum de deux nombres a, b = 12, 9 maxi = a if a > b else b
match / case (Python 3.10+)
Le structural pattern matching est l'équivalent Python du switch/case d'autres langages. Il compare une valeur à plusieurs motifs et exécute le bloc correspondant. Plus lisible que de longues chaînes de elif quand on teste une même variable.
python
# Syntaxe de base jour = input("Numéro du jour (1-7) : ") match jour: case "1": print("Lundi") case "2": print("Mardi") case "6" | "7": # plusieurs valeurs avec | print("Week-end !") case _: # cas par défaut (comme else) print("Jour inconnu")
python
# Exemple avec un menu de programme choix = int(input("Votre choix : ")) match choix: case 1: print("→ Nouvelle partie") case 2: print("→ Charger une partie") case 3: print("→ Options") case 0: print("→ Quitter") case _: print("Choix invalide")
🆚 match/case vs if/elif
•
•
•
•
match/case est idéal quand on compare une même variable à plusieurs valeurs fixes (menus, codes, états).
•
if/elif reste nécessaire pour des conditions complexes avec plusieurs variables ou des comparaisons (>, <, in…).
•
match/case requiert Python 3.10 minimum.
🧠 Quiz
Dans un bloc
match/case, à quoi correspond le motif case _: ?case _: est le "joker" (wildcard) du match/case — il capture tout ce qui n'a pas été intercepté par les cases précédents, comme un
else.Boucles
Répétez des instructions avec for et while.
La boucle for
python
# Itérer avec range() for i in range(5): # 0, 1, 2, 3, 4 print(i) for i in range(1, 11): # 1 à 10 print(i) for i in range(10, 0, -2): # 10, 8, 6, 4, 2 print(i) # Itérer sur une liste fruits = ["pomme", "banane", "cerise"] for fruit in fruits: print(fruit) # Avec enumerate (index + valeur) for i, fruit in enumerate(fruits): print(f"{i}: {fruit}")
La boucle while
python
# Boucle tant que la condition est vraie compteur = 1 while compteur <= 5: print(compteur) compteur += 1 # Validation d'entrée utilisateur mot_de_passe = "" while mot_de_passe != "secret": mot_de_passe = input("Mot de passe : ") print("Accès accordé !")
break, continue, else
python
# break — sortir de la boucle for i in range(10): if i == 5: break # arrête à 4 print(i) # continue — passer à l'itération suivante for i in range(10): if i % 2 == 0: continue # saute les pairs print(i) # affiche 1,3,5,7,9 # else sur une boucle (exécuté si pas de break) for i in range(5): print(i) else: print("Boucle terminée normalement")
⚠️ Boucle infinie
Un
while True: sans break tourne indéfiniment. Utilisez Ctrl+C pour arrêter. Assurez-vous toujours que la condition de sortie est atteignable.
🧠 Quiz
Combien de fois la boucle
for i in range(2, 10, 3): s'exécute-t-elle ?3 fois — les valeurs sont : 2, 5, 8. (10 est exclu, et 11 > 10)
Listes
La structure de données la plus utilisée en Python : séquences mutables et indexées.
Créer et accéder
python
notes = [15, 12, 18, 9, 14] # Accès par index (commence à 0) print(notes[0]) # 15 (premier) print(notes[-1]) # 14 (dernier) print(notes[1:3]) # [12, 18] (slicing) print(notes[:3]) # [15, 12, 18] print(notes[2:]) # [18, 9, 14] print(notes[::2]) # [15, 18, 14] (un sur deux)
Méthodes essentielles
python
lst = [3, 1, 4, 1, 5] lst.append(9) # ajoute en fin → [3,1,4,1,5,9] lst.insert(0, 0) # insère à l'index 0 lst.remove(1) # supprime la 1ère occurrence lst.pop() # supprime et retourne le dernier lst.pop(0) # supprime l'index 0 lst.sort() # tri croissant (en place) lst.sort(reverse=True) # tri décroissant lst.reverse() # inverse la liste lst.count(1) # nombre d'occurrences lst.index(4) # index de la valeur 4 # Fonctions natives print(len(lst)) # longueur print(sum(lst)) # somme print(min(lst), max(lst)) # min et max print(sorted(lst)) # retourne une copie triée
Compréhension de liste
python
# Syntaxe : [expression for element in iterable if condition] carres = [x**2 for x in range(1, 6)] # → [1, 4, 9, 16, 25] pairs = [x for x in range(20) if x % 2 == 0] # → [0, 2, 4, 6, ..., 18] majuscules = [m.upper() for m in ["alice", "bob"]] # → ['ALICE', 'BOB']
Tuples & Sets
Collections immuables (tuples) et ensembles sans doublons (sets).
Les Tuples
Un tuple est une séquence immuable (on ne peut pas la modifier après création). Idéal pour des données constantes.
python
point = (3, 7) couleurs = ("rouge", "vert", "bleu") # Accès identique aux listes print(point[0]) # 3 print(couleurs[-1]) # bleu # Unpacking (déballage) x, y = point print(f"x={x}, y={y}") # Retourner plusieurs valeurs d'une fonction def min_max(lst): return min(lst), max(lst) # retourne un tuple mi, ma = min_max([3, 1, 8, 2])
Les Sets (ensembles)
Un set est une collection non ordonnée sans doublons. Très rapide pour tester l'appartenance.
python
s = {1, 2, 3, 2, 1} # → {1, 2, 3} # Éliminer les doublons d'une liste lst = [1, 2, 2, 3, 3, 3] unique = list(set(lst)) # [1, 2, 3] # Opérations ensemblistes a = {1, 2, 3, 4} b = {3, 4, 5, 6} print(a | b) # Union → {1,2,3,4,5,6} print(a & b) # Intersect. → {3, 4} print(a - b) # Différence → {1, 2} print(a ^ b) # Sym. diff → {1,2,5,6}
Dictionnaires
Stockez des données sous forme clé → valeur.
Créer et accéder
python
etudiant = { "nom": "Alice", "age": 21, "notes": [15, 17, 12] } # Accès print(etudiant["nom"]) # Alice print(etudiant.get("age")) # 21 (safe) print(etudiant.get("promo"span>, "N/A")) # N/A si absent # Modifier / ajouter etudiant["age"] = 22 etudiant["promo"] = "INFO-2" # Supprimer del etudiant["age"] val = etudiant.pop("promo")
Itérer sur un dictionnaire
python
scores = {"Alice": 95, "Bob": 87, "Charlie": 92} # Sur les clés for nom in scores: print(nom) # Sur les valeurs for score in scores.values(): print(score) # Sur les paires clé-valeur for nom, score in scores.items(): print(f"{nom}: {score}/100")
Chaînes de caractères
Manipulation avancée du texte en Python.
Méthodes de chaînes
python
s = " Bonjour le Monde ! " # Nettoyage s.strip() # "Bonjour le Monde !" s.lstrip() # supprime espaces gauche s.rstrip() # supprime espaces droite # Casse s.upper() # "BONJOUR LE MONDE !" s.lower() # "bonjour le monde !" s.title() # "Bonjour Le Monde !" s.capitalize() # "Bonjour le monde !" # Recherche s.find("le") # index de la 1ère occurrence s.count("o") # nombre d'occurrences s.startswith(" B") # True s.endswith("! ") # True "monde" in s # False (casse) # Remplacement & séparation s.replace("Monde", "Python") "a,b,c".split(",") # ["a", "b", "c"] "-".join(["a", "b"]) # "a-b"
f-strings avancés
python
n = 3.14159 print(f"{n:.2f}") # 3.14 print(f"{n:08.3f}") # 0003.142 print(f"{1000000:,}") # 1,000,000 print(f"{'titre':^20}") # centré en 20 chars print(f"{'gauche':<20}") # aligné à gauche print(f"{'droite':>20}") # aligné à droite
Fonctions
Organisez et réutilisez votre code avec des fonctions bien conçues.
Définir une fonction
python
def saluer(prenom): """Affiche un message de bienvenue.""" # docstring print(f"Bonjour, {prenom} !") saluer("Alice") # Bonjour, Alice ! def addition(a, b): """Retourne la somme de a et b.""" return a + b resultat = addition(3, 5) # 8
Paramètres avancés
python
# Valeurs par défaut def puissance(base, exposant=2): return base ** exposant print(puissance(3)) # 9 (exposant=2 par défaut) print(puissance(2, 8)) # 256 # Arguments nommés (keyword) def info(nom, age, ville="Paris"): print(f"{nom}, {age} ans, {ville}") info("Bob", age=25, ville="Lyon") # Nombre variable d'arguments (*args) def somme(*nombres): return sum(nombres) print(somme(1, 2, 3, 4)) # 10 # Arguments nommés variables (**kwargs) def afficher(**infos): for cle, val in infos.items(): print(f"{cle}: {val}") afficher(nom="Alice", age=21)
Fonctions récursives
python
# Factorielle récursive def factorielle(n): """Retourne n! de façon récursive.""" if n <= 1: return 1 # cas de base return n * factorielle(n - 1) # appel récursif print(factorielle(5)) # 120 # 5 * 4 * 3 * 2 * 1 = 120
✅ Bonne pratique : docstrings
Documentez toujours vos fonctions avec un docstring (entre triples guillemets). Indiquez ce que fait la fonction, ses paramètres et ce qu'elle retourne.
🧠 Quiz
Quelle est la valeur retournée par une fonction sans instruction
return ?None — toute fonction Python sans
return retourne implicitement None.Portée & Modules
Comprenez la portée des variables et organisez votre code en modules.
Portée des variables (Scope)
python
x = 10 # variable globale def ma_fonction(): y = 5 # variable locale print(x) # peut lire x global print(y) ma_fonction() # print(y) ← NameError : y n'existe pas ici # Modifier une variable globale compteur = 0 def incrementer(): global compteur # déclarer l'intention compteur += 1
Modules standards
python
import math print(math.sqrt(16)) # 4.0 print(math.pi) # 3.14159... print(math.floor(3.9)) # 3 print(math.ceil(3.1)) # 4 import random print(random.randint(1, 6)) # dé aléatoire print(random.random()) # float entre 0 et 1 random.shuffle([1,2,3,4]) # mélange en place import datetime auj = datetime.date.today() print(auj) # 2026-03-04 # Import sélectif from math import sqrt, pi print(sqrt(25)) # sans préfixe "math."
Gestion des fichiers
Lisez et écrivez des fichiers texte et CSV en Python.
Lire un fichier texte
python
# Toujours utiliser "with" — fermeture automatique with open("notes.txt", "r", encoding="utf-8") as f: contenu = f.read() # tout le fichier with open("notes.txt", "r", encoding="utf-8") as f: lignes = f.readlines() # liste de lignes # Ligne par ligne (efficace pour gros fichiers) with open("notes.txt", "r") as f: for ligne in f: print(ligne.strip())
Écrire un fichier
python
# "w" — écriture (écrase si existe) with open("sortie.txt", "w", encoding="utf-8") as f: f.write("Première ligne\n") f.write("Deuxième ligne\n") # "a" — ajout à la fin with open("sortie.txt", "a") as f: f.write("Troisième ligne\n")
Fichiers CSV
python
import csv # Lire un CSV with open("etudiants.csv", newline="") as f: lecteur = csv.DictReader(f) for ligne in lecteur: print(ligne["nom"], ligne["note"]) # Écrire un CSV donnees = [ {"nom": "Alice", "note": 18}, {"nom": "Bob", "note": 15}, ] with open("resultats.csv", "w", newline="") as f: ecrivain = csv.DictWriter(f, fieldnames=["nom", "note"]) ecrivain.writeheader() ecrivain.writerows(donnees)
Gestion des erreurs
Traitez les exceptions pour rendre vos programmes robustes.
Try / Except
python
try: n = int(input("Entrez un nombre : ")) res = 100 / n print(f"100 / {n} = {res}") except ValueError: print("Erreur : entrez un nombre entier !") except ZeroDivisionError: print("Erreur : division par zéro !") except Exception as e: print(f"Erreur inattendue : {e}") else: print("Aucune erreur !") # si try réussi finally: print("Toujours exécuté")
Exceptions courantes
| Exception | Cause |
|---|---|
ValueError | Type correct mais valeur invalide (int("abc")) |
TypeError | Type incorrect ("5" + 3) |
ZeroDivisionError | Division par zéro |
IndexError | Index hors limites (lst[99]) |
KeyError | Clé absente dans un dict |
FileNotFoundError | Fichier inexistant |
NameError | Variable non définie |
Lever une exception
python
def racine(n): if n < 0: raise ValueError(f"Impossible : {n} est négatif") return n ** 0.5 try: print(racine(-4)) except ValueError as e: print(f"Erreur : {e}")
Bonnes pratiques
Écrivez du code Python lisible, maintenable et professionnel.
PEP 8 — Le guide de style Python
python
# ✅ BON — conforme PEP 8 def calculer_moyenne(liste_notes): """Calcule et retourne la moyenne d'une liste.""" if not liste_notes: return 0 return sum(liste_notes) / len(liste_notes) TAUX_TVA = 0.20 # constante en MAJUSCULES # ❌ MAUVAIS def CalcMoy(l): # nom non explicite return sum(l)/len(l) # pas d'espaces
Règles PEP 8 essentielles
- Indentation : 4 espaces (pas de tabulations)
- Lignes : max 79 caractères
- Nommage :
snake_casepour variables/fonctions,MAJUSCULESpour constantes,PascalCasepour classes - Espaces : autour des opérateurs, après les virgules
- Lignes vides : 2 entre fonctions, 1 à l'intérieur
- Imports : en haut du fichier, un par ligne
Structure d'un programme bien organisé
python
#!/usr/bin/env python3 """ Module : calculatrice.py Auteur : Votre nom Description : Calculatrice simple en procédural """ import math # ── Constantes ────────────────────────── VERSION = "1.0" # ── Fonctions ─────────────────────────── def addition(a, b): """Retourne a + b.""" return a + b def menu(): """Affiche le menu principal.""" print("\n=== Calculatrice ===") print("1. Addition") print("0. Quitter") # ── Point d'entrée ────────────────────── def main(): """Fonction principale du programme.""" print(f"Calculatrice v{VERSION}") menu() if __name__ == "__main__": main()
🎓 Conseils pour l'examen
• Relisez toujours votre code avant de soumettre
• Testez avec des cas limites (liste vide, division par 0, valeur négative)
• Commentez les parties complexes
• Utilisez des noms de variables clairs
• Indentez systématiquement et uniformément
• Relisez toujours votre code avant de soumettre
• Testez avec des cas limites (liste vide, division par 0, valeur négative)
• Commentez les parties complexes
• Utilisez des noms de variables clairs
• Indentez systématiquement et uniformément