Bases de la programmation avec Python

B.O. spécial n° 1 du 22 janvier 2019 - SNT Seconde

Notions transversales de programmation - Tout au long de l'année, les élèves apprennent les bases de la programmation en Python :

Contenus	Capacités attendues
Affectations, variables	Écrire et développer des programmes avec des variables.
Séquences d'instructions	Comprendre et écrire une suite ordonnée d'instructions.
Instructions conditionnelles (`if`, `elif`, `else`)	Programmer des choix dans un algorithme.
Boucles bornées (`for`) et non bornées (`while`)	Programmer des répétitions.
Définitions et appels de fonctions	Décomposer un programme en fonctions réutilisables.

1. Qu'est-ce que la programmation ?

Programmer, c'est écrire une suite d'instructions dans un langage compris par l'ordinateur pour lui faire accomplir une tâche. En SNT, le langage utilisé est Python, créé en 1991 par Guido van Rossum. Python est très répandu dans l'enseignement, la science des données, le développement web et l'intelligence artificielle.

1.1. Les environnements de travail

Pour écrire et exécuter du Python, plusieurs outils existent :

Outil	Description	Idéal pour
Console Python (interpréteur)	On tape une instruction, Python l'exécute immédiatement	Tester rapidement une idée
Fichier `.py` (script)	On écrit un programme complet puis on l'exécute d'un bloc	Écrire de vrais programmes
Thonny	Éditeur simple avec débogueur intégré	Débuter en Python
EduPython	Suite pédagogique (éditeur + modules scientifiques)	Maths et sciences
Basthon (en ligne)	Python dans le navigateur, rien à installer	Travailler sans installation
VS Code	Éditeur professionnel avec extensions Python	Aller plus loin

# Mon tout premier programme Python
print("Bonjour, bienvenue en SNT !")

>>> 2 + 3
5
>>> print("Bonjour")
Bonjour
>>> "SNT".lower()
'snt'

La console exécute chaque ligne immédiatement et affiche le résultat. Le symbole >>> s'appelle le prompt : c'est Python qui attend votre instruction.

nom = input("Comment t'appelles-tu ? ")
print(f"Bonjour {nom} !")
print("Bienvenue en cours de SNT.")

Un script est un fichier texte contenant plusieurs instructions. On l'exécute d'un bloc avec le bouton « Exécuter » de l'éditeur ou via le terminal : python mon_programme.py.

En console, Python affiche automatiquement le résultat d'une expression. Dans un script, il faut utiliser print() pour voir quelque chose à l'écran.

>>> 2 + 3       # En console : affiche automatiquement 5
5

# Dans un script : rien ne s'affiche sans print()
2 + 3            # Cette ligne ne produit aucun affichage !
print(2 + 3)     # Il faut écrire ceci pour voir 5

1.3. Les commentaires

Les commentaires sont des textes ignorés par Python, destinés aux humains qui lisent le code :

# Ceci est un commentaire sur une ligne entière
age = 16  # Ceci est un commentaire en fin de ligne

# Les commentaires servent à :
# - expliquer POURQUOI on fait quelque chose
# - rendre le code plus lisible
# - désactiver temporairement une ligne de code

2. Variables et affectations

2.1. Qu'est-ce qu'une variable ?

Une variable est un espace en mémoire dans lequel on stocke une valeur. On lui donne un nom pour pouvoir la retrouver et l'utiliser plus tard. On peut la voir comme une étiquette collée sur une boîte contenant une valeur.

prenom = "Alice"
age = 16
taille = 1.68
est_eleve = True

L'opération = s'appelle l'affectation : elle associe une valeur (à droite) à un nom de variable (à gauche).

Le = n'est pas l'égalité mathématique !

En Python, = signifie « stocker la valeur de droite dans la variable de gauche ». L'égalité mathématique s'écrit ==.

x = 5       # On STOCKE 5 dans x (affectation)
x == 5      # On TESTE si x vaut 5 (comparaison → True ou False)

2.2. Les types de données de base

Chaque valeur en Python a un type qui détermine ce qu'on peut en faire :

Type	Description	Exemples	Remarques
`int`	Nombre entier	`42`, `-7`, `0`	Pas de limite de taille en Python !
`float`	Nombre à virgule	`3.14`, `-0.5`, `1.0`	Attention : on utilise le point, pas la virgule
`str`	Chaîne de caractères (texte)	`"Bonjour"`, `'Python'`	Délimitée par des guillemets simples `'` ou doubles `"`
`bool`	Booléen (vrai ou faux)	`True`, `False`	Toujours avec une majuscule !

On peut connaître le type d'une variable avec la fonction type() :

x = 42
print(type(x))     # <class 'int'>

y = 3.14
print(type(y))     # <class 'float'>

nom = "Alice"
print(type(nom))   # <class 'str'>

vrai = True
print(type(vrai))  # <class 'bool'>

En Python (et dans tous les langages de programmation), le séparateur décimal est le point ., jamais la virgule ,.

taille = 1.68    # ✅ Correct
taille = 1,68    # ❌ Crée un tuple (1, 68), pas un nombre !

Un texte doit toujours être entouré de guillemets. Sans guillemets, Python croit que c'est un nom de variable.

nom = Alice      # ❌ NameError: name 'Alice' is not defined
nom = "Alice"    # ✅ Correct

2.3. Nommer ses variables

Règles obligatoires (sinon Python refuse) :

Le nom commence par une lettre ou un underscore _
Il ne contient que des lettres, chiffres et underscores (pas d'espaces, pas de tirets, pas d'accents)
Il ne doit pas être un mot réservé de Python

# ✅ Noms valides
age = 16
nom_eleve = "Alice"
_compteur = 0
note2 = 15.5

# ❌ Noms invalides
2nd_note = 12       # SyntaxError : commence par un chiffre
nom-eleve = "Bob"   # SyntaxError : le tiret est interdit
mon age = 16        # SyntaxError : les espaces sont interdits
for = 5             # SyntaxError : for est un mot réservé

Les 35 mots réservés de Python

Ces mots ont une signification spéciale et ne peuvent pas être utilisés comme noms de variables :

