Chapitre 01 — Variables, types et opérateurs¶

⏱️ Durée estimée : 4 à 5 heures

📋 Prérequis : Chapitre 00 — Installer Python et son environnement de travail : savoir créer et exécuter un script .py, et utiliser l'interpréteur interactif.

🎯 Objectifs — À la fin de ce chapitre, tu sauras : - créer des variables, leur donner de bons noms et modifier leur valeur ; - reconnaître les quatre types de base : int, float, str et bool ; - faire des calculs avec tous les opérateurs arithmétiques, y compris //, % et ** ; - dialoguer avec l'utilisateur grâce à input() et print() ; - convertir une valeur d'un type à un autre (int(), float(), str()) ; - produire des affichages propres et bien formatés avec les f-strings.

Cours¶

1. Les variables : donner un nom à une valeur¶

Au chapitre précédent, dans l'exercice de la facture, on recopiait les mêmes nombres plusieurs fois. Si le prix changeait, il fallait le modifier partout. Les variables règlent ce problème.

Une variable, c'est un nom qui désigne une valeur. Imagine une étiquette que tu colles sur un objet : l'étiquette « prix_cahier » est collée sur le nombre 2.5. Quand tu écris prix_cahier dans ton code, Python va chercher la valeur qui porte cette étiquette.

prix_cahier = 2.5
quantite = 4
total = prix_cahier * quantite
print(total)

Sortie :

10.0

Le signe = s'appelle l'opérateur d'affectation. Attention, il ne signifie pas « est égal à » comme en maths ! Il se lit de droite à gauche : « calcule ce qui est à droite, puis colle l'étiquette de gauche sur le résultat ».

age = 30          # la variable age désigne 30
age = age + 1     # on calcule age + 1 (= 31), puis age désigne 31
print(age)

Sortie :

En maths, age = age + 1 serait absurde. En Python, c'est parfaitement normal : on met à jour la variable.

1.1. Réaffecter une variable¶

Une variable peut changer de valeur autant de fois que tu veux. Seule la dernière affectation compte :

meteo = "soleil"
print(meteo)
meteo = "pluie"
print(meteo)

Sortie :

soleil
pluie

1.2. Une variable doit exister avant d'être utilisée¶

Python lit ton code de haut en bas. Si tu utilises un nom avant de l'avoir créé, il ne le connaît pas encore :

print(prenom)
prenom = "Camille"

Traceback (most recent call last):
  File "variables.py", line 1, in <module>
    print(prenom)
          ^^^^^^
NameError: name 'prenom' is not defined

1.3. Bien nommer ses variables¶

Les règles obligatoires (sinon, erreur) :

un nom contient uniquement des lettres, des chiffres et le caractère _ (tiret bas, ou underscore) ;
il ne commence pas par un chiffre (2nom est interdit, nom2 est autorisé) ;
il ne contient pas d'espace (mon nom est interdit) ;
il n'est pas un mot réservé de Python, comme if, for, while, True, class, def, import…
les majuscules comptent : age, Age et AGE sont trois variables différentes.

Les conventions (pas obligatoires, mais suivies par tous les programmeurs Python, voir la PEP 8 au chapitre 13) :

tout en minuscules, mots séparés par des _ : prix_total, nombre_eleves. C'est le style snake_case (« style serpent ») ;
des noms parlants : prix_total plutôt que pt ou x ;
dans ce cours, des noms en français sans accents : annee plutôt que année. (Python accepte les accents dans les noms, mais ils compliquent la vie quand on partage son code.)

# ✅ Bons noms
prix_total = 13.6
nombre_eleves = 28
age_minimum = 18

# ❌ Mauvais noms (autorisés, mais à éviter)
x = 13.6            # que représente x ?
NombreEleves = 28   # pas le style Python pour une variable
a_m = 18            # abréviation obscure

1.4. Affectations multiples¶

Python permet d'affecter plusieurs variables d'un coup :

largeur, hauteur = 1920, 1080
print(largeur, hauteur)

a = b = 0   # a et b valent toutes les deux 0
print(a, b)

Sortie :

1920 1080
0 0

Et voici une astuce célèbre : échanger deux variables en une ligne.

gauche = "chat"
droite = "chien"
gauche, droite = droite, gauche
print(gauche, droite)

Sortie :

chien chat

2. Les types de base¶

Chaque valeur en Python a un type, c'est-à-dire une nature : un nombre entier, un texte, etc. Le type détermine ce qu'on peut faire avec la valeur. On ne fait pas les mêmes opérations avec un prix qu'avec un prénom.

Les quatre types de base à connaître :

Type	Nom complet	Exemples	Sert à représenter
`int`	integer (entier)	`42`, `-7`, `0`, `1_000_000`	des quantités entières, des compteurs
`float`	floating point (nombre à virgule)	`3.14`, `-0.5`, `2.0`, `1e3`	des mesures, des prix, des moyennes
`str`	string (chaîne de caractères)	`"Bonjour"`, `'A'`, `""`, `"42"`	du texte
`bool`	boolean (booléen)	`True`, `False`	une réponse oui/non

La fonction type() te dit de quel type est une valeur :

print(type(42))
print(type(3.14))
print(type("Bonjour"))
print(type(True))
print(type("42"))

Sortie :

<class 'int'>
<class 'float'>
<class 'str'>
<class 'bool'>
<class 'str'>

Remarque la dernière ligne : "42" entre guillemets est du texte, pas un nombre ! C'est une source d'erreurs très fréquente, on y reviendra avec input().

2.1. Les entiers (`int`)¶

Les entiers n'ont pas de limite de taille en Python. Pour les grands nombres, tu peux utiliser _ comme séparateur de milliers, Python l'ignore :

population_france = 68_000_000
grains_de_riz = 2 ** 64
print(population_france)
print(grains_de_riz)

Sortie :

68000000
18446744073709551616

2.2. Les nombres à virgule (`float`)¶

On les écrit avec un point décimal. Un nombre comme 2.0 est un float, même s'il « tombe juste ». L'écriture 1e3 signifie 1 × 10³, soit 1000.0.

