Variables, Types et Opérateurs : Aller plus loin

# ❌ Mauvais exemple
x = 30
y = "Dupont"
z = x * 1.5

# ✅ Bon exemple
age_utilisateur = 30
nom_de_famille = "Dupont"
prix_promotionnel = age_utilisateur * 1.5

TAUX_TVA = 0.20
VITESSE_MAX_AUTOROUTE = 130
PI = 3.14159

prix_ht = 100
montant_tva = prix_ht * TAUX_TVA

# Python voit le nombre 10, il en déduit que le type est 'int' (entier)
ma_variable = 10
print(type(ma_variable)) # Affiche : <class 'int'>

# Maintenant, on assigne une chaîne de caractères. Python "oublie" l'ancien type.
ma_variable = "Bonjour le monde"
print(type(ma_variable)) # Affiche : <class 'str'>

# Et maintenant un booléen
ma_variable = True
print(type(ma_variable)) # Affiche : <class 'bool'>

def calculer_prix_double(prix):
 # Cette fonction s'attend à ce que 'prix' soit un nombre
 return prix * 2

print(calculer_prix_double(50)) # ✅ Affiche 100, tout va bien
print(calculer_prix_double("50")) # ❌ Provoque une erreur ! On ne peut pas "multiplier" du texte comme ça.
# Résultat : "5050". Ce n'est pas une multiplication, mais une répétition de la chaîne.

age: int = 25
nom: str = "Alice"
est_majeur: bool = True

def saluer(nom_personne: str) -> str:
 return f"Bonjour, {nom_personne}!"

# La manière longue
compteur = 0
compteur = compteur + 1 # compteur vaut maintenant 1

# La manière courte et pythonique
compteur = 0
compteur += 1 # compteur vaut maintenant 1

age_requis = 18
age_candidat = 20

# Si j'écris 'if age_candidat = 18:', Python lèvera une erreur de syntaxe.
# Je dois utiliser l'opérateur de comparaison.
if age_candidat >= age_requis:
 print("Le candidat est majeur.") # Cette phrase sera affichée

p = 150
t = 0.2
res = p * t
final = p + res
print(final)

# Définir les valeurs de base avec des noms clairs
prix_hors_taxe = 150.0

# Utiliser une constante pour les valeurs de configuration
TAUX_TVA = 0.20 # 20%

# Effectuer les calculs en utilisant des variables intermédiaires explicites
montant_tva = prix_hors_taxe * TAUX_TVA
prix_ttc = prix_hors_taxe + montant_tva

# Afficher le résultat de manière formatée et compréhensible
print(f"Prix HT : {prix_hors_taxe}€")
print(f"Montant TVA : {montant_tva}€")
print(f"Prix final TTC : {prix_ttc}€")

