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.
Preferez toujours les f-strings a la concatenation avec + pour construire des messages. C'est plus lisible, plus court, et moins risque 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
# Echange 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 a modifier.
Exercices pratiques
En Python, utilisez toujours le snake_case pour nommer vos variables : nb_eleves plutot que nbEleves (camelCase) ou NbEleves (PascalCase). La convention snake_case est definit dans la PEP 8, le guide de style officiel de Python.
type() est tres utile pendant le developpement pour verifier que vous manipulez le bon type. En production, utilisez plutot isinstance(valeur, int) qui est plus robuste et gere l'heritage.
Lorsque vous convertissez une entree utilisateur avec int(), protegez-vous avec un bloc try/except pour gerer le cas ou l'utilisateur saisit quelque chose qui n'est pas un nombre.
Stockez les calculs intermediaires dans des variables bien nommees (aire, perimetre, taux_final) plutot de tout mettre dans un seul print(). Le code est plus lisible et plus facile a deboguer.
Dans les accolades d'une f-string, vous pouvez ecrire n'importe quelle expression Python valide : f"{prix * 1.2:.2f} euros" formate un flottant avec 2 decimales. Tres puissant pour l'affichage de donnees.
En Python, on peut enchaîner les methodes de chaînes : texte.strip().lower().replace(" ", "_"). C'est elegant, mais ne chaînez pas trop de methodes sur une seule ligne si cela nuit a la lisibilite.
Quiz de révision
Une solution
Vous devez être connecté pour voir le contenu.