Les floats ont une petite particularité : l'ordinateur les stocke en binaire, ce qui provoque parfois de minuscules imprécisions.

print(0.1 + 0.2)
print(3 * 1.2)

Sortie :

0.30000000000000004
3.5999999999999996

Ce n'est pas un bug de Python : c'est pareil dans presque tous les langages. C'est comme essayer d'écrire 1/3 en décimal : 0,3333… on doit bien s'arrêter quelque part. La solution pour l'affichage : arrondir, avec round() ou avec les f-strings (section 8).

print(round(0.1 + 0.2, 2))   # arrondi à 2 chiffres après la virgule
print(round(3.14159, 3))
print(round(7.6))            # sans 2e argument : arrondi à l'entier

Sortie :

0.3
3.142
8

2.3. Les chaînes de caractères (`str`)¶

Une chaîne est une suite de caractères entre guillemets simples '...' ou doubles "...". On verra leurs nombreux outils au chapitre 06 ; pour l'instant, voici l'essentiel.

prenom = "Camille"
message = 'Il a dit "bonjour"'   # guillemets doubles à l'intérieur de simples
phrase = "J'apprends Python"      # apostrophe à l'intérieur de doubles
vide = ""                          # une chaîne vide, c'est permis
print(prenom)
print(message)
print(phrase)
print(len(phrase))                 # len() donne le nombre de caractères

Sortie :

Camille
Il a dit "bonjour"
J'apprends Python
17

2.4. Les booléens (`bool`)¶

Un booléen ne peut valoir que True (vrai) ou False (faux), avec une majuscule. Ils servent à représenter une réponse à une question oui/non :

est_majeur = True
a_un_billet = False
print(est_majeur, a_un_billet)
print(10 > 3)     # une comparaison produit un booléen

Sortie :

True False
True

Les booléens et les comparaisons (>, ==, etc.) sont au cœur du chapitre 02, où ils permettront à ton programme de prendre des décisions.

2.5. Le typage dynamique¶

En Python, ce n'est pas la variable qui a un type, c'est la valeur. Une même variable peut désigner un entier, puis un texte :

truc = 42
print(type(truc))
truc = "quarante-deux"
print(type(truc))

Sortie :

<class 'int'>
<class 'str'>

C'est permis, mais déconseillé : une variable devrait toujours représenter la même sorte de chose.

3. Les opérateurs arithmétiques¶

Opérateur	Opération	Exemple	Résultat
`+`	addition	`7 + 2`	`9`
`-`	soustraction	`7 - 2`	`5`
`*`	multiplication	`7 * 2`	`14`
`/`	division	`7 / 2`	`3.5`
`//`	division entière	`7 // 2`	`3`
`%`	modulo (reste de la division entière)	`7 % 2`	`1`
`**`	puissance	`7 ** 2`	`49`

3.1. La division `/` donne toujours un float¶

print(10 / 2)
print(type(10 / 2))

Sortie :

5.0
<class 'float'>

Même quand la division tombe juste, le résultat est un float (5.0, pas 5).

3.2. Division entière `//` et modulo `%`¶

Souviens-toi de la division posée de l'école primaire : 17 divisé par 5, ça fait 3, et il reste 2. En Python :

17 // 5 donne le quotient : 3 ;
17 % 5 donne le reste : 2.

Analogie : tu as 17 bonbons à répartir dans des sachets de 5. Tu remplis 17 // 5 = 3 sachets complets, et il te reste 17 % 5 = 2 bonbons.

bonbons = 17
par_sachet = 5
sachets = bonbons // par_sachet
reste = bonbons % par_sachet
print("Sachets complets :", sachets)
print("Bonbons restants :", reste)

Sortie :

Sachets complets : 3
Bonbons restants : 2

Ces deux opérateurs sont incroyablement utiles. Par exemple pour convertir une durée :

duree_totale = 200          # en minutes
heures = duree_totale // 60
minutes = duree_totale % 60
print(duree_totale, "minutes =", heures, "h", minutes, "min")

Sortie :

200 minutes = 3 h 20 min

Ou pour récupérer le dernier chiffre d'un nombre : nombre % 10 (le reste de la division par 10).

