Questions spéciales de programmation avancees
Professeur John Malala, Ph.D.
EXERCICE SUR LA MODULARITE
Vous allez créer deux modules distincts, et je vous donne déjà l’explication de comment vous
allez le faire :
Un module appelé en_tete pour afficher des informations générales au début du programme.
Un module pour les calculs mathématiques, séparé pour un usage clair et organisé.
1. Créer le Module "en_tete"
Structure du Module :
Le module en_tete.py contiendra une fonction appelée afficher_en_tete pour afficher des
informations générales.
Code : en_tete.py
# en_tete.py
# Module pour afficher un en-tête personnalisé dans un programme
# Auteur : [Votre Nom]
# Date : [Date d'aujourd'hui]
def afficher_en_tete(titre, auteur, date):
"""Affiche un en-tête personnalisé."""
print("=" * 50)
print(f"Titre : {titre}")
print(f"Auteur : {auteur}")
print(f"Date : {date}")
print("=" * 50)
2. Créer le Module pour les Calculs
Structure du Module :
Le module calculs.py contiendra plusieurs fonctions pour effectuer des calculs comme l'addition
et la soustraction.
Code : calculs.py
# calculs.py
# Module pour les calculs mathématiques de base
# Auteur : [Votre Nom]
# Date : [Date d'aujourd'hui]
def add(a, b):
"""Retourne la somme de deux nombres."""
return a + b
def subtract(a, b):
"""Retourne la différence entre deux nombres."""
return a - b
def multiply(a, b):
"""Retourne le produit de deux nombres."""
return a * b
def divide(a, b):
"""Retourne le quotient de deux nombres."""
if b != 0:
return a / b
else:
return "Erreur : Division par zéro !"
3. Utiliser les Modules dans le Fichier Principal
Fichier Principal : main.py
Dans ce fichier, nous allons importer et utiliser les deux modules (en_tete et calculs).
Code : main.py
# main.py
# Utilisation des modules "en_tete" et "calculs"
import en_tete
import calculs
# Afficher l'en-tête du programme
en_tete.afficher_en_tete(
titre="Programme de Calculs",
auteur="Votre Nom",
date="2023-12-19"
)
# Effectuer des calculs
a = 10
b=5
print("Addition :", calculs.add(a, b)) # Affiche : Addition : 15
print("Soustraction :", calculs.subtract(a, b)) # Affiche : Soustraction : 5
print("Multiplication :", calculs.multiply(a, b)) # Affiche : Multiplication : 50
print("Division :", calculs.divide(a, b)) # Affiche : Division : 2.0
4. Tester les Modules Séparément
Si vous exécutez directement en_tete.py ou calculs.py, ils ne doivent pas interférer avec le fichier
principal. Ajoutez une clause if __name__ == "__main__" pour les tester individuellement.
Dans en_tete.py
if __name__ == "__main__":
afficher_en_tete("Test Module en_tete", "Testeur", "2023-12-19")
Dans calculs.py
if __name__ == "__main__":
print("Test Calculs")
print("Addition :", add(2, 3)) # Affiche : Addition : 5
print("Division :", divide(6, 0)) # Affiche : Erreur : Division par zéro !
Résultat Final :
Lorsque vous exécutez main.py, voici ce que vous devriez voir :
==================================================
Titre : Programme de Calculs
Auteur : Votre Nom
Date : 2023-12-19
==================================================
Addition : 15
Soustraction : 5
Multiplication : 50
Division : 2.0
Explications :
Modularité : Vous avez séparé le programme en deux modules logiques (en_tete et calculs) pour
une organisation claire.
Réutilisabilité : Les modules peuvent être utilisés dans d’autres projets.
Clarté : Le fichier principal (main.py) est propre et facile à lire.
Pourquoi nous avons utilisé le f-strings
POUR CLARIFIER
Le f dans print(f"Titre : {titre}") est utilisé pour les chaînes formatées (f-strings), une
fonctionnalité introduite dans Python 3.6. Elles permettent d’insérer directement des variables
dans une chaîne de caractères tout en maintenant une syntaxe claire et lisible. Voici pourquoi je
l'ai utilisé et comment cela fonctionne.
1. Pourquoi utiliser les f-strings ?
Clarté et Simplicité
Au lieu de concaténer manuellement les chaînes de caractères et les variables avec des opérateurs
comme +, ou d'utiliser la méthode .format(), les f-strings offrent une syntaxe concise et facile à
lire.
Exemple sans f-strings :
titre = "Programme de Calculs"
print("Titre : " + titre)
Avec f-strings :
titre = "Programme de Calculs"
print(f"Titre : {titre}")
Les f-strings rendent le code plus propre, surtout lorsque vous manipulez plusieurs variables.
2. Comment fonctionnent les f-strings ?
Les f-strings permettent d'évaluer des expressions Python directement à l'intérieur des accolades
{}. Vous pouvez insérer des variables, effectuer des calculs, ou même appeler des fonctions
directement.
Exemples :
# Exemple 1 : Insérer une variable
auteur = "Jean Dupont"
print(f"Auteur : {auteur}") # Affiche : Auteur : Jean Dupont
# Exemple 2 : Effectuer un calcul
a=5
b=3
print(f"Le résultat de {a} + {b} est {a + b}") # Affiche : Le résultat de 5 + 3 est 8
# Exemple 3 : Appeler une fonction
def format_date():
return "2024-12-19"
print(f"Date : {format_date()}") # Affiche : Date : 2024-12-19
3. Comparaison avec d'autres méthodes
Concaténation avec +
titre = "Programme de Calculs"
print("Titre : " + titre) # Moins lisible si plusieurs variables sont utilisées
Méthode .format()
titre = "Programme de Calculs"
print("Titre : {}".format(titre)) # Syntaxe un peu plus verbeuse
f-strings (recommandé)
titre = "Programme de Calculs"
print(f"Titre : {titre}") # Syntaxe claire et concise
4. Pourquoi je l'ai utilisé ?
J'ai utilisé les f-strings car :
1. Elles sont plus lisibles et modernes.
2. Elles sont efficaces (elles sont légèrement plus rapides que .format() et la concaténation).
3. Elles permettent une insertion directe des variables dans le texte sans manipulation
supplémentaire.
5. Compatibilité
Les f-strings fonctionnent uniquement à partir de Python 3.6. Si vous utilisez une version
antérieure, vous devrez utiliser une alternative comme .format() ou la concaténation avec +.
EXPLICATION
L’expression if __name__ == "__main__": est une construction spéciale en Python utilisée pour
contrôler l’exécution d’un script. Elle permet de distinguer si un fichier Python est exécuté
directement ou importé comme module dans un autre fichier. Voici une explication complète :
1. Que signifie __name__ en Python ?
__name__ est une variable spéciale en Python.
Lorsque Python exécute un fichier, il assigne automatiquement à __name__ une valeur :
o Si le fichier est exécuté directement (par exemple, avec python myscript.py), la
valeur de __name__ sera "__main__".
o Si le fichier est importé comme module dans un autre script, la valeur de
__name__ sera le nom du fichier (sans l'extension .py).
2. Le rôle de if __name__ == "__main__":
Cette construction permet de contrôler ce qui doit se passer lorsqu’un fichier est exécuté
directement versus lorsqu’il est importé comme module.
Cas 1 : Le fichier est exécuté directement
# fichier : example.py
print("Ce fichier est en cours d'exécution directe.")
Si vous exécutez ce fichier avec :
python example.py
La sortie sera :
Ce fichier est en cours d'exécution directe.
Cas 2 : Le fichier est importé comme module
Ajoutez example.py comme module dans un autre fichier :
# fichier : main.py
import example
print("Ce fichier est main.py.")
La sortie sera :
Ce fichier est en cours d'exécution directe.
Ce fichier est main.py.
Pourquoi cela pose un problème ?
Dans le cas ci-dessus, le fichier example.py exécute immédiatement son contenu lorsque vous
l’importez. Cela peut ne pas être souhaité. Pour éviter cela, on utilise if __name__ ==
"__main__":.
3. Exemple avec if __name__ == "__main__":
Ajoutons cette condition dans example.py :
# example.py
def afficher_message():
print("Bonjour depuis example.py")
if __name__ == "__main__":
print("Ce fichier est en cours d'exécution directe.")
Exécution directe :
Si vous exécutez example.py avec :
python example.py
La sortie sera :
Ce fichier est en cours d'exécution directe.
Importation comme module :
Si vous importez example.py dans un autre fichier :
# main.py
import example
example.afficher_message()
La sortie sera uniquement :
Bonjour depuis example.py
4. Pourquoi utiliser cette construction ?
1. Empêcher une exécution non désirée : Si un fichier contient du code qui ne doit pas
s’exécuter lorsqu’il est importé, cette construction le protège.
2. Faciliter les tests : Vous pouvez inclure un bloc de tests ou de démonstrations dans if
__name__ == "__main__":, sans interférer avec d’autres fichiers qui utilisent ce module.
5. Bonnes pratiques
Ajoutez toujours if __name__ == "__main__": dans vos fichiers contenant du code test
ou des démonstrations.
Placez dans ce bloc uniquement le code destiné à être exécuté directement.
6. Cas Pratique
Fichier : math_utils.py
# math_utils.py
def add(a, b):
return a + b
def subtract(a, b):
return a - b
if __name__ == "__main__":
# Tests directs
print("Test d'addition :", add(10, 5)) # Affiche 15
print("Test de soustraction :", subtract(10, 5)) # Affiche 5
Fichier principal : main.py
# main.py
import math_utils
print("Résultat depuis main :", math_utils.add(20, 10)) # Affiche 30
Résumé
if __name__ == "__main__": vérifie si un fichier est exécuté directement.
Il protège votre code des exécutions non voulues lorsqu’il est importé comme module.
C’est une bonne pratique en Python pour séparer les tests ou les démonstrations du reste
du code.
MORE EXERCISE
Bonne Réponse à la Question : Utiliser les Modules pour un Programme de Gestion de
Stocks
Pour concevoir un programme de gestion de stocks en utilisant des modules, l'idée est de diviser
les responsabilités du programme en différentes parties logiques, chaque partie étant gérée par
un module.
Approche structurée :
1. Identifier les Fonctions Principales
Un programme de gestion de stocks typique pourrait inclure :
Ajout de produits au stock.
Mise à jour des quantités.
Consultation des informations sur un produit.
Génération de rapports (ex. : inventaire actuel).
2. Créer des Modules pour Diviser les Tâches
Voici comment organiser les modules pour un tel programme :
Module 1 : produits.py
Ce module est responsable de gérer les informations sur les produits (nom, prix, catégorie, etc.).
Code :
# produits.py
# Module pour gérer les informations des produits
produits = {}
def ajouter_produit(id, nom, prix, categorie):
"""Ajoute un produit avec ses informations de base."""
if id in produits:
print("Erreur : Produit avec cet ID existe déjà.")
else:
produits[id] = {"nom": nom, "prix": prix, "categorie": categorie, "quantite": 0}
print(f"Produit ajouté : {nom}")
def afficher_produit(id):
"""Affiche les détails d'un produit."""
if id in produits:
print(f"ID : {id}, Détails : {produits[id]}")
else:
print("Produit introuvable.")
Module 2 : stocks.py
Ce module gère les quantités des produits (ajout ou retrait de stock).
Code :
# stocks.py
# Module pour gérer le stock des produits
import produits
def ajouter_stock(id, quantite):
"""Ajoute une quantité au stock d'un produit."""
if id in produits.produits:
produits.produits[id]["quantite"] += quantite
print(f"Stock mis à jour : {produits.produits[id]}")
else:
print("Produit introuvable.")
def retirer_stock(id, quantite):
"""Retire une quantité du stock d'un produit."""
if id in produits.produits:
if produits.produits[id]["quantite"] >= quantite:
produits.produits[id]["quantite"] -= quantite
print(f"Stock mis à jour : {produits.produits[id]}")
else:
print("Erreur : Stock insuffisant.")
else:
print("Produit introuvable.")
Module 3 : rapports.py
Ce module génère des rapports, comme une liste complète des stocks actuels.
Code :
# rapports.py
# Module pour générer des rapports sur le stock
import produits
def generer_rapport():
"""Affiche tous les produits avec leurs stocks."""
print("Rapport d'inventaire :")
for id, details in produits.produits.items():
print(f"ID : {id}, Nom : {details['nom']}, Quantité : {details['quantite']}")
3. Utiliser les Modules dans le Fichier Principal
Le fichier principal importe les modules et orchestre leurs interactions.
Code : main.py
# main.py
# Programme principal de gestion de stocks
import produits
import stocks
import rapports
# Ajouter des produits
produits.ajouter_produit(1, "Chaise", 50, "Mobilier")
produits.ajouter_produit(2, "Table", 150, "Mobilier")
# Mettre à jour les stocks
stocks.ajouter_stock(1, 30)
stocks.ajouter_stock(2, 15)
# Retirer du stock
stocks.retirer_stock(1, 5)
# Afficher les détails d'un produit
produits.afficher_produit(1)
# Générer un rapport d'inventaire
rapports.generer_rapport()
4. Exécution et Résultat
Lorsque vous exécutez main.py, voici ce que vous pourriez voir :
Produit ajouté : Chaise
Produit ajouté : Table
Stock mis à jour : {'nom': 'Chaise', 'prix': 50, 'categorie': 'Mobilier', 'quantite': 30}
Stock mis à jour : {'nom': 'Table', 'prix': 150, 'categorie': 'Mobilier', 'quantite': 15}
Stock mis à jour : {'nom': 'Chaise', 'prix': 50, 'categorie': 'Mobilier', 'quantite': 25}
ID : 1, Détails : {'nom': 'Chaise', 'prix': 50, 'categorie': 'Mobilier', 'quantite': 25}
Rapport d'inventaire :
ID : 1, Nom : Chaise, Quantité : 25
ID : 2, Nom : Table, Quantité : 15
5. Points Clés
1. Pourquoi diviser en modules ?
o Organisation : Le code est divisé en parties logiques.
o Réutilisabilité : Chaque module peut être utilisé indépendamment dans d’autres
projets.
o Maintenance : Les changements dans un module n’affectent pas les autres.
2. Comment améliorer ce programme ?
o Ajouter une base de données pour enregistrer les informations au lieu d’un
dictionnaire en mémoire.
o Intégrer une interface utilisateur pour rendre l’application plus interactive.
3. Discussion sur les limitations actuelles :
o Que se passe-t-il si deux produits ont le même ID ?
o Comment gérer des erreurs plus complexes, comme un produit inexistant ?
Résumé : Vous remarquerez qu’avec l’utilisation des modules, nous avons construit un
programme modulaire et extensible pour la gestion de stocks. Chaque module a une
responsabilité claire, ce qui facilite son développement, sa maintenance, et sa réutilisation. Cette
approche reflète une bonne pratique professionnelle dans le développement logiciel.
