backend / python

Variables, types et print

Leçon 11 exercice

Explication

Un peu d'histoire

Python est créé par Guido van Rossum, chercheur néerlandais, qui commence à l'écrire fin 1989 pendant les vacances de Noël, au CWI (un centre de recherche à Amsterdam), comme successeur d'un langage nommé ABC. La première version publique sort en 1991. Le nom ne vient pas du serpent, mais de la troupe comique britannique Monty Python, que Guido van Rossum appréciait beaucoup : il voulait un langage à la fois sérieux et un peu ludique dans son esprit.

Dès le départ, l'objectif est clair : un langage simple à lire, presque comme du pseudo-code, pour que le développeur passe son temps à réfléchir au problème plutôt qu'à la syntaxe.

Pourquoi apprendre Python aujourd'hui

Python est aujourd'hui l'un des langages les plus utilisés au monde, quasiment dans tous les domaines : automatisation de tâches, développement web (avec Django ou FastAPI), science des données, intelligence artificielle et machine learning, scripts système, DevOps... Sa syntaxe simple en fait un excellent premier langage pour apprendre à programmer, mais ce n'est pas un langage "jouet" : il est utilisé en production par Google, Instagram, Netflix, Spotify ou encore la NASA. Son écosystème de bibliothèques (disponibles via PyPI) est immense, et la demande pour des développeurs Python reste très forte sur le marché de l'emploi.

Ce que vous allez apprendre

Comprendre ce qu'une variable représente réellement en mémoire (une étiquette, pas une boîte)
Distinguer le typage dynamique du typage fort, et pourquoi Python est les deux à la fois
Utiliser les f-strings pour afficher des valeurs proprement, y compris en mode debug ({valeur=})
Convertir explicitement un type vers un autre avec int(), float(), str() sans erreur surprise
Repérer les pièges classiques : "123" qui reste une chaîne, True qui est en réalité 1

Dans quel contexte ?

Imaginez un développeur qui débute un script et qui, en testant age = input("Ton âge : "), obtient une erreur TypeError: unsupported operand type(s) for +: 'int' and 'str' dès qu'il tente de calculer age + 10. Comprendre que input() renvoie toujours une chaîne de caractères, et qu'il faut la convertir explicitement avec int(age), est exactement le genre de réflexe que cette première leçon doit installer durablement.

1. Le point de départ : donner un nom à une valeur

Avant les subtilités, retenez la chose la plus simple : une variable, c'est juste un nom qu'on donne à une valeur pour pouvoir la réutiliser. Quand vous écrivez age = 29, vous dites à Python "retiens le nombre 29 sous le nom age". Rien de plus compliqué pour commencer.

2. Ce qui se passe réellement en coulisses

Une fois cette image en tête, on peut l'affiner : une variable n'est pas une case qui contient une valeur, comme la mémoire d'une calculatrice. C'est plutôt une étiquette collée sur un objet qui vit quelque part en mémoire. Quand on écrit age = 29, Python crée d'abord l'objet entier 29, puis colle l'étiquette age dessus.

Astuce

Pour vérifier rapidement une valeur pendant que vous codez, utilisez le mode debug des f-strings : print(f"{age=}") affiche directement age=29, sans avoir à écrire print("age =", age) à la main.

3. Pourquoi cette nuance change tout

Cette image de l'étiquette a une conséquence concrète : on peut coller plusieurs étiquettes sur le même objet, comme avec a = b = c = 0. Et réaffecter une variable ne modifie jamais l'objet d'origine : ça déplace simplement l'étiquette ailleurs, sur un nouvel objet.

4. Le type appartient à l'objet, pas au nom

Une fois qu'on a compris cela, une question se pose naturellement : pourquoi n'écrit-on jamais int age = 29 comme en Java ? Parce qu'en Python, le type appartient à l'objet, pas à l'étiquette. On dit que Python est à typage dynamique.

Langage	Typage	Exemple de déclaration
Python	Dynamique et fort	`age = 29` (le type est déduit)
Java	Statique et fort	`int age = 29;` (le type est imposé)
JavaScript	Dynamique et faible	`let age = 29; age + "3"` donne `"293"`
C	Statique et fort	`int age = 29;` (vérifié à la compilation)

