9 Variables et types de données

Toute programmation commence par une question : comment stocker de l’information pour la manipuler ? La réponse en Python tient en un mot : la variable. Ce premier chapitre pose les briques indispensables — sans maîtrise parfaite du contenu de ce chapitre, impossible de progresser sereinement.

9.1 La notion de variable

Une variable est un nom associé à une valeur stockée en mémoire. En Python, on crée une variable simplement en lui affectant une valeur avec le signe = :

age = 30
prenom = "Alice"
taille = 1.72

L’opérateur = s’appelle l’affectation : on lit « la variable age reçoit la valeur 30 ». Une fois créée, la variable s’utilise comme une valeur :

age = 30
print("J'ai", age, "ans.")

J'ai 30 ans.

Le typage dynamique de Python

Python est à typage dynamique : on ne déclare pas le type d’une variable, il est déduit automatiquement de la valeur affectée. Une même variable peut même changer de type au cours du programme (à éviter en pratique).

x = 10          # x est un entier
x = "bonjour"   # maintenant x est une chaîne
print(x, type(x))

bonjour <class 'str'>

9.2 Règles de nommage des variables

Les noms de variables en Python suivent des règles strictes :

Règle	Exemple valide	Exemple invalide
Commence par une lettre ou `_`	`age`, `_prive`	`2chats` ❌
Contient lettres, chiffres, `_`	`nom_utilisateur`, `x1`	`nom-utilisateur` ❌
Sensible à la casse	`Age` et `age` sont différents	—
Ne peut pas être un mot-clé réservé	—	`if`, `for`, `class`, `def`… ❌

Démonstration d’une erreur classique :

2chats = 2

  Cell In[4], line 1
    2chats = 2
    ^
SyntaxError: invalid decimal literal

Convention PEP 8 — snake_case

Par convention, on écrit les noms de variables en snake_case : mots en minuscules séparés par _.

# ✅ Conforme PEP 8
nombre_de_clients = 50
prix_unitaire_ht = 19.99

# ❌ À éviter
NombreDeClients = 50       # ← camelCase (style Java/JavaScript)
NOMBRE = 50                # ← réservé aux constantes

Nommez précisément

Un bon nom de variable décrit son contenu, même au prix de quelques caractères :

# ❌ Obscur
x = 0.20
t = 99.99

# ✅ Parlant
taux_tva = 0.20
prix_unitaire = 99.99

9.3 Les types simples (built-in)

Python possède plusieurs types natifs à connaître parfaitement pour le TOSA.

Les entiers (`int`)

Nombres sans virgule, précision illimitée (Python peut manipuler des entiers aussi grands que la mémoire le permet).

age = 30
grand_nombre = 10 ** 100   # un gogol
print(age, type(age))
print(grand_nombre)

30 <class 'int'>
10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

Les flottants (`float`)

Nombres à virgule, notation avec un point (.) en anglais — jamais de virgule.

pi = 3.14159
temperature = -5.5
ratio = 2.0      # un float même si la partie décimale est 0
print(pi, type(pi))

3.14159 <class 'float'>

⚠️ Piège TOSA : la précision des flottants

Les float ne sont pas parfaitement précis à cause de leur représentation binaire interne :

print(0.1 + 0.2)

0.30000000000000004

Résultat surprenant : 0.30000000000000004 au lieu de 0.3. C’est normal et commun à tous les langages. Pour des calculs financiers précis, on utilise le module decimal (hors programme Basique).

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

Textes délimités par des guillemets simples '...' ou doubles "...". Les deux sont équivalents.

nom = "Alice"
ville = 'Paris'
print(nom, type(nom))

Alice <class 'str'>

Pour inclure des apostrophes ou guillemets dans le texte, on alterne les délimiteurs :

phrase = "L'ami de Bob dit \"bonjour\"."
autre = 'Il a dit "salut"'
print(phrase)
print(autre)

L'ami de Bob dit "bonjour".
Il a dit "salut"

On verra les chaînes en détail au Chapitre 3.

Les booléens (`bool`)

Deux valeurs seulement : True (vrai) ou False (faux). Attention à la majuscule — c’est une convention Python stricte.

est_majeur = True
a_remise = False
print(est_majeur, type(est_majeur))

True <class 'bool'>

Les booléens résultent le plus souvent de comparaisons :

age = 25
est_majeur = age >= 18
print(est_majeur)

True

La valeur `None`

