0 XP
?
Python : de zéro à la maîtrise/Variables et types de données
Débutant40 min25 XP

Objectifs de cette leçon

  • Créer des variables de différents types
  • Comprendre la différence entre int, float, str et bool
  • Utiliser type() pour vérifier le type d'une variable

Variables et types de données 🧱

Créer des variables 📦

En Python, créer une variable est simple : il suffit de donner un nom et une valeur avec le signe =.

prenom = "Marie"
age = 22
taille = 1.68
est_etudiant = True

💡 Pas besoin de déclarer le type ! Python le détecte automatiquement. On dit que Python est faiblement typé.

x = 42          # Python comprend que c'est un entier
x = "Bonjour"   # Même variable, maintenant c'est une chaîne !
# Pas d'erreur en Python (mais attention, c'est rarement une bonne idée)

Les types de données 🏷️

TypeNomExempleDescription
Entierint42, -7, 0Nombre sans virgule
Décimalfloat3.14, -0.5Nombre à virgule
Chaînestr"Hello", 'Bonjour'Texte entre guillemets
BooléenboolTrue, FalseVrai ou Faux
VideNoneTypeNoneAbsence de valeur

Les entiers (int)

a = 100
b = -42
grand = 9_999_999_999  # Les underscores améliorent la lisibilité

print(type(a))  # <class 'int'>
print(grand)    # 9999999999

💡 En Python, il n'y a pas de limite à la taille des entiers. Tu peux écrire 10**100 sans problème !

Les flottants (float)

pi = 3.14159
temperature = -2.5
avion = 30_000.50

print(type(pi))  # <class 'float'>

⚠️ Attention aux imprécisions avec les floats :

print(0.1 + 0.2)  # 0.30000000000000004 (pas exactement 0.3 !)

Les chaînes de caractères (str)

nom = "Alice"
prenom = 'Bob'
adresse = "123 rue de la Paix, Paris"
multi_ligne = """
Ceci est
un texte
sur plusieurs lignes
"""

print(type(nom))  # <class 'str'>

Les guillemets simples et doubles sont équivalents en Python :

# Avec des apostrophes dans le texte → utiliser des doubles guillemets
texte1 = "J'apprends Python"

# Avec des guillemets dans le texte → utiliser des apostrophes
texte2 = 'Il a dit "Bonjour"'

# Concaténation
prenom = "Jean"
nom = "Dupont"
nom_complet = prenom + " " + nom  # "Jean Dupont"

# Répétition
traits = "-" * 30  # "------------------------------"

Les booléens (bool)

est_vrai = True
est_faux = False

print(type(est_vrai))  # <class 'bool'>

# Comparaison → résultat booléen
print(5 > 3)    # True
print(5 == 3)   # False
print(5 != 3)   # True

None — la valeur vide

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

# Vérifier si une variable est None
if resultat is None:
    print("Pas encore de résultat")

📌 None n'est ni 0, ni "", ni False. C'est l'absence de valeur. Utilise toujours is None ou is not None pour le comparer, pas ==.


Conversions de types 🔄

FonctionConvertit enExempleRésultat
int()Entierint("42")42
float()Décimalfloat("3.14")3.14
str()Chaînestr(42)"42"
bool()Booléenbool(0)False
list()Listelist("abc")['a','b','c']
# Cas fréquent : input() renvoie toujours une chaîne
age_str = input("Ton âge : ")   # L'utilisateur tape "25"
age = int(age_str)               # Conversion en entier
print(age + 5)                   # 30

# Autre exemple
prix = 19.99
print("Le prix est de " + str(prix) + " euros")

⚠️ Si tu essaies de convertir int("bonjour"), tu auras une erreur ValueError. Vérifie toujours avant !


Règles de nommage 📏

Règle✅ Correct❌ Incorrect
Commencer par une lettre ou _age, _cache2nd, -val
Lettres, chiffres, _ uniquementmon_varma variable, mon-var
Pas de mot réservéprenomif, for, class
Sensible à la casseAgeage

Bonnes pratiques de nommage

# ✅ Bonnes pratiques
prenom = "Alice"           # snake_case pour les variables
max_retry = 3              # Descriptif et court
PI = 3.14159               # MAJUSCULES pour les constantes

# ❌ Mauvaises pratiques
a = "Alice"                # Trop vague
x = 3                      # Que contient x ?
prenomutilisateur = "Bob"  # Difficile à lire

🐍 Convention Python (PEP 8) : Les variables et fonctions utilisent snake_case, les classes utilisent CamelCase.


Opérations sur les nombres ➕➖✖️➗

a = 15
b = 4

print(a + b)    # 19    Addition
print(a - b)    # 11    Soustraction
print(a * b)    # 60    Multiplication
print(a / b)    # 3.75  Division (toujours un float)
print(a // b)   # 3     Division entière
print(a % b)    # 3     Modulo (reste de la division)
print(a ** b)   # 50625 Puissance (15^4)
OpérateurNomExempleRésultat
+Addition7 + 310
-Soustraction7 - 34
*Multiplication7 * 321
/Division7 / 32.333...
//Division entière7 // 32
%Modulo7 % 31
**Puissance7 ** 3343

Diagramme mémoire 🧠

Chaque variable a :

  • Un nom (l'étiquette)
  • Un type (la forme de la boîte)
  • Une valeur (le contenu)
  • Une adresse mémoire (la position dans la RAM)

Pièges à éviter ⚠️

# 1. Confondre = et ==
x = 5      # Affectation
x == 5     # Comparaison

# 2. Mélanger types dans une concaténation
age = 25
# print("J'ai " + age + " ans")       # TypeError
print("J'ai " + str(age) + " ans")    # OK
print(f"J'ai {age} ans")              # Encore mieux (f-string)

# 3. Floats imprévisibles
0.1 + 0.2 != 0.3  # True !

# 4. None vs 0 vs False vs ""
print(None == 0)    # False
print(None == False) # False
# None est Unique : seule "is None" fonctionne

Exercice pour toi 🎯

# Exercice : Simule une caisse de supermarché
prix_pomme = 1.50
prix_banane = 0.80
quantite_pomme = 4
quantite_banane = 6

total = (prix_pomme * quantite_pomme) + (prix_banane * quantite_banane)
print(f"Total a payer : {total:.2f} euros")

# Exercice : Convertir la temperature
temp_celsius = 37.5
temp_fahrenheit = temp_celsius * 9/5 + 32
print(f"{temp_celsius}C = {temp_fahrenheit}F")

# Exercice : Verifier la parite
nombre = 7
est_pair = (nombre % 2 == 0)
print(f"{nombre} est pair : {est_pair}")

💡 Astuce : Les f-strings (f"texte {variable}") sont le moyen le plus elegant d'inserter des variables dans du texte en Python.

⚡ Simulateur — Variables et types

Étape 1/7
📝 Pseudo-code
1age = 25
2nom = "Alice"
3prix = 19.99
4est_actif = True
5rien = None
6print(type(age))
7print(type(nom))
⚙️ Exécution
📦 Mémoire
age
25
🔀 Flux d'exécution
age: int
3
Type entier (int)

On crée une variable age de type int (entier). Python utilise le type dynamique : pas besoin de déclarer le type.