Rappels essentiels sur Python (variables, fonctions, modules)

# En Python, c'est possible
ma_variable = 10
print(f"Type: {type(ma_variable)}, Valeur: {ma_variable}")

ma_variable = "Bonjour le monde"
print(f"Type: {type(ma_variable)}, Valeur: {ma_variable}")

# Mauvais exemple : peu informatif
x = "Dupont"
y = 42
c = 5

# Bon exemple : clair et respectant les conventions
last_name = "Dupont"\nuser_age = 42
MAX_LOGIN_ATTEMPTS = 5

def calculate_order_total_with_vat(items, vat_rate=0.20):
 """Calcule le total d'une commande, TVA incluse.

 Args:
 items (list): Une liste de dictionnaires, chaque dictionnaire représentant un article
 avec une clé 'price' et 'quantity'.
 vat_rate (float): Le taux de TVA à appliquer (par défaut 20%).

 Returns:
 float: Le prix total TTC, arrondi à 2 décimales.
 """
 subtotal = sum(item['price'] * item['quantity'] for item in items)
 total = subtotal * (1 + vat_rate)
 return round(total, 2)

# Exemple d'utilisation
cart = [ {'price': 15.50, 'quantity': 2}, {'price': 120.00, 'quantity': 1} ]

total_price = calculate_order_total_with_vat(cart)
print(f"Le total de la commande est de {total_price} €") # Affiche 181.20 €

# utils.py
PI = 3.14159

def format_user_name(first_name, last_name):
 return f"{last_name.upper()}, {first_name.capitalize()}"