5. Dynamique ne veut pas dire laxiste

Attention à ne pas confondre "dynamique" et "permissif" : Python devine le type automatiquement, mais reste très strict une fois ce type connu. Additionner un texte et un nombre lève toujours une erreur : on parle de typage fort.

6. Les pièges classiques du débutant

Maintenant que vous avez les bases, voici deux pièges à connaître. D'abord, une chaîne comme "123" reste une chaîne tant qu'on ne la convertit pas explicitement avec int() : Python ne devine jamais tout seul qu'il faut la transformer en nombre. Ensuite, True et False sont en réalité des nombres déguisés (1 et 0), une surprise fréquente au début.

Piège fréquent

bool est une sous-classe de int en Python : True == 1 et False == 0 renvoient True. Un test comme if resultat == True: fonctionne donc "par accident" mais n'est pas idiomatique — préférez simplement if resultat:.

7. Le point de départ de tout le reste

Cette leçon est la fondation de tout le cours : chaque structure de contrôle, chaque fonction, chaque classe manipule des variables et des types. Prenez le temps de bien comprendre print() et les f-strings avant de continuer : vous vous en servirez à chaque ligne du parcours.

Commandes & code

Variables, types et print

Les bases : nommer une valeur, connaitre son type, l'afficher.

# Affectation simple : Python infere le type automatiquement
nom = "Alice"          # str
age = 29                # int
taille = 1.68            # float
est_active = True        # bool
rien = None               # NoneType

print(type(nom), type(age), type(taille), type(est_active), type(rien))

# Affectation multiple
x, y, z = 1, 2, 3

# Meme valeur pour plusieurs variables
a = b = c = 0

# Swap sans variable temporaire (idiome Python)
x, y = y, x

# f-strings : formatage moderne (Python 3.6+)
print(f"{nom} a {age} ans, mesure {taille:.2f} m")

# f-strings avec expressions et debug (Python 3.8+)
valeur = 42
print(f"{valeur=}")          # affiche : valeur=42
print(f"{valeur * 2 = }")    # affiche : valeur * 2 = 84

# Conversion explicite de types (casting)
texte_nombre = "123"
nombre = int(texte_nombre)          # str -> int
flottant = float("3.14")            # str -> float
chaine = str(456)                   # int -> str
booleen = bool(0)                   # False (0, "", None, [] sont falsy)

# Nombres : entiers illimites, complexes, notation scientifique
grand_nombre = 10_000_000_000       # underscore pour la lisibilite
notation_sci = 1.5e3                # 1500.0
complexe = 3 + 4j

# Verification de type stricte vs duck typing
print(isinstance(age, int))          # True
print(isinstance(True, int))         # True : bool est une sous-classe de int !

# Lancer l'interpreteur interactif
python3

# Executer un script
python3 mon_script.py

# Verifier la version installee
python3 --version

Résumé

Python est un langage a typage dynamique mais fortement type.
type() inspecte, isinstance() verifie (et gere l'heritage).
Les f-strings sont la methode moderne et recommandee de formatage.
bool est une sous-classe de int : True == 1 et False == 0.

Exercices pratiques

1 disponible

Mission : réparer un script de facturation qui plante en production

Objectif : Diagnostiquer et corriger un bug de types dans un script qui mélange des valeurs saisies en texte et des calculs numériques.

Contexte

Un collègue a écrit un script qui lit un prix et une quantité saisis par l'utilisateur avec input(), puis calcule un total. En production, le script plante avec TypeError: can only concatenate str (not "int") to str dès que quelqu'un tape une quantité. Il jure que ses variables sont "évidemment des nombres" parce qu'elles ressemblent à des nombres à l'écran.

Tu dois comprendre pourquoi Python ne les traite pas comme il le pense, corriger le script, et être capable d'expliquer la différence entre ce qu'affiche print() et ce que contient réellement la variable.

Résoudre l’exercice →