🐍
Les instructions essentielles de Python
Fiche de référence, classe de 5e
Cette fiche rassemble les instructions Python les plus utilisées, regroupées en six parties qui vont du plus simple au plus élaboré. Chaque instruction est présentée avec son rôle, un exemple de code et ce que ce code affiche à l’écran. Tous les résultats reproduits ici ont été obtenus en exécutant réellement les exemples. Dans le code, les couleurs aident à la lecture : les mots réservés du langage apparaissent en violet, les fonctions de base en bleu, les textes en vert et les commentaires, précédés du signe #, en gris. Les exemples fonctionnent avec Python 3.10 et les versions suivantes.
- 👣 Premiers pas
- 🧮 Nombres, textes et calculs
- 🔀 Décider
- 🔁 Répéter
- 🗂️ Ranger des données
- 🧰 Organiser son programme
Un programme est une suite d’instructions que l’ordinateur exécute dans l’ordre, de la première ligne à la dernière. Trois instructions suffisent déjà à écrire un programme complet : afficher un message, commenter son code et ranger une valeur dans une variable.
print() : afficher
La fonction print() affiche à l’écran ce qui est placé entre ses parenthèses : un texte entre guillemets, un nombre ou le contenu d’une variable. Plusieurs éléments, séparés par des virgules dans le code, s’affichent sur la même ligne avec une espace entre eux. Le paramètre sep remplace cette espace par un autre séparateur, et le paramètre end remplace le retour à la ligne final par ce que tu choisis.
Le code
print("Bonjour !")
print("Nombre de chats :", 3)
print("12", "05", "2026", sep="/")
print("Trois, deux, un,", end=" ")
print("partez !")Ce qui s’affiche
Bonjour !
Nombre de chats : 3
12/05/2026
Trois, deux, un, partez !
# : commenter
Python ignore tout ce qui suit le signe # sur une ligne. Le commentaire s’adresse au lecteur humain : il explique ce que fait le code, ou pourquoi il le fait. Il permet aussi de neutraliser une ligne sans l’effacer, ce qui est commode pour chercher une erreur.
Le code
# Ce programme salue l'utilisateur
print("Salut") # affiche un salut
# print("Cette ligne n'est pas exécutée")
= : ranger une valeur dans une variable
Une variable est un nom qui désigne une valeur conservée dans la mémoire de l’ordinateur. Le signe = n’a pas ici le sens mathématique de l’égalité : il ordonne de ranger la valeur de droite sous le nom de gauche. Voilà pourquoi age = age + 1 a un sens en Python : l’ordinateur calcule d’abord age + 1 avec l’ancienne valeur, puis range le résultat sous le nom age. L’écriture raccourcie age += 1 produit le même effet. Un nom de variable commence par une lettre ou par un tiret bas (_) et ne contient ni espace ni trait d’union, car Python le prendrait pour un signe moins. Python distingue les majuscules des minuscules : age et Age sont deux variables différentes. Les lettres accentuées sont acceptées, mais l’usage est de les éviter dans les noms.
Le code
age = 12
print(age)
age = age + 1 # l'anniversaire est passé
print(age)
age += 1 # même effet, écriture raccourcie
print(age)
prenom = "Léa"
print(prenom)
Ce qui s’affiche
12
13
14
Léa
🧮Partie 2
Nombres, textes et calculs
Une valeur n’est pas seulement un contenu : elle possède un type, qui détermine ce que Python accepte d’en faire. Additionner deux nombres a un sens, additionner un nombre et un texte n’en a pas. Cette partie présente les types de base, les calculs, les conversions, puis la saisie au clavier et l’affichage mis en forme.
type() : les quatre types de base
Le type int regroupe les nombres entiers et le type float les nombres à virgule, que Python écrit avec un point à la manière anglaise (3.5). Le type str correspond aux chaînes de caractères, c’est-à-dire les textes, écrits entre guillemets. Le type bool, enfin, est celui des booléens, qui ne prennent que deux valeurs : True (vrai) et False (faux), avec une majuscule. La fonction type() indique le type d’une valeur. Attention au piège : "12", entre guillemets, est un texte et non un nombre.
Le code
print(type(12))
print(type(3.5))
print(type("chat"))
print(type(True))
print(type("12")) # des guillemets : c'est un texteCe qui s’affiche
<class 'int'>
<class 'float'>
<class 'str'>
<class 'bool'>
<class 'str'>
+ - * / // % ** : calculer
Les quatre opérations s’écrivent +, -, * et /. La division / donne un nombre à virgule, même quand elle tombe juste. Pour la division euclidienne, // fournit le quotient entier et % le reste. L’opérateur ** calcule une puissance. Les priorités sont celles des mathématiques, et les parenthèses permettent de les modifier. Deux nuances méritent d’être connues. D’une part, // arrondit vers le bas : -7 // 2 vaut donc -4 et non -3. D’autre part, les nombres à virgule sont stockés de façon approchée, si bien que 0.1 + 0.2 ne donne pas tout à fait 0.3. Enfin, + colle deux textes bout à bout et * répète un texte.
Le code
print(17 + 5, 17 - 5, 17 * 5)
print(17 / 5)
print(10 / 2) # nombre à virgule
print(17 // 5) # quotient entier
print(17 % 5) # reste
print(-7 // 2) # arrondi vers le bas
print(2 ** 10) # 2 puissance 10
print(2 + 3 * 4) # multiplication d'abord
print((2 + 3) * 4)
print(0.1 + 0.2) # valeur approchée
print("pom" + "me")
print("ha" * 3)Ce qui s’affiche
22 12 85
3.4
5.0
3
2
-4
1024
14
20
0.30000000000000004
pomme
hahaha
int(), float(), str(), round() : convertir
Python refuse de mélanger les types de lui-même : "12" + 1 provoque une erreur. Les fonctions de conversion règlent ce problème. int() transforme en entier, float() en nombre à virgule et str() en texte. Attention : appliquée à un nombre à virgule, int() supprime la partie décimale sans arrondir. La fonction round(), elle, renvoie l’entier le plus proche, ou le nombre de décimales demandé en second argument. Dans le cas d’un demi, Python choisit l’entier pair : round(2.5) vaut 2 et round(3.5) vaut 4. Enfin, int("douze") provoque une erreur, car le texte ne contient pas de chiffres ; la sixième partie montre comment la gérer.
Le code
print(int("15") + 1)
print(float("2.5") * 2)
print(str(12) + " ans")
print(int(3.9)) # partie décimale supprimée
print(round(3.9)) # entier le plus proche
print(round(2.5), round(3.5)) # demi : entier pair
print(round(3.14159, 2)) # deux décimalesCe qui s’affiche
16
5.0
12 ans
3
4
2 4
3.14
input() : demander une réponse au clavier
La fonction input() affiche une question, attend que l’utilisateur tape sa réponse et appuie sur Entrée, puis renvoie le texte saisi. Point capital : ce texte reste une chaîne de caractères, même lorsque l’utilisateur tape un nombre. Pour calculer, il faut donc le convertir avec int() ou float(). Dans l’encadré « Ce qui s’affiche », les saisies au clavier apparaissent soulignées.
Le code
prenom = input("Quel est ton prénom ? ")
naissance = int(input("Ton année de naissance ? "))
print("Bonjour", prenom)
print("En 2030, tu fêteras tes", 2030 - naissance, "ans.")Ce qui s’affiche
Quel est ton prénom ? Léa
Ton année de naissance ? 2014
Bonjour Léa
En 2030, tu fêteras tes 16 ans.
f"..." : mettre en forme un affichage
Une chaîne précédée de la lettre f est une chaîne formatée. Python y remplace chaque expression écrite entre accolades par sa valeur, ce qui évite d’enchaîner les virgules et les conversions. Entre les accolades peut aussi figurer un calcul. Après un deux-points, une indication de format règle l’affichage : :.2f affiche un nombre à virgule avec deux décimales, en l’arrondissant.
Le code
prenom = "Léa"
age = 12
moyenne = 44 / 3
print(f"{prenom} a {age} ans.")
print(f"Dans 5 ans, elle aura {age + 5} ans.")
print(f"Moyenne : {moyenne}")
print(f"Moyenne arrondie : {moyenne:.2f}")Ce qui s’affiche
Léa a 12 ans.
Dans 5 ans, elle aura 17 ans.
Moyenne : 14.666666666666666
Moyenne arrondie : 14.67
Un programme utile ne fait pas la même chose dans toutes les situations : il examine les données et choisit sa route. Pour cela, il pose des questions dont la réponse est vraie ou fausse, puis exécute tel ou tel bloc d’instructions selon la réponse.
== != < > <= >= : comparer
Une comparaison produit un booléen, True ou False. Le signe == teste l’égalité et != la différence ; <= et >= signifient « inférieur ou égal » et « supérieur ou égal ». L’erreur la plus fréquente consiste à écrire =, qui range une valeur, au lieu de ==, qui compare. Pour les textes, Python distingue les majuscules des minuscules.
Le code
note = 14
print(note == 14)
print(note != 14)
print(note > 10)
print(note <= 12)
print("chat" == "Chat") # majuscule différente
print(3 == 3.0) # même valeurCe qui s’affiche
True
False
True
False
False
True
if, elif, else : choisir
Python teste les conditions dans l’ordre, exécute le bloc de la première condition vraie, puis passe directement à la suite du programme sans examiner les suivantes. C’est pourquoi une note de 13, qui est aussi supérieure à 10, n’affiche que « Bien ». Le bloc else, facultatif, s’exécute lorsque toutes les conditions précédentes sont fausses. Les deux-points en fin de ligne et le décalage vers la droite des lignes suivantes, appelé indentation, sont obligatoires : c’est ainsi que Python sait quelles instructions appartiennent au bloc. L’usage est de décaler de quatre espaces.
Le code
note = 13
if note >= 16:
print("Très bien")
elif note >= 12:
print("Bien")
elif note >= 10:
print("Passable")
else:
print("Insuffisant")
print("Fin du bulletin") # hors du blocCe qui s’affiche
Bien
Fin du bulletin
and, or, not : combiner des conditions
Le mot and exige que les deux comparaisons soient vraies, tandis que or se contente d’une seule. Le mot not inverse une condition. Le tableau ci-dessous résume le fonctionnement de and et de or.
| Condition A | Condition B | A and B | A or B |
|---|
| vraie | vraie | vraie | vraie |
| vraie | fausse | fausse | vraie |
| fausse | vraie | fausse | vraie |
| fausse | fausse | fausse | fausse |
Le code
age = 11
taille = 138 # en centimètres
print(age >= 10 and taille >= 140)
print(age >= 10 or taille >= 140)
print(not age >= 10)
if age >= 10 and taille >= 140:
print("Tu peux monter dans le manège.")
else:
print("Pas encore, reviens l'an prochain !")Ce qui s’affiche
False
True
False
Pas encore, reviens l'an prochain !
L’ordinateur excelle dans ce que l’être humain trouve fastidieux : refaire la même tâche des centaines de fois sans se tromper. Une boucle répète un bloc d’instructions, soit un nombre de fois connu à l’avance, soit tant qu’une condition reste vraie.
for et range() : répéter un nombre de fois connu
La boucle for donne successivement à une variable chacune des valeurs d’une séquence, et exécute son bloc à chaque tour. La fonction range(n) produit les entiers de 0 à n - 1 : la borne de fin est exclue, ce qui surprend souvent. range(debut, fin) commence à debut, et range(debut, fin, pas) avance de pas en pas. La boucle for sait aussi parcourir directement les lettres d’un texte, ou les éléments d’une liste (voir la cinquième partie).
Le code
for i in range(4):
print(i, end=" ")
print() # retour à la ligne
for i in range(1, 4):
print(i, "x 7 =", i * 7)
for i in range(0, 21, 5):
print(i, end=" ")
print()
for lettre in "chat":
print(lettre.upper(), end=" ")
print()Ce qui s’affiche
0 1 2 3
1 x 7 = 7
2 x 7 = 14
3 x 7 = 21
0 5 10 15 20
C H A T
while : répéter tant qu’une condition est vraie
La boucle while répète son bloc tant que sa condition reste vraie. Elle convient lorsque le nombre de tours n’est pas connu à l’avance, comme dans le second exemple, où le nombre de semaines d’économies est justement ce que le programme cherche. Attention : si rien dans le bloc ne finit par rendre la condition fausse, la boucle tourne sans fin. Dans la plupart des environnements, la combinaison de touches Ctrl + C interrompt alors le programme.
Le code
compte = 3
while compte > 0:
print(compte)
compte -= 1
print("Décollage !")
epargne = 0
semaines = 0
while epargne < 20:
epargne += 3 # 3 euros par semaine
semaines += 1
print(f"{semaines} semaines, {epargne} euros.")Ce qui s’affiche
3
2
1
Décollage !
7 semaines, 21 euros.
break et continue : sortir ou sauter un tour
L’instruction break arrête immédiatement la boucle, même si des tours restaient prévus : elle sert à stopper une recherche dès que la réponse est trouvée. L’instruction continue abandonne seulement le tour en cours et passe directement au suivant. Dans le second exemple, les nombres pairs n’atteignent pas la ligne print().
Le code
for n in range(1, 10):
if n % 4 == 0:
print("Premier multiple de 4 :", n)
break
for n in range(1, 8):
if n % 2 == 0:
continue # les pairs sont sautés
print(n, end=" ")
print()Ce qui s’affiche
Premier multiple de 4 : 4
1 3 5 7
🗂️Partie 5
Ranger des données
Une variable ne contient qu’une valeur. Pour une liste de courses, les notes d’un trimestre ou la fiche d’un animal, Python propose des structures qui rassemblent plusieurs valeurs sous un seul nom. Cette partie présente les deux plus utilisées, la liste et le dictionnaire, puis les outils qui servent à travailler les textes.
Les listes : [ ], append(), len()
Une liste range plusieurs valeurs dans un ordre précis, entre crochets et séparées par des virgules. Chaque élément occupe une position numérotée, appelée indice : le premier porte l’indice 0, et -1 désigne le dernier. Demander une position qui n’existe pas provoque une erreur. La fonction len() compte les éléments, la méthode append() en ajoute un à la fin, et l’écriture liste[1] = ... remplace un élément. Une tranche liste[debut:fin] extrait une partie de la liste, la borne de fin étant exclue comme dans range(). Le mot in teste si un élément est présent. Pour une liste de nombres, sum(), min() et max() donnent la somme, le plus petit et le plus grand élément.
Le code
courses = ["pain", "lait", "œufs"]
print(courses[0], courses[-1])
courses.append("pommes")
print(courses)
print(len(courses))
print(courses[1:3]) # indices 1 et 2
courses[1] = "beurre"
print("pain" in courses)
for article in courses:
print("-", article)
notes = [12, 15, 9, 17]
print(sum(notes), min(notes), max(notes))
print(sum(notes) / len(notes)) # moyenneCe qui s’affiche
pain œufs
['pain', 'lait', 'œufs', 'pommes']
4
['lait', 'œufs']
True
- pain
- beurre
- œufs
- pommes
53 9 17
13.25
Les dictionnaires : { }, get(), items()
Un dictionnaire associe des clés à des valeurs, entre accolades, de la même façon qu’un dictionnaire imprimé associe un mot à sa définition. Une valeur se retrouve par sa clé, et non par une position. Affecter une valeur à une clé nouvelle l’ajoute ; l’affecter à une clé existante la remplace. Demander une clé absente provoque une erreur, que la méthode get() évite en renvoyant une valeur par défaut. La méthode items() permet de parcourir les couples clé-valeur avec une boucle for. Depuis la version 3.7 de Python, un dictionnaire conserve l’ordre dans lequel les clés ont été ajoutées.
Le code
animal = {"nom": "Rex", "espèce": "chien", "pattes": 4}
print(animal["nom"])
animal["âge"] = 5 # nouvelle clé
animal["nom"] = "Médor" # clé existante
print(animal)
print(animal.get("couleur", "inconnue"))
print("espèce" in animal)
for cle, valeur in animal.items():
print(cle, ":", valeur)Ce qui s’affiche
Rex
{'nom': 'Médor', 'espèce': 'chien', 'pattes': 4, 'âge': 5}
inconnue
True
nom : Médor
espèce : chien
pattes : 4
âge : 5
Les textes : strip(), upper(), replace(), split(), join()
Une chaîne de caractères se travaille avec des méthodes, écrites après un point. strip() retire les espaces au début et à la fin, upper() et lower() passent en majuscules ou en minuscules, et replace() remplace un morceau de texte par un autre. split() découpe un texte en liste de mots, et join() fait l’inverse en recollant une liste avec le séparateur choisi. Comme une liste, un texte possède une longueur et des indices. Nuance essentielle : un texte ne se modifie pas. Chaque méthode renvoie un nouveau texte, qu’il faut ranger dans une variable pour le conserver, et la variable de départ reste intacte.
Le code
phrase = " le chat dort "
propre = phrase.strip()
print(propre)
print(propre.upper())
print("BONJOUR".lower())
print(propre.replace("chat", "chien"))
mots = propre.split()
print(mots)
print("-".join(mots))
print(len(propre), propre[3])
print(f"[{phrase}]") # l'original est intactCe qui s’affiche
le chat dort
LE CHAT DORT
bonjour
le chien dort
['le', 'chat', 'dort']
le-chat-dort
12 c
[ le chat dort ]
🧰Partie 6
Organiser son programme
Dès qu’un programme grandit, il faut l’organiser : regrouper les instructions en fonctions réutilisables, emprunter des outils déjà écrits, prévoir les erreurs et conserver les résultats dans des fichiers.
def et return : créer une fonction
Le mot def crée une fonction, c’est-à-dire un bloc d’instructions nommé que le programme peut appeler autant de fois que nécessaire. Les paramètres, écrits entre parenthèses, reçoivent les valeurs transmises lors de l’appel, appelées arguments. Le mot return renvoie un résultat à l’endroit de l’appel et termine la fonction. La nuance entre les deux fonctions de l’exemple est capitale : print() affiche une valeur sans la renvoyer, si bien que cette valeur ne peut pas servir dans un calcul. Une fonction dépourvue de return renvoie la valeur spéciale None, qui signifie « rien ». Une fonction doit être définie avant son premier appel.
Le code
def aire_rectangle(longueur, largeur):
return longueur * largeur
def saluer(prenom):
print(f"Bonjour {prenom} !")
a = aire_rectangle(5, 3)
print(a)
print(aire_rectangle(2, 4) + 10)
saluer("Tom")
resultat = saluer("Inès")
print(resultat)Ce qui s’affiche
15
18
Bonjour Tom !
Bonjour Inès !
None
import : utiliser un module
Python est livré avec de nombreux modules, des bibliothèques d’outils prêts à l’emploi. L’instruction import charge un module ; ses fonctions s’écrivent ensuite avec le nom du module, un point et le nom de la fonction. Le module math fournit les outils mathématiques, comme la racine carrée ou la constante pi, et le module random, le hasard. La forme from math import floor ne charge que la fonction nommée, qui s’utilise alors sans préfixe. Les tirages changent à chaque exécution : ceux qui figurent ici ne sont qu’un exemple.
Le code
import math
import random
print(math.sqrt(49)) # racine carrée
print(math.pi)
print(round(math.pi, 2))
tirage = random.randint(1, 6) # de 1 à 6 inclus
print("Le dé indique", tirage)
print(random.choice(["pile", "face"]))
from math import floor
print(floor(7.8)) # arrondi vers le basUn affichage possible
7.0
3.141592653589793
3.14
Le dé indique 3
pile
7
try et except : prévoir une erreur
Certaines instructions échouent en cours de route : conversion impossible, division par zéro, clé absente d’un dictionnaire. Python appelle ces erreurs des exceptions. Sans précaution, le programme s’arrête net et affiche un message d’erreur. Le bloc try tente d’exécuter ses instructions ; si une exception du type indiqué survient, Python abandonne le bloc try et exécute le bloc except au lieu de s’arrêter. Il vaut mieux nommer l’erreur attendue, comme ValueError ou ZeroDivisionError, plutôt que d’intercepter toutes les erreurs, afin de ne pas masquer un autre problème. Dans le premier exemple, la ligne qui suit int(texte) n’est pas exécutée.
Le code
texte = "douze"
try:
nombre = int(texte)
print("Nombre lu :", nombre)
except ValueError:
print("Ce texte n'est pas un nombre.")
try:
print(10 / 0)
except ZeroDivisionError:
print("Division par zéro impossible.")Ce qui s’affiche
Ce texte n'est pas un nombre.
Division par zéro impossible.
with open() : écrire et lire un fichier
La fonction open() ouvre un fichier selon un mode : "r" pour lire (mode choisi si rien n’est précisé), "w" pour écrire et "a" pour ajouter à la fin. Attention : le mode "w" efface le contenu d’un fichier qui existe déjà. Le bloc with referme le fichier à la fin du bloc, même si une erreur survient. L’indication encoding="utf-8" garantit que les lettres accentuées sont lues comme elles ont été écrites. La méthode write() n’ajoute pas de retour à la ligne : il faut écrire soi-même le caractère spécial \n. Pour lire, une boucle for parcourt le fichier ligne par ligne, et read() renvoie tout le contenu d’un coup.
Le code
with open("courses.txt", "w", encoding="utf-8") as f:
f.write("pain\n")
f.write("lait\n")
with open("courses.txt", "a", encoding="utf-8") as f:
f.write("œufs\n")
with open("courses.txt", "r", encoding="utf-8") as f:
for ligne in f:
print(ligne.strip())
with open("courses.txt", encoding="utf-8") as f:
contenu = f.read()
print(contenu.split())Ce qui s’affiche
pain
lait
œufs
['pain', 'lait', 'œufs']