Bonjour et bienvenue dans ce module. En tant que développeur senior, je peux vous assurer d'une chose : la qualité d'une application web ne réside pas dans la complexité du framework utilisé, mais dans la solidité de ses fondations. Imaginez que vous construisiez un gratte-ciel. Utiliseriez-vous des matériaux de mauvaise qualité pour les fondations ? Certainement pas. En développement web avec Python, vos fondations sont votre maîtrise des concepts de base : les variables, les fonctions et les modules. Cette leçon est conçue comme un rappel, mais avec une perspective professionnelle. Nous n'allons pas simplement revoir la syntaxe, mais nous allons surtout discuter du *pourquoi* : pourquoi nommer une variable d'une certaine manière, pourquoi une fonction ne devrait faire qu'une seule chose, et pourquoi l'organisation de votre code en modules est non négociable pour tout projet sérieux. Préparez-vous à solidifier vos bases pour construire des applications robustes et élégantes. ## Les Variables : Plus que de Simples Contenants Au premier abord, une variable semble simple : c'est un nom que l'on donne à une portion de mémoire pour y stocker une donnée. C'est vrai, mais en pratique, une variable bien utilisée est un outil de communication puissant. ### Typage Dynamique, mais Fort Python est un langage à typage dynamique, ce qui signifie que vous n'avez pas besoin de déclarer le type d'une variable avant de l'utiliser. La même variable peut contenir un nombre, puis une chaîne de caractères. ```python # En Python, c'est possible ma_variable = 10 print(f"Type: {type(ma_variable)}, Valeur: {ma_variable}") ma_variable = "Bonjour le monde" print(f"Type: {type(ma_variable)}, Valeur: {ma_variable}") ``` Cependant, ne confondez pas *dynamique* et *faible*. Python a un typage *fort*. Cela signifie que le type d'un objet est important et que Python ne fera pas de conversions implicites hasardeuses. Tenter d'additionner un nombre et une chaîne de caractères lèvera une $TypeError$. C'est une sécurité. Dans le monde du web, où vous manipulez des données venant de sources diverses (formulaires, bases de données, API externes), cette rigueur vous évite d'innombrables bugs. ### L'importance des Conventions de Nommage Le code est lu beaucoup plus souvent qu'il n'est écrit. Un nom de variable clair est un cadeau que vous faites à votre futur vous, et à vos collègues. * **snake_casepour les variables et fonctions** : Les mots sont en minuscules et séparés par des underscores (_$). C'est la convention officielle de la communauté Python (PEP 8). * **`ALL_CAPS` pour les constantes** : Si une variable est destinée à ne jamais changer de valeur au cours de l'exécution du programme, nommez-la en majuscules. C'est un signal fort pour les autres développeurs : "Ne touchez pas à cette valeur". Dans une application web, cela peut être une clé d'API, le nombre maximum de connexions à la base de données, etc. Voyons un exemple concret : ```python # Mauvais exemple : peu informatif x = "Dupont" y = 42 c = 5 # Bon exemple : clair et respectant les conventions last_name = "Dupont"\nuser_age = 42 MAX_LOGIN_ATTEMPTS = 5 ``` La deuxième version est instantanément compréhensible. Dans le contexte d'une application web, `last_name` pourrait venir d'un champ de formulaire, et `MAX_LOGIN_ATTEMPTS` serait une règle de sécurité cruciale. ## Les Fonctions : Les Briques Réutilisables de Votre Logique Si les variables sont les données, les fonctions sont les actions. Une application n'est, au fond, qu'une chorégraphie complexe de fonctions qui manipulent des données. Pensez-y comme à des recettes de cuisine : vous les définissez une fois, et vous pouvez les exécuter autant de fois que nécessaire, avec des ingrédients (arguments) différents. ### Anatomie et Principe de Responsabilité Unique Pourquoi ? 1. **Réutilisabilité** : Vous pourriez avoir besoin de valider un email ailleurs sans envoyer de message. 2. **Testabilité** : Il est infiniment plus simple de tester une petite fonction qui retourne `True` ou `False` qu'une fonction qui a un effet de bord comme envoyer un email. 3. **Lisibilité** : Le code devient une histoire que l'on peut lire de haut en bas. ```python def calculate_order_total_with_vat(items, vat_rate=0.20): """Calcule le total d'une commande, TVA incluse. Args: items (list): Une liste de dictionnaires, chaque dictionnaire représentant un article avec une clé 'price' et 'quantity'. vat_rate (float): Le taux de TVA à appliquer (par défaut 20%). Returns: float: Le prix total TTC, arrondi à 2 décimales. """ subtotal = sum(item['price'] * item['quantity'] for item in items) total = subtotal * (1 + vat_rate) return round(total, 2) # Exemple d'utilisation cart = [ {'price': 15.50, 'quantity': 2}, {'price': 120.00, 'quantity': 1} ] total_price = calculate_order_total_with_vat(cart) print(f"Le total de la commande est de {total_price} €") # Affiche 181.20 € ``` Notez l'utilisation d'une *docstring* pour expliquer ce que fait la fonction, ses arguments (`Args`) et ce qu'elle retourne (`Returns`). C'est une pratique professionnelle indispensable. ### Arguments Positionnels, Mots-clés et par Défaut La flexibilité des fonctions Python vient en grande partie de la manière dont on peut leur passer des arguments. * **Arguments positionnels** : Ils sont attribués aux paramètres en fonction de leur ordre (`calculate_order_total_with_vat(cart)`). ## Les Modules : Organiser Votre Code Efficacement Une application web ne peut pas vivre dans un seul fichier. Ce serait le chaos. Les modules sont la réponse de Python à ce besoin d'organisation. Un module n'est rien de plus qu'un fichier Python ($.py$) contenant des fonctions, des classes et des variables. Imaginez un atelier de menuiserie. Vous ne laissez pas tous vos outils (scies, marteaux, vis) en vrac au milieu de la pièce. Vous avez des boîtes à outils, des tiroirs, des armoires. Les modules sont ces boîtes à outils. ### L'art d'importer : `import` vs `from` Pour utiliser le contenu d'un module, vous devez l'importer. Il y a plusieurs façons de le faire, chacune avec ses avantages et ses inconvénients. Considérons un projet avec la structure suivante : - $main.py$ - $utils.py$ Où $utils.py$ contient : ```python # utils.py PI = 3.14159 def format_user_name(first_name, last_name): return f"{last_name.upper()}, {first_name.capitalize()}" ``` Dans $main.py$, vous pouvez importer ces outils de différentes manières. Le choix que vous ferez aura un impact direct sur la clarté et la maintenabilité de votre code. Une bonne gestion des importations est la marque d'un développeur expérimenté. ### La Structure d'un Projet Web Dans une application web typique, vous n'aurez pas seulement un $utils.py$. Vous aurez une structure bien plus élaborée qui sépare les responsabilités : * $main.py$ ou $app.py$ : Le point d'entrée de l'application. * $views.py$ ou $routes.py$ : Les fonctions qui gèrent les requêtes web. * $models.py$ : Les définitions de vos structures de données (ex: classes Utilisateur, Produit). * $services.py$ : La logique métier complexe. * $config.py$ : Les paramètres de configuration. Cette organisation, permise par le système de modules, est fondamentale. Elle vous permet de savoir exactement où chercher quand un bug apparaît ou quand vous devez ajouter une nouvelle fonctionnalité. C'est la base des architectures logicielles comme MVC (Modèle-Vue-Contrôleur) que nous explorerons plus tard. ## Exercice Pratique : Mini-Gestionnaire de Tâches Pour mettre ces concepts en pratique, créez une petite application en ligne de commande. 1. Créez un dossier `task_manager`. 2. À l'intérieur, créez deux fichiers : $main.py$ et $tasks.py$. * `add_task(title)`: Ajoute une nouvelle tâche (un dictionnaire `{'title': title, 'completed': False}`) à la liste `all_tasks`. * `list_tasks()`: Affiche toutes les tâches de la liste. 4. Dans $main.py$, importez les fonctions de $tasks.py$. Créez une boucle simple qui demande à l'utilisateur ce qu'il veut faire ("ajouter", "lister", "terminer", "quitter") et appelez les fonctions correspondantes du module `tasks`. Cet exercice vous forcera à penser en termes de séparation de la logique (le module `tasks`) et de la présentation (le module `main`). ## Résumé et Prochaines Étapes Nous avons revisité les trois piliers du développement Python structuré : - **Variables** : Le stockage nommé et typé de vos données. Utilisez des noms clairs et des conventions (`snake_case`, `ALL_CAPS`). - **Fonctions** : Les unités d'action réutilisables de votre code. Visez des fonctions courtes, avec une seule responsabilité, bien documentées. - **Modules** : Les unités d'organisation de votre projet. Importez judicieusement et structurez votre application pour séparer les préoccupations. Maîtriser ces concepts n'est pas une simple étape préliminaire ; c'est un investissement continu. Un code bien structuré à ce niveau fondamental est plus facile à déboguer, à tester et à faire évoluer. Vous êtes maintenant prêts à voir comment des frameworks comme Flask ou Django s'appuient sur ces fondations pour nous permettre de construire des applications web puissantes et maintenables.