False, None, True, and, as, assert, async, await, break, class, continue, def, del, elif, else, except, finally, for, from, global, if, import, in, is, lambda, nonlocal, not, or, pass, raise, return, try, while, with, yield

Conventions (pas obligatoires, mais fortement recommandées) :

Utiliser le snake_case : mots en minuscules séparés par des underscores
Choisir des noms explicites qui décrivent le contenu

# ❌ Mauvais noms (fonctionnent mais incompréhensibles)
a = 16
b = "Alice"
x = 15.5

# ✅ Bons noms (on comprend immédiatement)
age_eleve = 16
prenom = "Alice"
note_maths = 15.5

2.4. L'affectation en détail

Affectation simple

x = 10          # x reçoit la valeur 10
x = x + 5      # x reçoit la valeur de x + 5, soit 15

Affectation augmentée (raccourcis)

Python propose des raccourcis pour modifier une variable :

x = 10
x += 3      # Équivalent à : x = x + 3    → x vaut 13
x -= 2      # Équivalent à : x = x - 2    → x vaut 11
x *= 4      # Équivalent à : x = x * 4    → x vaut 44
x //= 5     # Équivalent à : x = x // 5   → x vaut 8
x %= 3      # Équivalent à : x = x % 3    → x vaut 2
x **= 4     # Équivalent à : x = x ** 4   → x vaut 16

Affectation multiple

On peut affecter plusieurs variables en une seule ligne :

# Variante 1 : plusieurs valeurs sur une ligne
x, y, z = 1, 2, 3

# Variante 2 : même valeur pour toutes
a = b = c = 0

# Astuce : échanger deux variables (très pratique !)
x, y = 10, 20
x, y = y, x      # Maintenant x = 20 et y = 10

Dans la plupart des langages, échanger deux variables nécessite une variable temporaire :

# Méthode classique (fonctionne dans tous les langages)
temp = x
x = y
y = temp

# Méthode Python (plus élégante)
x, y = y, x

2.5. Conversions de types

On a souvent besoin de convertir une valeur d'un type à un autre :

# str → int
age = int("16")          # 16

# str → float
taille = float("1.68")   # 1.68

# int → str
texte = str(42)           # "42"

# float → int (tronque la partie décimale, ne l'arrondit PAS)
n = int(3.7)              # 3 (pas 4 !)
n = int(-3.7)             # -3 (pas -4 !)

# int → float
x = float(5)              # 5.0

# Vers booléen
bool(0)       # False     (0 est « faux »)
bool(42)      # True      (tout nombre non nul est « vrai »)
bool("")      # False     (chaîne vide est « fausse »)
bool("hello") # True      (chaîne non vide est « vraie »)

int("3.14")      # ❌ ValueError : on ne peut pas convertir directement
                  # un texte avec un point en int
int(float("3.14"))  # ✅ Il faut d'abord passer par float : 3

int("abc")       # ❌ ValueError: invalid literal for int()
float("bonjour") # ❌ ValueError: could not convert string to float

2.6. Opérations sur les nombres

Opérateur	Signification	Exemple	Résultat
`+`	Addition	`7 + 3`	`10`
`-`	Soustraction	`7 - 3`	`4`
`*`	Multiplication	`7 * 3`	`21`
`/`	Division (toujours un `float`)	`7 / 2`	`3.5`
`//`	Division entière (partie entière)	`7 // 2`	`3`
`%`	Modulo (reste de la division)	`7 % 3`	`1`
`**`	Puissance	`2 ** 10`	`1024`

# La division / renvoie TOUJOURS un float, même si le résultat est entier
10 / 2       # 5.0 (pas 5 !)
type(10 / 2) # <class 'float'>

# La division entière // tronque vers le bas (pas vers zéro !)
7 // 2       # 3   ✅ comme attendu
-7 // 2      # -4  ⚠️ pas -3 ! (arrondi vers le bas)

# Le modulo suit la même logique
7 % 3        # 1   (car 7 = 3 × 2 + 1)
-7 % 3       # 2   ⚠️ (car -7 = 3 × (-3) + 2)

Priorité des opérations

Python respecte les mêmes règles de priorité qu'en mathématiques :

** (puissance) - priorité la plus haute
*, /, //, % (multiplication, divisions, modulo)
+, - (addition, soustraction) - priorité la plus basse

2 + 3 * 4       # 14  (pas 20 ! La multiplication est prioritaire)
(2 + 3) * 4     # 20  (les parenthèses changent l'ordre)
2 ** 3 ** 2      # 512 (= 2 ** 9, car ** s'évalue de droite à gauche)

2.7. Opérations sur les chaînes de caractères

prenom = "Alice"
nom = "Martin"

# Concaténation (assemblage de chaînes)
nom_complet = prenom + " " + nom
print(nom_complet)    # Alice Martin

# Répétition
ligne = "-" * 30
print(ligne)          # ------------------------------

# Longueur
print(len(prenom))    # 5

# Accès à un caractère (l'index commence à 0 !)
print(prenom[0])      # A  (premier caractère)
print(prenom[1])      # l  (deuxième caractère)
print(prenom[-1])     # e  (dernier caractère)
print(prenom[-2])     # c  (avant-dernier)

age = 16
print("J'ai " + age + " ans")   # ❌ TypeError: can only concatenate str to str

# 3 façons de corriger :
print("J'ai " + str(age) + " ans")     # Conversion en str
print("J'ai", age, "ans")               # Virgules dans print()
print(f"J'ai {age} ans")                # f-string (recommandé)

Quelques méthodes utiles sur les chaînes

texte = "Bonjour le Monde"

texte.upper()       # "BONJOUR LE MONDE"  (tout en majuscules)
texte.lower()       # "bonjour le monde"  (tout en minuscules)
texte.capitalize()  # "Bonjour le monde"  (1re lettre en majuscule)
texte.replace("Monde", "Python")  # "Bonjour le Python"
texte.count("o")    # 3  (nombre d'occurrences de "o")
texte.startswith("Bon")  # True
texte.endswith("de")     # True

