Variables et types de données
Les variables
Une variable est un espace nommé en mémoire qui stocke une valeur. En Python, on crée une variable simplement en lui affectant une valeur avec l'opérateur = :
age = 25
prenom = "Alice"
prix = 9.99
actif = True
Pas besoin de déclarer le type à l'avance — Python le détermine automatiquement. C'est ce qu'on appelle le typage dynamique.
Règles de nommage
- Utiliser le style snake_case : mots en minuscules séparés par des tirets bas (
mon_age,nom_complet). - Peut contenir des lettres, des chiffres et
_, mais ne peut pas commencer par un chiffre. - Pas d'espaces dans le nom.
- Pas de mots réservés (
if,for,while,class,def, etc.). - Sensible à la casse :
ageetAgesont deux variables différentes.
# Correct
nom_utilisateur = "Alice"
age_minimum = 18
est_connecte = True
# Incorrect
2eme_joueur = "Bob" # commence par un chiffre
mon age = 25 # espace interdit
class = "Python" # mot réservé
Les types de données fondamentaux
int — Entiers
Les entiers sont des nombres sans virgule, positifs ou négatifs.
score = 100
temperature = -5
population = 8_000_000_000 # le _ améliore la lisibilité des grands nombres
float — Nombres décimaux
Les flottants sont des nombres avec une partie décimale.
prix = 19.99
pi = 3.14159
taux = 0.07
str — Chaînes de caractères
Les chaînes sont des séquences de caractères, délimitées par des guillemets simples ou doubles.
prenom = "Alice"
message = 'Bonjour tout le monde'
texte_long = """Ceci est
un texte sur
plusieurs lignes."""
bool — Booléens
Les booléens ne peuvent valoir que True ou False (avec une majuscule).
est_majeur = True
est_connecte = False
a_paye = True
La fonction type()
type() retourne le type d'une variable ou d'une valeur.
age = 25
print(type(age)) # <class 'int'>
prix = 9.99
print(type(prix)) # <class 'float'>
nom = "Alice"
print(type(nom)) # <class 'str'>
actif = True
print(type(actif)) # <class 'bool'>
Conversion de types
Python ne convertit pas automatiquement les types. Il faut utiliser des fonctions de conversion explicites :
| Fonction | Description | Exemple |
|---|---|---|
int() | Convertit en entier | int("42") → 42 |
float() | Convertit en flottant | float("3.14") → 3.14 |
str() | Convertit en chaîne | str(42) → "42" |
bool() | Convertit en booléen | bool(0) → False |
# input() retourne toujours une str — il faut convertir
age_texte = input("Votre age : ") # "25"
age = int(age_texte) # 25
print(age + 1) # 26
# Conversion float
valeur = float("3.14")
print(valeur * 2) # 6.28
# bool : 0, "", None, [] sont False ; tout le reste est True
print(bool(0)) # False
print(bool(1)) # True
print(bool("")) # False
print(bool("abc")) # True
Toujours convertir les données saisies avec input() avant de faire des calculs. Une erreur classique est d'essayer d'additionner une chaîne et un entier, ce qui provoque une TypeError.
Les opérateurs arithmétiques
| Opérateur | Description | Exemple | Résultat |
|---|---|---|---|
+ | Addition | 5 + 3 | 8 |
- | Soustraction | 10 - 4 | 6 |
* | Multiplication | 3 * 4 | 12 |
/ | Division (flottante) | 7 / 2 | 3.5 |
// | Division entière | 7 // 2 | 3 |
% | Modulo (reste) | 7 % 2 | 1 |
** | Puissance | 2 ** 8 | 256 |
a = 17
b = 5
print(a + b) # 22
print(a - b) # 12
print(a * b) # 85
print(a / b) # 3.4
print(a // b) # 3
print(a % b) # 2
print(a ** 2) # 289
Opérateurs d'affectation augmentée
Ces raccourcis modifient une variable en place :
score = 0
score += 10 # score = score + 10 => 10
score *= 2 # score = score * 2 => 20
score -= 5 # score = score - 5 => 15
score //= 2 # score = score // 2 => 7
Les opérations sur les chaînes
Concaténation avec +
prenom = "Alice"
nom = "Dupont"
nom_complet = prenom + " " + nom
print(nom_complet) # Alice Dupont
Répétition avec *
separateur = "-" * 20
print(separateur) # --------------------
len() — longueur d'une chaîne
message = "Bonjour"
print(len(message)) # 7
Les f-strings
Les f-strings (formatted string literals) permettent d'insérer des variables directement dans une chaîne. On préfixe la chaîne avec f :
prenom = "Alice"
age = 25
message = f"Bonjour {prenom}, tu as {age} ans."
print(message) # Bonjour Alice, tu as 25 ans.
On peut même faire des calculs à l'intérieur des accolades :
longueur = 8
largeur = 5
print(f"L'aire du rectangle est {longueur * largeur} m2.")
# L'aire du rectangle est 40 m2.
Préférez toujours les f-strings à la concaténation avec + pour construire des messages. C'est plus lisible, plus court, et moins risqué d'erreurs de type.
Les méthodes de chaînes
Les chaînes en Python disposent de nombreuses méthodes utiles :
texte = " Bonjour, Monde ! "
print(texte.upper()) # " BONJOUR, MONDE ! "
print(texte.lower()) # " bonjour, monde ! "
print(texte.strip()) # "Bonjour, Monde !" (sans espaces)
print(texte.replace("Monde", "Python")) # " Bonjour, Python ! "
phrase = "Python est super"
print(phrase.startswith("Python")) # True
print(phrase.endswith("super")) # True
print(phrase.count("e")) # 2
Affectation multiple
Python permet d'assigner plusieurs variables sur une seule ligne :
# Affectation multiple
a, b, c = 1, 2, 3
print(a, b, c) # 1 2 3
# Échange de valeurs (sans variable temporaire !)
a, b = b, a
print(a, b) # 2 1
# Même valeur pour plusieurs variables
x = y = z = 0
Les constantes
Python n'a pas de vraies constantes, mais la convention est d'écrire les noms en MAJUSCULES_AVEC_TIRETS_BAS pour signaler qu'une valeur ne doit pas être modifiée :
PI = 3.14159265358979
TAUX_TVA = 0.20
COULEUR_FOND = "#FFFFFF"
MAX_TENTATIVES = 3
Regroupez vos constantes en haut du fichier. Cela facilite la maintenance : si une valeur change (ex. taux de TVA), vous n'avez qu'un seul endroit à modifier.
Exercices pratiques
En Python, utilisez toujours le snake_case pour nommer vos variables : nb_eleves plutôt que nbEleves (camelCase) ou NbEleves (PascalCase). La convention snake_case est définie dans la PEP 8, le guide de style officiel de Python.
type() est très utile pendant le développement pour vérifier que vous manipulez le bon type. En production, utilisez plutôt isinstance(valeur, int) qui est plus robuste et gère l'héritage.
Lorsque vous convertissez une entrée utilisateur avec int(), protégez-vous avec un bloc try/except pour gérer le cas où l'utilisateur saisit quelque chose qui n'est pas un nombre.
Stockez les calculs intermédiaires dans des variables bien nommées (aire, perimetre, taux_final) plutôt de tout mettre dans un seul print(). Le code est plus lisible et plus facile à déboguer.
Dans les accolades d'une f-string, vous pouvez écrire n'importe quelle expression Python valide : f"{prix * 1.2:.2f} euros" formate un flottant avec 2 décimales. Très puissant pour l'affichage de données.
En Python, on peut enchaîner les méthodes de chaînes : texte.strip().lower().replace(" ", "_"). C'est élégant, mais ne chaînez pas trop de méthodes sur une seule ligne si cela nuit à la lisibilité.