Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 1 / 73

PYTHON

LES VARIABLES

Le Guide Complet du Débutant

✅ Déclaration & règles de nommage (PEP 8)

✅ Types fondamentaux : int, float, str, bool

✅ Affectation, réaffectation, variables multiples

✅ input(), conversions de types (cast)

✅ Portée locale / globale — mot-clé global

✅ Constantes — gestion mémoire (id, mutable/immutable)

✅ Opérateurs arithmétiques, comparaison, logiques, is

✅ Annotations de type (type hints)

✅ is vs == en profondeur

✅ +50 exercices corrigés · 3 projets réels complets

Version Python 3.x · Niveau : Débutant absolu

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 2 / 73
 TABLE DES MATIÈRES

CHAPITRE Introduction aux Variables

1.1

1.1 Qu'est-ce qu'une variable ? 5

1.1.2 Déclaration des variables 7

1.1.3 Règles de nommage 11

1.1.4 Bonnes pratiques PEP 8 15

CHAPITRE Types de Données de Base

1.2

1.2.1 Integer — Entiers (int) 20

1.2.2 Float — Décimaux (float) 26

1.2.3 String — Chaînes de caractères (str) 32

1.2.4 Boolean — Booléens (bool) 42

CHAPITRE Opérations sur les Variables

1.3

1.3.1 Affectation & Réaffectation 49

1.3.2 Entrées utilisateur — input() 53

1.3.3 Conversion de types (cast) 58

1.3.4 Variables multiples & échange 64

CHAPITRE Portée & Mémoire

1.4

1.4.1 Portée des variables (locale / globale) 70

1.4.2 Constantes (convention) 76

1.4.3 Gestion mémoire — id(), mutable/immutable 80

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 3 / 73
CHAPITRE Opérateurs Applicables aux Variables
1.5

1.5.1 Opérateurs arithmétiques 87

1.5.2 Opérateurs de comparaison 91

1.5.3 Opérateurs logiques 94

1.5.4 Opérateurs d'appartenance (in, not in) 97

1.5.5 Opérateur d'identité (is, is not) 99

CHAPITRE Annotations de Type & is vs ==

1.6

1.6.1 Annotations de type (type hints) 103

1.6.2 Différence entre is et == 108

CHAPITRE Erreurs Fréquentes Récapitulatives

1.7

CHAPITRE Projet Final Corrigé

1.8

ANNEXE Projets Réels et Utiles

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 4 / 73
 CHAPITRE 1.1 — Introduction aux Variables

Avant d'écrire votre premier programme utile, vous devez maîtriser le concept fondamental de toute
programmation : la variable. Sans variables, un programme ne peut retenir aucune information, ne peut pas
réagir à l'utilisateur, et ne peut accomplir aucune tâche réelle.

1.1.1 — Qu'est-ce qu'une variable ?

ANALOGIE

Imaginez une boîte en carton portant une étiquette écrite au feutre.

L'étiquette, c'est le NOM de la variable.
Ce qu'il y a dans la boîte, c'est la VALEUR stockée.
Vous pouvez changer le contenu de la boîte sans changer l'étiquette.
Et grâce à l'étiquette, vous retrouvez toujours la boîte — même si son contenu a changé.

1. Définition technique

Une variable est un espace de stockage nommé en mémoire RAM qui contient une valeur. En Python,
contrairement au C, Java ou C++, il n'est pas nécessaire de déclarer le type à l'avance : Python l'infère
automatiquement. C'est ce qu'on appelle le typage dynamique.
La syntaxe universelle est : NOM = VALEUR. Le signe = est l'opérateur d'affectation (pas l'égalité
mathématique !).

2. Utilité — pourquoi les variables sont indispensables

• Stocker des informations : prénom, score, température, prix…

• Réutiliser une valeur sans la réécrire partout.
• Modifier une valeur en un seul endroit (maintenance facile).
• Rendre le code lisible

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 5 / 73
 • Communiquer des résultats intermédiaires entre les parties du programme.

3. Inconvénient SANS variables

SCÉNARIO SANS CETTE NOTION

Un programme de caisse calcule la TVA de 5 articles.

Sans variable, la valeur 0.20 est écrite en dur à 5 endroits.
Si la TVA passe à 21%, il faut modifier 5 lignes — risque d'en oublier une !

# ❌ CODE SANS VARIABLE — piège de maintenance

print(10.0 + 10.0 * 0.20)
print(25.0 + 25.0 * 0.20)
print(5.0 + 5.0 * 0.20)
# Si TVA → 0.21 : 3 modifications manuelles, risque d'erreur !

4. Solution AVEC variables

# ✅ CODE AVEC VARIABLES — maintenu en 1 seul endroit

tva = 0.20 # ← modifier UNE seule fois
prix_article_1 = 10.0
prix_article_2 = 25.0
prix_article_3 = 5.0

print(prix_article_1 + prix_article_1 * tva)

print(prix_article_2 + prix_article_2 * tva)
print(prix_article_3 + prix_article_3 * tva)

1.1.2 — Déclaration des variables

1. Syntaxe et mécanisme
En Python, déclarer une variable, c'est lui donner un nom et une valeur en même temps. Il n'y a pas de
mot-clé spécial (pas de var, let, int ou String comme dans d'autres langages).

# ─── Syntaxe générale ───

# nom_variable = valeur

# --- Types automatiquement détectés ---

prenom = "Marie" # str → chaîne de texte
age = 28 # int → entier
taille = 1.65 # float→ décimal
est_etudiant = True # bool → vrai/faux
inconnu = None # NoneType → absence de valeur
Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 6 / 73
 # --- Affectation multiple sur une ligne ---
x, y, z = 10, 20, 30 # trois variables en une ligne

# --- Affectation en chaîne (même valeur) ---

a = b = c = 0 # a, b et c valent tous 0

# --- Réaffectation ---

score = 100 # score vaut 100
score = 250 # score vaut maintenant 250
print(score) # → 250

📌 INFO — Coloration syntaxique utilisée dans ce livre

🔵 Bleu (569CD6) : mots-clés Python — True, False, None, if, for, def, class…
🔵 Jaune (DCDCAA) : noms de fonctions — print(), input(), len(), type()…
🔵 Orange(CE9178) : chaînes de caractères — "texte", 'texte'
🔵 Vert (B5CEA8) : nombres — 42, 3.14, -10
🔵 Vert foncé (6A9955) : commentaires — # ceci est un commentaire
🔵 Bleu pâle (9CDCFE) : noms de variables — prenom, age, score
🔵 Violet(C586C0) : fonctions intégrées — bool(), int(), str()…
⚪ Gris (D4D4D4) : code par défaut, opérateurs

2. Erreurs fréquentes

❌ ERREUR FRÉQUENTE — Variable utilisée avant d'être déclarée

Code erroné :
print(resultat) # NameError: name 'resultat' is not defined
resultat = 42

Solution : toujours déclarer AVANT d'utiliser.

resultat = 42
print(resultat) # ✅→ 42

❌ ERREUR FRÉQUENTE — Confondre = (affectation) et == (comparaison)

Code erroné :
age = 18 # ← affectation : ok
if age = 18: # ← SyntaxError ! = interdit dans un if

Solution : == pour comparer, = pour affecter.

if age == 18: # ✅double égal pour comparer

❌ ERREUR FRÉQUENTE — Espace ou tiret dans le nom de variable

Code erroné :
mon nom = "Alice" # SyntaxError : espace interdit
mon-age = 25 # SyntaxError : tiret interdit

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 7 / 73
 Solution : utiliser l'underscore _ à la place.
mon_nom = "Alice" # ✅
mon_age = 25 #✅

❌ ERREUR FRÉQUENTE — Commencer le nom par un chiffre

Code erroné :
1er_prix = 100 # SyntaxError

Solution : commencer par une lettre ou _.

premier_prix = 100 # ✅

3. Exercices corrigés — Déclaration

📌 EXERCICE 1 — Déclaration basique

Déclarez une variable message = "Bonjour Python!" et affichez-la avec print().

✅ CORRIGÉ 1 — Déclaration basique

Code :
message = "Bonjour Python!" # Déclaration
print(message) # Affichage

Sortie console :
Bonjour Python!

Explication pas à pas :

1) On crée la variable message avec l'opérateur =
2) Python détecte automatiquement le type str (chaîne)
3) print() affiche le CONTENU de la variable, pas son nom

📌 EXERCICE 2 — Variables numériques

longueur=15, largeur=8, hauteur=3. Calculez et affichez volume = l×L×h.

✅ CORRIGÉ 2 — Variables numériques

longueur = 15
largeur = 8
hauteur = 3
volume = longueur * largeur * hauteur # 15×8×3 = 360
print(volume) # → 360

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 8 / 73
 📌 EXERCICE 3 — Réaffectation
Créez compteur=0. Ajoutez-lui 1 trois fois. Affichez après chaque ajout.

✅ CORRIGÉ 3 — Réaffectation
compteur = 0
print(compteur) #→0
compteur = compteur + 1
print(compteur) #→1
compteur = compteur + 1
print(compteur) #→2
compteur = compteur + 1
print(compteur) #→3

Version abrégée : compteur += 1 (identique à compteur = compteur + 1)

📌 EXERCICE 4 — Affectation multiple

En une seule ligne : x=5, y=10, z=15. Calculez et affichez leur somme.

✅ CORRIGÉ 4 — Affectation multiple

x, y, z = 5, 10, 15 # tuple unpacking
somme = x + y + z
print(somme) # → 30

Python décompacte le côté droit (5,10,15) et assigne chaque valeur

à la variable correspondante (x, y, z) — dans l'ordre.

📌 EXERCICE 5 — Variable None

Créez une variable resultat = None. Affichez-la et son type.

✅ CORRIGÉ 5 — Variable None

resultat = None
print(resultat) # → None
print(type(resultat)) # → <class 'NoneType'>

None représente l'absence de valeur — utile pour initialiser une

variable dont la valeur sera calculée plus tard.

4. Exercices non corrigés — À vous !

📌 EXERCICE 6 — À vous !
Créez nom_ville="Paris" et population=2161000. Affichez les deux. (Indice : print() pour
chacune)

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 9 / 73
 📌 EXERCICE 7 — À vous !
Calculez perimetre = 2×(longueur + largeur) avec longueur=12, largeur=7. Affichez le résultat.

📌 EXERCICE 8 — À vous !
Déclarez a=100, b=200. Échangez leurs valeurs (a=200, b=100). (Indice : variable temporaire
temp)

📌 EXERCICE 9 — À vous !
phrase="Apprendre Python". Réaffectez-lui "Python est génial !". Affichez les deux états.

📌 EXERCICE 10 — À vous !
prix_ht=49.90, taux_tva=0.20. Calculez et affichez prix_ttc. (Indice : ht + ht * tva)