"  espaces  ".strip()    # "espaces"  (supprime les espaces autour)
"a,b,c".split(",")       # ["a", "b", "c"]  (découpe en liste)

On ne peut pas modifier un caractère individuel d'une chaîne :

mot = "Python"
mot[0] = "p"    # ❌ TypeError: 'str' object does not support item assignment

# Il faut créer une nouvelle chaîne
mot = "p" + mot[1:]   # ✅ "python"

Guillemets simples, doubles et triples

# Trois façons d'écrire une chaîne - elles sont équivalentes :
message1 = 'Bonjour'
message2 = "Bonjour"

# Utile quand la chaîne contient des guillemets :
phrase1 = "L'élève travaille"        # Guillemets doubles autour d'une apostrophe
phrase2 = 'Il a dit "bonjour"'       # Guillemets simples autour de guillemets doubles

# Triples guillemets : pour les textes sur plusieurs lignes
poeme = """Roses are red,
Violets are blue,
Python is great,
And so are you."""

# Caractères spéciaux avec l'antislash \
print("Première ligne\nDeuxième ligne")   # \n = saut de ligne
print("Colonne1\tColonne2")               # \t = tabulation
print("Il a dit : \"Bonjour\"")           # \" = guillemet dans la chaîne

3. Entrées et sorties

3.1. Afficher avec `print()`

La fonction print() est très flexible. Voici toutes les façons de l'utiliser :

nom = "Alice"
age = 16
print("Bonjour", nom, "tu as", age, "ans")
# Bonjour Alice tu as 16 ans

Les éléments sont automatiquement séparés par un espace et suivis d'un saut de ligne.

nom = "Alice"
age = 16
print(f"Bonjour {nom}, tu as {age} ans")
# Bonjour Alice, tu as 16 ans

# On peut mettre des expressions dans les accolades
print(f"Dans 10 ans, tu auras {age + 10} ans")
print(f"Note : {15.6789:.2f}")  # Note : 15.68 (2 décimales)

nom = "Alice"
age = 16
print("Bonjour " + nom + ", tu as " + str(age) + " ans")
# Plus lourd, il faut convertir les nombres en str

nom = "Alice"
age = 16
print("Bonjour {}, tu as {} ans".format(nom, age))
# Méthode plus ancienne, les f-strings sont préférées

Paramètres utiles de print() :

# sep : changer le séparateur (par défaut : espace)
print("Alice", "Bob", "Charlie", sep=", ")
# Alice, Bob, Charlie

print("2026", "07", "06", sep="-")
# 2026-07-06

# end : changer ce qui est ajouté à la fin (par défaut : saut de ligne)
print("Chargement", end="...")
print("Terminé !")
# Chargement...Terminé !

# Afficher sans saut de ligne dans une boucle
for i in range(5):
    print(i, end=" ")
# 0 1 2 3 4

3.2. Lire une saisie avec `input()`

La fonction input() affiche un message et attend que l'utilisateur tape quelque chose. Elle renvoie toujours une chaîne de caractères (str) :

prenom = input("Comment t'appelles-tu ? ")
print(f"Bonjour {prenom} !")

Piège n° 1 : input() renvoie toujours un str

age = input("Ton âge : ")  # L'utilisateur tape 16
print(type(age))            # <class 'str'> (c'est du texte, pas un nombre !)
print(age + 2)              # ❌ TypeError: can only concatenate str to str

# Il faut CONVERTIR :
age = int(input("Ton âge : "))      # Pour un entier
taille = float(input("Ta taille : "))  # Pour un décimal

age = int(input("Ton âge : "))
# Si l'utilisateur tape "seize" → ValueError: invalid literal for int()
# Si l'utilisateur tape "16.5" → ValueError aussi ! (int n'accepte pas les décimaux en texte)
# Si l'utilisateur tape "" (rien) → ValueError

4. Séquences d'instructions

Un programme Python est une séquence (suite ordonnée) d'instructions exécutées les unes après les autres, de haut en bas :

# Étape 1 : lire les données
longueur = float(input("Longueur du rectangle : "))
largeur = float(input("Largeur du rectangle : "))

# Étape 2 : calculer
aire = longueur * largeur
perimetre = 2 * (longueur + largeur)

# Étape 3 : afficher les résultats
print(f"Aire : {aire}")
print(f"Périmètre : {perimetre}")

# ❌ ERREUR : on utilise 'aire' avant de la calculer
print(f"Aire : {aire}")         # NameError: name 'aire' is not defined
aire = longueur * largeur

# ✅ CORRECT : on calcule d'abord, on affiche ensuite
aire = longueur * largeur
print(f"Aire : {aire}")

L'erreur NameError

C'est l'une des erreurs les plus fréquentes. Elle signifie que Python ne connaît pas le nom que vous utilisez :

NameError: name 'aire' is not defined

Causes possibles :

La variable n'a pas encore été créée (utilisée avant l'affectation)
Faute de frappe dans le nom (ariee au lieu de aire)
Oubli des guillemets autour d'un texte (print(Bonjour) au lieu de print("Bonjour"))

5. Instructions conditionnelles

Les instructions conditionnelles permettent au programme de prendre des décisions : exécuter un bloc de code seulement si une condition est vraie.

5.1. Le `if` simple

age = int(input("Quel âge as-tu ? "))

if age >= 18:
    print("Tu es majeur(e).")
    print("Tu peux passer le permis.")

Structure :

if condition:
    instruction(s) à exécuter si la condition est vraie

En Python, le bloc de code à l'intérieur du if est indenté (décalé vers la droite). C'est l'indentation (4 espaces) qui définit quelles lignes font partie du bloc - pas des accolades {} comme dans d'autres langages.

if age >= 18:
print("Majeur")     # ❌ IndentationError: expected an indented block

if age >= 18:
    print("Majeur") # ✅ Correct (4 espaces d'indentation)

5.2. Le `if / else`

Pour exécuter un bloc si la condition est vraie, et un autre bloc si elle est fausse :

age = int(input("Quel âge as-tu ? "))

if age >= 18:
    print("Tu es majeur(e).")
else:
    print("Tu es mineur(e).")