### Introduction : La Variable, bien plus qu'une simple boîte Imaginez que vous organisez votre cuisine. Vous avez des boîtes pour le sucre, le sel, la farine... Vous ne vous contentez pas de tout jeter dans des boîtes identiques sans étiquette. Vous utilisez des étiquettes claires ("Sucre de Canne", "Fleur de Sel") et des contenants adaptés. Un pot à épices n'est pas idéal pour conserver de la soupe. En programmation, c'est exactement la même chose. Une variable n'est pas juste une "boîte". C'est une **étiquette** que vous collez sur une **donnée** qui a un certain **type**. Le nom de l'étiquette (le nom de la variable) et la compréhension du type de donnée sont cruciaux pour écrire un code que les autres (et surtout votre futur vous !) pourront comprendre et maintenir. Dans cette leçon, nous allons apprendre à bien nommer nos variables, à comprendre comment Python gère les types de données de manière flexible (mais avec quelques pièges), et à maîtriser les opérateurs pour manipuler ces données efficacement. ## Le Nommage : Votre Première Ligne de Documentation Le choix du nom d'une variable est l'un des actes les plus importants et les plus simples pour rendre votre code propre. Un nom bien choisi est une forme d'auto-documentation. Il révèle l'**intention** du code. Considérez ce fragment de code : ```python # ❌ Mauvais exemple x = 30 y = "Dupont" z = x * 1.5 ``` Que font $x$, $y$, et $z$ ? Il faut deviner. $x$ pourrait être un âge, un nombre de jours, une quantité... C'est ambigu. Maintenant, regardons cette version : ```python # ✅ Bon exemple age_utilisateur = 30 nom_de_famille = "Dupont" prix_promotionnel = age_utilisateur * 1.5 ``` C'est le jour et la nuit. Le code se lit presque comme une phrase en français. Nous savons immédiatement ce que chaque variable représente. C'est comme étiqueter une boîte de déménagement "Livres du Salon" au lieu de juste "Trucs". Vous vous remercierez plus tard. ### La Convention `snake_case` en Python Dans l'écosystème Python, la convention la plus répandue pour nommer les variables et les fonctions est le `snake_case`. Cela signifie que les mots sont en minuscules et séparés par des tirets bas (`_`). - `nom_utilisateur` (pas `nomUtilisateur` - ça, c'est du *camelCase*, courant en JavaScript ou Java) - `total_des_ventes` - `nombre_elements_par_page` Respecter cette convention rend votre code plus "pythonique", c'est-à-dire qu'il semblera naturel et familier aux autres développeurs Python. ### Le cas des Constantes Une constante est une variable dont la valeur n'est pas censée changer au cours de l'exécution du programme. En Python, il n'y a pas de véritable mécanisme pour "verrouiller" une variable, mais la convention est d'écrire son nom entièrement en majuscules. ```python TAUX_TVA = 0.20 VITESSE_MAX_AUTOROUTE = 130 PI = 3.14159 prix_ht = 100 montant_tva = prix_ht * TAUX_TVA ``` Quand un autre développeur voit `TAUX_TVA`, il sait immédiatement qu'il s'agit d'une valeur de configuration, une constante à ne pas modifier à la légère. ## Le Typage Dynamique de Python : Puissance et Pièges Contrairement à d'autres langages comme Java ou C++, vous n'avez pas besoin de déclarer le type d'une variable avant de l'utiliser. C'est Python qui s'en charge pour vous au moment où vous lui assignez une valeur. C'est ce qu'on appelle le **typage dynamique**. ```python # Python voit le nombre 10, il en déduit que le type est 'int' (entier) ma_variable = 10 print(type(ma_variable)) # Affiche : <class 'int'> # Maintenant, on assigne une chaîne de caractères. Python "oublie" l'ancien type. ma_variable = "Bonjour le monde" print(type(ma_variable)) # Affiche : <class 'str'> # Et maintenant un booléen ma_variable = True print(type(ma_variable)) # Affiche : <class 'bool'> ``` **La puissance :** C'est extrêmement flexible et permet d'écrire du code très rapidement. C'est l'une des raisons pour lesquelles Python est si populaire pour le prototypage et l'analyse de données. **Le piège :** Cette flexibilité peut conduire à des erreurs inattendues. Si une fonction attend un nombre pour faire un calcul, mais qu'elle reçoit accidentellement une chaîne de caractères, votre programme plantera. ```python def calculer_prix_double(prix): # Cette fonction s'attend à ce que 'prix' soit un nombre return prix * 2 print(calculer_prix_double(50)) # ✅ Affiche 100, tout va bien print(calculer_prix_double("50")) # ❌ Provoque une erreur ! On ne peut pas "multiplier" du texte comme ça. # Résultat : "5050". Ce n'est pas une multiplication, mais une répétition de la chaîne. ``` ### L'Annotation de Type : une bonne pratique moderne Pour pallier ce problème et améliorer la lisibilité, le Python moderne encourage l'utilisation des **annotations de type** (type hints). Celles-ci ne sont pas contraignantes (Python ne vérifiera pas les types à l'exécution), mais elles servent d'indication précieuse pour les développeurs et les outils d'analyse de code. ```python age: int = 25 nom: str = "Alice" est_majeur: bool = True def saluer(nom_personne: str) -> str: return f"Bonjour, {nom_personne}!" ``` En lisant ce code, vous savez immédiatement quels types de données sont attendus, sans avoir à deviner. C'est une excellente habitude à prendre dès le début. ## Les Opérateurs : Au-delà de l'Addition Les opérateurs sont les symboles qui vous permettent d'effectuer des opérations sur vos variables. Vous connaissez déjà les bases, mais explorons quelques subtilités utiles. ### Opérateurs Arithmétiques (Revisités) Au-delà de $+$, $-$ et $*$, il en existe plusieurs qui sont très pratiques : - **$/$ (Division flottante) :** Donne toujours un résultat avec une virgule (un `float`). $10 / 4$ donne $2.5$. - **$//$ (Division entière) :** Ne garde que la partie entière du résultat. $10 // 4$ donne $2$. Très utile pour savoir "combien de fois 4 rentre-t-il entièrement dans 10 ?". - **** (Puissance) :** Élève un nombre à la puissance d'un autre. $2 ** 3$ donne $8$ (2 * 2 * 2). ### Opérateurs d'Assignation Composés Il est très courant de vouloir modifier une variable en se basant sur sa propre valeur. Par exemple, pour incrémenter un compteur. ```python # La manière longue compteur = 0 compteur = compteur + 1 # compteur vaut maintenant 1 # La manière courte et pythonique compteur = 0 compteur += 1 # compteur vaut maintenant 1 ``` ```python age_requis = 18 age_candidat = 20 # Si j'écris 'if age_candidat = 18:', Python lèvera une erreur de syntaxe. # Je dois utiliser l'opérateur de comparaison. if age_candidat >= age_requis: print("Le candidat est majeur.") # Cette phrase sera affichée ``` ## Un Cas Pratique : Calculer un Prix TTC Métons tout cela en pratique. Notre mission est de calculer le prix final d'un produit, toutes taxes comprises. **Version 1 : Le code confus** ```python p = 150 t = 0.2 res = p * t final = p + res print(final) ``` Ce code fonctionne, mais il est illisible. Que sont `p`, `t`, `res` ? Il faut deviner. **Version 2 : Le code propre et clair** ```python # Définir les valeurs de base avec des noms clairs prix_hors_taxe = 150.0 # Utiliser une constante pour les valeurs de configuration TAUX_TVA = 0.20 # 20% # Effectuer les calculs en utilisant des variables intermédiaires explicites montant_tva = prix_hors_taxe * TAUX_TVA prix_ttc = prix_hors_taxe + montant_tva # Afficher le résultat de manière formatée et compréhensible print(f"Prix HT : {prix_hors_taxe}€") print(f"Montant TVA : {montant_tva}€") print(f"Prix final TTC : {prix_ttc}€") ``` La deuxième version est un peu plus longue, mais elle est infiniment supérieure. Chaque ligne a un sens. Un collègue (ou vous-même dans 6 mois) peut la lire et la comprendre instantanément, sans effort. C'est ça, l'objectif du code propre. ## Résumé et Bonnes Pratiques Pour conclure, retenez ces quelques règles d'or : 1. **Le nommage est roi :** Utilisez des noms de variables explicites en `snake_case`. Votre code doit raconter une histoire. 2. **Les constantes en MAJUSCULES :** Pour les valeurs qui ne doivent pas changer (`TAUX_TVA`, `PI`), utilisez des majuscules pour signaler leur nature. 3. **Comprenez le typage dynamique :** Profitez de sa flexibilité, mais soyez conscient des risques. Utilisez les annotations de type (`nom: str`) pour clarifier vos intentions. Écrire du code, c'est comme écrire un message pour votre futur vous. Soyez gentil avec lui, offrez-lui un code clair, lisible et bien structuré. Il vous en sera reconnaissant !