nombre = 2847
print(nombre % 10)      # dernier chiffre
print(nombre // 10)     # le nombre sans son dernier chiffre

Sortie :

7
284

💡 Un nombre est pair si nombre % 2 vaut 0, et impair s'il vaut 1. Tu t'en serviras beaucoup au chapitre 02.

3.3. Puissance `**`¶

print(2 ** 3)      # 2 × 2 × 2
print(10 ** 6)     # un million
print(9 ** 0.5)    # puissance 0.5 = racine carrée

Sortie :

8
1000000
3.0

3.4. Priorité des opérateurs¶

Python respecte les priorités mathématiques habituelles. Du plus prioritaire au moins prioritaire :

les parenthèses ( ) ;
la puissance ** ;
le signe moins devant un nombre (-x) ;
*, /, //, % (de gauche à droite) ;
+, - (de gauche à droite).

print(2 + 3 * 4)       # la multiplication d'abord
print((2 + 3) * 4)     # les parenthèses d'abord
print(-2 ** 2)         # la puissance passe avant le signe moins !
print((-2) ** 2)
print(10 - 4 - 3)      # de gauche à droite : (10 - 4) - 3

Sortie :

💡 Dans le doute, mets des parenthèses. Elles ne coûtent rien et rendent le calcul plus lisible.

3.5. Mélanger `int` et `float`¶

Quand un calcul mélange un int et un float, le résultat est un float :

print(3 + 2.0)
print(4 * 2.5)

Sortie :

5.0
10.0

3.6. Quelques fonctions mathématiques intégrées¶

Python fournit d'office quelques fonctions bien pratiques :

print(abs(-7))            # valeur absolue
print(round(2.567, 1))    # arrondi
print(max(4, 9, 2))       # le plus grand
print(min(4, 9, 2))       # le plus petit

Sortie :

Pour des fonctions plus avancées (racine carrée, sinus, π…), il existe le module math, que tu découvriras au chapitre 09.

4. Les opérateurs d'affectation composée¶

Mettre à jour une variable à partir de sa propre valeur est si fréquent qu'il existe des raccourcis :

Écriture longue	Raccourci
`x = x + 3`	`x += 3`
`x = x - 3`	`x -= 3`
`x = x * 3`	`x *= 3`
`x = x / 3`	`x /= 3`
`x = x // 3`	`x //= 3`
`x = x % 3`	`x %= 3`
`x = x ** 3`	`x **= 3`

score = 0
score += 10     # on gagne 10 points
score += 5      # puis 5
score -= 3      # on en perd 3
score *= 2      # bonus : score doublé
print("Score final :", score)

Sortie :

Score final : 24

⚠️ Python n'a pas d'opérateur ++ comme d'autres langages. Pour ajouter 1, écris compteur += 1.

5. Opérations sur les chaînes¶

5.1. Concaténation `+` et répétition `*`¶

prenom = "Ada"
nom = "Lovelace"
nom_complet = prenom + " " + nom    # on « colle » les chaînes
print(nom_complet)
print("-" * 20)                      # on répète la chaîne 20 fois
print("Bip" * 3)

Sortie :

Ada Lovelace
--------------------
BipBipBip

⚠️ + ne colle que des chaînes entre elles. "J'ai " + 25 + " ans" provoque une erreur (voir les pièges fréquents). Les f-strings de la section 8 sont bien plus pratiques.

5.2. Caractères spéciaux¶

Certains caractères s'écrivent avec une barre oblique inversée \ (antislash) :

Séquence	Signification
`\n`	retour à la ligne
`\t`	tabulation
`\\`	un antislash
`\"`	un guillemet double (dans une chaîne entre `"`)
`\'`	un guillemet simple (dans une chaîne entre `'`)

print("Ligne 1\nLigne 2")
print("Nom :\tCamille")
print("C:\\Users\\camille")
print('L\'école')

Sortie :

Ligne 1
Ligne 2
Nom :   Camille
C:\Users\camille
L'école

5.3. Chaînes sur plusieurs lignes¶

Avec trois guillemets (""" ou '''), une chaîne peut s'étendre sur plusieurs lignes :

menu = """=== MENU ===
1. Jouer
2. Options
3. Quitter"""
print(menu)

Sortie :

=== MENU ===
1. Jouer
2. Options
3. Quitter

6. Afficher avec `print()`¶

Tu connais déjà print(). Voici deux options utiles : sep et end.

sep (separator) : ce qui est placé entre les valeurs. Par défaut, une espace.
end : ce qui est affiché à la fin. Par défaut, un retour à la ligne \n.

print("01", "02", "2025", sep="/")
print("a", "b", "c", sep="")
print("Chargement", end="...")
print("terminé !")

Sortie :

01/02/2025
abc
Chargement...terminé !

Sans end="...", « terminé ! » aurait été affiché sur une nouvelle ligne.

7. Demander des informations avec `input()`¶

Jusqu'ici, nos programmes faisaient toujours la même chose. Avec input(), ils deviennent interactifs : le programme pose une question, attend que l'utilisateur tape une réponse et appuie sur Entrée, puis récupère ce qui a été tapé.

prenom = input("Comment t'appelles-tu ? ")
print("Enchanté,", prenom)

Exemple d'exécution (l'utilisateur tape Camille puis Entrée) :

Comment t'appelles-tu ? Camille
Enchanté, Camille

💡 Mets une espace à la fin du message de input() : sinon, la réponse de l'utilisateur est collée au point d'interrogation.

7.1. ⚠️ `input()` renvoie TOUJOURS une chaîne¶

C'est le piège numéro un des débutants. Même si l'utilisateur tape un nombre, input() renvoie du texte :

nombre = input("Donne un nombre : ")
print(type(nombre))
print(nombre * 3)

Exemple d'exécution :

Donne un nombre : 4
<class 'str'>
444

"4" * 3 répète le texte "4" trois fois : "444". Pour faire des calculs, il faut convertir la réponse en nombre.

8. Les conversions de type¶

Fonction	Convertit en	Exemple	Résultat
`int(...)`	entier	`int("42")`	`42`
`float(...)`	nombre à virgule	`float("3.5")`	`3.5`
`str(...)`	chaîne	`str(42)`	`"42"`
`bool(...)`	booléen	`bool(0)`	`False`

La bonne façon de lire un nombre au clavier :

age = int(input("Quel âge as-tu ? "))
print("L'année prochaine, tu auras", age + 1, "ans.")

Exemple d'exécution :

Quel âge as-tu ? 25
L'année prochaine, tu auras 26 ans.

Lis int(input(...)) de l'intérieur vers l'extérieur : input() récupère le texte "25", puis int() le transforme en entier 25.

Pour un nombre à virgule (une taille, un prix…), utilise float() :

taille = float(input("Ta taille en mètres : "))
print("Ta taille en centimètres :", taille * 100)

Exemple d'exécution :

Ta taille en mètres : 1.75
Ta taille en centimètres : 175.0

Quelques conversions à connaître :

print(int(3.99))          # int() tronque : il coupe, il n'arrondit pas
print(int(-3.99))
print(int(" 42 "))        # les espaces autour sont tolérés
print(float("7"))
print(float(10))
print(str(3.5) + " €")    # pour coller un nombre à du texte

Sortie :

3
-3
42
7.0
10.0
3.5 €

Et les conversions qui échouent :

int("3.5")        # ValueError : "3.5" n'est pas l'écriture d'un entier
int("douze")      # ValueError : ce n'est pas un nombre du tout
float("3,5")      # ValueError : la virgule n'est pas acceptée

Chacune de ces lignes, exécutée seule, se termine par l'un de ces messages :

ValueError: invalid literal for int() with base 10: '3.5'
ValueError: invalid literal for int() with base 10: 'douze'
ValueError: could not convert string to float: '3,5'

Pour transformer "3.5" en entier, passe par float : int(float("3.5")) donne 3. Et pour gérer proprement le cas où l'utilisateur tape n'importe quoi, il faudra attendre le chapitre 08 (try / except).

Les conversions en booléen. bool() renvoie False pour les valeurs « vides » ou nulles (0, 0.0, "") et True pour tout le reste :

print(bool(0), bool(0.0), bool(""))
print(bool(42), bool(-1), bool("bonjour"), bool("0"), bool(" "))

Sortie :

False False False
True True True True True

Attention : bool("0") vaut True, car "0" est une chaîne non vide !

9. Les f-strings : l'affichage moderne¶

Pour mélanger texte et valeurs, on a vu les virgules dans print() et la concaténation avec + (qui oblige à convertir avec str()). Les f-strings sont la méthode moderne, la plus lisible et la plus utilisée.

Une f-string est une chaîne précédée de la lettre f. À l'intérieur, tout ce qui est entre accolades { } est remplacé par sa valeur :

prenom = "Camille"
age = 25
print(f"Je m'appelle {prenom} et j'ai {age} ans.")

Sortie :

Je m'appelle Camille et j'ai 25 ans.

Compare avec les autres méthodes :

prenom = "Camille"
age = 25
print("Je m'appelle", prenom, "et j'ai", age, "ans.")
print("Je m'appelle " + prenom + " et j'ai " + str(age) + " ans.")
print(f"Je m'appelle {prenom} et j'ai {age} ans.")

Sortie :

Je m'appelle Camille et j'ai 25 ans.
Je m'appelle Camille et j'ai 25 ans.
Je m'appelle Camille et j'ai 25 ans.

Même résultat, mais la f-string est la plus facile à lire et à écrire. Pas besoin de str(), pas de problèmes d'espaces oubliées.

9.1. Des calculs dans les accolades¶

Tu peux mettre n'importe quelle expression entre les accolades :

prix = 12.5
quantite = 3
print(f"{quantite} articles à {prix} € = {prix * quantite} €")
print(f"Dans 10 ans, j'aurai {25 + 10} ans.")

Sortie :

3 articles à 12.5 € = 37.5 €
Dans 10 ans, j'aurai 35 ans.

9.2. Formater les nombres¶

Après la valeur, on peut ajouter : suivi d'une spécification de format :

pi = 3.14159265
print(f"{pi:.2f}")          # 2 chiffres après la virgule
print(f"{pi:.0f}")          # aucun chiffre après la virgule
print(f"{3 * 1.2:.2f}")     # adieu 3.5999999999999996 !
print(f"{1234567.891:,.2f}")   # séparateur de milliers
print(f"{0.256:.1%}")       # pourcentage
print(f"{7:03d}")           # sur 3 chiffres, complété par des zéros

Sortie :

3.14
3
3.60
1,234,567.89
25.6%
007

Le f de .2f signifie fixed point (nombre à virgule avec un nombre fixe de décimales) ; le d de 03d signifie decimal (entier).

9.3. Aligner du texte¶

On peut aussi réserver une largeur et choisir l'alignement : < à gauche, > à droite, ^ au centre.

print(f"[{'chat':<10}]")
print(f"[{'chat':>10}]")
print(f"[{'chat':^10}]")
print(f"[{'chat':*^10}]")   # caractère de remplissage : *

Sortie :

[chat      ]
[      chat]
[   chat   ]
[***chat***]

C'est parfait pour faire des tableaux bien alignés :

article1, prix1 = "Pain", 1.1
article2, prix2 = "Fromage", 4.75
article3, prix3 = "Confiture", 3.2
print(f"{'Article':<12}{'Prix':>8}")
print("-" * 20)
print(f"{article1:<12}{prix1:>8.2f}")
print(f"{article2:<12}{prix2:>8.2f}")
print(f"{article3:<12}{prix3:>8.2f}")
print("-" * 20)
print(f"{'TOTAL':<12}{prix1 + prix2 + prix3:>8.2f}")

Sortie :

Article         Prix
--------------------
Pain            1.10
Fromage         4.75
Confiture       3.20
--------------------
TOTAL           9.05

{prix1:>8.2f} combine les deux : largeur 8, alignement à droite, 2 décimales.

9.4. L'astuce de débogage `=`¶

En ajoutant = après une expression, la f-string affiche l'expression et sa valeur. Très pratique pour vérifier ce que contiennent tes variables :

largeur = 5
hauteur = 3
print(f"{largeur = }")
print(f"{largeur * hauteur = }")

Sortie :

largeur = 5
largeur * hauteur = 15

10. Mettre tout ensemble : un programme complet¶

Voici un petit programme qui utilise tout ce que tu as appris : variables, saisie, conversion, calcul et affichage formaté.

# Calcul du prix d'un plein d'essence
print("=== Calculateur de plein ===")

prix_litre = float(input("Prix du litre (en €) : "))
capacite = float(input("Capacité du réservoir (en litres) : "))
niveau_actuel = float(input("Litres déjà présents : "))

litres_a_mettre = capacite - niveau_actuel
cout = litres_a_mettre * prix_litre

print()
print(f"Litres à mettre : {litres_a_mettre:.1f} L")
print(f"Coût du plein   : {cout:.2f} €")

Exemple d'exécution :

=== Calculateur de plein ===
Prix du litre (en €) : 1.85
Capacité du réservoir (en litres) : 50
Litres déjà présents : 12.5

Litres à mettre : 37.5 L
Coût du plein   : 69.38 €

Remarque la structure classique d'un programme : entrées (input) → traitement (calculs) → sorties (print). Tu la retrouveras partout.

Pièges fréquents¶

Piège 1 — Oublier de convertir le résultat de `input()`¶

age = input("Quel âge as-tu ? ")
print(age + 1)

Quel âge as-tu ? 25
Traceback (most recent call last):
  File "age.py", line 2, in <module>
    print(age + 1)
          ~~~~^~~
TypeError: can only concatenate str (not "int") to str

Python te dit qu'il ne peut coller (concatenate) qu'une chaîne à une chaîne, pas un entier. Normal : age est la chaîne "25".

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

Piège 2 — Coller un nombre à du texte avec `+`¶

age = 25
print("J'ai " + age + " ans")

Traceback (most recent call last):
  File "age.py", line 2, in <module>
    print("J'ai " + age + " ans")
          ~~~~~~~~^~~~~
TypeError: can only concatenate str (not "int") to str

Correction : utilise une f-string : print(f"J'ai {age} ans"). (Ou str(age), mais c'est moins lisible.)

Piège 3 — Confondre `=` et `==`¶

= affecte une valeur ; == compare deux valeurs (on le verra au chapitre 02).

x = 5      # x désigne 5
x == 5     # pose la question « x vaut-il 5 ? » → True (mais ne change rien)

Écrire 5 = x provoque même une erreur : on ne peut pas coller une étiquette sur un nombre. Python devine d'ailleurs ce que tu voulais faire :

5 = x

  File "egalite.py", line 1
    5 = x
    ^
SyntaxError: cannot assign to literal here. Maybe you meant '==' instead of '='?

Piège 4 — Mettre des guillemets autour d'une variable¶

prenom = "Camille"
print("prenom")
print(f"Bonjour prenom")

Sortie :

prenom
Bonjour prenom

Entre guillemets, prenom est un texte comme un autre, pas la variable.

Correction : print(prenom) et print(f"Bonjour {prenom}"). Et n'oublie pas le f devant la f-string : sans lui, "Bonjour {prenom}" affiche littéralement les accolades.

Piège 5 — Écrire un nombre avec une virgule¶

prix = 3,5
print(prix)
print(type(prix))

Sortie :

(3, 5)
<class 'tuple'>

Pas d'erreur, mais pas du tout ce qu'on voulait : Python a créé un tuple (deux valeurs, 3 et 5, qu'on verra au chapitre 04). De même, float("3,5") provoque ValueError: could not convert string to float: '3,5'.

Correction : toujours un point décimal : prix = 3.5.

Piège 6 — `int()` sur un texte qui contient une virgule ou un point¶

note = int(input("Ta note : "))

Ta note : 14.5
Traceback (most recent call last):
  File "note.py", line 1, in <module>
    note = int(input("Ta note : "))
ValueError: invalid literal for int() with base 10: '14.5'

Correction : si la valeur peut avoir des décimales, utilise float(input(...)).

Piège 7 — Un nom de variable invalide¶

2eme_joueur = "Léa"

  File "joueurs.py", line 1
    2eme_joueur = "Léa"
    ^
SyntaxError: invalid decimal literal

mon score = 10

  File "score.py", line 1
    mon score = 10
        ^^^^^
SyntaxError: invalid syntax

Correction : joueur_2 = "Léa" et mon_score = 10.

Piège 8 — Écraser une fonction intégrée¶

print = "Bonjour"
print("Salut")

Traceback (most recent call last):
  File "ecrase.py", line 2, in <module>
    print("Salut")
    ~~~~~^^^^^^^^^
TypeError: 'str' object is not callable

En écrivant print = ..., tu as collé l'étiquette print sur une chaîne : la fonction d'affichage n'est plus accessible ! Même chose avec input, int, str, type, len, max, min, sum…

Correction : choisis un autre nom (message = "Bonjour"). Si c'est arrivé dans l'interpréteur interactif, quitte-le et relance-le.

Exercices¶

Exercice 1 ⭐ — Prédire l'affichage¶

Sans exécuter le code, écris sur papier ce qu'il va afficher. Vérifie ensuite en l'exécutant.

a = 7
b = 2
c = a // b
d = a % b
a = a + b
b *= 3
print(a, b, c, d)
print(a / 3, type(a / 3))
print("7" + "2", 7 + 2, "7" * 2)

Exercice 2 ⭐ — Celsius vers Fahrenheit¶

Écris un programme qui demande une température en degrés Celsius et l'affiche en degrés Fahrenheit, avec une décimale. Formule : F = C × 9 / 5 + 32.

Exemple d'exécution :

Température en °C : 21.5
21.5 °C = 70.7 °F

Exercice 3 ⭐ — Le rectangle¶

Écris un programme qui demande la largeur et la longueur d'un rectangle (nombres à virgule possibles) et affiche son périmètre et son aire.

Exemple d'exécution :

Largeur : 4
Longueur : 6.5
Périmètre : 21.0
Aire : 26.0

Exercice 4 ⭐⭐ — Convertisseur de durée¶

Écris un programme qui demande une durée en secondes (un entier) et l'affiche en heures, minutes et secondes, avec // et %.

Exemple d'exécution :

Durée en secondes : 7384
7384 secondes = 2 h 3 min 4 s

Exercice 5 ⭐⭐ — Somme des chiffres¶

Écris un programme qui demande un nombre entier à trois chiffres et affiche séparément ses chiffres des centaines, des dizaines et des unités, puis leur somme. Interdiction de traiter le nombre comme du texte : utilise uniquement // et %.

Exemple d'exécution :

Nombre à 3 chiffres : 472
Centaines : 4
Dizaines  : 7
Unités    : 2
Somme des chiffres : 13

Exercice 6 ⭐⭐ — Carte d'identité formatée¶

Écris un programme qui demande le prénom, le nom, l'année de naissance et la taille (en mètres) d'une personne, puis affiche une fiche alignée comme ci-dessous, avec l'âge calculé à partir de l'année en cours (stockée dans une variable annee_actuelle, ici 2026). Le cadre fait 30 caractères de large.

Exemple d'exécution :

Prénom : Ada
Nom : Lovelace
Année de naissance : 1990
Taille (m) : 1.68
******************************
* Prénom :              Ada  *
* Nom    :         Lovelace  *
* Âge    :          36 ans   *
* Taille :          168 cm   *
******************************

Indice : {prenom:>16} réserve 16 caractères alignés à droite. Pour la taille en centimètres, pense à round().

Exercice 7 ⭐⭐⭐ — Partage de l'addition¶

Un groupe d'amis va au restaurant. Écris un programme qui demande le montant de l'addition, le pourcentage de pourboire souhaité (un entier, par exemple 10 pour 10 %) et le nombre de personnes. Il affiche le montant du pourboire, le total et la part de chacun, arrondis au centime.

Exemple d'exécution :

Montant de l'addition (€) : 87.40
Pourboire (%) : 10
Nombre de personnes : 4
Pourboire : 8.74 €
Total     : 96.14 €
Par personne : 24.04 €

Exercice 8 ⭐⭐⭐ — Le rendu de monnaie¶

Un distributeur doit rendre une somme entière en euros avec le moins de billets et de pièces possible. Les coupures disponibles sont : billets de 50, 20, 10 et 5 €, pièces de 2 et 1 €. Écris un programme qui demande la somme à rendre et affiche le nombre de chaque coupure. (Tu n'as pas encore les conditions, donc affiche aussi les coupures dont le nombre est 0.)

Exemple d'exécution :

Somme à rendre (€) : 188
Billets de 50 € : 3
Billets de 20 € : 1
Billets de 10 € : 1
Billets de 5 €  : 1
Pièces de 2 €   : 1
Pièces de 1 €   : 1

Indice : après avoir calculé le nombre de billets de 50 avec //, la somme restant à rendre s'obtient avec %.

Mini-projet¶

Le calculateur de budget de vacances¶

Objectif : écrire un programme budget_vacances.py qui aide à estimer le coût d'un séjour et la part de chaque participant.

Cahier des charges :

Le programme affiche un titre, puis demande :
la destination (texte) ;
le nombre de participants (entier) ;
le nombre de nuits (entier) ;
le prix d'une nuit de logement pour tout le groupe (float) ;
le budget repas par personne et par jour (float) ;
le coût du transport par personne (float).
Il calcule :
le coût total du logement ;
le coût total des repas (on compte un jour de repas par nuit) ;
le coût total du transport ;
le coût total du séjour et le coût par personne ;
combien chaque personne doit épargner par semaine si le départ est dans un nombre de semaines saisi au clavier.
Il affiche un récapitulatif sous forme de tableau aligné, avec les montants à 2 décimales et alignés à droite, et la destination en majuscules dans le titre du récapitulatif (indice : destination.upper() renvoie la chaîne en majuscules ; les méthodes de chaînes seront détaillées au chapitre 06).
Le code est commenté, en trois blocs : entrées, calculs, affichage.

Exemple d'exécution :

=== Budget vacances ===
Destination : Lisbonne
Nombre de participants : 4
Nombre de nuits : 5
Prix d'une nuit pour le groupe (€) : 140
Budget repas par personne et par jour (€) : 35
Transport par personne (€) : 120
Départ dans combien de semaines ? 10

======= RÉCAPITULATIF : LISBONNE =======
Logement                        700.00 €
Repas                           700.00 €
Transport                       480.00 €
----------------------------------------
TOTAL                          1880.00 €
Par personne                    470.00 €
Épargne par semaine              47.00 €
========================================

Étapes suggérées :

Écris d'abord tous les input() avec les bonnes conversions, et affiche les variables avec l'astuce f"{variable = }" pour vérifier.
Écris les calculs, un par variable, avec des noms clairs (cout_logement, cout_repas…).
Construis l'affichage ligne par ligne. Commence sans alignement, puis ajoute les spécifications de format (:<25, :>10.2f).
Teste avec plusieurs jeux de valeurs et vérifie un résultat à la main.

Pistes d'amélioration :

Ajoute une ligne « Activités » avec un budget par personne pour tout le séjour.
Affiche la part de chaque poste en pourcentage du total (:.1%).
Ajoute une marge de sécurité de 10 % pour les imprévus.
Au chapitre 02, tu pourras vérifier que le nombre de participants n'est pas nul et comparer avec un budget maximum ; au chapitre 03, tu pourras demander le détail de chaque participant.

Corrigés¶

Corrigé de l'exercice 1

Le code de l'énoncé affiche :

9 6 3 1
3.0 <class 'float'>
72 9 77

Explication pas à pas : - `c = 7 // 2` → `3` et `d = 7 % 2` → `1` (calculés **avant** que `a` et `b` changent) ; - `a = 7 + 2` → `9`, puis `b *= 3` → `b = 2 * 3` → `6` ; - `a / 3` → `9 / 3` → `3.0` : la division `/` donne toujours un `float` ; - `"7" + "2"` colle deux textes → `72` ; `7 + 2` additionne → `9` ; `"7" * 2` répète le texte → `77`.

Corrigé de l'exercice 2

# Conversion Celsius -> Fahrenheit
celsius = float(input("Température en °C : "))
fahrenheit = celsius * 9 / 5 + 32
print(f"{celsius} °C = {fahrenheit:.1f} °F")

Exemple d'exécution :

Température en °C : 21.5
21.5 °C = 70.7 °F

On utilise `float()` car une température peut avoir des décimales. Les priorités font que `celsius * 9 / 5` est calculé avant `+ 32`, comme dans la formule.

Corrigé de l'exercice 3

# Périmètre et aire d'un rectangle
largeur = float(input("Largeur : "))
longueur = float(input("Longueur : "))

perimetre = 2 * (largeur + longueur)
aire = largeur * longueur

print(f"Périmètre : {perimetre}")
print(f"Aire : {aire}")

Exemple d'exécution :

Largeur : 4
Longueur : 6.5
Périmètre : 21.0
Aire : 26.0

Les parenthèses dans `2 * (largeur + longueur)` sont indispensables : sans elles, on calculerait `2 * largeur + longueur`.

Corrigé de l'exercice 4

# Conversion d'une durée en secondes vers h / min / s
duree = int(input("Durée en secondes : "))

heures = duree // 3600            # 3600 secondes dans une heure
reste = duree % 3600              # secondes qui ne font pas une heure complète
minutes = reste // 60
secondes = reste % 60

print(f"{duree} secondes = {heures} h {minutes} min {secondes} s")

Exemple d'exécution :

Durée en secondes : 7384
7384 secondes = 2 h 3 min 4 s

Vérification : 2 × 3600 + 3 × 60 + 4 = 7200 + 180 + 4 = 7384. ✔️ Variante sans la variable `reste` : `minutes = duree // 60 % 60` et `secondes = duree % 60`.

Corrigé de l'exercice 5

# Décomposer un nombre à trois chiffres
nombre = int(input("Nombre à 3 chiffres : "))

centaines = nombre // 100          # 472 // 100 -> 4
dizaines = nombre // 10 % 10       # 472 // 10 -> 47, puis 47 % 10 -> 7
unites = nombre % 10               # 472 % 10 -> 2

print(f"Centaines : {centaines}")
print(f"Dizaines  : {dizaines}")
print(f"Unités    : {unites}")
print(f"Somme des chiffres : {centaines + dizaines + unites}")

Exemple d'exécution :

Nombre à 3 chiffres : 472
Centaines : 4
Dizaines  : 7
Unités    : 2
Somme des chiffres : 13

`//` et `%` ont la même priorité et s'évaluent de gauche à droite : `nombre // 10 % 10` signifie `(nombre // 10) % 10`.

Corrigé de l'exercice 6

# Fiche d'identité formatée
annee_actuelle = 2026

prenom = input("Prénom : ")
nom = input("Nom : ")
annee_naissance = int(input("Année de naissance : "))
taille = float(input("Taille (m) : "))

age = annee_actuelle - annee_naissance
taille_cm = round(taille * 100)

print("*" * 30)
print(f"* Prénom : {prenom:>16}  *")
print(f"* Nom    : {nom:>16}  *")
print(f"* Âge    : {age:>11} ans   *")
print(f"* Taille : {taille_cm:>12} cm   *")
print("*" * 30)

Exemple d'exécution :

Prénom : Ada
Nom : Lovelace
Année de naissance : 1990
Taille (m) : 1.68
******************************
* Prénom :              Ada  *
* Nom    :         Lovelace  *
* Âge    :          36 ans   *
* Taille :          168 cm   *
******************************

Pourquoi `round()` ? D'abord pour obtenir un entier (`168` plutôt que `168.0`). Ensuite à cause de l'imprécision des floats : avec une taille de `1.15`, le calcul `1.15 * 100` donne `114.99999999999999`, et `int()` (qui tronque) donnerait `114` ! `round()` donne l'entier le plus proche, `115`. Chaque ligne fait bien 30 caractères : 11 caractères avant la valeur, la largeur réservée, puis la fin de ligne.

Corrigé de l'exercice 7

# Partage de l'addition au restaurant
addition = float(input("Montant de l'addition (€) : "))
pourcentage = int(input("Pourboire (%) : "))
nb_personnes = int(input("Nombre de personnes : "))

pourboire = addition * pourcentage / 100
total = addition + pourboire
part = total / nb_personnes

print(f"Pourboire : {pourboire:.2f} €")
print(f"Total     : {total:.2f} €")
print(f"Par personne : {part:.2f} €")

Exemple d'exécution :

Montant de l'addition (€) : 87.40
Pourboire (%) : 10
Nombre de personnes : 4
Pourboire : 8.74 €
Total     : 96.14 €
Par personne : 24.04 €

On garde les valeurs exactes dans les variables et on n'arrondit qu'**à l'affichage** avec `:.2f` : arrondir trop tôt accumule les erreurs. Si l'utilisateur tape `0` personne, le programme plante avec `ZeroDivisionError` : on apprendra à l'en empêcher au chapitre 02.

Corrigé de l'exercice 8

# Rendu de monnaie avec le moins de coupures possible
somme = int(input("Somme à rendre (€) : "))

billets_50 = somme // 50
somme = somme % 50          # ce qui reste à rendre

billets_20 = somme // 20
somme %= 20                 # même chose, écrit en raccourci

billets_10 = somme // 10
somme %= 10

billets_5 = somme // 5
somme %= 5

pieces_2 = somme // 2
pieces_1 = somme % 2

print(f"Billets de 50 € : {billets_50}")
print(f"Billets de 20 € : {billets_20}")
print(f"Billets de 10 € : {billets_10}")
print(f"Billets de 5 €  : {billets_5}")
print(f"Pièces de 2 €   : {pieces_2}")
print(f"Pièces de 1 €   : {pieces_1}")

Exemple d'exécution :

Somme à rendre (€) : 188
Billets de 50 € : 3
Billets de 20 € : 1
Billets de 10 € : 1
Billets de 5 €  : 1
Pièces de 2 €   : 1
Pièces de 1 €   : 1

Vérification : 3 × 50 + 20 + 10 + 5 + 2 + 1 = 188. ✔️ La méthode est toujours la même : `//` donne le nombre de coupures, `%` donne ce qui reste à rendre. Tu remarques la répétition ? Au chapitre 03, une boucle fera ce travail en quelques lignes.

Corrigé du mini-projet

# budget_vacances.py
# Estime le coût d'un séjour et la part de chaque participant.

# ---------- Entrées ----------
print("=== Budget vacances ===")
destination = input("Destination : ")
nb_participants = int(input("Nombre de participants : "))
nb_nuits = int(input("Nombre de nuits : "))
prix_nuit_groupe = float(input("Prix d'une nuit pour le groupe (€) : "))
repas_par_jour = float(input("Budget repas par personne et par jour (€) : "))
transport_par_personne = float(input("Transport par personne (€) : "))
nb_semaines = int(input("Départ dans combien de semaines ? "))

# ---------- Calculs ----------
cout_logement = nb_nuits * prix_nuit_groupe
cout_repas = nb_participants * nb_nuits * repas_par_jour
cout_transport = nb_participants * transport_par_personne
cout_total = cout_logement + cout_repas + cout_transport
cout_par_personne = cout_total / nb_participants
epargne_hebdo = cout_par_personne / nb_semaines

# ---------- Affichage ----------
largeur = 40
titre = f" RÉCAPITULATIF : {destination.upper()} "
print()
print(f"{titre:=^{largeur}}")
print(f"{'Logement':<25}{cout_logement:>13.2f} €")
print(f"{'Repas':<25}{cout_repas:>13.2f} €")
print(f"{'Transport':<25}{cout_transport:>13.2f} €")
print("-" * largeur)
print(f"{'TOTAL':<25}{cout_total:>13.2f} €")
print(f"{'Par personne':<25}{cout_par_personne:>13.2f} €")
print(f"{'Épargne par semaine':<25}{epargne_hebdo:>13.2f} €")
print("=" * largeur)

Exemple d'exécution :

=== Budget vacances ===
Destination : Lisbonne
Nombre de participants : 4
Nombre de nuits : 5
Prix d'une nuit pour le groupe (€) : 140
Budget repas par personne et par jour (€) : 35
Transport par personne (€) : 120
Départ dans combien de semaines ? 10

======= RÉCAPITULATIF : LISBONNE =======
Logement                        700.00 €
Repas                           700.00 €
Transport                       480.00 €
----------------------------------------
TOTAL                          1880.00 €
Par personne                    470.00 €
Épargne par semaine              47.00 €
========================================

Remarques : - Chaque ligne du tableau fait 25 + 13 + 2 = 40 caractères, comme le cadre. - `{titre:=^{largeur}}` centre le titre sur 40 caractères en complétant avec des `=`. On peut mettre une variable (`{largeur}`) à l'intérieur de la spécification de format. - Stocker la largeur dans une variable permet de changer la taille du tableau à un seul endroit.

Récapitulatif¶

Points clés :

Une variable est un nom qui désigne une valeur. = affecte (de droite à gauche), il ne compare pas.
Noms en snake_case, parlants, sans accents ; jamais de chiffre au début, jamais d'espace, jamais de mot réservé.
Quatre types de base : int (entier), float (à virgule, avec un point), str (texte entre guillemets), bool (True / False). type() donne le type d'une valeur.
Opérateurs : + - * / (toujours un float), // (quotient entier), % (reste), ** (puissance). Les priorités sont celles des maths ; dans le doute, des parenthèses.
Raccourcis : +=, -=, *=, /=… (pas de ++ en Python).
Sur les chaînes : + colle, * répète, len() compte les caractères, \n passe à la ligne.
input() renvoie toujours une chaîne : convertis avec int() ou float() avant de calculer.
Les f-strings f"... {expression} ..." sont la meilleure façon d'afficher : :.2f pour les décimales, :<10 / :>10 / :^10 pour aligner, {x = } pour déboguer.
Les floats sont parfois imprécis (0.1 + 0.2) : arrondis à l'affichage.

Checklist de validation :

Je sais créer une variable, la modifier et l'afficher.
Je sais dire si un nom de variable est valide et s'il respecte les conventions.
Je connais les types int, float, str, bool et je sais vérifier un type avec type().
Je sais utiliser // et % pour découper une quantité (durée, monnaie, chiffres).
Je convertis systématiquement le résultat de input() quand j'attends un nombre.
Je sais écrire une f-string avec un nombre de décimales et un alignement.
J'ai réalisé le mini-projet et vérifié un résultat à la main.

← Chapitre précédent | Sommaire | Chapitre suivant →

Chapitre 01 — Variables, types et opérateurs¶

Cours¶

1. Les variables : donner un nom à une valeur¶

1.1. Réaffecter une variable¶

1.2. Une variable doit exister avant d'être utilisée¶

1.3. Bien nommer ses variables¶

1.4. Affectations multiples¶

2. Les types de base¶

2.1. Les entiers (int)¶

2.2. Les nombres à virgule (float)¶

2.3. Les chaînes de caractères (str)¶

2.4. Les booléens (bool)¶

2.5. Le typage dynamique¶

3. Les opérateurs arithmétiques¶

3.1. La division / donne toujours un float¶

3.2. Division entière // et modulo %¶

3.3. Puissance **¶

3.4. Priorité des opérateurs¶

3.5. Mélanger int et float¶

3.6. Quelques fonctions mathématiques intégrées¶

4. Les opérateurs d'affectation composée¶

5. Opérations sur les chaînes¶

5.1. Concaténation + et répétition *¶

5.2. Caractères spéciaux¶

5.3. Chaînes sur plusieurs lignes¶

6. Afficher avec print()¶

7. Demander des informations avec input()¶

7.1. ⚠️ input() renvoie TOUJOURS une chaîne¶

8. Les conversions de type¶

9. Les f-strings : l'affichage moderne¶

9.1. Des calculs dans les accolades¶

9.2. Formater les nombres¶

9.3. Aligner du texte¶

9.4. L'astuce de débogage =¶

10. Mettre tout ensemble : un programme complet¶

Pièges fréquents¶

Piège 1 — Oublier de convertir le résultat de input()¶

Piège 2 — Coller un nombre à du texte avec +¶

Piège 3 — Confondre = et ==¶

Piège 4 — Mettre des guillemets autour d'une variable¶

Piège 5 — Écrire un nombre avec une virgule¶

Piège 6 — int() sur un texte qui contient une virgule ou un point¶

Piège 7 — Un nom de variable invalide¶

Piège 8 — Écraser une fonction intégrée¶

Exercices¶

Exercice 1 ⭐ — Prédire l'affichage¶

Exercice 2 ⭐ — Celsius vers Fahrenheit¶

Exercice 3 ⭐ — Le rectangle¶

Exercice 4 ⭐⭐ — Convertisseur de durée¶

Exercice 5 ⭐⭐ — Somme des chiffres¶

Exercice 6 ⭐⭐ — Carte d'identité formatée¶

Exercice 7 ⭐⭐⭐ — Partage de l'addition¶

Exercice 8 ⭐⭐⭐ — Le rendu de monnaie¶

Mini-projet¶

Le calculateur de budget de vacances¶

Corrigés¶

Récapitulatif¶

2.1. Les entiers (`int`)¶

2.2. Les nombres à virgule (`float`)¶

2.3. Les chaînes de caractères (`str`)¶

2.4. Les booléens (`bool`)¶

3.1. La division `/` donne toujours un float¶

3.2. Division entière `//` et modulo `%`¶

3.3. Puissance `**`¶

3.5. Mélanger `int` et `float`¶

5.1. Concaténation `+` et répétition `*`¶

6. Afficher avec `print()`¶

7. Demander des informations avec `input()`¶

7.1. ⚠️ `input()` renvoie TOUJOURS une chaîne¶

9.4. L'astuce de débogage `=`¶

Piège 1 — Oublier de convertir le résultat de `input()`¶

Piège 2 — Coller un nombre à du texte avec `+`¶

Piège 3 — Confondre `=` et `==`¶

Piège 6 — `int()` sur un texte qui contient une virgule ou un point¶