5.3. Le `if / elif / else`

Pour tester plusieurs conditions enchaînées :

note = float(input("Ta note sur 20 : "))

if note >= 16:
    print("Très bien !")
elif note >= 14:
    print("Bien !")
elif note >= 12:
    print("Assez bien.")
elif note >= 10:
    print("Tu as la moyenne.")
else:
    print("Il faut réviser...")

elif est la contraction de « else if ». Python teste les conditions dans l'ordre : dès qu'une condition est vraie, il exécute le bloc correspondant et ignore tous les suivants.

Le même programme peut s'écrire avec des if séparés, mais le comportement est différent :

# Avec elif : UNE SEULE branche est exécutée
note = 17
if note >= 16:
    print("Très bien")    # ✅ Exécuté
elif note >= 14:
    print("Bien")         # Ignoré (une branche a déjà été choisie)
elif note >= 12:
    print("Assez bien")   # Ignoré

# Avec des if séparés : TOUTES les conditions sont testées
note = 17
if note >= 16:
    print("Très bien")    # ✅ Exécuté
if note >= 14:
    print("Bien")         # ✅ Aussi exécuté (17 >= 14 est vrai !)
if note >= 12:
    print("Assez bien")   # ✅ Aussi exécuté (17 >= 12 est vrai !)

5.4. Conditions imbriquées

On peut mettre un if à l'intérieur d'un autre if :

age = int(input("Ton âge : "))
a_carte = input("As-tu une carte de réduction ? (oui/non) : ")

if age < 18:
    if a_carte == "oui":
        print("Tarif jeune avec réduction : 5 €")
    else:
        print("Tarif jeune : 8 €")
else:
    if a_carte == "oui":
        print("Tarif adulte avec réduction : 10 €")
    else:
        print("Tarif plein : 15 €")

Variante : aplatir avec and

On peut souvent éviter l'imbrication avec des opérateurs logiques :

if age < 18 and a_carte == "oui":
    print("Tarif jeune avec réduction : 5 €")
elif age < 18:
    print("Tarif jeune : 8 €")
elif a_carte == "oui":
    print("Tarif adulte avec réduction : 10 €")
else:
    print("Tarif plein : 15 €")

5.5. Les opérateurs de comparaison

Opérateur	Signification	Exemple	Résultat
`==`	Égal à	`5 == 5`	`True`
`!=`	Différent de	`5 != 3`	`True`
`<`	Strictement inférieur	`3 < 5`	`True`
`>`	Strictement supérieur	`5 > 3`	`True`
`<=`	Inférieur ou égal	`5 <= 5`	`True`
`>=`	Supérieur ou égal	`5 >= 6`	`False`

Python permet d'écrire des comparaisons enchaînées, comme en mathématiques :

# Au lieu de :
if age >= 12 and age <= 17:

# On peut écrire directement :
if 12 <= age <= 17:

# Cela fonctionne aussi avec d'autres combinaisons :
if 0 <= note <= 20:
if a < b < c:

5.6. Les opérateurs logiques

On peut combiner plusieurs conditions avec and, or et not :

Opérateur	Signification	Exemple
`and`	ET logique (les deux conditions doivent être vraies)	`age >= 12 and age <= 17`
`or`	OU logique (au moins une condition doit être vraie)	`jour == "samedi" or jour == "dimanche"`
`not`	NON logique (inverse la condition)	`not inscrit`

# AND : les deux conditions doivent être vraies
age = 16
a_carte = True
if age >= 12 and a_carte:
    print("Tarif réduit.")

# OR : au moins une condition doit être vraie
temperature = 35
if temperature < 0 or temperature > 40:
    print("Température extrême !")

# NOT : inverse vrai et faux
inscrit = False
if not inscrit:
    print("Veuillez vous inscrire.")

Table de vérité :

`a`	`b`	`a and b`	`a or b`	`not a`
`True`	`True`	`True`	`True`	`False`
`True`	`False`	`False`	`True`	`False`
`False`	`True`	`False`	`True`	`True`
`False`	`False`	`False`	`False`	`True`

5.7. L'expression conditionnelle (en une ligne)

Pour les cas simples, Python permet d'écrire un if/else en une seule ligne :

age = 20

# Forme classique
if age >= 18:
    statut = "majeur"
else:
    statut = "mineur"

# Forme condensée (expression conditionnelle)
statut = "majeur" if age >= 18 else "mineur"

# Utile dans un print
print("Accès autorisé" if age >= 18 else "Accès refusé")

6. Les boucles

Les boucles permettent de répéter un bloc d'instructions plusieurs fois, ce qui évite de dupliquer du code.

6.1. La boucle `for` (boucle bornée)

La boucle for répète un bloc de code un nombre déterminé de fois :

# Afficher les nombres de 0 à 4
for i in range(5):
    print(i)
# Affiche : 0, 1, 2, 3, 4

Les variantes de `range()`

Appel	Valeurs générées	Nombre de valeurs
`range(5)`	0, 1, 2, 3, 4	5
`range(1, 6)`	1, 2, 3, 4, 5	5
`range(0, 10, 2)`	0, 2, 4, 6, 8	5
`range(10, 0, -1)`	10, 9, 8, ..., 1	10
`range(5, 0, -2)`	5, 3, 1	3
`range(3, 3)`	(rien)	0

# Pour afficher 1, 2, 3, 4, 5 :
for i in range(5):       # ❌ Affiche 0, 1, 2, 3, 4
    print(i)

for i in range(1, 5):    # ❌ Affiche 1, 2, 3, 4 (5 est exclu !)
    print(i)

for i in range(1, 6):    # ✅ Affiche 1, 2, 3, 4, 5
    print(i)

Parcourir une chaîne de caractères

# Deux façons de parcourir les caractères d'un mot :

# Méthode 1 : directement (plus simple et plus « pythonique »)
mot = "Python"
for lettre in mot:
    print(lettre)

# Méthode 2 : par indice (utile quand on a besoin de la position)
mot = "Python"
for i in range(len(mot)):
    print(f"Caractère n°{i} : {mot[i]}")

Parcourir une liste