None représente l’absence de valeur. C’est l’équivalent Python de null ou nil dans d’autres langages.

resultat = None
print(resultat, type(resultat))

None <class 'NoneType'>

On l’utilise notamment :

Comme valeur par défaut d’une variable pas encore initialisée.
Comme valeur de retour d’une fonction qui ne renvoie « rien ».

Comparer à None

Toujours utiliser is et is not, jamais == :

# ✅ Correct
if resultat is None:
    ...

# ❌ À éviter (fonctionne mais non idiomatique)
if resultat == None:
    ...

La fonction `type()`

Pour connaître le type d’une valeur ou variable, on utilise la fonction native type() :

print(type(42))
print(type(3.14))
print(type("Alice"))
print(type(True))
print(type(None))

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

9.4 Les conversions de type (casting)

Python permet de convertir une valeur d’un type à un autre avec des fonctions portant le nom du type cible :

Fonction	Conversion vers	Exemple
`int(x)`	Entier	`int("42")` → `42`
`float(x)`	Flottant	`float("3.14")` → `3.14`
`str(x)`	Chaîne	`str(42)` → `"42"`
`bool(x)`	Booléen	`bool(0)` → `False`

Démonstrations :

# Chaîne → entier
age_txt = "30"
age = int(age_txt)
print(age, type(age))

30 <class 'int'>

# Entier → chaîne (pour concaténer du texte)
age = 30
message = "J'ai " + str(age) + " ans."
print(message)

J'ai 30 ans.

# Flottant → entier : ATTENTION, la partie décimale est TRONQUÉE (pas arrondie)
print(int(3.7))
print(int(-3.7))

3
-3

⚠️ Piège TOSA : int() tronque, ne arrondit pas

int(3.7) donne 3, pas 4. Pour arrondir, utilisez round() :

print(round(3.7))   # 4
print(int(3.7))     # 3 (troncature)

4
3

Conversions impossibles

Toutes les conversions ne sont pas possibles. int("abc") lève une ValueError :

int("abc")

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[18], line 1
----> 1 int("abc")

ValueError: invalid literal for int() with base 10: 'abc'

Alors que int("42") fonctionne car la chaîne contient un entier valide :

print(int("42"))

Le booléen en conversion

Un point important pour le TOSA : toute valeur peut être convertie en booléen. Sont considérés False :

Le nombre 0 (entier ou flottant).
La chaîne vide "".
Les collections vides [], {}, ().
La valeur None.

Tout le reste est True.

print(bool(0))        # False
print(bool(42))       # True
print(bool(""))       # False
print(bool("Bonjour"))# True
print(bool([]))       # False
print(bool([1, 2]))   # True
print(bool(None))     # False

False
True
False
True
False
True
False

🧩 Quiz 1.1 — Variables et types

Question 1

Quel est le type de x = 3.0 ?

int
float
str
bool

🔍 Réponse

b) float — la présence du point décimal (même si la partie décimale est nulle) en fait un flottant.

x = 3.0
print(type(x))

<class 'float'>

Question 2

Lequel de ces noms de variables est invalide en Python ?

nom_1
_age
2chats
prenomLong

🔍 Réponse

c) 2chats — un nom de variable ne peut pas commencer par un chiffre. Les autres sont valides (bien que prenomLong ne suive pas la convention PEP 8 qui préconise prenom_long).

Question 3

Que renvoie int("3.7") ?

3
4
3.7
Une erreur

🔍 Réponse

d) Une erreur (ValueError). int() ne sait pas convertir une chaîne qui contient un point décimal. Il faudrait passer par float :

int("3.7")

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[22], line 1
----> 1 int("3.7")

ValueError: invalid literal for int() with base 10: '3.7'

print(int(float("3.7")))   # 3 (troncature)

Question 4

Que vaut bool("") ?

True
False
None
Une erreur

🔍 Réponse

b) False — la chaîne vide est considérée comme fausse. Toute autre chaîne (même " " avec un espace !) est vraie.

print(bool(""))
print(bool(" "))

False
True

Question 5

Quelle est la bonne façon de comparer une variable à None ?

if x = None:
if x == None:
if x is None:
if x equals None:

🔍 Réponse

c) if x is None: — c’est la convention Python stricte. == fonctionne mais n’est pas idiomatique ; = est une affectation (pas une comparaison) ; equals n’existe pas en Python.

Question 6

Que renvoie ce code ?

x = 10
x = "dix"
print(type(x))