📌 RÉSUMÉ DU POINT
Une variable est un nom qui pointe vers une valeur en mémoire RAM.
En Python, on la crée par simple affectation : nom = valeur — sans mot-clé spécial.
L'opérateur = est l'AFFECTATION (pas l'égalité) ; == est la comparaison.
Une variable peut être réaffectée autant de fois que nécessaire.
Python détecte automatiquement le type selon la valeur (typage dynamique).

Mot / Concept (Python) Traduction française Mode d'emploi en Python

variable variable nom = valeur → crée un espace

mémoire nommé
= (simple) affectation x = 10 → stocke 10 dans x
== (double) comparaison x == 10 → teste si x vaut 10
x, y = 1, 2 affectation multiple deux variables en une ligne
a = b = 0 affectation chaîne a et b valent tous les deux 0
réaffectation changement de valeur x = 5 puis x = 10 → x vaut 10
None absence de valeur x = None → variable sans valeur
NameError erreur de nom variable utilisée avant d'être définie

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 10 / 73
 1.1.3 — Règles de nommage

📌 SCÉNARIO SANS CETTE NOTION

Sans règles de nommage claires, le code devient illisible.
Imaginez un programme avec des variables nommées a, b, c, x1, tmp2, zz — impossible à
déboguer !

1. Règles OBLIGATOIRES imposées par Python

• Commence par une lettre (a-z, A-Z) ou un underscore (_).
• Contient uniquement des lettres, des chiffres (0-9) et des underscores.
• Pas d'espace, pas de tiret (-), pas de caractère spécial (!@#$%^&*).
• Ne peut pas être un mot-clé réservé Python (if, for, class, True, False…).
• Sensible à la casse : age ≠ Age ≠ AGE — trois variables différentes !

✅ Noms valides ❌ Noms invalides — raison

prenom 1prenom → commence par un chiffre

_age mon age → contient un espace

total_ht total-ht → contient un tiret

prix2024 if → mot-clé réservé Python

montantTTC @email → caractère spécial

_private_var True → valeur booléenne réservée

2. Mots-clés réservés (à ne jamais utiliser comme noms)

# 35 mots réservés en Python 3 — INTERDITS 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

📌 ASTUCE — Vérifier si un mot est réservé

import keyword
print([Link]) # Liste complète
print([Link]("for")) # → True
print([Link]("prix")) # → False

3. Sensibilité à la casse

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 11 / 73
 # Ces TROIS noms sont trois variables DISTINCTES !
age = 25 # variable n°1
Age = 30 # variable n°2 — DIFFÉRENTE !
AGE = 99 # variable n°3 — DIFFÉRENTE !

print(age) # → 25
print(Age) # → 30
print(AGE) # → 99

4. Erreurs fréquentes — Nommage

❌ ERREUR FRÉQUENTE — Mot-clé utilisé comme nom de variable

for = 5 # SyntaxError: invalid syntax
if = "test" # SyntaxError: invalid syntax

Solution : ajouter _ ou changer le nom.

for_ = 5 # ✅underscore final autorisé
condition = "test" # ✅nom explicite

❌ ERREUR FRÉQUENTE — Confusion majuscule/minuscule

Nom = "Alice"
print(nom) # NameError: name 'nom' is not defined

Solution : utiliser exactement le même nom partout.

nom = "Alice"
print(nom) # ✅→ Alice

❌ ERREUR FRÉQUENTE — Accent dans le nom (légal mais déconseillé)

prénom = "Alice" # Légal en Python 3, mais...

Problème : encodages différents selon OS/éditeur → bugs subtils.

Solution : lettres ASCII uniquement (a-z, A-Z).
prenom = "Alice" # ✅universellement compatible

5. Exercices corrigés — Nommage

📌 EXERCICE 1 — Noms valides ou invalides

Lesquels sont valides ? 2eme, _score, class, total HT, monNom, x1y2z3, lambda_

✅ CORRIGÉ 1 — Noms valides ou invalides

✅Valides : _score, monNom, x1y2z3, lambda_
❌Invalides :
2eme → commence par un chiffre
class → mot-clé réservé

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 12 / 73
 total HT → espace interdit

📌 EXERCICE 2 — Corriger les noms

Corrigez : 1prix, mon-age, for, total$, class_name reçue

✅ CORRIGÉ 2 — Corriger les noms

1prix → premier_prix
mon-age → mon_age
for → for_ (ou boucle, iteration)
total$ → total_dollars
class_name reçue→ classe_recue (sans accent ni espace)

📌 EXERCICE 3 — Casse et variables

Que s'affiche-t-il ? x = "bonjour" X = "BONSOIR" print(x) print(X)

✅ CORRIGÉ 3 — Casse et variables

Affichage : bonjour
BONSOIR

x et X sont deux variables DISTINCTES. Python est sensible à la casse.

📌 EXERCICE 4 — Mot-clé ?
import keyword ; print([Link]("pass")) — qu'affiche-t-il ? Pourquoi ?

✅ CORRIGÉ 4 — Mot-clé ?
→ True

pass est un mot-clé Python (instruction de non-opération).

Il ne peut donc pas être utilisé comme nom de variable.

📌 EXERCICE 5 — Nommage expressif

Renommez : a, b, c, x, tmp pour un programme de gestion d'élèves.

✅ CORRIGÉ 5 — Nommage expressif

a → prenom_eleve
b → nom_famille
c → note_moyenne
x → numero_etudiant
tmp → note_temporaire

Exercices non corrigés

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 13 / 73
 📌 EXERCICE 6 — À vous !
Listez 5 noms valides pour une appli météo (température, humidité, ville, vent, date).

📌 EXERCICE 7 — À vous !
[Link]("lambda") — True ou False ? Pourquoi ?

📌 EXERCICE 8 — À vous !
Créez couleur, Couleur, COULEUR avec des valeurs différentes. Affichez les trois.

📌 EXERCICE 9 — À vous !
Corrigez : 1vitesse, km-heure, if_cond, total €, Année Naissance.

📌 EXERCICE 10 — À vous !
Qu'est-ce que le snake_case ? Donnez 5 exemples de votre invention.

📌 RÉSUMÉ DU POINT
Un nom de variable doit commencer par une lettre ou _ — jamais par un chiffre.
Il ne peut contenir que des lettres, chiffres et underscores (pas d'espace ni tiret).
Les 35 mots-clés Python sont réservés et interdits comme noms.
Python est sensible à la casse : age, Age et AGE sont trois variables distinctes.
Évitez les accents : utilisez prenom plutôt que prénom pour la portabilité.

Mot / Concept (Python) Traduction française Mode d'emploi en Python

snake_case style serpent (recommandé) mon_age, prix_ttc, nom_utilisateur

identifiant nom de variable tout nom valide Python
keyword mot-clé réservé if, for, class, True, False, None…
case sensitive sensible à la casse age ≠ Age ≠ AGE
SyntaxError erreur de syntaxe nom invalide → Python refuse
NameError erreur de nom variable non définie utilisée
underscore _ séparateur mon_age au lieu de monAge

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 14 / 73
 1.1.4 — Bonnes pratiques (PEP 8)

1. Définition
PEP 8 (Python Enhancement Proposal n°8) est le guide de style officiel de Python, rédigé par Guido van
Rossum. Il définit des conventions de formatage et de nommage. Ces règles ne sont pas imposées par
Python mais sont indispensables dans le monde professionnel.

Contexte Convention PEP 8 Exemple

Variable / Fonction snake_case mon_age, calculer_prix()

Constante SCREAMING_SNAKE_CASE TVA = 0.20, PI = 3.14159

Classe CamelCase CompteBancaire, Utilisateur

Module (fichier .py) snake_case gestion_stock.py

Variable privée _underscore_debut _cache, _temp

Variable très privée __double_underscore __pin, __secret

# ✅ Code respectant PEP 8

TVA = 0.20 # CONSTANTE en SCREAMING_SNAKE_CASE
prix_hors_taxe = 49.90 # variable en snake_case
prix_ttc = prix_hors_taxe * (1 + TVA)

# ❌ Code NON conforme PEP 8

PrixHorsTaxe=49.90 # camelCase → style Java
tva=0.20 # constante en minuscules
PRIX_TTC=PrixHorsTaxe*(1+tva)# variable en MAJUSCULES

📌 ASTUCE — Outils automatiques pour respecter PEP 8

black → reformate automatiquement (pip install black)
flake8 → détecte les violations (pip install flake8)
autopep8 → corrige automatiquement (pip install autopep8)

Usage : black mon_fichier.py ou flake8 mon_fichier.py

2. Erreurs fréquentes — Style

❌ ERREUR FRÉQUENTE — camelCase au lieu de snake_case

monAge = 25 # ❌style Java
prixTotal = 99.99 # ❌

mon_age = 25 # ✅ PEP 8
prix_total = 99.99 # ✅

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 15 / 73
 ❌ ERREUR FRÉQUENTE — Constante non signalée
tva = 0.20 # ❌on ne sait pas que c'est une constante

TVA = 0.20 # ✅MAJUSCULES → signal visuel "ne pas modifier"

3. Exercices corrigés — PEP 8

📌 EXERCICE 1 — Réécriture PEP 8

Réécrivez selon PEP 8 : MonAge, PRENOM, nb_tentatives_USER, prix$Total

✅ CORRIGÉ 1 — Réécriture PEP 8

MonAge → mon_age
PRENOM → prenom (ou PRENOM si c'est une constante)
nb_tentatives_USER → nb_tentatives_user
prix$Total → prix_total

📌 EXERCICE 2 — Contexte de nommage

Identifiez la convention pour : classe Voiture, fonction calculer_distance(), constante
VITESSE_SON, variable temporaire temp.

✅ CORRIGÉ 2 — Contexte de nommage

Voiture → CamelCase ✅(classe)
calculer_distance → snake_case ✅(fonction)
VITESSE_SON → SCREAMING_SNAKE_CASE ✅(constante)
temp → snake_case ✅(variable temporaire)

📌 EXERCICE 3 — Lire du mauvais code

Identifiez les violations PEP 8 : X=10 prixTtc=19.99 Nom_Utilisateur="bob"

✅ CORRIGÉ 3 — Lire du mauvais code

X=10 → x = 10 (minuscule + espaces autour de =)
prixTtc=19.99 → prix_ttc = 19.99 (snake_case + espaces)
Nom_Utilisateur → nom_utilisateur (tout en minuscules)

Exercices non corrigés

📌 EXERCICE 4 — À vous !
Écrivez 5 variables PEP 8 pour une appli météo : température, humidité, ville, date, vent.

📌 EXERCICE 5 — À vous !

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 16 / 73
 Créez 3 constantes (PI, VITESSE_SON, GRAVITE) et 3 variables. Affichez-les.

📌 EXERCICE 6 — À vous !
Réécrivez un code existant en améliorant uniquement le nommage selon PEP 8.

📌 RÉSUMÉ DU POINT
PEP 8 est le guide de style officiel Python — non obligatoire mais indispensable en pratique.
Variables et fonctions : snake_case (minuscules + underscores).
Constantes : SCREAMING_SNAKE_CASE (tout en majuscules).
Classes : CamelCase (chaque mot commence par une majuscule).
Des outils (black, flake8) automatisent la vérification et la correction.

Mot / Concept (Python) Traduction française Mode d'emploi en Python

snake_case style recommandé variables mon_age, prix_ttc, nom_utilisateur

SCREAMING_SNAKE style constantes TVA = 0.20, PI = 3.14159
CamelCase style classes CompteBancaire, GestionStock
PEP 8 guide de style officiel [Link]/peps/pep-0008/
black formateur automatique pip install black → black [Link]
flake8 vérificateur pip install flake8 → détecte violations

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 17 / 73
 CHAPITRE 1.2 — Types de Données de Base

Chaque valeur en Python appartient à un type précis. Le type détermine ce qu'on peut faire avec la valeur
: additionner des nombres, concaténer du texte, tester une condition. Python détecte le type
automatiquement selon la valeur affectée.

1.2.1 — Integer — Entiers (int)

📌 SCÉNARIO SANS CETTE NOTION

Sans le type int, impossible de compter des articles, gérer des scores de jeu,
numéroter des pages ou calculer des quantités entières exactes.

1. Définition
Un entier (int) est un nombre sans partie décimale. En Python 3, les entiers ont une précision ILLIMITÉE
— pas de débordement possible, même pour des nombres astronomiques.

# --- Différentes façons de créer un int ---

population = 8_100_000_000 # Underscore pour lisibilité (Python 3.6+)
temperature = -18 # Entier négatif
score = 0 # Zéro
hexa = 0xFF # Hexadécimal → 255
binaire = 0b1010 # Binaire → 10
octal = 0o17 # Octal → 15

print(type(score)) # → <class 'int'>

print(2 ** 1000) # Nombre de 302 chiffres — aucun problème !

2. Opérateurs sur les entiers

Opérateur Nom Exemple Résultat

+ Addition 5+3 8

- Soustraction 10 - 4 6

* Multiplication 6*7 42

// Division entière 17 // 5 3 (arrondi bas)

% Modulo (reste) 17 % 5 2

** Puissance 2 ** 10 1024

abs() Valeur absolue abs(-42) 42

divmod(a,b) Quotient+reste divmod(17,5) (3, 2)

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 18 / 73
 a, b = 17, 5
print(a + b) # → 22
print(a - b) # → 12
print(a * b) # → 85
print(a // b) # → 3 (division entière)
print(a % b) # → 2 (reste)
print(a ** b) # → 1419857

# Priorité des opérations — PEMDAS

print(2 + 3 * 4) # → 14 (* avant +)
print((2 + 3) * 4) # → 20 (parenthèses en premier)

3. Erreurs fréquentes

❌ ERREUR FRÉQUENTE — / renvoie toujours un float, pas un int

resultat = 10 / 2 # → 5.0 (float !) pas 5

resultat = 10 // 2 # → 5 (int) — division entière

❌ ERREUR FRÉQUENTE — Oublier la priorité des opérateurs

moy = 10 + 14 + 18 / 3 # → 10 + 14 + 6.0 = 30.0 (FAUX !)
moy = (10 + 14 + 18) / 3 # → 42 / 3 = 14.0 (correct)

❌ ERREUR FRÉQUENTE — Division par zéro

n=0
result = 10 / n # ZeroDivisionError !

Vérifier avant de diviser :

if n != 0:
result = 10 / n

4. Exercices corrigés

📌 EXERCICE 1 — Score de jeu

score_initial=500, bonus=150, penalite=80. Calculez et affichez score_final.

✅ CORRIGÉ 1 — Score de jeu

score_initial = 500
bonus = 150
penalite = 80
score_final = score_initial + bonus - penalite
print(score_final) # → 570

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 19 / 73
 📌 EXERCICE 2 — Partage de pommes
37 pommes, 5 enfants. Combien chacun reçoit-il ? Combien reste-t-il ?

✅ CORRIGÉ 2 — Partage de pommes

total = 37
enfants = 5
chaque = total // enfants # → 7
reste = total % enfants # → 2
print("Chaque enfant reçoit :", chaque)
print("Reste :", reste)

📌 EXERCICE 3 — Secondes dans une année

Calculez combien de secondes il y a dans une année de 365 jours.

✅ CORRIGÉ 3 — Secondes dans une année

secondes_par_minute = 60
minutes_par_heure = 60
heures_par_jour = 24
jours_par_an = 365
secondes_par_an = secondes_par_minute * minutes_par_heure * heures_par_jour *
jours_par_an
print(secondes_par_an) # → 31 536 000

📌 EXERCICE 4 — Conversions de bases

Convertissez 255 en binaire, hexadécimal et octal.

✅ CORRIGÉ 4 — Conversions de bases

n = 255
print(bin(n)) # → 0b11111111
print(hex(n)) # → 0xff
print(oct(n)) # → 0o377

📌 EXERCICE 5 — Puissance et grand nombre

Calculez 2^32 et 10^100. Python gère-t-il ces grands nombres ?

✅ CORRIGÉ 5 — Puissance et grand nombre

print(2 ** 32) # → 4 294 967 296
print(10 ** 100) # → 1 suivi de 100 zéros (googol !)
# Oui, Python gère des entiers arbitrairement grands.

Exercices non corrigés

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 20 / 73
 📌 EXERCICE 6 — À vous !
Calculez la somme 1+2+…+100 avec la formule n*(n+1)//2.

📌 EXERCICE 7 — À vous !
Avec 100€ et des articles à 3€, combien peut-on en acheter ? Combien reste-t-il ?

📌 EXERCICE 8 — À vous !
Vérifiez si 2024 est bissextile (divisible par 4 ; si par 100 → doit être divisible par 400).

📌 EXERCICE 9 — À vous !
Calculez le chiffre des unités de 7^100 (astuce : 7**100 % 10).

📌 EXERCICE 10 — À vous !
PGCD de 48 et 18 : algorithme d'Euclide (a, b = b, a % b jusqu'à b==0).

📌 RÉSUMÉ DU POINT
Le type int représente les entiers — précision illimitée en Python 3.
Opérateurs clés : + - * // (division entière) % (modulo) ** (puissance).
La division / renvoie TOUJOURS un float ; // renvoie toujours un int.
Priorité : parenthèses > puissance > * / % > + - (règle PEMDAS).
Bases alternatives : 0b (binaire), 0x (hexa), 0o (octal). Underscore pour lisibilité.

Mot / Concept (Python) Traduction française Mode d'emploi en Python

int entier age = 25 / score = 0 / n = -10

// division entière 17 // 5 → 3
% modulo (reste) 17 % 5 → 2
** puissance 2 ** 8 → 256
abs(n) valeur absolue abs(-15) → 15
bin(n) en binaire bin(10) → "0b1010"
hex(n) en hexadécimal hex(255) → "0xff"
divmod(a,b) quotient + reste divmod(17,5) → (3, 2)

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 21 / 73
 1.2.2 — Float — Décimaux (float)

📌 SCÉNARIO SANS CETTE NOTION

Sans float, comment représenter 9.99€, 36.6°C ou 75.3 kg ?
Avec des entiers, vous ne pourriez stocker que 9, 36 ou 75 — perte d'information !

1. Définition
Un float représente un nombre décimal. Python utilise le point (.) comme séparateur décimal (jamais la
virgule). Les floats sont stockés en binaire IEEE 754 64 bits, ce qui implique des limites de précision.

prix = 9.99 # Prix en euros

temperature = 36.6 # Température
negatif = -0.5 # Float négatif
grand = 1.5e10 # Notation scientifique : 1.5 × 10¹⁰
petit = 2.3e-4 # 0.00023

# Division / → toujours float

print(10 / 2) # → 5.0 (float, pas 5 !)
print(type(9.99)) # → <class 'float'>

2. Problème de précision — piège majeur

# ⚠️ Les floats ne sont PAS exacts !

print(0.1 + 0.2) # → 0.30000000000000004 !!!
print(0.1 + 0.2 == 0.3) # → False !!!

# ✅ Solution 1 : round()
print(round(0.1 + 0.2, 2)) # → 0.3

# ✅ Solution 2 : module decimal (calculs exacts)

from decimal import Decimal
print(Decimal('0.1') + Decimal('0.2')) # → 0.3

3. Fonctions utiles

import math
n = 3.7

print(round(n, 1)) # → 3.7 (arrondi à 1 décimale)

print(round(n)) # → 4 (arrondi à l'entier)
print(int(n)) # → 3 (troncature, pas arrondi !)
print([Link](n)) # → 3 (toujours vers le bas)
print([Link](n)) # → 4 (toujours vers le haut)
print([Link](16)) # → 4.0 (racine carrée)

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 22 / 73
4. Erreurs fréquentes

❌ ERREUR FRÉQUENTE — Virgule au lieu du point

prix = 9,99 # → crée un TUPLE (9, 99), pas 9.99 !

prix = 9.99 # ✅Toujours utiliser le POINT

❌ ERREUR FRÉQUENTE — Comparer deux floats avec ==

if 0.1 + 0.2 == 0.3: # → False ! Erreur de précision binaire

if abs((0.1 + 0.2) - 0.3) < 1e-9: # ✅Tolérance

❌ ERREUR FRÉQUENTE — Calculs monétaires avec float

total = 1.10 + 2.20 # → 3.3000000000000003 !

from decimal import Decimal

total = Decimal("1.10") + Decimal("2.20") # → 3.30 ✅

5. Exercices corrigés

📌 EXERCICE 1 — Prix TTC

prix_ht=12.50€, TVA=20%. Calculez prix_ttc arrondi à 2 décimales.

✅ CORRIGÉ 1 — Prix TTC

prix_ht = 12.50
tva = 0.20
prix_ttc = prix_ht * (1 + tva)
print(round(prix_ttc, 2)) # → 15.0

📌 EXERCICE 2 — IMC
poids=70.5 kg, taille=1.75 m. IMC = poids / taille². Affichez arrondi à 2 décimales.

✅ CORRIGÉ 2 — IMC
poids = 70.5
taille = 1.75
imc = poids / (taille ** 2)
print(round(imc, 2)) # → 23.02

📌 EXERCICE 3 — Conversion Fahrenheit → Celsius

100°F en °C. Formule : C = (F - 32) × 5 / 9.

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 23 / 73
 ✅ CORRIGÉ 3 — Conversion Fahrenheit → Celsius
fahrenheit = 100
celsius = (fahrenheit - 32) * 5 / 9
print(round(celsius, 2)) # → 37.78

📌 EXERCICE 4 — Notation scientifique

Déclarez vitesse_lumiere = 3e8 m/s. Affichez en décimal et son type.

✅ CORRIGÉ 4 — Notation scientifique

vitesse_lumiere = 3e8
print(vitesse_lumiere) # → 300000000.0
print(type(vitesse_lumiere)) # → <class 'float'>

📌 EXERCICE 5 — Arrondi vs troncature

Pour n=7.8 et n=-7.8 : affichez int(), round(), floor(), ceil().

✅ CORRIGÉ 5 — Arrondi vs troncature

import math
for n in [7.8, -7.8]:
print(f"n={n}: int={int(n)}, round={round(n)}, floor={[Link](n)}, ceil={[Link](n)}")
# n=7.8 : int=7, round=8, floor=7, ceil=8
# n=-7.8 : int=-7, round=-8, floor=-8, ceil=-7

Exercices non corrigés

📌 EXERCICE 6 — À vous !
Calculez l'aire d'un cercle de rayon 7.5 cm (pi ≈ 3.14159).

📌 EXERCICE 7 — À vous !
Comparez 0.1+0.2 et 0.3 : d'abord ==, puis avec abs() et une tolérance 1e-9.

📌 EXERCICE 8 — À vous !
Calculez la moyenne de : 14.5, 12.0, 17.5, 9.0, 16.0.

📌 EXERCICE 9 — À vous !
Qu'affiche float("inf") + 1 ? Et float("nan") + 1 ?

📌 EXERCICE 10 — À vous !

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 24 / 73
 from decimal import Decimal : calculez 1.1 + 2.2. Comparez avec float ordinaire.

📌 RÉSUMÉ DU POINT
Le type float représente les décimaux. Toujours utiliser le POINT (jamais la virgule).
Les floats sont des approximations binaires : 0.1 + 0.2 ≠ 0.3 exactement.
round(n, d) pour arrondir ; int(n) pour tronquer ; [Link]/ceil pour des arrondis précis.
Pour des calculs monétaires exacts : utiliser le module decimal.
La notation scientifique 1.5e10 = 15 milliards est supportée nativement.

Mot / Concept (Python) Traduction française Mode d'emploi en Python

float décimal prix = 9.99 / temp = 36.6

1.5e10 notation scientifique 1.5 × 10¹⁰ = 15 000 000 000.0
round(n, d) arrondir round(3.14159, 2) → 3.14
int(f) tronquer (pas arrondir) int(3.9) → 3
[Link](f) arrondi vers le bas [Link](3.9) → 3
[Link](f) arrondi vers le haut [Link](3.1) → 4
Decimal précision exacte from decimal import Decimal

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 25 / 73
 1.2.3 — String — Chaînes de caractères (str)

SCÉNARIO SANS CETTE NOTION

Sans str, impossible d'afficher un message, lire un prénom, stocker une adresse email.
Les chaînes sont le type le plus utilisé dans les programmes du quotidien.

1. Définition
Une chaîne (str) est une séquence ordonnée et IMMUABLE de caractères. On la délimite par des
guillemets simples, doubles, ou triples.

s1 = 'guillemets simples'
s2 = "guillemets doubles"
s3 = '''triple guillemets
sur plusieurs lignes'''

# Séquences d'échappement
tab = "Colonne1\tColonne2" # \t = tabulation
nl = "Ligne1\nLigne2" # \n = saut de ligne
raw = r"C:\Users\Alice" # r = raw : \ non interprété

# f-strings (Python 3.6+) — méthode recommandée

prenom = "Alice"
age = 25
msg = f"Bonjour {prenom}, tu as {age} ans !"
print(msg) # → Bonjour Alice, tu as 25 ans !
print(f"Dans 5 ans : {age+5} ans") # calcul dans le f-string

2. Indexation et slicing

mot = "Python"
# P y t h o n
# 0 1 2 3 4 5 ← indices positifs
# -6 -5 -4 -3 -2 -1 ← indices négatifs

print(mot[0]) # → P (premier)
print(mot[-1]) # → n (dernier)
print(mot[1:4]) # → yth
print(mot[::-1]) # → nohtyP (inversé)
print(mot[::2]) # → Pto (1 caractère sur 2)

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 26 / 73
3. Méthodes des chaînes les plus utiles
Méthode Description Exemple → Résultat

.upper() Tout en majuscules "python".upper() → "PYTHON"

.lower() Tout en minuscules "PYTHON".lower() → "python"

.capitalize() 1ère lettre maj. "alice".capitalize() → "Alice"

.title() Chaque mot maj. "bon jour".title() → "Bon Jour"

.strip() Supprime espaces " hi ".strip() → "hi"

début/fin

.replace(a,b) Remplace a par b "chat".replace("ch","b") → "bat"

.split(sep) Découpe en liste "a,b".split(",") → ["a","b"]

.join(list) Réunit une liste ",".join(["a","b"]) → "a,b"

.find(s) Indice (−1 si absent) "bonjour".find("jo") → 3

.startswith(s) Commence par s ? "Python".startswith("Py") → True

.endswith(s) Finit par s ? "[Link]".endswith(".py") → True

.isdigit() Que des chiffres ? "123".isdigit() → True

.isalpha() Que des lettres ? "abc".isalpha() → True

.zfill(n) Rembourre avec 0 "42".zfill(5) → "00042"

# --- Chaînage de méthodes ---

saisie = " alice MARTIN "
propre = [Link]().title()
print(propre) # → "Alice Martin"

# --- ⚠️ Les méthodes ne modifient PAS l'original ---

texte = "bonjour"
[Link]() # Appel SANS capturer le résultat
print(texte) # → "bonjour" (INCHANGÉ !)

texte = [Link]() # ✅ On réaffecte

print(texte) # → "BONJOUR"

4. Erreurs fréquentes

❌ ERREUR FRÉQUENTE — Oublier les guillemets

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

❌ ERREUR FRÉQUENTE — Concaténer str et int sans conversion

age = 25

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 27 / 73
 print("Âge : " + age) # TypeError !

print("Âge : " + str(age)) # ✅

print(f"Âge : {age}") # ✅f-string recommandé

❌ ERREUR FRÉQUENTE — IndexError — indice hors limites

mot = "Python"
print(mot[10]) # IndexError: string index out of range

if 10 < len(mot): # Vérifier avant d'accéder

print(mot[10])

5. Exercices corrigés

📌 EXERCICE 1 — Nettoyage et casse

Saisie " alice MARTIN " → formater en "Alice Martin".

✅ CORRIGÉ 1 — Nettoyage et casse

saisie = " alice MARTIN "
formate = [Link]().title()
print(formate) # → "Alice Martin"

📌 EXERCICE 2 — f-string complet

Créez un message de bienvenue avec prénom, âge et ville.

✅ CORRIGÉ 2 — f-string complet

prenom = "Lucas"
age = 17
ville = "Lyon"
print(f"Bienvenue {prenom} ! Tu as {age} ans et tu habites à {ville}.")

📌 EXERCICE 3 — Inversion
Inversez "Bonjour" avec le slicing [::-1].

✅ CORRIGÉ 3 — Inversion
mot = "Bonjour"
print(mot[::-1]) # → ruojnoB

📌 EXERCICE 4 — Décomposer/recomposer
Séparez "Paris:Lyon:Marseille" par ":" et rejoignez avec " - ".

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 28 / 73
 ✅ CORRIGÉ 4 — Décomposer/recomposer
villes = "Paris:Lyon:Marseille"
liste = [Link](":") # → ["Paris","Lyon","Marseille"]
resultat = " - ".join(liste) # → "Paris - Lyon - Marseille"
print(resultat)

📌 EXERCICE 5 — Vérification code postal

Vérifiez qu'un code postal contient exactement 5 chiffres.

✅ CORRIGÉ 5 — Vérification code postal

cp = "75001"
valide = len(cp) == 5 and [Link]()
print(valide) # → True

cp = "7500A"
valide = len(cp) == 5 and [Link]()
print(valide) # → False

Exercices non corrigés

📌 EXERCICE 6 — À vous !
Affichez "RAPPORT ANNUEL" centré dans une ligne de 50 "=" grâce à .center().

📌 EXERCICE 7 — À vous !
Comptez combien de fois "e" apparaît dans "les éléments essentiels".

📌 EXERCICE 8 — À vous !
Vérifiez si "data_science.py" commence par "data" et finit par ".py".

📌 EXERCICE 9 — À vous !
Affichez chaque caractère de "Bonjour" sur une ligne séparée. (for c in mot)

📌 EXERCICE 10 — À vous !
Comparez "python" == "Python". Pourquoi ce résultat ? Corrigez pour les comparer sans tenir
compte de la casse.

📌 RÉSUMÉ DU POINT

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 29 / 73
 Le type str est une séquence immuable de caractères entre guillemets simples, doubles ou
triples.
Indexation : s[0] = premier, s[-1] = dernier. Slicing : s[a:b:p].
Les f-strings (f"texte {variable}") sont la façon moderne de formater les chaînes.
Les méthodes (.upper, .strip, .replace, .split, .join…) retournent de NOUVELLES chaînes.
Chaînage possible : [Link]().lower().replace(" ","_").

Mot / Concept (Python) Traduction française Mode d'emploi en Python

str chaîne de caractères nom = "Alice"

f-string chaîne formatée f"Bonjour {prenom} !"
s[i] indexation s[0]=premier, s[-1]=dernier
s[a:b:p] slicing s[1:4] ou s[::-1] (inversé)
.upper()/.lower() changer la casse "abc".upper() → "ABC"
.strip() supprimer espaces " hi ".strip() → "hi"
.split(sep) découper→liste "a,b".split(",") → ["a","b"]
.join(lst) liste→chaîne ",".join(["a","b"]) → "a,b"
immuable non modifiable s[0]="X" → TypeError

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 30 / 73
 12.4 — Boolean — Booléens (bool)

📌 SCÉNARIO SANS CETTE NOTION

Sans bool, comment représenter qu'un utilisateur est connecté ou non ?
Qu'une porte est verrouillée ou ouverte ? Que l'accès est autorisé ou refusé ?

1. Définition
Un booléen (bool) ne peut prendre que deux valeurs : True (Vrai) ou False (Faux) — avec majuscule
obligatoire. bool est une sous-classe de int en Python : True vaut 1 et False vaut 0.

est_connecte = True
fichier_existe = False

# Résultat d'une comparaison → toujours bool

age = 18
est_majeur = age >= 18 # → True

# Opérateurs logiques
a = True ; b = False
print(a and b) # → False (les deux doivent être True)
print(a or b) # → True (au moins un True)
print(not a) # → False (inverse)

# bool est une sous-classe de int

print(True + True + False) # → 2
print(int(True)) # → 1
print(int(False)) # → 0

2. Valeurs truthy et falsy

Toute valeur Python peut être évaluée comme booléen. Certaines valent False (falsy), les autres True
(truthy) :
Falsy → évalué False Truthy → évalué True

False / None True

0 (int) ou 0.0 (float) Tout nombre ≠ 0 : 1, -5, 3.14

"" (chaîne vide) Toute chaîne non vide : "a", "0", " "
[] (liste vide) Toute liste non vide : [0], [False]

{} (dict/set vide) Tout dict/set non vide

print(bool(0)) # → False
print(bool(42)) # → True
print(bool("")) # → False
print(bool("bonjour")) # → True
print(bool(None)) # → False

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 31 / 73
 print(bool([])) # → False (liste vide)
print(bool([0])) # → True (liste NON vide)

3. Erreurs fréquentes

❌ ERREUR FRÉQUENTE — Minuscule sur True ou False

connecte = true # NameError: name 'true' is not defined
connecte = True # ✅

❌ ERREUR FRÉQUENTE — Tester None avec == au lieu de is

if valeur == None: # Fonctionne, mais déconseillé
if valeur is None: # ✅Idiomatique Python

❌ ERREUR FRÉQUENTE — = au lieu de == dans une condition

if connecte = True: # SyntaxError
if connecte == True: # Fonctionne
if connecte: # ✅Plus élégant (exploite la véracité)

4. Exercices corrigés

📌 EXERCICE 1 — Opérateurs logiques

Évaluez (True and False) or (not False) et vérifiez en Python.

✅ CORRIGÉ 1 — Opérateurs logiques

# (True and False) → False
# (not False) → True
# False or True → True
print((True and False) or (not False)) # → True

📌 EXERCICE 2 — Truthy/Falsy
Prédisez bool() pour : 0, -1, "", " ", [], [0], None.

✅ CORRIGÉ 2 — Truthy/Falsy
print(bool(0)) # → False
print(bool(-1)) # → True
print(bool("")) # → False
print(bool(" ")) # → True (espace = non vide !)
print(bool([])) # → False
print(bool([0])) # → True (liste non vide)
print(bool(None)) # → False

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 32 / 73
 📌 EXERCICE 3 — Comptage de True
Liste de booléens : [True, False, True, True, False, True]. Comptez les True.

✅ CORRIGÉ 3 — Comptage de True

resultats = [True, False, True, True, False, True]
nb_vrais = sum(resultats) # True=1, False=0
print(nb_vrais) # → 4

📌 EXERCICE 4 — Comparaison chaînée

n entre 10 et 20 ? Testez n=15 et n=25.

✅ CORRIGÉ 4 — Comparaison chaînée

n = 15
print(10 <= n <= 20) # → True
n = 25
print(10 <= n <= 20) # → False

📌 EXERCICE 5 — Accès conditionnel

Accès si age>=18 ET (premium=True OU admin=True). Testez plusieurs cas.

✅ CORRIGÉ 5 — Accès conditionnel

age = 20 ; premium = False ; admin = True
acces = age >= 18 and (premium or admin)
print(acces) # → True

age = 16
acces = age >= 18 and (premium or admin)
print(acces) # → False (mineur)

Exercices non corrigés

📌 EXERCICE 6 — À vous !
Testez toutes les combinaisons and/or/not avec a=True, b=False.

📌 EXERCICE 7 — À vous !
Qu'affiche print(True + True + True * False) ? Expliquez.

📌 EXERCICE 8 — À vous !
Variable "panier_vide" = True si une liste est vide. (Indice : not liste)

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 33 / 73
 📌 EXERCICE 9 — À vous !
Simulez une porte : ouverte=True, verrouillee=False. Peut-on l'ouvrir ?

📌 EXERCICE 10 — À vous !
bool("False") → True ou False ? Pourquoi ? (attention, c'est un piège !)

📌 RÉSUMÉ DU POINT
Le type bool ne prend que deux valeurs : True et False — MAJUSCULE obligatoire.
bool est une sous-classe de int : True vaut 1 et False vaut 0.
Opérateurs : and (ET), or (OU), not (NON).
Valeurs falsy : 0, 0.0, "", [], {}, None, False.
Utiliser "if variable:" au lieu de "if variable == True:" — plus pythonique.

Mot / Concept (Python) Traduction française Mode d'emploi en Python

bool booléen est_connecte = True

True / False valeurs booléennes toujours avec majuscule
and ET logique True and False → False
or OU logique True or False → True
not NON logique not True → False
falsy évalué comme False 0, "", [], {}, None, False
truthy évalué comme True tout le reste
bool() conversion bool(0) → False / bool(1) → True

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 34 / 73
 CHAPITRE 1.3 — Opérations sur les Variables

1.3.1 — Affectation & Réaffectation

1. L'opérateur d'affectation augmentée

Python propose des raccourcis pour modifier une variable en combinant l'opération et l'affectation.
Opérateur Signification Exemple Équivalent long

+= Addition + affectation x += 5 x=x+5

-= Soustraction + affectation x -= 3 x=x-3

*= Multiplication + affectation x *= 2 x=x*2

/= Division + affectation x /= 4 x=x/4

//= Division entière + x //= 2 x = x // 2

affectation

%= Modulo + affectation x %= 3 x=x%3

**= Puissance + affectation x **= 2 x = x ** 2

score = 100
score += 50 # score = 100 + 50 = 150
score *= 2 # score = 150 * 2 = 300
score //= 4 # score = 300 // 4 = 75
print(score) # → 75

2. Échange de variables

a = 10 ; b = 20

# ❌ Méthode naïve (écrase la valeur)

a = b # a = 20, mais l'ancienne valeur de a est perdue !

# ✅ Méthode avec variable temporaire

a = 10 ; b = 20
temp = a # sauvegarde a
a = b # a ← b
b = temp # b ← ancienne valeur de a
print(a, b) # → 20 10

# ✅✅ Méthode Pythonique (en une ligne !)

a = 10 ; b = 20
a, b = b, a # échange simultané !
print(a, b) # → 20 10

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 35 / 73
 ❌ ERREUR FRÉQUENTE — Échange qui écrase
a = 10 ; b = 20
a = b # a = 20 → ancienne valeur de a PERDUE
b = a # b = 20 (pas 10 ! a vaut déjà 20)

Solution : tuple unpacking a, b = b, a

3. Exercices corrigés

📌 EXERCICE 1 — Opérateurs augmentés

Partez de x=100. Effectuez : +=50, *=2, -=75, //=3. Affichez après chaque étape.

✅ CORRIGÉ 1 — Opérateurs augmentés

x = 100
x += 50 ; print(x) # → 150
x *= 2 ; print(x) # → 300
x -= 75 ; print(x) # → 225
x //= 3 ; print(x) # → 75

📌 EXERCICE 2 — Échange
Échangez a="Bonjour" et b="Au revoir" sans variable temporaire.

✅ CORRIGÉ 2 — Échange
a = "Bonjour"
b = "Au revoir"
a, b = b, a
print(a) # → Au revoir
print(b) # → Bonjour

Exercices non corrigés

📌 EXERCICE 3 — À vous !
Compteur avec +=1 : partez de compteur=0 et incrémentez 5 fois. Affichez chaque étape.

📌 EXERCICE 4 — À vous !
Échangez trois variables a, b, c (décalez : a→b, b→c, c→a) en une seule ligne.

📌 EXERCICE 5 — À vous !
Doublez puis divisez par 3 un nombre avec *= et //=.

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 36 / 73
 Mot / Concept (Python) Traduction française Mode d'emploi en Python

+= ajout et affectation x += 5 ↔ x = x + 5
-= soustraction affectation x -= 3 ↔ x = x - 3
*= mult. affectation x *= 2 ↔ x = x * 2
//= div. entière affectation x //= 2 ↔ x = x // 2
a,b = b,a échange pythonique swap sans variable temporaire

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 37 / 73
 1.3.2 — Entrées utilisateur — input()

📌 SCÉNARIO SANS CETTE NOTION

Sans input(), votre programme est figé : il ne peut jamais réagir à l'utilisateur.
Toutes vos variables auraient des valeurs codées en dur — aucune interactivité.

1. Définition et syntaxe
La fonction input() lit une ligne saisie par l'utilisateur au clavier et la retourne TOUJOURS sous forme de
chaîne (str) — même si l'utilisateur tape un nombre !

# Syntaxe : variable = input("Message affiché : ")

prenom = input("Votre prénom : ")

print(f"Bonjour, {prenom} !")

# ⚠️ input() retourne TOUJOURS une str !

age_texte = input("Votre âge : ") # → "25" (str)
print(type(age_texte)) # → <class 'str'>

# Conversion nécessaire pour faire des calculs

age = int(input("Votre âge : "))
annee_naissance = 2024 - age
print(f"Né(e) vers {annee_naissance}")

2. Paramètres et bonnes pratiques

# Le message d'invite est optionnel

x = input() # Attendre sans message
x = input("Saisir : ") # Avec message

# Validation de la saisie — bonne pratique

saisie = input("Entrez un nombre : ")
if [Link]():
n = int(saisie)
print(f"Vous avez entré : {n}")
else:
print("Ce n'est pas un entier !")

❌ ERREUR FRÉQUENTE — Oublier de convertir le résultat d'input()

age = input("Âge : ") # → "25" (str !)
annee = 2024 - age # TypeError: unsupported operand type(s)

age = int(input("Âge : ")) # ✅Conversion immédiate

annee = 2024 - age

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 38 / 73
 ❌ ERREUR FRÉQUENTE — Convertir sans vérifier (crash si l'utilisateur tape du
texte)
n = int(input("Entrez un nombre : ")) # Si l'user tape "abc" → ValueError !

Solution : vérifier avec isdigit() avant de convertir.

3. Exercices corrigés

📌 EXERCICE 1 — Calculatrice simple

Demandez deux nombres entiers et affichez leur somme, différence, produit.

✅ CORRIGÉ 1 — Calculatrice simple

a = int(input("Premier nombre : "))
b = int(input("Deuxième nombre : "))
print(f"Somme : {a + b}")
print(f"Différence: {a - b}")
print(f"Produit : {a * b}")

📌 EXERCICE 2 — Bienvenue personnalisée

Demandez prénom et ville. Affichez : "Bonjour [prénom] de [ville] !"

✅ CORRIGÉ 2 — Bienvenue personnalisée

prenom = input("Prénom : ")
ville = input("Ville : ")
print(f"Bonjour {prenom} de {ville} !")

📌 EXERCICE 3 — input + float

Demandez le rayon d'un cercle (float). Affichez aire et périmètre.

✅ CORRIGÉ 3 — input + float

rayon = float(input("Rayon du cercle (cm) : "))
PI = 3.14159
aire = PI * rayon ** 2
perimetre = 2 * PI * rayon
print(f"Aire : {round(aire, 2)} cm²")
print(f"Périmètre : {round(perimetre, 2)} cm")

Exercices non corrigés

📌 EXERCICE 4 — À vous !
Demandez longueur, largeur, hauteur d'un aquarium. Calculez le volume en litres (1000 cm³ = 1
L).

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 39 / 73
 📌 EXERCICE 5 — À vous !
Demandez un nom. Affichez-le en MAJUSCULES, en minuscules, et sa longueur.

📌 EXERCICE 6 — À vous !
Demandez deux nombres. Affichez les 4 résultats : +, -, *, /. Gérez la division par zéro.

Mot / Concept (Python) Traduction française Mode d'emploi en Python

input() saisie utilisateur saisie = input("Message : ")

input() retourne toujours str même si l'user tape "42"
int(input()) saisie entière n = int(input("Nombre : "))
float(input()) saisie décimale n = float(input("Valeur : "))
.isdigit() vérifier avant conversion [Link]() → True si chiffres

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 40 / 73
 1.3.3 — Conversion de types (cast)

📌 SCÉNARIO SANS CETTE NOTION

Sans conversion de types, impossible de mélanger int et str dans une opération.
"25" + 10 lève une TypeError — Python ne mélange pas les types sans votre accord.

1. Fonctions de conversion
Fonction Convertit vers Exemple Résultat

int(x) Entier "42" → int 42

int(x) Entier (troncature) 3.9 → int 3

float(x) Décimal "3.14" → float 3.14

float(x) Décimal 42 → float 42.0

str(x) Chaîne 42 → str "42"

str(x) Chaîne True → str "True"

bool(x) Booléen 0 → bool False

bool(x) Booléen "" → bool False

round(x,n) Float arrondi 3.14159, 2 3.14

# --- str → int ---

age_str = "25"
age_int = int(age_str) # → 25 (entier)

# --- int → float ---

n = 42
f = float(n) # → 42.0

# --- float → int (troncature vers zéro) ---

print(int(3.9)) # → 3 (pas 4 !)
print(int(-3.9)) # → -3 (pas -4 !)

# --- n'importe quel type → str ---

s = str(42) # → "42"
s = str(True) # → "True"

# --- Conversion qui échoue ---

# int("bonjour") → ValueError: invalid literal
# float("abc") → ValueError: could not convert

2. Conversions implicites

# Python convertit parfois automatiquement

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 41 / 73
 resultat = 5 + 2.0 # int + float → float automatiquement
print(resultat) # → 7.0 (float)
print(type(resultat)) # → <class 'float'>

resultat2 = True + 4 # bool + int → int

print(resultat2) # → 5

❌ ERREUR FRÉQUENTE — Convertir str → int quand la chaîne contient des

espaces
saisie = " 42 "
n = int(saisie) # ValueError: invalid literal

n = int([Link]()) # ✅Nettoyer avant de convertir

❌ ERREUR FRÉQUENTE — Convertir un float str en int directement

n = int("3.14") # ValueError !

n = int(float("3.14")) # ✅str → float → int

3. Exercices corrigés

📌 EXERCICE 1 — Chaîne vers calcul

L'utilisateur entre "25". Ajoutez 5 et affichez 30.

✅ CORRIGÉ 1 — Chaîne vers calcul

saisie = "25"
n = int(saisie) + 5
print(n) # → 30

📌 EXERCICE 2 — Affichage formaté

Concaténez "Résultat : " + str(42 * 1.5) + " euros".

✅ CORRIGÉ 2 — Affichage formaté

resultat = 42 * 1.5
message = "Résultat : " + str(resultat) + " euros"
print(message) # → Résultat : 63.0 euros

# Plus simple avec f-string :

print(f"Résultat : {42 * 1.5} euros")

📌 EXERCICE 3 — Chaîne float vers int

Convertissez "3.99" d'abord en float puis en int. Affichez chaque étape.

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 42 / 73
 ✅ CORRIGÉ 3 — Chaîne float vers int
s = "3.99"
f = float(s) # → 3.99
i = int(f) # → 3 (troncature)
print(s, f, i) # → 3.99 3.99 3

Exercices non corrigés

📌 EXERCICE 4 — À vous !
input() retourne "42.5". Convertissez en float, doublez, re-convertissez en str pour afficher.

📌 EXERCICE 5 — À vous !
Que retourne int(True) + int(False) + int(True) ? Pourquoi ?

📌 EXERCICE 6 — À vous !
Convertissez 255 en binaire (str), comparez str(255) et bin(255). Quelle différence ?

Mot / Concept (Python) Traduction française Mode d'emploi en Python

int(x) conversion en entier int("42") → 42 / int(3.9) → 3

float(x) conversion en décimal float("3.14") → 3.14
str(x) conversion en chaîne str(42) → "42"
bool(x) conversion en booléen bool(0) → False
ValueError erreur de valeur int("abc") → impossible
conversion implicite auto int→float 5 + 2.0 → 7.0

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 43 / 73
 1.3.4 — Variables multiples & Échange de valeurs

# Décomposition de tuple (tuple unpacking)

x, y = 10, 20
a = b = c = 0 # trois variables, même valeur
lat, lon = 48.8566, 2.3522 # coord. Paris

# Échange pythonique
a = 1 ; b = 2
a, b = b, a # échange en une ligne
print(a, b) # → 2 1

# Rotation de trois variables

x = 1 ; y = 2 ; z = 3
x, y, z = y, z, x
print(x, y, z) # → 2 3 1

Exercices corrigés

📌 EXERCICE 1 — Coordonnées GPS

lat, lon = 48.8566, 2.3522. Affichez avec f-string et échangez les deux valeurs.

✅ CORRIGÉ 1 — Coordonnées GPS

lat, lon = 48.8566, 2.3522
print(f"Lat={lat}, Lon={lon}")
lat, lon = lon, lat
print(f"Lat={lat}, Lon={lon}") # échangées

📌 EXERCICE 2 — Retour multiple

Simulez une fonction retournant min et max d'une liste.

✅ CORRIGÉ 2 — Retour multiple

valeurs = [5, 2, 8, 1, 9, 3]
minimum, maximum = min(valeurs), max(valeurs)
print(f"Min={minimum}, Max={maximum}") # → Min=1, Max=9

Exercices non corrigés

📌 EXERCICE 3 — À vous !
Déclarez en une ligne : nom="Alice", age=25, ville="Paris". Affichez un f-string complet.

📌 EXERCICE 4 — À vous !
Échangez a, b, c en rotation gauche (a←b, b←c, c←a) en une seule ligne.

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 44 / 73
 📌 EXERCICE 5 — À vous !
Demandez à input() deux valeurs d'un coup (ex: "5 10") et séparez-les avec split().

Mot / Concept (Python) Traduction française Mode d'emploi en Python

x, y = 1, 2 affectation multiple deux variables en une ligne

a = b = c = 0 affectation chaîne même valeur pour plusieurs vars
a, b = b, a échange pythonique sans variable temporaire
x,y,z = y,z,x rotation de valeurs décalage circulaire
tuple unpacking décomposition de tuple accès à plusieurs valeurs en une fois

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 45 / 73
 CHAPITRE 1.4 — Portée & Mémoire des Variables

1.4.1 — Portée des variables (locale / globale)

1. Définition
La portée (scope) d'une variable désigne l'endroit du code où elle est accessible. Python applique la règle
LEGB : Local → Enclosing → Global → Built-in.
Portée Signification Exemple

L — Local Dans la fonction courante Variable définie dans def

E— Fonction englobante (closures) Fonctions imbriquées

Enclosing

G — Global Niveau du module (fichier) Variable hors de toute fonction

B — Built-in Python lui-même print, len, range, True…

# --- Variable globale ---

compteur = 0 # portée GLOBALE

def incrementer():
score_local = 100 # portée LOCALE (accessible seulement ici)
print(score_local) # ✅ accessible ici
print(compteur) # ✅ accessible (lecture du global)

incrementer()
print(compteur) # ✅ accessible ici
# print(score_local) # ❌ NameError: hors de la fonction !

2. Le mot-clé global

compteur = 0

def incrementer():
global compteur # DÉCLARER qu'on veut modifier la variable GLOBALE
compteur += 1 # modifie le global

incrementer()
incrementer()
print(compteur) # → 2

📌 ATTENTION — global — à utiliser avec parcimonie

Le mot-clé global rend le code difficile à déboguer et à tester.

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 46 / 73
 Préférez passer la variable en paramètre et retourner la nouvelle valeur.

À éviter : global x dans chaque fonction

Mieux : def f(x): return x + 1 puis x = f(x)

3. Erreurs fréquentes

❌ ERREUR FRÉQUENTE — Modifier une variable globale sans global

n = 10
def ajouter():
n += 1 # UnboundLocalError !
# Python voit n += 1 comme n = n + 1
# et cherche n LOCAL avant le global → introuvable

def ajouter():
global n
n += 1 # ✅

❌ ERREUR FRÉQUENTE — Utiliser une variable locale hors de sa fonction

def calcul():
resultat = 42

calcul()
print(resultat) # NameError: "resultat" n'est pas défini ici

4. Exercices corrigés

📌 EXERCICE 1 — Portée locale

Créez une fonction avec une variable locale. Tentez d'y accéder hors de la fonction.

✅ CORRIGÉ 1 — Portée locale

def ma_fonction():
message_local = "Je suis locale"
print(message_local) # ✅

ma_fonction() # → "Je suis locale"

# print(message_local) # NameError (hors de la fonction)

📌 EXERCICE 2 — global
Compteur global incrémenté par une fonction appelée 3 fois.

✅ CORRIGÉ 2 — global
compteur = 0

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 47 / 73
 def incrementer():
global compteur
compteur += 1

incrementer() ; incrementer() ; incrementer()

print(compteur) # → 3

Exercices non corrigés

📌 EXERCICE 3 — À vous !
Créez une variable globale "total = 0". Créez une fonction ajouter(n) qui l'incrémente sans global
(passez par le return).

📌 EXERCICE 4 — À vous !
Observez la règle LEGB : une variable locale x=10 et globale x=99. Que s'affiche dans la
fonction ?

Mot / Concept (Python) Traduction française Mode d'emploi en Python

portée (scope) zone d'accessibilité variable locale vs globale

LEGB règle de résolution Local→Enclosing→Global→Built-in
global x déclarer variable globale dans une fonction, pour modifier
NameError variable non trouvée accès hors de la portée
UnboundLocalError locale non initialisée modifier globale sans global

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 48 / 73
 1.4.2 — Constantes (convention)

1. Définition
Python n'a pas de vraie constante (pas de mot-clé const). Par convention, une variable dont la valeur ne
doit JAMAIS changer est nommée en SCREAMING_SNAKE_CASE (tout en majuscules). C'est un signal
visuel pour tous les développeurs.

# --- Constantes par convention ---

PI = 3.14159265358979
VITESSE_LUMIERE = 299_792_458 # m/s
TVA = 0.20 # 20%
NOM_APP = "MonApp v1.0"
MAX_TENTATIVES = 3

# Utilisation
rayon = 5
aire = PI * rayon ** 2
print(f"Aire : {round(aire, 2)}")

📌 ASTUCE — Module constants ou [Link]

Pour une vraie protection en Python, utilisez [Link] :
from typing import Final
TVA: Final = 0.20
TVA = 0.30 # mypy signalera une erreur (mais Python l'autorise quand même)

Exercices

📌 EXERCICE 1 — Constantes physiques

Déclarez PI=3.14159, G=9.81, C=3e8. Calculez le poids d'un objet de 70 kg sur Terre.

✅ CORRIGÉ 1 — Constantes physiques

G = 9.81 # accélération gravitationnelle m/s²
MASSE = 70 # kg
poids = MASSE * G
print(f"Poids : {poids} N") # → Poids : 686.7 N

📌 EXERCICE 2 — À vous !
Déclarez TVA=0.20 et MAX_ARTICLES=10. Calculez le prix TTC de 7 articles à 15€.

Mot / Concept (Python) Traduction française Mode d'emploi en Python

SCREAMING_SNAKE convention constante PI = 3.14159, TVA = 0.20

Final typage constant from typing import Final

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 49 / 73
 Mot / Concept (Python) Traduction française Mode d'emploi en Python

convention accord non imposé Python n'empêche pas de modifier

module fichier [Link] centraliser les constantes

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 50 / 73
 1.4.3 — Gestion mémoire — id(), mutable / immutable

1. Identité d'un objet — id()

En Python, TOUT est un objet. Chaque objet possède un identifiant unique en mémoire, accessible via
id(). Deux variables peuvent pointer vers le même objet.

a = 42
b = a # b pointe vers le MÊME objet que a
print(id(a)) # ex: 140735567283360
print(id(b)) # même identifiant !
print(a is b) # → True (même objet)

b = 100 # b pointe maintenant vers un NOUVEL objet

print(a is b) # → False (objets différents)

2. Objets immuables vs mutables

Type Mutable ? Conséquence

int, float, bool, str, tuple Non (immuable) Toute "modification" crée un NOUVEL objet

list, dict, set Oui (mutable) Modification en place — l'objet change

# --- Immuable : str ---

s = "bonjour"
print(id(s)) # ex: 2345
s = s + "!" # NOUVEL objet créé
print(id(s)) # ex: 6789 (DIFFÉRENT !)

# --- Mutable : list ---

liste = [1, 2, 3]
print(id(liste)) # ex: 1111
[Link](4) # modification EN PLACE
print(id(liste)) # ex: 1111 (MÊME objet !)

# ⚠️ Piège : deux variables pointent sur la même liste

a = [1, 2, 3]
b = a # b ET a pointent le MÊME objet
[Link](99)
print(a) # → [1, 2, 3, 99] (a aussi modifié !)

# ✅ Solution : copier la liste

a = [1, 2, 3]
b = [Link]() # objet indépendant

3. Interning des petits entiers

# Python réutilise les petits entiers (-5 à 256)

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 51 / 73
 a = 100 ; b = 100
print(a is b) # → True (même objet en cache)

a = 1000 ; b = 1000
print(a is b) # → False (grands entiers : nouveaux objets)
print(a == b) # → True (mêmes valeurs)

❌ ERREUR FRÉQUENTE — Copier une liste avec = (alias, pas copie)

original = [1, 2, 3]
copie = original # ← PAS une copie ! c'est un alias
[Link](4)
print(original) # → [1, 2, 3, 4] modifié !

copie = [Link]() # ✅vraie copie

Exercices corrigés

📌 EXERCICE 1 — id() et identité

Créez a=10, b=a. Vérifiez id(a)==id(b). Réaffectez b=20. Vérifiez de nouveau.

✅ CORRIGÉ 1 — id() et identité

a = 10 ; b = a
print(id(a) == id(b)) # → True
print(a is b) # → True
b = 20
print(id(a) == id(b)) # → False
print(a, b) # → 10 20

📌 EXERCICE 2 — Mutable vs immuable

Montrez qu'un str est immuable et qu'une list est mutable via id().

✅ CORRIGÉ 2 — Mutable vs immuable

s = "abc"
print(id(s)) # ID avant
s += "d"
print(id(s)) # ID différent (nouvel objet)

lst = [1, 2, 3]
print(id(lst)) # ID avant
[Link](4)
print(id(lst)) # MÊME ID (modifié en place)

Exercices non corrigés

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 52 / 73
 📌 EXERCICE 3 — À vous !
Démontrez le piège alias avec deux listes. Puis corrigez avec .copy().

📌 EXERCICE 4 — À vous !
Testez l'interning : a=256, b=256 → a is b ? puis a=257, b=257 → a is b ?

Mot / Concept (Python) Traduction française Mode d'emploi en Python

id(x) identifiant mémoire id(a) → adresse unique de l'objet

is même objet ? a is b → True si même id()
immuable non modifiable en place int, float, str, tuple, bool
mutable modifiable en place list, dict, set
.copy() copie indépendante lst2 = [Link]()
interning réutilisation objets petits entiers (-5 à 256) partagés

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 53 / 73
 CHAPITRE 1.5 — Opérateurs Applicables aux
Variables

Les opérateurs permettent d'agir sur les variables : calculer, comparer, combiner des conditions, tester
l'appartenance ou l'identité. Ce CHAPITRE [Link]ésente tous les opérateurs Python dans le contexte des
variables.

1.5.1 — Opérateurs arithmétiques

a = 17 ; b = 5
print(a + b) # → 22 Addition
print(a - b) # → 12 Soustraction
print(a * b) # → 85 Multiplication
print(a / b) # → 3.4 Division (float)
print(a // b) # → 3 Division entière
print(a % b) # → 2 Modulo (reste)
print(a ** b) # → 1419857 Puissance

1.5.2 — Opérateurs de comparaison

Retournent toujours un bool (True ou False).
Opérateur Signification Exemple Résultat

== Égal à 5 == 5 True

!= Différent de 5 != 3 True

> Supérieur 5>3 True

< Inférieur 5<3 False

>= Supérieur ou égal 5 >= 5 True

<= Inférieur ou égal 3 <= 5 True

age = 20
print(age == 18) # → False
print(age >= 18) # → True

# Comparaison chaînée — propre à Python

note = 15
print(0 <= note <= 20) # → True (note valide)

1.5.3 — Opérateurs logiques

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 54 / 73
 1.5.4 — Opérateurs d'appartenance (in, not in)

fruits = "pomme,banane,cerise"
print("banane" in fruits) # → True
print("kiwi" not in fruits) # → True

liste = [1, 2, 3, 4, 5]
print(3 in liste) # → True
print(10 not in liste) # → True

1.5.5 — Opérateur d'identité (is, is not)

Teste si deux variables pointent vers le MÊME objet en mémoire (pas si elles ont la même valeur).

a = [1, 2, 3]
b = a # b pointe le MÊME objet
c = [1, 2, 3] # c est un NOUVEL objet identique

print(a is b) # → True (même objet)

print(a is c) # → False (objets différents)
print(a == c) # → True (valeurs identiques)

# Usage idiomatique de is : tester None

valeur = None
print(valeur is None) # → True

❌ ERREUR FRÉQUENTE — Utiliser is pour comparer des valeurs

a = 1000
b = 1000
print(a is b) # → False (grands entiers = objets distincts)
print(a == b) # → True (valeurs identiques)

Règle : is pour tester l'IDENTITÉ (None, True, False).

== pour tester l'ÉGALITÉ de valeurs.

Exercices corrigés

📌 EXERCICE 1 — Tous les opérateurs

a=15, b=4. Calculez et affichez les 7 opérations arithmétiques.

✅ CORRIGÉ 1 — Tous les opérateurs

a, b = 15, 4
print(f"+ = {a+b}") # 19
print(f"- = {a-b}") # 11
print(f"* = {a*b}") # 60
print(f"/ = {a/b}") # 3.75

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 55 / 73
 print(f"// = {a//b}") # 3
print(f"% = {a%b}") # 3
print(f"** = {a**b}") # 50625

📌 EXERCICE 2 — is vs ==
Créez a=[1,2,3], b=a, c=[1,2,3]. Testez is et == entre a,b et a,c. Expliquez.

✅ CORRIGÉ 2 — is vs ==
a = [1,2,3] ; b = a ; c = [1,2,3]
print(a is b) # → True (même objet)
print(a == b) # → True (valeurs égales)
print(a is c) # → False (objets différents)
print(a == c) # → True (valeurs égales)

Exercices non corrigés

📌 EXERCICE 3 — À vous !
Vérifiez si la note 14.5 est comprise entre 10 et 20 avec une comparaison chaînée.

📌 EXERCICE 4 — À vous !
Testez "Python" in "Apprendre Python facilement". Quel type retourne in ?

📌 EXERCICE 5 — À vous !
Créez une phrase et testez si elle contient le mot "erreur" avec in.

Mot / Concept (Python) Traduction française Mode d'emploi en Python

+ - * / // % ** opérateurs arithmétiques calculs sur int et float

== != < > <= >= comparaison retournent True ou False
and or not logiques combinent des booléens
in / not in appartenance x in liste / "a" in "abc"
is / is not identité (même objet) valeur is None (usage idiomatique)
== égalité de valeurs 1000 == 1000 → True
is identité mémoire petits int : souvent True / grands : False

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 56 / 73
 CHAPITRE 1.6 — Annotations de Type & is vs ==

1.6.1 — Annotations de type (Type Hints)

📌 SCÉNARIO SANS CETTE NOTION

Sans annotations de type, une grande base de code devient opaque :
on ne sait pas si une variable est un int, un str ou autre chose
sans lire l'implémentation complète.

1. Définition
Introduites en Python 3.5 (PEP 484), les annotations de type (type hints) permettent de spécifier le TYPE
ATTENDU d'une variable ou d'un paramètre. Elles n'ont AUCUN effet sur l'exécution — Python reste
dynamiquement typé — mais sont analysées par des outils comme mypy.

# Syntaxe : variable: type = valeur

prenom: str = "Alice"
age: int = 25
taille: float = 1.65
actif: bool = True

# Variable non encore initialisée

resultat: int # déclaration sans valeur

# Annotation dans une fonction

def additionner(a: int, b: int) -> int:
return a + b

# Types optionnels (Python 3.10+)

from typing import Optional
nom: Optional[str] = None # str ou None
# Python 3.10+
nom2: str | None = None # syntaxe moderne

2. Vérification avec mypy

# Installation : pip install mypy

# Utilisation : mypy mon_fichier.py

age: int = "vingt-cinq" # mypy signale : Incompatible types

age2: int = 25 # ✅ mypy valide

3. Types courants

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 57 / 73
 Annotation Signification Exemple

int Entier age: int = 25

float Décimal prix: float = 9.99

str Chaîne nom: str = "Alice"

bool Booléen actif: bool = True

list[int] Liste d'entiers scores: list[int] = [10, 20]

dict[str,int] Dictionnaire str→int notes: dict[str,int] = {}

tuple[int,str] Tuple tyipé coord: tuple[int,int] = (0,0)

str | None str ou None nom: str | None = None

Final Constante from typing import Final; TVA: Final = 0.20

❌ ERREUR FRÉQUENTE — Penser que les annotations ont un effet runtime

age: int = "vingt-cinq" # Python l'accepte à l'exécution !
print(age) # → "vingt-cinq" (pas d'erreur)

Les annotations n'affectent PAS l'exécution.

Seul mypy (ou pyright) les vérifie — et seulement si vous les lancez.

4. Exercices corrigés

📌 EXERCICE 1 — Annoter des variables

Réécrivez : nom="Bob", age=30, salaire=2500.0, en_poste=True avec des annotations.

✅ CORRIGÉ 1 — Annoter des variables

nom: str = "Bob"
age: int = 30
salaire: float = 2500.0
en_poste: bool = True

📌 EXERCICE 2 — Annoter une fonction

Écrivez calculer_ttc(prix: float, taux: float) -> float qui retourne prix*(1+taux).

✅ CORRIGÉ 2 — Annoter une fonction

def calculer_ttc(prix: float, taux: float) -> float:
return prix * (1 + taux)

ttc = calculer_ttc(10.0, 0.20)

print(ttc) # → 12.0

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 58 / 73
Exercices non corrigés

📌 EXERCICE 3 — À vous !
Installez mypy. Créez un fichier avec age: int = "vingt". Lancez mypy. Que signale-t-il ?

📌 EXERCICE 4 — À vous !
Annotez 5 variables d'un programme de gestion d'élèves (nom, note, age, promo, diplome).

Mot / Concept (Python) Traduction française Mode d'emploi en Python

x: int = 5 annotation de type déclare x comme entier

-> int type de retour def f() -> int: return 42
Optional[str] str ou None from typing import Optional
str | None str ou None (3.10+) syntaxe moderne (union)
Final constante annotée TVA: Final = 0.20
mypy vérificateur de types pip install mypy; mypy [Link]

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 59 / 73
 1.6.2 — Différence entre is et ==

1. La distinction fondamentale
C'est l'une des confusions les plus fréquentes chez les débutants Python. Ces deux opérateurs testent
des choses fondamentalement différentes :
Opérateur Teste Retourne True si…

== Égalité de VALEUR les deux variables ont la même valeur

is Identité d'OBJET les deux variables pointent le MÊME objet mémoire

# --- Démonstration avec les listes ---

a = [1, 2, 3]
b = [1, 2, 3] # Nouvel objet, même contenu
c = a # Même objet

print(a == b) # → True (valeurs identiques)

print(a is b) # → False (objets DIFFÉRENTS)
print(a == c) # → True (valeurs identiques)
print(a is c) # → True (MÊME objet)

# --- Avec les entiers : piège du cache ---

x = 100 ; y = 100
print(x is y) # → True (cachés entre -5 et 256)

x = 300 ; y = 300
print(x is y) # → False (hors du cache)
print(x == y) # → True (valeurs égales)

2. Règle d'or

📌 INFO — Quand utiliser is / quand utiliser ==

✅Utilisez is : uniquement pour tester None, True, False
if valeur is None:
if condition is True: (rare, "if condition:" suffit)

✅Utilisez == : pour comparer des VALEURS (nombres, chaînes, listes…)

if age == 18:
if nom == "Alice":
if liste1 == liste2:

3. Erreurs fréquentes

❌ ERREUR FRÉQUENTE — Utiliser is pour comparer des chaînes

prenom = "Alice"

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 60 / 73
 if prenom is "Alice": # → peut être True OU False selon l'interning
print("OK")

if prenom == "Alice": # ✅Toujours correct pour comparer des valeurs

print("OK")

❌ ERREUR FRÉQUENTE — Ne pas tester None avec ==

if valeur == None: # Fonctionne, mais SyntaxWarning en Python 3.8+
if valeur is None: # ✅Idiomatique et sans avertissement

4. Exercices corrigés

📌 EXERCICE 1 — Démonstration
Créez a="Bonjour", b="Bonjour", c=a. Testez == et is entre chaque paire.

✅ CORRIGÉ 1 — Démonstration
a = "Bonjour" ; b = "Bonjour" ; c = a
print(a == b) # → True (même valeur)
print(a is b) # → True (interning des petites chaînes)
print(a == c) # → True
print(a is c) # → True (c alias de a)

📌 EXERCICE 2 — Tester None

Créez resultat = None. Testez avec is None et == None. Quelle est la bonne pratique ?

✅ CORRIGÉ 2 — Tester None

resultat = None
print(resultat is None) # → True ✅recommandé
print(resultat == None) # → True ❌déconseillé (warning)

# None est un singleton : il n'existe qu'UN seul objet None en Python.

# is None est donc toujours fiable.

Exercices non corrigés

📌 EXERCICE 3 — À vous !
Testez is entre deux listes identiques créées séparément. Puis entre une liste et son alias.

📌 EXERCICE 4 — À vous !
Quand faut-il utiliser is True ? Y a-t-il des cas où if ma_var: est insuffisant ?

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 61 / 73
 Mot / Concept (Python) Traduction française Mode d'emploi en Python

== égalité de valeur a == b → True si même contenu

is identité d'objet a is b → True si même id()
is None test None recommandé if x is None: (idiomatique)
is not None test non-None if x is not None:
interning réutilisation d'objets petits int et courtes str réutilisés
singleton objet unique None, True, False → toujours is

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 62 / 73
 CHAPITRE 1.7 — Erreurs Fréquentes
Récapitulatives

Ce chapitre rassemble les erreurs les plus fréquentes observées chez les débutants Python, classées par
catégorie. Gardez cette liste comme référence lors de vos débogages.

N° Erreur Code erroné Correction

1 Variable non définie print(x) # x jamais créé x = 0 print(x)

2 = vs == if age = 18: if age == 18:

3 Espace dans nom mon age = 5 mon_age = 5

4 Début chiffre 1prix = 10 premier_prix = 10

5 Minuscule True actif = true actif = True

6 input() sans cast n = input() ; n + 1 n = int(input())

7 Virgule (float) prix = 9,99 prix = 9.99

8 Float == exact 0.1+0.2 == 0.3 abs(0.1+0.2-0.3) < 1e-9

9 Alias liste b = a ; [Link](1) b = [Link]()

10 is vs == if x is 1000: if x == 1000:

11 Méthode sans () [Link] ; print(s) s = [Link]() ; print(s)

12 global oublié n += 1 (dans fn) global n ; n += 1

13 Indice hors limites s[10] (s = "abc") s[2] ou vérifier len

14 Concaténer int+str "Âge: " + age f"Âge: {age}"

15 Modifier une str s[0] = "X" s = "X" + s[1:]

Erreurs avec exemples de code

❌ ERREUR FRÉQUENTE — La plus dangereuse — alias de liste mutable

original = [10, 20, 30]
copie = original # ← ALIAS, pas une copie !
[Link](99)
print(original) # → [10, 20, 30, 99] (modifié !)

copie = [Link]() # ✅Vraie copie indépendante

[Link](99)
print(original) # → [10, 20, 30] (intact)

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 63 / 73
 ❌ ERREUR FRÉQUENTE — La plus fréquente — input() non converti
age = input("Âge : ") # → "25" (str)
annee = 2024 - age # TypeError !

age = int(input("Âge : ")) # ✅Conversion directe

annee = 2024 - age # ✅Fonctionne

❌ ERREUR FRÉQUENTE — La plus subtile — is pour comparer des valeurs

n = 500
if n is 500: # → Peut être False ! (hors cache)

if n == 500: # ✅Toujours correct pour les valeurs

Mot / Concept (Python) Traduction française Mode d'emploi en Python

NameError var non définie créer la var avant de l'utiliser

SyntaxError erreur de syntaxe = dans if, nom invalide…
TypeError types incompatibles int+str sans conversion
ValueError valeur invalide int("abc") impossible
IndexError indice hors limites vérifier len() avant
UnboundLocalError var locale non init. global x ou passer en paramètre

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 64 / 73
 CHAPITRE 1.8 — Projet Final Corrigé

Ce projet met en pratique TOUTES les notions vues dans ce livre : variables de tous types, input(),
conversions, opérateurs, portée, constantes, annotations et bonnes pratiques PEP 8.

Projet : Gestionnaire de budget personnel

Objectif
L'utilisateur entre son revenu mensuel et ses dépenses par catégorie. Le programme calcule le solde, le
taux d'épargne, et donne un conseil.

# ╔══════════════════════════════════════════════════╗
# ║ GESTIONNAIRE DE BUDGET PERSONNEL ║
# ║ Projet final — Variables Python ║
# ╚══════════════════════════════════════════════════╝

# ── Constantes ──────────────────────────────────────
TAUX_EPARGNE_IDEAL: float = 0.20 # 20% recommandé
SEPARATEUR : str = "=" * 48

# ── Saisie des revenus ──────────────────────────────

print(SEPARATEUR)
print(" ⚠️ GESTIONNAIRE DE BUDGET MENSUEL")
print(SEPARATEUR)

revenu_str : str = input("Revenu mensuel net (€) : ")

revenu : float= float(revenu_str)

# ── Saisie des dépenses par catégorie ───────────────

print("\nEntrez vos dépenses mensuelles :")
loyer : float= float(input(" Loyer / logement (€) : "))
alimentation: float= float(input(" Alimentation (€) : "))
transport : float= float(input(" Transport (€) : "))
loisirs : float= float(input(" Loisirs (€) : "))
autres : float= float(input(" Autres (€) : "))

# ── Calculs ─────────────────────────────────────────
total_depenses : float= loyer + alimentation + transport + loisirs + autres
solde : float= revenu - total_depenses
taux_epargne : float= (solde / revenu) * 100 if revenu > 0 else 0

# ── Conseil basé sur le taux d'épargne ─────────────

est_sain: bool = taux_epargne >= TAUX_EPARGNE_IDEAL * 100
conseil : str = "✅ Excellent ! Votre épargne est suffisante." if est_sain else
"⚠️ Réduisez vos dépenses pour mieux épargner."

# ── Affichage du rapport ────────────────────────────

print(f"\n{SEPARATEUR}")
print(" ⚠️ RAPPORT BUDGET")
print(SEPARATEUR)
Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 65 / 73
 print(f" Revenu net : {revenu:>10.2f} €")
print(f" Total dépenses : {total_depenses:>10.2f} €")
print(f" Solde / Épargne : {solde:>10.2f} €")
print(f" Taux d'épargne : {taux_epargne:>9.1f} %")
print(SEPARATEUR)
print(f" {conseil}")
print(SEPARATEUR)

Exemple d'exécution

================================================
⚠️ GESTIONNAIRE DE BUDGET MENSUEL
================================================
Revenu mensuel net (€) : 2800

Entrez vos dépenses mensuelles :

Loyer / logement (€) : 850
Alimentation (€) : 350
Transport (€) : 120
Loisirs (€) : 200
Autres (€) : 80

================================================
⚠️ RAPPORT BUDGET
================================================
Revenu net : 2800.00 €
Total dépenses : 1600.00 €
Solde / Épargne : 1200.00 €
Taux d'épargne : 42.9 %
================================================
✅ Excellent ! Votre épargne est suffisante.
================================================

Notions du livre utilisées

• Variables annotées : revenu: float, est_sain: bool…
• Constantes : TAUX_EPARGNE_IDEAL, SEPARATEUR
• Conversions : float(input())
• Opérateurs arithmétiques : + - / * 100
• Opérateur de comparaison : >= (taux_epargne >= seuil)
• Opérateur ternaire : valeur if condition else autre_valeur
• f-strings avec formatage : {valeur:>10.2f}
• PEP 8 : snake_case, SCREAMING_SNAKE, commentaires

Améliorations possibles
• Ajouter une catégorie "épargne voulue" et calculer l'objectif.
• Boucle pour ressaisir si la valeur est négative.
• Exporter le rapport dans un fichier texte.

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 66 / 73
 ANNEXE — Projets Réels et Utiles pour Rester
Motivé

Vous avez terminé le livre ! Voici 3 projets concrets que vous pouvez réaliser immédiatement, en utilisant
uniquement les notions vues. Chaque projet résout un problème du quotidien.

Projet 1 — Convertisseur d'unités

Contexte
Vous voyagez souvent et devez convertir des kilomètres en miles, des Celsius en Fahrenheit, ou des euros
en dollars. Construisez un convertisseur interactif.

Notions utilisées
• Variables float et str · input() + float()
• Opérateurs arithmétiques · round()
• Constantes (TAUX_CHANGE…) · f-strings

# ╔══════════════════════════════════════╗
# ║ CONVERTISSEUR D'UNITÉS ║
# ╚══════════════════════════════════════╝

# ── Constantes de conversion ────────────

KM_PAR_MILE : float= 1.60934
TAUX_EUR_USD : float= 1.08 # Taux du jour
TAUX_EUR_GBP : float= 0.86

print("=== CONVERTISSEUR D'UNITÉS ===")

print("Choisissez : 1=km→miles 2=°C→°F 3=€→$ 4=€→£")
choix = input("Votre choix (1-4) : ")

if choix == "1":
km = float(input("Distance en km : "))
miles = km / KM_PAR_MILE
print(f"{km} km = {round(miles, 3)} miles")

elif choix == "2":

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

elif choix == "3":

euros = float(input("Montant en euros : "))
dollars= euros * TAUX_EUR_USD
print(f"{euros} € = {round(dollars,2)} $")

elif choix == "4":

euros = float(input("Montant en euros : "))
livres = euros * TAUX_EUR_GBP
print(f"{euros} € = {round(livres,2)} £")

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 67 / 73
 else:
print("Choix invalide.")

Projet 2 — Calculateur d'IMC

Contexte
L'Indice de Masse Corporelle est utilisé par les médecins et nutritionnistes pour évaluer la corpulence.
Créez un outil de calcul avec interprétation.

# ╔══════════════════════════════════════╗
# ║ CALCULATEUR D'IMC ║
# ╚══════════════════════════════════════╝

print("=== CALCULATEUR D'IMC ===")

prenom : str = input("Votre prénom : ")

poids : float= float(input("Poids en kg : "))
taille : float= float(input("Taille en cm : "))

taille_m : float= taille / 100 # cm → m

imc : float= poids / (taille_m ** 2)
imc_arrondi : float= round(imc, 1)

# Interprétation
if imc < 18.5:
interpretation = "⚠️ Insuffisance pondérale"
elif imc < 25:
interpretation = "✅ Poids normal"
elif imc < 30:
interpretation = "⚠️ Surpoids"
else:
interpretation = "⚠️ Obésité"

print(f"\n{prenom}, votre IMC : {imc_arrondi}")

print(f"Interprétation : {interpretation}")

Projet 3 — Jeu du Juste Prix

Contexte
Recréez le célèbre jeu TV. L'ordinateur choisit un nombre secret. Le joueur doit le trouver avec des indices
"plus grand" ou "plus petit".

# ╔══════════════════════════════════════╗
# ║ JEU DU JUSTE PRIX ║
# ╚══════════════════════════════════════╝

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 68 / 73
 import random

# ── Constantes ──────────────────────────
BORNE_MIN : int= 1
BORNE_MAX : int= 100
MAX_ESSAIS: int= 7

# ── Variables de jeu ────────────────────

nombre_secret : int= [Link](BORNE_MIN, BORNE_MAX)
nb_essais : int= 0
trouve : bool= False

print(f"Devinez un nombre entre {BORNE_MIN} et {BORNE_MAX} en {MAX_ESSAIS}

essais !")

while nb_essais < MAX_ESSAIS and not trouve:

nb_essais += 1
essai_str = input(f"Essai {nb_essais}/{MAX_ESSAIS} : ")
if not essai_str.isdigit():
print("Entrez un nombre entier !")
nb_essais -= 1 # ne compte pas l'essai raté
continue

proposition : int= int(essai_str)

if proposition < nombre_secret:

print("⚠️ Plus grand !")
elif proposition > nombre_secret:
print("⚠️ Plus petit !")
else:
trouve = True
print(f"⚠️ Bravo ! Trouvé en {nb_essais} essai(s) !")

if not trouve:
print(f"⚠️ Perdu ! Le nombre était {nombre_secret}.")

Améliorations possibles pour les 3 projets

• Convertisseur : ajouter kg↔livres, m²↔pieds², litres↔gallons.
• IMC : ajouter le calcul du poids idéal selon la formule de Lorentz.
• Juste prix : ajouter une option difficile (50 chiffres, 5 essais).

📌 RÉSUMÉ DU POINT
Vous avez maintenant toutes les bases pour créer des programmes Python utiles.
Chaque projet de l'annexe utilise uniquement les notions de ce livre.
La meilleure façon de progresser : coder tous les jours, même 15 minutes.
Cherchez des projets qui vous motivent : votre curiosité est votre meilleur moteur.
Prochaine étape : les conditions (if/elif/else) et les boucles (for/while).

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 69 / 73
Table des matières
TABLE DES MATIÈRES ............................................................................................................................3
CHAPITRE 1.1 — Introduction aux Variables ................................................................................................5
1.1.1 — Qu'est-ce qu'une variable ? ......................................................................................................5
1. Définition technique ..........................................................................................................................5
2. Utilité — pourquoi les variables sont indispensables .............................................................................5
3. Inconvénient SANS variables .............................................................................................................6
4. Solution AVEC variables ................................................................................................................6
1.1.2 — Déclaration des variables .........................................................................................................6
1. Syntaxe et mécanisme ...................................................................................................................6
2. Erreurs fréquentes .........................................................................................................................7
3. Exercices corrigés — Déclaration ..................................................................................................8
4. Exercices non corrigés — À vous !.................................................................................................9
1.1.3 — Règles de nommage ..............................................................................................................11
1. Règles OBLIGATOIRES imposées par Python ............................................................................11
2. Mots-clés réservés (à ne jamais utiliser comme noms) ................................................................11
3. Sensibilité à la casse....................................................................................................................11
4. Erreurs fréquentes — Nommage..................................................................................................12
5. Exercices corrigés — Nommage ..................................................................................................12
Exercices non corrigés .....................................................................................................................13
1.1.4 — Bonnes pratiques (PEP 8) ......................................................................................................15
1. Définition ......................................................................................................................................15
2. Erreurs fréquentes — Style ..........................................................................................................15
3. Exercices corrigés — PEP 8 ........................................................................................................16
Exercices non corrigés .....................................................................................................................16
CHAPITRE 1.2 — Types de Données de Base .......................................................................................18
1.2.1 — Integer — Entiers (int) ............................................................................................................18
1. Définition ......................................................................................................................................18
2. Opérateurs sur les entiers ............................................................................................................18
3. Erreurs fréquentes .......................................................................................................................19
4. Exercices corrigés ........................................................................................................................19
Exercices non corrigés .....................................................................................................................20
1.2.2 — Float — Décimaux (float)........................................................................................................22
1. Définition ......................................................................................................................................22
2. Problème de précision — piège majeur........................................................................................22
3. Fonctions utiles ............................................................................................................................22
4. Erreurs fréquentes .......................................................................................................................23
5. Exercices corrigés ........................................................................................................................23
Exercices non corrigés .....................................................................................................................24
Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 70 / 73
 1.2.3 — String — Chaînes de caractères (str) .....................................................................................26
1. Définition ......................................................................................................................................26
2. Indexation et slicing......................................................................................................................26
3. Méthodes des chaînes les plus utiles ...........................................................................................27
4. Erreurs fréquentes .......................................................................................................................27
5. Exercices corrigés ........................................................................................................................28
Exercices non corrigés .....................................................................................................................29
12.4 — Boolean — Booléens (bool) ....................................................................................................31
1. Définition ......................................................................................................................................31
2. Valeurs truthy et falsy...................................................................................................................31
3. Erreurs fréquentes .......................................................................................................................32
4. Exercices corrigés ........................................................................................................................32
Exercices non corrigés .....................................................................................................................33
CHAPITRE 1.3 — Opérations sur les Variables ......................................................................................35
1.3.1 — Affectation & Réaffectation .....................................................................................................35
1. L'opérateur d'affectation augmentée ............................................................................................35
2. Échange de variables...................................................................................................................35
3. Exercices corrigés ........................................................................................................................36
Exercices non corrigés .....................................................................................................................36
1.3.2 — Entrées utilisateur — input() ...................................................................................................38
1. Définition et syntaxe .....................................................................................................................38
2. Paramètres et bonnes pratiques ..................................................................................................38
3. Exercices corrigés ........................................................................................................................39
Exercices non corrigés .....................................................................................................................39
1.3.3 — Conversion de types (cast) .....................................................................................................41
1. Fonctions de conversion ..............................................................................................................41
2. Conversions implicites .................................................................................................................41
3. Exercices corrigés ........................................................................................................................42
Exercices non corrigés .....................................................................................................................43
1.3.4 — Variables multiples & Échange de valeurs..............................................................................44
Exercices corrigés............................................................................................................................44
Exercices non corrigés .....................................................................................................................44
CHAPITRE 1.4 — Portée & Mémoire des Variables................................................................................46
1.4.1 — Portée des variables (locale / globale) ....................................................................................46
1. Définition ......................................................................................................................................46
2. Le mot-clé global ..........................................................................................................................46
3. Erreurs fréquentes .......................................................................................................................47
4. Exercices corrigés ........................................................................................................................47
Exercices non corrigés .....................................................................................................................48

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 71 / 73
 1.4.2 — Constantes (convention) ........................................................................................................49
1. Définition ......................................................................................................................................49
Exercices .........................................................................................................................................49
1.4.3 — Gestion mémoire — id(), mutable / immutable .......................................................................51
1. Identité d'un objet — id() ..............................................................................................................51
2. Objets immuables vs mutables.....................................................................................................51
3. Interning des petits entiers ...........................................................................................................51
Exercices corrigés............................................................................................................................52
Exercices non corrigés .....................................................................................................................52
CHAPITRE 1.5 — Opérateurs Applicables aux Variables .......................................................................54
1.5.1 — Opérateurs arithmétiques .......................................................................................................54
1.5.2 — Opérateurs de comparaison ...................................................................................................54
1.5.3 — Opérateurs logiques ...............................................................................................................54
1.5.4 — Opérateurs d'appartenance (in, not in) ...................................................................................55
1.5.5 — Opérateur d'identité (is, is not) ...............................................................................................55
Exercices corrigés............................................................................................................................55
Exercices non corrigés .....................................................................................................................56
CHAPITRE 1.6 — Annotations de Type & is vs == .................................................................................57
1.6.1 — Annotations de type (Type Hints) ...........................................................................................57
1. Définition ......................................................................................................................................57
2. Vérification avec mypy .................................................................................................................57
3. Types courants ............................................................................................................................57
4. Exercices corrigés ........................................................................................................................58
Exercices non corrigés .....................................................................................................................59
1.6.2 — Différence entre is et == .........................................................................................................60
1. La distinction fondamentale..........................................................................................................60
2. Règle d'or.....................................................................................................................................60
3. Erreurs fréquentes .......................................................................................................................60
4. Exercices corrigés ........................................................................................................................61
Exercices non corrigés .....................................................................................................................61
CHAPITRE 1.7 — Erreurs Fréquentes Récapitulatives ...........................................................................63
Erreurs avec exemples de code .......................................................................................................63
CHAPITRE 1.8 — Projet Final Corrigé ....................................................................................................65
Projet : Gestionnaire de budget personnel ...........................................................................................65
Objectif ............................................................................................................................................65
Exemple d'exécution ........................................................................................................................66
Notions du livre utilisées ..................................................................................................................66
Améliorations possibles ...................................................................................................................66
ANNEXE — Projets Réels et Utiles pour Rester Motivé ..........................................................................67

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 72 / 73
 Projet 1 — Convertisseur d'unités........................................................................................................67
Contexte ..........................................................................................................................................67
Notions utilisées ...............................................................................................................................67
Projet 2 — Calculateur d'IMC ..............................................................................................................68
Contexte ..........................................................................................................................................68
Projet 3 — Jeu du Juste Prix ...............................................................................................................68
Contexte ..........................................................................................................................................68
Améliorations possibles pour les 3 projets .......................................................................................69

Les Variables en Python · Guide Complet du Débutant Auteur LDK ANASTA Page 73 / 73