fruits = ["pomme", "banane", "cerise"]

# Méthode 1 : parcourir les éléments
for fruit in fruits:
    print(fruit)

# Méthode 2 : parcourir avec l'indice (enumerate)
for i, fruit in enumerate(fruits):
    print(f"{i} : {fruit}")
# 0 : pomme
# 1 : banane
# 2 : cerise

Le patron « accumulateur »

C'est un schéma de programmation très courant : on initialise une variable, puis on la modifie à chaque tour de boucle :

# Somme des entiers de 1 à 100
somme = 0
for i in range(1, 101):
    somme = somme + i    # ou somme += i
print(f"La somme vaut {somme}")  # 5050

# Compter les voyelles d'un mot
mot = "programmation"
compteur = 0
for lettre in mot:
    if lettre in "aeiouy":
        compteur += 1
print(f"Nombre de voyelles : {compteur}")  # 5

# Construire une chaîne lettre par lettre
resultat = ""
for i in range(1, 6):
    resultat += str(i) + " "
print(resultat)  # "1 2 3 4 5 "

6.2. La boucle `while` (boucle non bornée)

La boucle while répète un bloc tant qu'une condition est vraie. On l'utilise quand on ne connaît pas à l'avance le nombre de répétitions :

# Deviner un nombre
secret = 42
proposition = int(input("Devinez le nombre : "))

while proposition != secret:
    if proposition < secret:
        print("C'est plus !")
    else:
        print("C'est moins !")
    proposition = int(input("Nouvel essai : "))

print("Bravo, c'est bien 42 !")

Si la condition du while ne devient jamais fausse, le programme tourne indéfiniment. C'est une boucle infinie - il faut alors forcer l'arrêt avec Ctrl+C.

# ❌ Boucle infinie : x ne change jamais !
x = 1
while x > 0:
    print(x)
# Le programme ne s'arrête JAMAIS

# ✅ Correction : modifier x dans la boucle
x = 10
while x > 0:
    print(x)
    x -= 1    # x diminue à chaque tour → finit par atteindre 0

Valider une saisie utilisateur :

# Méthode 1 : saisie avant la boucle
note = float(input("Note entre 0 et 20 : "))
while note < 0 or note > 20:
    print("Erreur ! La note doit être entre 0 et 20.")
    note = float(input("Note entre 0 et 20 : "))

# Méthode 2 : avec un « drapeau » (flag)
valide = False
while not valide:
    note = float(input("Note entre 0 et 20 : "))
    if 0 <= note <= 20:
        valide = True
    else:
        print("Erreur ! La note doit être entre 0 et 20.")

6.3. `break` et `continue`

Ces deux instructions modifient le comportement normal d'une boucle :

break : sort immédiatement de la boucle
continue : saute au tour suivant de la boucle

# break : arrêter la boucle quand on trouve ce qu'on cherche
for i in range(1, 100):
    if i * i > 50:
        print(f"Le plus petit entier dont le carré dépasse 50 est {i}")
        break
# Affiche : Le plus petit entier dont le carré dépasse 50 est 8

# continue : sauter certains tours
for i in range(1, 11):
    if i % 3 == 0:
        continue    # On saute les multiples de 3
    print(i)
# Affiche : 1, 2, 4, 5, 7, 8, 10

Utilisation de break avec while True

Un patron courant est de créer une boucle infinie avec while True et d'en sortir avec break :

while True:
    reponse = input("Tapez 'quit' pour quitter : ")
    if reponse == "quit":
        break
    print(f"Vous avez tapé : {reponse}")
print("Au revoir !")

Cette approche est parfois plus lisible que de répéter le input() avant et dans la boucle.

6.4. Boucles imbriquées

On peut mettre une boucle à l'intérieur d'une autre :

# Table de multiplication
for i in range(1, 6):
    for j in range(1, 6):
        print(f"{i} × {j} = {i * j:2d}", end="   ")
    print()  # Saut de ligne après chaque ligne du tableau

# Triangle d'étoiles
n = 5
for i in range(1, n + 1):
    print("*" * i)
# *
# **
# ***
# ****
# *****

6.5. `for` ou `while` ? Comment choisir

Situation	Boucle à utiliser	Exemple
On connaît le nombre de répétitions	`for`	Afficher 10 fois « Bonjour »
On répète jusqu'à une condition	`while`	Attendre un mot de passe correct
On parcourt une collection	`for`	Parcourir les lettres d'un mot
On attend une saisie correcte	`while`	Redemander jusqu'à obtenir un nombre valide
On cherche un seuil	`while`	Trouver n tel que la somme dépasse 1000

Astuce : tout for peut s'écrire en while (mais pas l'inverse)

# Avec for
for i in range(5):
    print(i)

# Équivalent avec while
i = 0
while i < 5:
    print(i)
    i += 1

Le for est plus court et plus sûr (pas de risque de boucle infinie), donc on le préfère quand c'est possible.

7. Les fonctions

7.1. Qu'est-ce qu'une fonction ?

Une fonction est un bloc de code réutilisable auquel on donne un nom. Elle permet de :