<class 'int'>
<class 'str'>
Une erreur (on ne peut pas changer de type)
<class 'type'>

🔍 Réponse

b) <class 'str'> — Python est à typage dynamique : une variable peut changer de type. x est réaffectée à une chaîne, donc type(x) est str.

x = 10
x = "dix"
print(type(x))

<class 'str'>

✏️ Exercice 1.1 — Calculs et conversions

Un étudiant obtient 3 notes : 12, 15 et 9. Écrivez un programme qui :

Stocke ces notes dans 3 variables.
Calcule et affiche leur moyenne.
Affiche un message de la forme : "La moyenne est 12.0 sur 20".

# Votre code ici
note1 = ...
note2 = ...
note3 = ...

moyenne = ...

print(...)

note1 = 12
note2 = 15
note3 = 9

moyenne = (note1 + note2 + note3) / 3

print("La moyenne est", moyenne, "sur 20")

La moyenne est 12.0 sur 20

note1 = 12
note2 = 15
note3 = 9

moyenne = (note1 + note2 + note3) / 3

# Conversion explicite en chaîne pour concaténer
print("La moyenne est " + str(moyenne) + " sur 20")

La moyenne est 12.0 sur 20

✏️ Exercice 1.2 — Saisie d’âge

Écrivez un programme qui demande à l’utilisateur son âge, puis affiche dans quelle année il est né (en supposant l’année courante 2026).

# Votre code
age_texte = input("Votre âge : ")
# Attention : input() renvoie une chaîne, il faut convertir !
age = ...

annee_naissance = ...

print("Vous êtes né(e) en", annee_naissance)

age_texte = input("Votre âge : ")
age = int(age_texte)           # conversion str → int

annee_naissance = 2026 - age

print("Vous êtes né(e) en", annee_naissance)

Démonstration avec un âge fixé :

age = 30  # au lieu de input() pour la démo
annee_naissance = 2026 - age
print("Vous êtes né(e) en", annee_naissance)

Vous êtes né(e) en 1996

Si l’utilisateur saisit autre chose qu’un nombre, int() plante. Version qui gère l’erreur :

age_texte = input("Votre âge : ")
try:
    age = int(age_texte)
    annee_naissance = 2026 - age
    print("Vous êtes né(e) en", annee_naissance)
except ValueError:
    print("Vous deviez saisir un nombre entier.")

La gestion des exceptions sera vue en détail au niveau Avancé.

✏️ Exercice 1.3 — Conversion de température

Écrivez un programme qui convertit une température de Celsius en Fahrenheit, sachant que F = C × 9/5 + 32.

celsius = 25   # degrés Celsius
fahrenheit = ...
print(celsius, "°C =", fahrenheit, "°F")

celsius = 25
fahrenheit = celsius * 9 / 5 + 32
print(celsius, "°C =", fahrenheit, "°F")

25 °C = 77.0 °F

celsius_txt = input("Température en °C : ")
celsius = float(celsius_txt)
fahrenheit = celsius * 9 / 5 + 32
print(celsius, "°C =", fahrenheit, "°F")

À retenir

Points clés du chapitre

Une variable se crée par affectation avec =. Pas de déclaration préalable.
Python a 5 types simples à maîtriser : int, float, str, bool, None.
Les nombres à virgule utilisent le point (3.14), jamais la virgule.
input() renvoie toujours une chaîne — convertissez avec int() ou float() pour faire des calculs.
int() tronque les flottants, round() arrondit.
bool(0), bool(""), bool([]), bool(None) valent tous False.
Comparez à None avec is, pas ==.

← Retour à la présentation du niveau • Chapitre suivant : Opérateurs →

9.1 La notion de variable

9.2 Règles de nommage des variables

Convention PEP 8 — snake_case

9.3 Les types simples (built-in)

Les entiers (int)

Les flottants (float)

Les chaînes de caractères (str)

Les booléens (bool)

La valeur None

La fonction type()

9.4 Les conversions de type (casting)

Conversions impossibles

Le booléen en conversion

🧩 Quiz 1.1 — Variables et types

Question 1

Question 2

Question 3

Question 4

Question 5

Question 6

✏️ Exercice 1.1 — Calculs et conversions

✏️ Exercice 1.2 — Saisie d’âge

✏️ Exercice 1.3 — Conversion de température

À retenir

Les entiers (`int`)

Les flottants (`float`)

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

Les booléens (`bool`)

La valeur `None`

La fonction `type()`