Python Procédural — Guide Complet

📖 Chapitre 01

Introduction à Python

Découvrez Python, son histoire, son installation et votre premier programme.

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 ?

echo()

print()

display()

console.log()

La fonction print() est la fonction standard pour afficher du texte en Python.

→

📖 Chapitre 02

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 ?

int

float

str

double

float (virgule flottante) est le type des nombres décimaux. Python n'a pas de type double.

←

→

📖 Chapitre 03

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 ?

3

3.4

2

5

2 — Le modulo (%) donne le reste de la division entière. 17 = 5×3 + 2.

←

→

📖 Chapitre 04

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}")

←

→

📖 Chapitre 05

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 _: ?

Il correspond uniquement à la valeur None

C'est le cas par défaut, il correspond à tout le reste

Il génère une erreur si aucun case ne correspond

Il correspond à une chaîne vide

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.

←

→

📖 Chapitre 06

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 ?

4

3

8

2

3 fois — les valeurs sont : 2, 5, 8. (10 est exclu, et 11 > 10)

←

→

📖 Chapitre 07

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']

←

→

📖 Chapitre 08

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}

←

→

📖 Chapitre 09

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")

←

→

📖 Chapitre 10

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

←

→

📖 Chapitre 11

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 ?

0

False

None

Une erreur

None — toute fonction Python sans return retourne implicitement None.

←

→

📖 Chapitre 12

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."

←

→

📖 Chapitre 13

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)

←

→

📖 Chapitre 14

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}")

←

→

📖 Chapitre 15

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_case pour variables/fonctions, MAJUSCULES pour constantes, PascalCase pour 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

←

🏆

Terminé !

Retour à l'accueil

Apprendre Pythonen Procédural

Introduction à Python

Qu'est-ce que Python ?

La programmation procédurale

Installation de Python

Votre premier programme

L'interpréteur interactif

Variables & Types de données

Les variables

Types fondamentaux

Conversion de types (casting)

Nommage des variables

Opérateurs

Opérateurs arithmétiques

Opérateurs de comparaison

Opérateurs logiques

Opérateurs d'affectation

Entrées & Sorties

La fonction print()

La fonction input() et le cast

Programme interactif complet

Structures conditionnelles

La structure if / elif / else

Conditions imbriquées

Expression conditionnelle (ternaire)

match / case (Python 3.10+)

Boucles

La boucle for

La boucle while

break, continue, else

Listes

Créer et accéder

Méthodes essentielles

Compréhension de liste

Tuples & Sets

Les Tuples

Les Sets (ensembles)

Dictionnaires

Créer et accéder

Itérer sur un dictionnaire

Chaînes de caractères

Méthodes de chaînes

f-strings avancés

Fonctions

Définir une fonction

Paramètres avancés

Fonctions récursives

Portée & Modules

Portée des variables (Scope)

Modules standards

Gestion des fichiers

Lire un fichier texte

Écrire un fichier

Fichiers CSV

Gestion des erreurs

Try / Except

Exceptions courantes

Lever une exception

Bonnes pratiques

PEP 8 — Le guide de style Python

Règles PEP 8 essentielles

Structure d'un programme bien organisé

Apprendre Python
en Procédural