Décomposer un programme en sous-tâches claires
Éviter la répétition de code (principe DRY : Don't Repeat Yourself)
Rendre le programme lisible et facile à maintenir

Vous avez déjà utilisé des fonctions prédéfinies : print(), input(), len(), range(), type(), int(), float(), str()...

7.2. Définir et appeler une fonction

# DÉFINIR la fonction (la créer)
def dire_bonjour():
    print("Bonjour !")
    print("Bienvenue en cours de SNT.")

# APPELER la fonction (l'exécuter)
dire_bonjour()
# Bonjour !
# Bienvenue en cours de SNT.

# On peut l'appeler autant de fois qu'on veut
dire_bonjour()
dire_bonjour()

La définition (def) crée la fonction mais ne l'exécute pas. Il faut l'appeler en écrivant son nom suivi de parenthèses ().

def saluer():
    print("Bonjour")

saluer     # ❌ N'exécute rien ! (c'est juste une référence à la fonction)
saluer()   # ✅ Exécute la fonction

dire_bonjour()      # ❌ NameError: name 'dire_bonjour' is not defined

def dire_bonjour():
    print("Bonjour")

Python lit le code de haut en bas : la fonction doit être définie avant d'être appelée.

7.3. Fonctions avec paramètres

Les paramètres sont des valeurs que l'on passe à la fonction lors de l'appel :

def saluer(prenom):
    print(f"Bonjour {prenom} !")

saluer("Alice")   # Bonjour Alice !
saluer("Bob")     # Bonjour Bob !

Plusieurs paramètres :

def aire_rectangle(longueur, largeur):
    return longueur * largeur

print(aire_rectangle(5, 3))   # 15
print(aire_rectangle(10, 7))  # 70

def saluer(prenom):
    print(f"Bonjour {prenom}")

saluer()              # ❌ TypeError: missing 1 required positional argument
saluer("Alice", 16)   # ❌ TypeError: takes 1 positional argument but 2 were given
saluer("Alice")       # ✅ Correct

Paramètres par défaut

On peut donner une valeur par défaut à un paramètre. Si l'argument n'est pas fourni lors de l'appel, la valeur par défaut est utilisée :

def saluer(prenom, formule="Bonjour"):
    print(f"{formule} {prenom} !")

saluer("Alice")              # Bonjour Alice !
saluer("Alice", "Salut")     # Salut Alice !
saluer("Alice", "Bonsoir")   # Bonsoir Alice !

Arguments nommés

On peut préciser le nom des paramètres lors de l'appel, ce qui permet de changer l'ordre :

def presentation(prenom, age, classe):
    print(f"{prenom}, {age} ans, en {classe}")

# Appel classique (par position)
presentation("Alice", 16, "2nde B")

# Appel avec arguments nommés (par nom)
presentation(classe="2nde B", prenom="Alice", age=16)

# On peut mélanger (les positionnels d'abord)
presentation("Alice", classe="2nde B", age=16)

7.4. `return` : renvoyer un résultat

Le mot-clé return permet à la fonction de renvoyer une valeur au programme qui l'a appelée :

def calculer_aire(longueur, largeur):
    return longueur * largeur

# On récupère le résultat dans une variable
a = calculer_aire(5, 3)
print(f"Aire : {a}")         # Aire : 15

# On peut utiliser directement le résultat
if calculer_aire(10, 7) > 50:
    print("Grand rectangle !")

print() vs return - la confusion n° 1 des débutants

# Avec print : AFFICHE mais ne renvoie rien
def aire_v1(longueur, largeur):
    print(longueur * largeur)

resultat = aire_v1(5, 3)    # Affiche 15
print(resultat)              # None ! (la fonction ne renvoie rien)
print(resultat * 2)          # ❌ TypeError: unsupported operand type(s) for *: 'NoneType' and 'int'

# Avec return : RENVOIE la valeur (sans l'afficher)
def aire_v2(longueur, largeur):
    return longueur * largeur

resultat = aire_v2(5, 3)    # Pas d'affichage !
print(resultat)              # 15
print(resultat * 2)          # 30 ✅

Règle : si la fonction doit être réutilisée dans un calcul, utilisez return. Si elle doit juste afficher quelque chose à l'écran, utilisez print().

Ce qui se passe après un return

Le return arrête immédiatement la fonction. Tout code après un return n'est jamais exécuté :

def tester(x):
    if x > 0:
        return "positif"
    print("Cette ligne est exécutée si x <= 0")
    return "négatif ou nul"

print(tester(5))    # "positif" (le print de la ligne 3 n'est PAS exécuté)
print(tester(-2))   # affiche d'abord le message, puis "négatif ou nul"

Renvoyer plusieurs valeurs

Python permet de renvoyer plusieurs valeurs avec un seul return :

def min_max(a, b, c):
    minimum = min(a, b, c)
    maximum = max(a, b, c)
    return minimum, maximum

petit, grand = min_max(7, 2, 9)
print(f"Min : {petit}, Max : {grand}")  # Min : 2, Max : 9

7.5. Portée des variables (local vs global)

Les variables créées à l'intérieur d'une fonction sont locales : elles n'existent que pendant l'exécution de la fonction.

def ma_fonction():
    x = 10    # Variable locale
    print(x)

ma_fonction()   # Affiche 10
print(x)        # ❌ NameError: name 'x' is not defined

x = 100         # Variable globale

def ma_fonction():
    print(x)    # On peut LIRE une variable globale

ma_fonction()   # Affiche 100

compteur = 0

def incrementer():
    compteur = compteur + 1   # ❌ UnboundLocalError !
    # Python croit qu'on veut créer une variable locale 'compteur'
    # mais on essaie de la lire avant de la créer

incrementer()

En SNT, il est préférable de passer les valeurs en paramètres et d'utiliser return plutôt que de modifier des variables globales.

7.6. Exemples complets de fonctions

Fonction qui teste si un nombre est pair :

# Plusieurs façons d'écrire la même fonction :

# Version 1 : avec if/else
def est_pair(n):
    if n % 2 == 0:
        return True
    else:
        return False

# Version 2 : simplifiée (le test est déjà un booléen !)
def est_pair(n):
    return n % 2 == 0

# Les deux versions donnent le même résultat
print(est_pair(4))   # True
print(est_pair(7))   # False

Fonction avec une boucle :

def table_multiplication(n):
    for i in range(1, 11):
        print(f"{n} × {i} = {n * i}")

table_multiplication(7)

Fonction avec un conditionnel :

def mention(note):
    if note >= 16:
        return "Très bien"
    elif note >= 14:
        return "Bien"
    elif note >= 12:
        return "Assez bien"
    elif note >= 10:
        return "Admis"
    else:
        return "Non admis"

print(mention(15.5))  # Bien

8. Les listes (introduction)

Les listes sont des collections ordonnées de valeurs. Elles sont indispensables en programmation et apparaissent dans de nombreux exercices.

8.1. Créer et manipuler une liste

# Créer une liste
notes = [15, 12, 18, 9, 14]
prenoms = ["Alice", "Bob", "Charlie"]
vide = []

# Accéder à un élément (les indices commencent à 0)
print(notes[0])     # 15  (premier élément)
print(notes[2])     # 18  (troisième élément)
print(notes[-1])    # 14  (dernier élément)

# Modifier un élément
notes[1] = 16       # notes vaut maintenant [15, 16, 18, 9, 14]

# Longueur de la liste
print(len(notes))   # 5

8.2. Ajouter et supprimer des éléments

fruits = ["pomme", "banane"]

# Ajouter à la fin
fruits.append("cerise")          # ["pomme", "banane", "cerise"]

# Insérer à une position donnée
fruits.insert(1, "orange")       # ["pomme", "orange", "banane", "cerise"]

# Supprimer par valeur
fruits.remove("banane")          # ["pomme", "orange", "cerise"]

# Supprimer par indice
del fruits[0]                    # ["orange", "cerise"]

# Supprimer et récupérer le dernier élément
dernier = fruits.pop()           # dernier = "cerise", fruits = ["orange"]

8.3. Parcourir une liste

notes = [15, 12, 18, 9, 14]

# Calculer la moyenne
total = 0
for note in notes:
    total += note
moyenne = total / len(notes)
print(f"Moyenne : {moyenne}")

# Variante avec sum() (fonction intégrée)
moyenne = sum(notes) / len(notes)

8.4. Quelques fonctions et méthodes utiles

nombres = [3, 1, 4, 1, 5, 9, 2, 6]

len(nombres)          # 8     (nombre d'éléments)
min(nombres)          # 1     (plus petit élément)
max(nombres)          # 9     (plus grand élément)
sum(nombres)          # 31    (somme de tous les éléments)
sorted(nombres)       # [1, 1, 2, 3, 4, 5, 6, 9]  (nouvelle liste triée)
nombres.sort()        # trie la liste en place (modifie nombres)
nombres.count(1)      # 2     (nombre d'occurrences de 1)
3 in nombres          # True  (teste si 3 est dans la liste)

9. Les erreurs en Python - Guide complet

Apprendre à lire et comprendre les messages d'erreur est une compétence essentielle. Python affiche toujours un message qui indique :

Où l'erreur s'est produite (numéro de ligne)
Quel type d'erreur c'est
Un message explicatif

9.1. Lire un message d'erreur (traceback)

Traceback (most recent call last):
  File "mon_programme.py", line 3, in <module>
    print(age + " ans")
          ~~~~^~~~~~~~
TypeError: unsupported operand type(s) for +: 'int' and 'str'

Ligne 1 : début du traceback (remontée de l'erreur)
Ligne 2 : fichier et numéro de ligne concernés
Ligne 3 : la ligne de code fautive
Ligne 4 : une flèche pointant vers l'endroit exact de l'erreur
Ligne 5 : le type d'erreur et son explication

9.2. Les erreurs de syntaxe - `SyntaxError`

Python ne peut même pas démarrer l'exécution du programme car le code est mal écrit :

# ❌ Oubli du deux-points
if age >= 18
    print("Majeur")
# SyntaxError: expected ':'

# ❌ Oubli d'une parenthèse fermante
print("Bonjour"
# SyntaxError: '(' was never closed

# ❌ Oubli d'un guillemet fermant
nom = "Alice
# SyntaxError: unterminated string literal

# ❌ Utilisation d'un mot réservé comme variable
class = "2nde B"
# SyntaxError: invalid syntax

# ❌ Oubli du = dans une affectation
if age = 18:
# SyntaxError: invalid syntax. Maybe you meant '==' or ':='?

9.3. Les erreurs d'indentation - `IndentationError`

# ❌ Bloc non indenté
if True:
print("Bonjour")
# IndentationError: expected an indented block after 'if' statement

# ❌ Indentation inattendue
x = 5
    y = 10
# IndentationError: unexpected indent

# ❌ Mélange tabulations et espaces (très sournois !)
if True:
  print("tab")     # tabulé
    print("espaces") # 4 espaces
# IndentationError: unindent does not match any outer indentation level

9.4. Les erreurs de nom - `NameError`

La variable ou la fonction n'existe pas dans le contexte actuel :

# ❌ Variable pas encore définie
print(resultat)
# NameError: name 'resultat' is not defined

# ❌ Faute de frappe
age_eleve = 16
print(age_elve)    # 'elve' au lieu de 'eleve'
# NameError: name 'age_elve' is not defined

# ❌ Oubli des guillemets autour d'un texte
print(Bonjour)
# NameError: name 'Bonjour' is not defined

# ❌ Variable locale utilisée hors de la fonction
def ma_fonction():
    resultat = 42
ma_fonction()
print(resultat)
# NameError: name 'resultat' is not defined

9.5. Les erreurs de type - `TypeError`

On essaie de faire une opération incompatible avec le type des données :

# ❌ Additionner un nombre et une chaîne
print(5 + "3")
# TypeError: unsupported operand type(s) for +: 'int' and 'str'

# ❌ Concaténer un nombre à une chaîne
print("J'ai " + 16 + " ans")
# TypeError: can only concatenate str (not "int") to str

# ❌ Multiplier deux chaînes
print("abc" * "def")
# TypeError: can't multiply sequence by non-int of type 'str'

# ❌ Appeler quelque chose qui n'est pas une fonction
x = 5
x()
# TypeError: 'int' object is not callable

# ❌ Utiliser len() sur un nombre
len(42)
# TypeError: object of type 'int' has no len()

9.6. Les erreurs de valeur - `ValueError`

La valeur n'est pas adaptée, même si le type est correct :

# ❌ Convertir un texte en nombre
int("abc")
# ValueError: invalid literal for int() with base 10: 'abc'

# ❌ Convertir un décimal en int directement
int("3.14")
# ValueError: invalid literal for int() with base 10: '3.14'

# ❌ Chercher un élément absent d'une liste
[1, 2, 3].index(5)
# ValueError: 5 is not in list

9.7. Les erreurs d'indice - `IndexError`

On accède à un indice qui n'existe pas :

notes = [15, 12, 18]

notes[3]
# IndexError: list index out of range
# Les indices valides sont 0, 1, 2 (ou -1, -2, -3)

notes[10]
# IndexError: list index out of range

# ❌ Erreur classique avec range
for i in range(len(notes) + 1):   # range va jusqu'à 3, mais l'indice 3 n'existe pas
    print(notes[i])
# IndexError: list index out of range

9.8. La division par zéro - `ZeroDivisionError`

print(10 / 0)
# ZeroDivisionError: division by zero

print(10 // 0)
# ZeroDivisionError: integer division or modulo by zero

print(10 % 0)
# ZeroDivisionError: integer division or modulo by zero

9.9. Tableau récapitulatif des erreurs

Erreur	Cause courante	Comment corriger
`SyntaxError`	Oubli de `:`, parenthèse, guillemet	Relire la ligne indiquée, vérifier la ponctuation
`IndentationError`	Mauvaise indentation ou mélange tab/espaces	Aligner les blocs à 4 espaces
`NameError`	Variable inexistante, faute de frappe, oubli de `""`	Vérifier le nom, l'ordre des instructions
`TypeError`	Opération entre types incompatibles	Convertir avec `int()`, `float()`, `str()`
`ValueError`	Conversion impossible (`int("abc")`)	Vérifier la valeur avant de convertir
`IndexError`	Indice hors limites d'une liste	Vérifier `len()` et les bornes de `range()`
`ZeroDivisionError`	Division par zéro	Tester `if diviseur != 0` avant de diviser

10. Plusieurs façons de faire la même chose

En programmation, il existe souvent plusieurs approches pour résoudre un même problème. Voici les plus courantes.

10.1. Construire une chaîne de caractères

nom = "Alice"
age = 16

# Méthode 1 : concaténation avec +
message = "Je m'appelle " + nom + " et j'ai " + str(age) + " ans."

# Méthode 2 : virgules dans print()
print("Je m'appelle", nom, "et j'ai", age, "ans.")

# Méthode 3 : f-string (recommandée ✅)
message = f"Je m'appelle {nom} et j'ai {age} ans."

# Méthode 4 : .format()
message = "Je m'appelle {} et j'ai {} ans.".format(nom, age)

10.2. Tester si un élément est dans une collection

voyelles = "aeiouy"
lettre = "e"

# Méthode 1 : avec in (recommandée ✅)
if lettre in voyelles:
    print("C'est une voyelle")

# Méthode 2 : avec une boucle
est_voyelle = False
for v in voyelles:
    if lettre == v:
        est_voyelle = True
if est_voyelle:
    print("C'est une voyelle")

# Méthode 3 : avec or (fastidieux mais explicite)
if lettre == "a" or lettre == "e" or lettre == "i":
    print("C'est une voyelle")

10.3. Calculer une somme

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

# Méthode 1 : boucle for avec accumulateur
total = 0
for n in nombres:
    total += n

# Méthode 2 : fonction intégrée sum() (recommandée ✅)
total = sum(nombres)

# Méthode 3 : boucle while
total = 0
i = 0
while i < len(nombres):
    total += nombres[i]
    i += 1

10.4. Créer une liste de nombres

# Méthode 1 : boucle for avec append
carres = []
for i in range(1, 6):
    carres.append(i ** 2)
# [1, 4, 9, 16, 25]

# Méthode 2 : compréhension de liste (plus avancé, très « pythonique »)
carres = [i ** 2 for i in range(1, 6)]
# [1, 4, 9, 16, 25]

# Méthode 3 : avec list() et range()
nombres = list(range(1, 11))
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

10.5. Échanger deux variables

a, b = 10, 20

# Méthode 1 : variable temporaire (classique, universelle)
temp = a
a = b
b = temp

# Méthode 2 : affectation multiple Python (recommandée ✅)
a, b = b, a

# Méthode 3 : arithmétique (sans variable supplémentaire, pour les curieux)
a = a + b    # a = 30
b = a - b    # b = 10
a = a - b    # a = 20

10.6. Lire une entrée utilisateur et la valider

# Méthode 1 : saisie + boucle while
note = float(input("Note (0-20) : "))
while not (0 <= note <= 20):
    note = float(input("Invalide. Note (0-20) : "))

# Méthode 2 : while True + break
while True:
    note = float(input("Note (0-20) : "))
    if 0 <= note <= 20:
        break
    print("Invalide, recommencez.")

# Méthode 3 : avec une fonction
def saisir_note():
    while True:
        note = float(input("Note (0-20) : "))
        if 0 <= note <= 20:
            return note
        print("Invalide, recommencez.")

note = saisir_note()

11. Bonnes pratiques et conseils

12. Tableau récapitulatif complet

Notion	Syntaxe	Ce qu'il faut retenir
Variable	`x = 42`	Espace mémoire nommé qui stocke une valeur
Affectation	`x = valeur`	Le `=` stocke la valeur de droite dans la variable
Affectation augmentée	`x += 3`	Raccourci pour `x = x + 3`
Types	`int`, `float`, `str`, `bool`	Entier, décimal, texte, booléen
Conversion	`int()`, `float()`, `str()`	Change le type d'une valeur
Séquence	-	Les instructions s'exécutent de haut en bas
`if / elif / else`	`if cond:`	Exécute un bloc selon qu'une condition est vraie ou fausse
Comparaison	`==`, `!=`, `<`, `>`, `<=`, `>=`	Renvoie `True` ou `False`
Logique	`and`, `or`, `not`	Combine des conditions
`for`	`for i in range(n):`	Boucle bornée, nombre de répétitions connu
`while`	`while cond:`	Boucle non bornée, répète tant que la condition est vraie
`break`	`break`	Sort immédiatement de la boucle
`continue`	`continue`	Passe directement au tour suivant
Fonction	`def nom(params):`	Bloc de code réutilisable
`return`	`return valeur`	Renvoie un résultat depuis une fonction
Liste	`[1, 2, 3]`	Collection ordonnée et modifiable de valeurs
`input()`	`input("message")`	Lit une saisie (renvoie toujours un `str`)
`print()`	`print(valeurs)`	Affiche des valeurs à l'écran
f-string	`f"texte {var}"`	Insère des variables dans du texte