img
Apprenez la programmation où que vous soyez avec Rachid Saad
📞 Appelez maintenant !

Les Fonctions en Python :
Tutoriel Complet pour Maîtriser la Programmation Modulaire

Ce tutoriel vous apprendra à créer et utiliser efficacement les fonctions en Python, un concept fondamental de la programmation. Vous découvrirez comment définir des fonctions, gérer les paramètres et arguments, utiliser les valeurs de retour, et comprendre la portée des variables. À la fin de ce guide, vous serez capable d'écrire du code Python modulaire, réutilisable et professionnel pour structurer vos programmes de manière optimale.

1. Introduction aux Fonctions en Python

Les fonctions sont des blocs de code réutilisables qui permettent d'organiser et de structurer vos programmes Python. Elles constituent l'un des concepts fondamentaux de la programmation modulaire.

Qu'est-ce qu'une fonction ?

Une fonction est un bloc de code nommé qui effectue une tâche spécifique. Elle peut prendre des données en entrée (paramètres), effectuer des opérations, et retourner un résultat.

definition_fonction.py
# Analogie avec la vie réelle au Maroc
					# Une fonction est comme un vendeur de jus d'orange sur la place Jamaâ El Fna
					# Il prend des oranges en entrée et retourne un verre de jus
					
					# Définition d'une fonction simple
					def preparer_the_marocain():
					    """Fonction pour préparer un thé marocain"""
					    print("1. Mettre l'eau à bouillir")
					    print("2. Ajouter le thé vert et la menthe")
					    print("3. Sucrez à votre goût")
					    print("4. Servir en versant de haut pour faire mousser")
					    return "Thé marocain prêt!"
					
					# Appel de la fonction
					resultat = preparer_the_marocain()
					print(resultat)
					
					# Fonction avec paramètres
					def calculer_prix_tajine(prix_base, nombre_personnes):
					    """Calcule le prix total d'un tajine selon le nombre de personnes"""
					    prix_total = prix_base * nombre_personnes
					    return prix_total
					
					# Utilisation avec différentes valeurs
					prix_agneau = calculer_prix_tajine(45, 4)  # Tajine d'agneau pour 4 personnes
					prix_poulet = calculer_prix_tajine(35, 2)  # Tajine de poulet pour 2 personnes
					
					print(f"Prix tajine agneau: {prix_agneau} DH")
					print(f"Prix tajine poulet: {prix_poulet} DH")

Pourquoi utiliser des fonctions dans vos programmes ?

L'utilisation des fonctions apporte de nombreux avantages qui améliorent la qualité et la maintenabilité de vos programmes :

avantages_fonctions.py
# EXEMPLE SANS FONCTIONS (code répétitif et difficile à maintenir)
					# Calcul des taxes pour différents produits au Maroc
					
					# Pour le couscous
					prix_couscous = 120
					tva_couscous = prix_couscous * 0.20  # TVA 20%
					prix_ttc_couscous = prix_couscous + tva_couscous
					print(f"Couscous: {prix_ttc_couscous} DH TTC")
					
					# Pour les dattes (même calcul répété)
					prix_dattes = 80
					tva_dattes = prix_dattes * 0.20
					prix_ttc_dattes = prix_dattes + tva_dattes
					print(f"Dattes: {prix_ttc_dattes} DH TTC")
					
					# Pour l'huile d'argan (encore le même calcul)
					prix_argan = 200
					tva_argan = prix_argan * 0.20
					prix_ttc_argan = prix_argan + tva_argan
					print(f"Huile d'argan: {prix_ttc_argan} DH TTC")
					
					# AVEC FONCTIONS (code organisé et réutilisable)
					def calculer_prix_ttc(prix_ht, taux_tva=0.20):
					    """Calcule le prix TTC pour un produit au Maroc"""
					    tva = prix_ht * taux_tva
					    prix_ttc = prix_ht + tva
					    return prix_ttc
					
					def afficher_prix_produit(nom_produit, prix_ht):
					    """Affiche le prix formaté d'un produit"""
					    prix_ttc = calculer_prix_ttc(prix_ht)
					    print(f"{nom_produit}: {prix_ttc} DH TTC")
					
					# Utilisation simple et claire
					afficher_prix_produit("Couscous", 120)
					afficher_prix_produit("Dattes", 80)
					afficher_prix_produit("Huile d'argan", 200)
					
					# AVANTAGES DÉMONTRÉS :
					# 1. RÉUTILISATION : Même fonction pour tous les produits
					# 2. MAINTENABILITÉ : Changement de TVA en un seul endroit
					# 3. LISIBILITÉ : Code plus clair et compréhensible
					# 4. TESTABILITÉ : Plus facile de tester une fonction isolée
					
					# Exemple d'évolution facile
					# Si la TVA change, on modifie seulement la fonction :
					def calculer_prix_ttc_v2(prix_ht, taux_tva=0.15):  # Nouveau taux TVA
					    # Même logique, seul le taux par défaut change
					    tva = prix_ht * taux_tva
					    prix_ttc = prix_ht + tva
					    return prix_ttc

Avantages de la programmation modulaire

La programmation modulaire avec des fonctions permet de découper un programme complexe en petites parties plus simples à gérer :

programmation_modulaire.py
# Exemple d'un système de gestion de restaurant marocain
					# Approche modulaire avec des fonctions spécialisées
					
					# Module 1: Gestion des commandes
					def prendre_commande(client, plats):
					    """Prend une commande d'un client"""
					    print(f"Commande prise pour {client}")
					    print("Plats commandés:")
					    for plat in plats:
					        print(f"- {plat}")
					    return {"client": client, "plats": plats, "statut": "en attente"}
					
					# Module 2: Calcul des prix
					def calculer_total_commande(commande, menu):
					    """Calcule le total d'une commande"""
					    total = 0
					    for plat in commande["plats"]:
					        if plat in menu:
					            total += menu[plat]
					    return total
					
					# Module 3: Préparation des plats
					def preparer_plat(nom_plat):
					    """Simule la préparation d'un plat marocain"""
					    print(f"Préparation du {nom_plat} en cours...")
					    # Simulation du temps de préparation
					    if "tajine" in nom_plat.lower():
					        print("Cuisson lente du tajine (30 minutes)")
					    elif "couscous" in nom_plat.lower():
					        print("Cuisson vapeur du couscous (20 minutes)")
					    else:
					        print("Préparation standard (15 minutes)")
					    
					    print(f"{nom_plat} prêt à servir!")
					    return True
					
					# Module 4: Service client
					def servir_client(commande):
					    """Sert un client et finalise la commande"""
					    print(f"\nService pour {commande['client']}:")
					    for plat in commande["plats"]:
					        preparer_plat(plat)
					    
					    commande["statut"] = "servi"
					    print(f"Commande de {commande['client']} servie avec succès!")
					    return commande
					
					# PROGRAMME PRINCIPAL - Utilisation des modules
					def main():
					    # Menu du restaurant marocain
					    menu_marocain = {
					        "Tajine de poulet aux olives": 45,
					        "Couscous royal": 60,
					        "Pastilla au pigeon": 75,
					        "Harira": 25,
					        "Thé à la menthe": 15
					    }
					    
					    # Simulation d'une soirée au restaurant
					    print("=== RESTAURANT MAROCAIN 'DAR TAJINE' ===\n")
					    
					    # Client 1
					    commande1 = prendre_commande("Famille Alami", [
					        "Tajine de poulet aux olives", 
					        "Couscous royal",
					        "Thé à la menthe"
					    ])
					    
					    total1 = calculer_total_commande(commande1, menu_marocain)
					    print(f"Total à payer: {total1} DH\n")
					    
					    servir_client(commande1)
					    
					    # AVANTAGES DE LA MODULARITÉ :
					    # - Chaque fonction a une responsabilité unique
					    # - Facile de modifier une fonction sans affecter les autres
					    # - Réutilisation possible dans d'autres contextes
					    # - Collaboration en équipe facilitée
					    # - Tests unitaires simplifiés
					
					# Lancement du programme
					if __name__ == "__main__":
					    main()

2. Créer Votre Première Fonction

Apprendre à créer des fonctions est une étape fondamentale en programmation Python. Une fonction bien conçue permet d'organiser votre code, de le rendre réutilisable et plus facile à maintenir.

Syntaxe de base avec def

En Python, on définit une fonction à l'aide du mot-clé def suivi du nom de la fonction et de parenthèses. La définition se termine par deux points, et le corps de la fonction est indenté.

syntaxe_fonction.py
# Structure de base d'une fonction en Python
					def nom_de_la_fonction(parametre1, parametre2):
					    """Docstring - description de la fonction"""
					    # Corps de la fonction
					    resultat = parametre1 + parametre2
					    return resultat
					
					# Exemple concret : fonction pour calculer le prix d'un produit marocain
					def calculer_prix_tva(prix_ht, taux_tva=0.20):
					    """
					    Calcule le prix TTC d'un produit avec TVA marocaine
					    
					    Args:
					        prix_ht (float): Prix hors taxes en dirhams
					        taux_tva (float): Taux de TVA (20% par défaut au Maroc)
					    
					    Returns:
					        float: Prix TTC en dirhams
					    """
					    tva = prix_ht * taux_tva
					    prix_ttc = prix_ht + tva
					    return prix_ttc
					
					# Utilisation de la fonction
					prix_tajine = calculer_prix_tva(80)  # Tajine à 80 DH HT
					prix_couscous = calculer_prix_tva(60, 0.10)  # Couscous avec TVA réduite
					
					print(f"Prix tajine TTC: {prix_tajine} DH")
					print(f"Prix couscous TTC: {prix_couscous} DH")
					
					# Fonction sans paramètres
					def afficher_bienvenue_maroc():
					    """Affiche un message de bienvenue au Maroc"""
					    print("Ahlan wa sahlan fi Al-Maghrib! ??")
					    print("Bienvenue au Royaume du Maroc!")
					
					# Appel de la fonction sans paramètres
					afficher_bienvenue_maroc()

Conventions de nommage des fonctions

Python suit des conventions de nommage spécifiques pour les fonctions. Le respect de ces conventions rend votre code plus lisible et conforme aux standards de la communauté.

nommage_fonctions.py
# BONNES PRATIQUES de nommage en Python (PEP 8)
					
					# ✓ Noms en minuscules avec underscores (snake_case)
					def calculer_prix_ttc():
					    pass
					
					def afficher_menu_marocain():
					    pass
					
					def gerer_reservation_hotel():
					    pass
					
					# ✗ MAUVAIS exemples (à éviter)
					# def CalculerPrixTTC():  # PascalCase - pour les classes
					# def calculerprixttc():   # tout attaché - illisible
					# def CALCULER_PRIX_TTC(): # majuscules - pour les constantes
					
					# Exemples concrets avec des fonctions marocaines
					
					# ✓ Nom clair et descriptif
					def convertir_dirhams_euros(montant_dirhams, taux_change=0.09):
					    """Convertit des dirhams marocains en euros"""
					    return montant_dirhams * taux_change
					
					# ✓ Nom explicite sur l'action
					def verifier_age_legale_maroc(age):
					    """Vérifie si l'âge est légal pour voter au Maroc (18 ans)"""
					    return age >= 18
					
					# ✓ Nom qui décrit le retour
					def obtenir_villes_imperiales():
					    """Retourne la liste des villes impériales du Maroc"""
					    return ["Marrakech", "Fès", "Meknès", "Rabat"]
					
					# Utilisation des fonctions bien nommées
					montant_euros = convertir_dirhams_euros(1000)  # 1000 DH en euros
					peut_voter = verifier_age_legale_maroc(20)     # Vérification pour 20 ans
					villes = obtenir_villes_imperiales()          # Liste des villes
					
					print(f"1000 DH = {montant_euros:.2f} €")
					print(f"Peut voter: {peut_voter}")
					print(f"Villes impériales: {', '.join(villes)}")
					
					# RÈGLES IMPORTANTES :
					# - Utiliser snake_case: mots en minuscules séparés par _
					# - Être descriptif mais concis
					# - Utiliser des verbes pour les actions
					# - Éviter les noms trop courts (x, y, z) ou trop longs

Indentation et bloc de code

En Python, l'indentation n'est pas seulement une question de style - elle définit la structure du code. Les blocs de fonction sont délimités par l'indentation, généralement de 4 espaces.

indentation_fonctions.py
# L'indentation en Python est OBLIGATOIRE
					# Elle définit le début et la fin d'un bloc de code
					
					# ✓ CORRECT : Indentation cohérente (4 espaces recommandés)
					def calculer_budget_voyage(destination, nombre_jours):
					    # Début du bloc de la fonction (niveau 1)
					    if destination == "Marrakech":
					        # Bloc if (niveau 2)
					        cout_journalier = 500
					    elif destination == "Agadir":
					        # Bloc elif (niveau 2)
					        cout_journalier = 400
					    else:
					        # Bloc else (niveau 2)
					        cout_journalier = 300
					    
					    budget_total = cout_journalier * nombre_jours
					    return budget_total
					
					# ✗ INCORRECT : Exemples d'erreurs d'indentation
					#
					# def mauvaise_indentation():
					# print("Cette ligne provoquera une IndentationError")
					#     print("Indentation incohérente")
					#
					# def melange_espaces_tabulations():
					#     print("4 espaces")
					#   print("2 espaces - erreur!")
					#     print("tabulation - pire!")
					
					# Exemple complexe avec plusieurs niveaux d'indentation
					def organiser_fete_marriage_marocain(nombre_invites, ville):
					    """Organise les détails d'un mariage marocain"""
					    
					    # Niveau 1 : Début de la fonction
					    print(f"Organisation du mariage à {ville}")
					    
					    # Niveau 1 : Calcul du budget
					    budget_total = 0
					    
					    # Niveau 1 : Boucle pour chaque service
					    services = ["salle", "nourriture", "musique", "décorations"]
					    for service in services:
					        # Niveau 2 : Début de la boucle for
					        if service == "salle":
					            # Niveau 3 : Condition if
					            if ville == "Casablanca":
					                # Niveau 4 : Condition imbriquée
					                cout_salle = 20000
					            else:
					                # Niveau 4 : Alternative
					                cout_salle = 15000
					            budget_total += cout_salle
					            
					        elif service == "nourriture":
					            # Niveau 3 : Condition elif
					            cout_par_personne = 300
					            cout_nourriture = cout_par_personne * nombre_invites
					            budget_total += cout_nourriture
					    
					    # Niveau 1 : Retour au niveau principal
					    return budget_total
					
					# Utilisation
					budget_marrakech = calculer_budget_voyage("Marrakech", 7)
					budget_mariage = organiser_fete_marriage_marocain(200, "Casablanca")
					
					print(f"Budget voyage Marrakech: {budget_marrakech} DH")
					print(f"Budget mariage: {budget_mariage} DH")
					
					# BONNES PRATIQUES :
					# - Utiliser 4 espaces par niveau (recommandation officielle)
					# - Ne jamais mélanger espaces et tabulations
					# - Être cohérent dans tout le projet
					# - Vérifier l'indentation après les deux-points (:)

Exemple pratique : fonction simple

Voyons maintenant un exemple complet qui rassemble tous les concepts pour créer une fonction utile dans un contexte marocain.

exemple_pratique.py
# EXEMPLE PRATIQUE COMPLET : Système de calcul de salaire net au Maroc
					
					def calculer_salaire_net_maroc(salaire_brut):
					    """
					    Calcule le salaire net après déduction des cotisations sociales au Maroc
					    
					    Args:
					        salaire_brut (float): Salaire brut en dirhams
					    
					    Returns:
					        dict: Dictionnaire contenant le détail des calculs
					    """
					    
					    # Cotisations sociales (taux approximatifs au Maroc)
					    taux_cnrps = 0.045  # CNRPS : 4.5%
					    taux_amo = 0.0226   # AMO : 2.26%
					    taux_cimr = 0.03    # CIMR : 3% (exemple)
					    
					    # Calcul des déductions
					    cnrps = salaire_brut * taux_cnrps
					    amo = salaire_brut * taux_amo
					    cimr = salaire_brut * taux_cimr
					    
					    # Total des cotisations
					    total_cotisations = cnrps + amo + cimr
					    
					    # Salaire net
					    salaire_net = salaire_brut - total_cotisations
					    
					    # Retourner un dictionnaire avec tous les détails
					    return {
					        "salaire_brut": salaire_brut,
					        "cnrps": cnrps,
					        "amo": amo,
					        "cimr": cimr,
					        "total_cotisations": total_cotisations,
					        "salaire_net": salaire_net
					    }
					
					def afficher_fiche_paie(nom, prenom, salaire_brut):
					    """
					    Affiche une fiche de paie formatée pour un employé
					    
					    Args:
					        nom (str): Nom de l'employé
					        prenom (str): Prénom de l'employé
					        salaire_brut (float): Salaire brut en DH
					    """
					    
					    # Calcul du salaire net
					    details = calculer_salaire_net_maroc(salaire_brut)
					    
					    # Affichage formaté
					    print("\n" + "=" * 50)
					    print("FICHE DE PAIE - MAROC")
					    print("=" * 50)
					    print(f"Employé: {prenom} {nom}")
					    print(f"Salaire brut: {details['salaire_brut']:,.2f} DH")
					    print("-" * 50)
					    print("DÉDUCTIONS:")
					    print(f"  CNRPS (4.5%): {details['cnrps']:,.2f} DH")
					    print(f"  AMO (2.26%): {details['amo']:,.2f} DH")
					    print(f"  CIMR (3%): {details['cimr']:,.2f} DH")
					    print(f"Total cotisations: {details['total_cotisations']:,.2f} DH")
					    print("-" * 50)
					    print(f"SALAIRE NET: {details['salaire_net']:,.2f} DH")
					    print("=" * 50)
					
					# Programme principal
					def main():
					    """Fonction principale du programme"""
					    
					    print("SYSTÈME DE CALCUL DE SALAIRE - MAROC\n")
					    
					    # Exemple 1 : Employé avec salaire moyen
					    afficher_fiche_paie("ALAOUI", "Fatima", 8000)
					    
					    # Exemple 2 : Cadre avec salaire élevé
					    afficher_fiche_paie("BENJELLOUN", "Mehdi", 15000)
					    
					    # Exemple 3 : Calcul simple pour vérification
					    resultat = calculer_salaire_net_maroc(5000)
					    print(f"\nVérification pour 5000 DH:")
					    print(f"Salaire net: {resultat['salaire_net']:.2f} DH")
					
					# Lancement du programme
					if __name__ == "__main__":
					    main()

3. Les Paramètres et Arguments

Les paramètres et arguments permettent de passer des données aux fonctions, les rendant ainsi flexibles et réutilisables. Python offre plusieurs méthodes pour gérer ces entrées de manière efficace.

Paramètres positionnels

Les paramètres positionnels sont les plus basiques - leur ordre d'appel détermine leur valeur. Ils doivent être fournis dans le même ordre que leur définition dans la fonction.

parametres_positionnels.py
# Les paramètres positionnels dépendent de leur position
def creer_fiche_client_maroc(nom, prenom, ville, telephone):
    """Crée une fiche client pour une entreprise marocaine"""
    fiche = {
        "nom_complet": f"{prenom} {nom}",
        "ville": ville,
        "telephone": telephone,
        "pays": "Maroc"
    }
    return fiche

# ✓ APPEL CORRECT : les arguments sont dans le bon ordre
client1 = creer_fiche_client_maroc(
    "Alaoui",       # nom
    "Fatima",      # prenom
    "Casablanca",  # ville
    "0612345678"   # telephone
)

# ✗ APPEL INCORRECT : l'ordre est mélangé
# client2 = creer_fiche_client_maroc(
#     "Casablanca",  # ville passée comme nom → ERREUR!
#     "Alaoui",      # nom passé comme prenom
#     "Fatima",      # prenom passé comme ville
#     "0612345678"   # telephone correct
# )

print("Fiche client créée:")
for cle, valeur in client1.items():
    print(f"  {cle}: {valeur}")

# Exemple pratique : réservation d'hôtel au Maroc
def reserver_hotel_maroc(nom_hotel, ville, date_arrivee, date_depart, nombre_personnes):
    """Effectue une réservation d'hôtel au Maroc"""
    print(f"\nRéservation confirmée à l'hôtel {nom_hotel} ({ville})")
    print(f"Du {date_arrivee} au {date_depart}")
    print(f"Pour {nombre_personnes} personne(s)")
    
    # Simulation de calcul de prix selon la ville
    prix_par_nuit = {
        "Marrakech": 800,
        "Agadir": 600,
        "Fès": 500,
        "Casablanca": 700
    }
    
    prix_nuit = prix_par_nuit.get(ville, 400)
    return prix_nuit * nombre_personnes

# Réservation correcte (ordre respecté)
prix_total = reserver_hotel_maroc(
    "La Mamounia",      # nom_hotel
    "Marrakech",        # ville
    "2024-06-15",       # date_arrivee
    "2024-06-20",       # date_depart
    2                    # nombre_personnes
)

print(f"Prix total: {prix_total} DH")

Arguments par défaut

Les arguments par défaut permettent de définir des valeurs prédéfinies pour certains paramètres. Ils rendent les fonctions plus flexibles en évitant de devoir spécifier toutes les valeurs à chaque appel.

arguments_defaut.py
# Les arguments par défaut ont une valeur prédéfinie
def commander_plat_marocain(plat, quantite=1, epices="moyen", accompagnement="salade marocaine"):
    """Commande un plat marocain avec des options par défaut"""
    
    # Menu des plats avec prix
    menu = {
        "tajine poulet": 45,
        "couscous": 60,
        "pastilla": 75,
        "harira": 25,
        "brochette": 35
    }
    
    prix_unitaire = menu.get(plat, 30)
    prix_total = prix_unitaire * quantite
    
    print(f"Commande: {quantite} x {plat}")
    print(f"Niveau d'épices: {epices}")
    print(f"Accompagnement: {accompagnement}")
    print(f"Prix total: {prix_total} DH")
    
    return {
        "plat": plat,
        "quantite": quantite,
        "epices": epices,
        "accompagnement": accompagnement,
        "prix": prix_total
    }

# DIFFÉRENTES FAÇONS D'APPELER LA FONCTION :

# 1. ✓ Seul l'argument obligatoire
print("=== Commande simple ===")
commande1 = commander_plat_marocain("tajine poulet")

# 2. ✓ Modification de quelques paramètres
print("\n=== Commande personnalisée ===")
commande2 = commander_plat_marocain(
    "couscous",
    quantite=2,
    epices="doux"
)

# 3. ✓ Tous les paramètres modifiés
print("\n=== Commande complète ===")
commande3 = commander_plat_marocain(
    "pastilla",
    quantite=3,
    epices="fort",
    accompagnement="salade d'oranges à la cannelle"
)

# Exemple avancé : système de livraison marocain
def calculer_frais_livraison(ville, montant_commande, express=False, livraison_dimanche=False):
    """Calcule les frais de livraison pour le Maroc"""
    
    # Frais de base par ville
    frais_base = {
        "Casablanca": 20,
        "Rabat": 25,
        "Marrakech": 30,
        "Fès": 35,
        "Agadir": 40
    }
    
    # Calcul initial
    frais = frais_base.get(ville, 50)  # 50 DH pour autres villes
    
    # Majorations
    if express:
        frais += 15  # Livraison express
    
    if livraison_dimanche:
        frais += 10  # Majoration dimanche
    
    # Livraison gratuite au-dessus de 200 DH
    if montant_commande > 200:
        frais = 0
    
    return frais

# Utilisations variées
print("\n" + "="*50)
print("CALCUL FRAIS DE LIVRAISON")
print("="*50)

# Livraison standard
frais1 = calculer_frais_livraison("Casablanca", 150)
print(f"Livraison standard Casablanca: {frais1} DH")

# Livraison express
frais2 = calculer_frais_livraison("Marrakech", 180, express=True)
print(f"Livraison express Marrakech: {frais2} DH")

# Livraison dimanche avec commande importante
frais3 = calculer_frais_livraison("Rabat", 250, livraison_dimanche=True)
print(f"Livraison dimanche Rabat (gratuite): {frais3} DH")

Arguments nommés (keyword arguments)

Les arguments nommés permettent de spécifier les paramètres par leur nom plutôt que par leur position. Cela rend le code plus lisible et permet de sauter des paramètres optionnels.

arguments_nommes.py
# Les arguments nommés améliorent la lisibilité
def creer_offre_emploi_maroc(poste, entreprise, ville, salaire, type_contrat="CDI", teletravail=False, langues=None):
    """Crée une offre d'emploi pour le marché marocain"""
    
    if langues is None:
        langues = ["Arabe", "Français"]
    
    offre = {
        "poste": poste,
        "entreprise": entreprise,
        "ville": ville,
        "salaire": f"{salaire:,} DH",
        "type_contrat": type_contrat,
        "teletravail": "Oui" if teletravail else "Non",
        "langues_requises": ", ".join(langues)
    }
    
    print(f"\n? OFFRE D'EMPLOI - {entreprise.upper()}")
    print("-" * 40)
    for cle, valeur in offre.items():
        print(f"  {cle.replace('_', ' ').title()}: {valeur}")
    
    return offre

# AVANTAGES DES ARGUMENTS NOMMÉS :

# 1. ✓ Lisibilité améliorée
print("=== Offre standard ===")
offre1 = creer_offre_emploi_maroc(
    poste="Développeur Python",
    entreprise="Maroc Numeric",
    ville="Casablanca",
    salaire=15000
)

# 2. ✓ Sauter des paramètres optionnels
print("\n=== Offre avec télétravail ===")
offre2 = creer_offre_emploi_maroc(
    poste="Data Analyst",
    entreprise="DataMaroc",
    ville="Rabat",
    salaire=12000,
    teletravail=True,
    langues=["Arabe", "Français", "Anglais"]
)

# 3. ✓ Mélange positionnel + nommé (les positionnels d'abord!)
print("\n=== Offre CDD ===")
offre3 = creer_offre_emploi_maroc(
    "Commercial",           # poste (positionnel)
    "Sahara Tech",          # entreprise (positionnel)
    "Marrakech",            # ville (positionnel)
    8000,                    # salaire (positionnel)
    type_contrat="CDD",      # nommé
    langues=["Arabe", "Anglais"]  # nommé
)

# Exemple complexe : système de voyage au Maroc
def organiser_voyage_maroc(destination, duree, voyageurs=1, budget=2000, saison="printemps", guide=False, activites=None):
    """Organise un voyage personnalisé au Maroc"""
    
    if activites is None:
        activites = ["visite culturelle", "gastronomie"]
    
    # Coûts estimatifs
    couts_destination = {
        "Marrakech": 500,
        "Fès": 400,
        "Chefchaouen": 350,
        "Sahara": 800
    }
    
    cout_base = couts_destination.get(destination, 300) * duree
    cout_total = cout_base * voyageurs
    
    if guide:
        cout_total += 200 * duree
    
    print(f"\n? VOYAGE ORGANISÉ - {destination.upper()}")
    print(f"Durée: {duree} jours, Voyageurs: {voyageurs}")
    print(f"Saison: {saison}, Guide: {'Oui' if guide else 'Non'}")
    print(f"Activités: {', '.join(activites)}")
    print(f"Coût estimé: {cout_total} DH")
    print(f"Budget disponible: {budget} DH")
    
    return cout_total <= budget

# Planification de différents voyages
print("\n" + "?️  PLANIFICATION DE VOYAGES AU MAROC")
print("="*60)

		
				

4. La Valeur de Retour (return)

L'instruction return est essentielle en Python car elle permet à une fonction de renvoyer un résultat au code appelant. Comprendre son utilisation est crucial pour créer des fonctions efficaces et réutilisables.

Comprendre l'instruction return

L'instruction return met fin à l'exécution d'une fonction et renvoie une valeur au code appelant. Une fonction sans return explicite retourne None par défaut.

instruction_return.py
# L'instruction return termine la fonction et renvoie une valeur
					def calculer_tva_maroc(prix_ht):
					    """Calcule la TVA marocaine (20%) et retourne le prix TTC"""
					    tva = prix_ht * 0.20
					    prix_ttc = prix_ht + tva
					    return prix_ttc  # ← Retourne le résultat
					
					# Utilisation du retour
					prix_tajine = calculer_tva_maroc(100)
					prix_couscous = calculer_tva_maroc(80)
					
					print(f"Prix tajine TTC: {prix_tajine} DH")
					print(f"Prix couscous TTC: {prix_couscous} DH")
					
					# return termine immédiatement la fonction
					def verifier_majorite_maroc(age):
					    """Vérifie si une personne est majeure au Maroc (18 ans)"""
					    if age >= 18:
					        return True   # ← La fonction s'arrête ici si condition vraie
					        print("Cette ligne ne sera jamais exécutée!")
					    
					    return False  # ← Exécuté seulement si age < 18
					
					# Tests
					print(f"20 ans → Majeur: {verifier_majorite_maroc(20)}")
					print(f"16 ans → Majeur: {verifier_majorite_maroc(16)}")
					
					# Exemple pratique : système de scoring pour un concours marocain
					def calculer_score_concours(reponses_correctes, reponses_incorrectes, reponses_blanches=0):
					    """
					    Calcule le score pour un concours marocain
					    Système: +4 points bonne réponse, -1 point mauvaise, 0 point blanc
					    """
					    
					    # Vérification des entrées
					    if reponses_correctes < 0 or reponses_incorrectes < 0:
					        return -1  # Code d'erreur
					    
					    # Calcul du score
					    score = (reponses_correctes * 4) - reponses_incorrectes
					    
					    # Score minimum à 0
					    if score < 0:
					        return 0
					    
					    return score
					
					# Simulation de candidats
					candidats = [
					    {"nom": "Ahmed Alami", "correctes": 15, "incorrectes": 5},
					    {"nom": "Fatima Zahra", "correctes": 12, "incorrectes": 8},
					    {"nom": "Mehdi Benjelloun", "correctes": 8, "incorrectes": 12},
					    {"nom": "Erreur", "correctes": -5, "incorrectes": 10}  # Données invalides
					]
					
					print("\n? RÉSULTATS DU CONCOURS MAROCAIN")
					print("=" * 40)
					for candidat in candidats:
					    score = calculer_score_concours(
					        candidat["correctes"], 
					        candidat["incorrectes"]
					    )
					    
					    if score == -1:
					        print(f"{candidat['nom']}: Données invalides")
					    else:
					        print(f"{candidat['nom']}: {score} points")

Retourner plusieurs valeurs

En Python, une fonction peut retourner plusieurs valeurs simultanément sous forme de tuple. Cette fonctionnalité est très pratique pour regrouper des résultats liés.

retour_multiple.py
# Retourner plusieurs valeurs avec un tuple
					def analyser_ventes_maroc(ventes_journalieres):
					    """Analyse les ventes et retourne plusieurs statistiques"""
					    total_ventes = sum(ventes_journalieres)
					    moyenne_ventes = total_ventes / len(ventes_journalieres)
					    meilleur_jour = max(ventes_journalieres)
					    pire_jour = min(ventes_journalieres)
					    
					    # Retour multiple sous forme de tuple
					    return total_ventes, moyenne_ventes, meilleur_jour, pire_jour
					
					# Récupération des multiples valeurs
					ventes_semaine = [1200, 1500, 800, 2000, 1700, 900, 1300]
					total, moyenne, meilleur, pire = analyser_ventes_maroc(ventes_semaine)
					
					print("? ANALYSE DES VENTES - MAROC")
					print(f"Total des ventes: {total} DH")
					print(f"Moyenne quotidienne: {moyenne:.2f} DH")
					print(f"Meilleur jour: {meilleur} DH")
					print(f"Pire jour: {pire} DH")
					
					# Alternative : récupérer le tuple complet
					resultats = analyser_ventes_maroc(ventes_semaine)
					print(f"\nTuple complet: {resultats}")
					print(f"Type: {type(resultats)}")
					
					# Exemple avancé : système de paie marocain
					def calculer_fiche_paie_maroc(salaire_brut, heures_supplementaires=0):
					    """Calcule une fiche de paie complète selon la législation marocaine"""
					    
					    # Cotisations sociales (taux approximatifs)
					    cnrps = salaire_brut * 0.045   # 4.5%
					    amo = salaire_brut * 0.0226    # 2.26%
					    cimr = salaire_brut * 0.03     # 3% (exemple)
					    
					    # Heures supplémentaires (majoration 25%)
					    taux_horaire = salaire_brut / 191  # Base mensuelle standard
					    majoration_hs = (taux_horaire * 0.25) * heures_supplementaires
					    
					    # Calculs finaux
					    total_cotisations = cnrps + amo + cimr
					    salaire_net = salaire_brut - total_cotisations + majoration_hs
					    
					    # Retour multiple avec un dictionnaire pour plus de clarté
					    return {
					        "salaire_brut": salaire_brut,
					        "cnrps": cnrps,
					        "amo": amo,
					        "cimr": cimr,
					        "heures_supp": heures_supplementaires,
					        "majoration_hs": majoration_hs,
					        "total_cotisations": total_cotisations,
					        "salaire_net": salaire_net
					    }
					
					# Utilisation avec déballage multiple
					fiche = calculer_fiche_paie_maroc(8000, heures_supplementaires=10)
					
					print("\n? FICHE DE PAIE DÉTAILLÉE - MAROC")
					print("=" * 50)
					for cle, valeur in fiche.items():
					    nom_affichage = cle.replace('_', ' ').title()
					    if isinstance(valeur, (int, float)):
					        print(f"{nom_affichage}: {valeur:,.2f} DH")
					    else:
					        print(f"{nom_affichage}: {valeur}")
					
					# Retour multiple avec différents types
					def analyser_produit_maroc(nom_produit, prix, stock):
					    """Analyse un produit et retourne différentes informations"""
					    
					    # Classification par prix
					    if prix < 50:
					        categorie = "Économique"
					    elif prix < 200:
					        categorie = "Standard"
					    else:
					        categorie = "Premium"
					    
					    # Statut du stock
					    if stock == 0:
					        statut_stock = "Rupture"
					    elif stock < 10:
					        statut_stock = "Faible"
					    else:
					        statut_stock = "Disponible"
					    
					    # Valeur totale du stock
					    valeur_stock = prix * stock
					    
					    return nom_produit, categorie, statut_stock, valeur_stock
					
					# Utilisation
					produit, cat, statut, valeur = analyser_produit_maroc("Tapis Berbère", 450, 5)
					print(f"\n?️  {produit} - Catégorie: {cat} - Stock: {statut} - Valeur: {valeur} DH")

Fonctions sans return (None)

Les fonctions sans instruction return explicite retournent automatiquement None. Ces fonctions sont utiles pour effectuer des actions sans nécessiter de valeur de retour.

fonctions_sans_return.py
# Fonctions sans return retournent None
					def afficher_menu_marocain():
					    """Affiche un menu marocain - pas de return nécessaire"""
					    print("\n?️  MENU MAROCAIN TRADITIONNEL")
					    print("-" * 35)
					    print("1. Tajine de poulet aux olives - 45 DH")
					    print("2. Couscous royal - 60 DH")
					    print("3. Pastilla au pigeon - 75 DH")
					    print("4. Harira - 25 DH")
					    print("5. Thé à la menthe - 15 DH")
					    # Pas de return → retourne None automatiquement
					
					# La fonction retourne None
					resultat = afficher_menu_marocain()
					print(f"\nValeur de retour: {resultat}")
					print(f"Type: {type(resultat)}")
					
					# Fonction avec return None explicite
					def enregistrer_client_maroc(nom, telephone):
					    """Enregistre un client dans la base de données"""
					    
					    # Validation du numéro marocain
					    if not telephone.startswith(("06", "07")) or len(telephone) != 10:
					        print("❌ Numéro de téléphone marocain invalide")
					        return None  # Retour explicite de None en cas d'erreur
					    
					    # Simulation d'enregistrement
					    print(f"✅ Client {nom} enregistré avec le numéro {telephone}")
					    # Pas de return → None implicite
					
					# Tests
					print("\n? ENREGISTREMENT CLIENTS")
					print("=" * 30)
					
					client1 = enregistrer_client_maroc("Karim Alami", "0612345678")
					print(f"Retour: {client1}")
					
					client2 = enregistrer_client_maroc("Fatima Zahra", "0512345678")  # Invalide
					print(f"Retour: {client2}")
					
					# Exemple pratique : système de notification
					def envoyer_notification_maroc(message, type_notif="info"):
					    """Envoie une notification avec formatage marocain"""
					    
					    # Icônes selon le type
					    icones = {
					        "info": "ℹ️",
					        "success": "✅",
					        "warning": "⚠️",
					        "error": "❌"
					    }
					    
					    icone = icones.get(type_notif, "?")
					    
					    # Affichage formaté
					    print(f"\n{icone} [MAROC] {message}")
					    
					    # Journalisation (simulée)
					    with open("notifications.log", "a", encoding="utf-8") as f:
					        f.write(f"[datetime.now()] {type_notif}: {message}\n")
					    
					    # Pas de return nécessaire - action pure
					
					# Utilisation de fonctions sans retour
					print("\n? SYSTÈME DE NOTIFICATION MAROC")
					print("=" * 35)
					
					envoyer_notification_maroc("Commande #1234 confirmée", "success")
					envoyer_notification_maroc("Maintenance programmée samedi", "
							

5. Portée des Variables (Scope)

La portée des variables détermine où une variable peut être accessible dans un programme Python. Comprendre les différentes portées est essentiel pour éviter les erreurs et écrire du code maintenable.

Variables locales vs variables globales

Les variables locales sont définies à l'intérieur d'une fonction et ne sont accessibles que dans cette fonction. Les variables globales sont définies au niveau du module et sont accessibles partout.

portee_variables.py
# Variables globales - accessibles partout
					taux_tva_maroc = 0.20  # Variable globale
					devise = "DH"         # Variable globale
					
					def calculer_prix_ttc(prix_ht):
					    """Calcule le prix TTC avec TVA marocaine"""
					    # Variables locales - accessibles seulement dans cette fonction
					    tva = prix_ht * taux_tva_maroc  # tva est locale
					    prix_ttc = prix_ht + tva        # prix_ttc est locale
					    
					    print(f"À l'intérieur de la fonction:")
					    print(f"  - Variable locale 'tva': {tva} {devise}")
					    print(f"  - Variable locale 'prix_ttc': {prix_ttc} {devise}")
					    print(f"  - Variable globale 'taux_tva_maroc': {taux_tva_maroc}")
					    
					    return prix_ttc
					
					# Utilisation
					resultat = calculer_prix_ttc(100)
					print(f"\nÀ l'extérieur de la fonction:")
					print(f"  - Variable globale 'taux_tva_maroc': {taux_tva_maroc}")
					print(f"  - Variable globale 'devise': {devise}")
					print(f"  - Résultat: {resultat} {devise}")
					
					# ✗ ERREUR: Tentative d'accès à une variable locale depuis l'extérieur
					# print(f"Variable locale 'tva': {tva}")  # NameError: name 'tva' is not defined
					# print(f"Variable locale 'prix_ttc': {prix_ttc}")  # NameError
					
					# Exemple pratique : système de gestion de restaurant marocain
					# Variables globales pour la configuration du restaurant
					nom_restaurant = "Dar Tajine"
					ville_restaurant = "Marrakech"
					service_charge = 0.10  # 10% de service
					
					def prendre_commande(client, plats):
					    """Prend une commande et calcule le total"""
					    
					    # Variables locales à la fonction
					    menu = {
					        "tajine": 45,
					        "couscous": 60,
					        "pastilla": 75,
					        "harira": 25
					    }
					    
					    total_ht = 0
					    details_commande = []
					    
					    for plat in plats:
					        prix = menu.get(plat, 0)
					        total_ht += prix
					        details_commande.append(f"{plat}: {prix} DH")
					    
					    # Utilisation des variables globales
					    frais_service = total_ht * service_charge
					    total_ttc = total_ht + frais_service
					    
					    print(f"\n?️  {nom_restaurant} - {ville_restaurant}")
					    print(f"Client: {client}")
					    print("Commande:")
					    for detail in details_commande:
					        print(f"  - {detail}")
					    print(f"Total HT: {total_ht} DH")
					    print(f"Service ({service_charge*100}%): {frais_service} DH")
					    print(f"Total TTC: {total_ttc} DH")
					    
					    return total_ttc
					
					# Commandes
					commande1 = prendre_commande("Famille Alami", ["tajine", "couscous", "harira"])
					commande2 = prendre_commande("M. Benjelloun", ["pastilla", "tajine"])
					
					# Démonstration des portées
					print(f"\n? DÉMONSTRATION DES PORTÉES:")
					print(f"Variables globales accessibles:")
					print(f"  - nom_restaurant: {nom_restaurant}")
					print(f"  - ville_restaurant: {ville_restaurant}")
					print(f"  - service_charge: {service_charge}")
					
					# ✗ Les variables locales ne sont pas accessibles
					# print(f"Variable locale 'menu': {menu}")  # NameError
					# print(f"Variable locale 'total_ht': {total_ht}")  # NameError

Le mot-clé global

Le mot-clé global permet de modifier une variable globale depuis l'intérieur d'une fonction. Il doit être utilisé avec prudence car il peut rendre le code difficile à comprendre.

mot_cle_global.py
# Variables globales pour un système bancaire marocain
					solde_banque = 1000000  # DH
					nombre_clients = 0
					transactions = []
					
					def ajouter_client(nom, depot_initial=0):
					    """Ajoute un nouveau client et met à jour les statistiques globales"""
					    
					    # Déclaration des variables globales à modifier
					    global nombre_clients, solde_banque, transactions
					    
					    # Modification des variables globales
					    nombre_clients += 1
					    solde_banque += depot_initial
					    
					    # Ajout de la transaction
					    transaction = {
					        "type": "nouveau_client",
					        "client": nom,
					        "montant": depot_initial,
					        "date": "2024-01-15"
					    }
					    transactions.append(transaction)
					    
					    print(f"✅ Client {nom} ajouté avec dépôt de {depot_initial} DH")
					    print(f"   Nombre total de clients: {nombre_clients}")
					    print(f"   Solde banque: {solde_banque} DH")
					
					def afficher_statistiques():
					    """Affiche les statistiques globales de la banque"""
					    # Lecture seule - pas besoin de 'global'
					    print(f"\n? STATISTIQUES BANCAIRES MAROC")
					    print(f"Nombre de clients: {nombre_clients}")
					    print(f"Solde total: {solde_banque} DH")
					    print(f"Nombre de transactions: {len(transactions)}")
					
					# Démonstration
					ajouter_client("Karim Alami", 5000)
					ajouter_client("Fatima Zahra", 10000)
					ajouter_client("Mehdi Benjelloun", 7500)
					
					afficher_statistiques()
					
					# Exemple des problèmes sans 'global'
					taux_change = 0.09  # 1 DH = 0.09 €
					
					def mauvaise_modification_taux(nouveau_taux):
					    """Tentative de modification SANS global → crée une variable locale"""
					    taux_change = nouveau_taux  # Crée une variable locale, ne modifie pas la globale
					    print(f"À l'intérieur (local): taux_change = {taux_change}")
					
					def bonne_modification_taux(nouveau_taux):
					    """Modification AVEC global → modifie la variable globale"""
					    global taux_change
					    taux_change = nouveau_taux
					    print(f"À l'intérieur (global): taux_change = {taux_change}")
					
					print(f"\n? DÉMONSTRATION AVEC/SANS GLOBAL:")
					print(f"Avant modification: taux_change = {taux_change}")
					
					# Mauvaise modification (sans global)
					mauvaise_modification_taux(0.10)
					print(f"Après mauvaise modification: taux_change = {taux_change}")  # Toujours 0.09!
					
					# Bonne modification (avec global)
					bonne_modification_taux(0.10)
					print(f"Après bonne modification: taux_change = {taux_change}")  # Maintenant 0.10
					
					# Exemple pratique : système de scoring pour un jeu marocain
					score_global = 0
					meilleur_score = 0
					joueurs = []
					
					def ajouter_score(joueur, score):
					    """Ajoute un score et met à jour les statistiques globales"""
					    global score_global, meilleur_score, joueurs
					    
					    score_global += score
					    
					    if score > meilleur_score:
					        meilleur_score = score
					    
					    joueurs.append({"nom": joueur, "score": score})
					    
					    print(f"? {joueur} a marqué {score} points")
					
					def afficher_classement():
					    """Affiche le classement des joueurs"""
					    print(f"\n? CLASSEMENT - JEU MAROCAIN")
					    print(f"Score global: {score_global} points")
					    print(f"Meilleur score: {meilleur_score} points")
					    print(f"Nombre de joueurs: {len(joueurs)}")
					    
					    # Tri par score décroissant
					    joueurs_tries = sorted(joueurs, key=lambda x: x["score"], reverse=True)
					    
					    for i, joueur in enumerate(joueurs_tries, 1):
					        print(f"  {i}. {joueur['nom']}: {joueur['score']} points")
					
					# Simulation de parties
					ajouter_score("Ahmed", 150)
					ajouter_score("Fatima", 200)
					ajouter_score("Mehdi", 180)
					ajouter_score("Youssef", 250)
					
					afficher_classement()

Le mot-clé nonlocal

Le mot-clé nonlocal permet de modifier une variable dans la portée englobante (mais pas globale). Il est utilisé dans les fonctions imbriquées pour accéder aux variables des fonctions parentes.

mot_cle_nonlocal.py
# Exemple de nonlocal avec un système de compte épargne marocain
					def creer_compte_epargne(titulaire, solde_initial=0):
					    """Crée un compte épargne avec des fonctions imbriquées"""
					    
					    # Variables dans la portée de creer_compte_epargne
					    solde = solde_initial
					    historique = []
					    taux_interet = 0.03  # 3% d'intérêt annuel
					    
					    def deposer(montant):
					        """Dépose de l'argent sur le compte"""
					        nonlocal solde, historique  # Permet de modifier les variables parentes
					        
					        if montant > 0:
					            solde += montant
					            historique.append(f"Dépôt: +{montant} DH")
					            print(f"✅ {montant} DH déposés. Nouveau solde: {solde} DH")
					        else:
					            print("❌ Le montant doit être positif")
					    
					    def retirer(montant):
					        """Retire de l'argent du compte"""
					        nonlocal solde, historique
					        
					        if 0 < montant <= solde:
					            solde -= montant
					            historique.append(f"Retrait: -{montant} DH")
					            print(f"✅ {montant} DH retirés. Nouveau solde: {solde} DH")
					        else:
					            print("❌ Solde insuffisant ou montant invalide")
					    
					    def calculer_interets():
					        """Calcule et ajoute les intérêts annuels"""
					        nonlocal solde, historique
					        
					        interets = solde * taux_interet
					        solde += interets
					        historique.append(f"Intérêts: +{interets:.2f} DH")
					        print(f"? Intérêts de {interets:.2f} DH ajoutés. Nouveau solde: {solde:.2f} DH")
					    
					    def afficher_solde():
					        """Affiche le solde actuel"""
					        print(f"? Solde de {titulaire}: {solde} DH")
					    
					    def afficher_historique():
					        """Affiche l'historique des transactions"""
					        print(f"\n? Historique de {titulaire}:")
					        for operation in historique:
					            print(f"  - {operation}")
					    
					    # Retourne un dictionnaire avec les fonctions internes
					    return {
					        "deposer": deposer,
					        "retirer": retirer,
					        "calculer_interets": calculer_interets,
					        "afficher_solde": afficher_solde,
					        "afficher_historique": afficher_historique
					    }
					
					# Utilisation
					print("? SYSTÈME D'ÉPARGNE MAROCAIN")
					print("=" * 35)
					
					# Création de comptes
					compte_karim = creer_compte_epargne("Karim Alami", 1000)
					compte_fatima = creer_compte_epargne("Fatima Zahra", 500)
					
					# Opérations sur le compte de Karim
					compte_karim["afficher_solde"]()
					compte_karim["deposer"](500)
					compte_karim["retirer"](200)
					compte_karim["calculer_interets"]()
					compte_karim["afficher_historique"]()
					
					# Opérations sur le compte de Fatima
					print("\n" + "-"*40)
					compte_fatima["afficher_solde"]()
					compte_fatima["deposer"](1000)
					compte_fatima["calculer_interets"]()
					compte_fatima["afficher_historique"]()
					
					# Démonstration du problème sans nonlocal
					def exemple_sans_nonlocal():
					    """Montre ce qui se passe sans le mot-clé nonlocal"""
					    compteur = 0
					    
					    def incrementer_sans_nonlocal():
					        # Sans nonlocal, cela crée une variable locale
					        compteur = compteur + 1  # UnboundLocalError!
					        print(f"Compteur: {compteur}")
					    
					    def incrementer_avec_nonlocal():
					        nonlocal compteur
					        compteur += 1
					        print(f"Compteur: {compteur}")
					    
					    print(f"\n? DÉMONSTRATION NONLOCAL:")
					    
					    # ✗ Sans nonlocal - provoque une erreur
					    # incrementer_sans_nonlocal()  # UnboundLocalError
					    
					    # ✓ Avec nonlocal - fonctionne correctement
					    incrementer_avec_nonlocal()  # Compteur: 1
					    incrementer_avec_nonlocal()  # Compteur: 2
					    incrementer_avec_nonlocal()  # Compteur: 3
					
					exemple_sans_nonlocal()
					
					# RÉCAPITULATIF DES PORTÉES :
					# - Local: variables définies dans une fonction
					# - Enclosing: variables des fonctions parentes (accès avec nonlocal)
					# - Global: variables du module (accès avec global)
					# - Built-in: fonctions intégrées de Python

6. Fonctions Avancées

Python offre des fonctionnalités avancées qui rendent les fonctions plus puissantes et flexibles. Ces concepts permettent d'écrire du code plus concis, réutilisable et élégant.

Fonctions lambda (anonymes)

Les fonctions lambda sont des fonctions anonymes définies en une seule ligne avec le mot-clé lambda. Elles sont utiles pour des opérations simples et temporaires.

fonctions_lambda.py
# Syntaxe de base: lambda arguments: expression
					
					# Fonction classique
					def calculer_tva(prix):
					    return prix * 0.20
					
					# Fonction lambda équivalente
					calculer_tva_lambda = lambda prix: prix * 0.20
					
					# Test
					prix_produit = 100
					print(f"Fonction classique: {calculer_tva(prix_produit)} DH")
					print(f"Fonction lambda: {calculer_tva_lambda(prix_produit)} DH")
					
					# Exemples pratiques dans un contexte marocain
					
					# 1. Conversion de devises
					converter_dh_vers_euro = lambda dh: dh * 0.09
					converter_dh_vers_dollar = lambda dh: dh * 0.10
					
					print(f"\n? CONVERSION DE DEVISES MAROC")
					print(f"1000 DH = {converter_dh_vers_euro(1000):.2f} €")
					print(f"1000 DH = {converter_dh_vers_dollar(1000):.2f} $")
					
					# 2. Calcul de taxes marocaines
					calculer_taxe_habitation = lambda loyer: loyer * 0.10  # Taxe d'habitation 10%
					calculer_orsom = lambda salaire: salaire * 0.0265      # OR SOM 2.65%
					
					loyer_mensuel = 3000
					salaire_brut = 8000
					
					print(f"\n? CALCUL DE TAXES")
					print(f"Taxe habitation (loyer {loyer_mensuel} DH): {calculer_taxe_habitation(loyer_mensuel)} DH")
					print(f"OR SOM (salaire {salaire_brut} DH): {calculer_orsom(salaire_brut):.2f} DH")
					
					# 3. Utilisation avec les fonctions de tri
					clients_maroc = [
					    {"nom": "Alaoui", "ville": "Casablanca", "achats": 1500},
					    {"nom": "Benjelloun", "ville": "Rabat", "achats": 800},
					    {"nom": "Zahra", "ville": "Marrakech", "achats": 2500},
					    {"nom": "Amrani", "ville": "Fès", "achats": 1200}
					]
					
					# Tri par montant d'achats (décroissant)
					clients_tries_achats = sorted(clients_maroc, key=lambda client: client["achats"], reverse=True)
					
					print(f"\n? CLIENTS TRIÉS PAR ACHATS (DESC)")
					for client in clients_tries_achats:
					    print(f"  {client['nom']} - {client['ville']}: {client['achats']} DH")
					
					# 4. Filtrage avec filter()
					clients_grands_achats = list(filter(lambda client: client["achats"] > 1000, clients_maroc))
					
					print(f"\n? CLIENTS AVEC ACHATS > 1000 DH")
					for client in clients_grands_achats:
					    print(f"  {client['nom']} - {client['ville']}: {client['achats']} DH")
					
					# 5. Transformation avec map()
					villes_maroc = ["casablanca", "rabat", "marrakech", "fès"]
					villes_majuscules = list(map(lambda ville: ville.upper(), villes_maroc))
					
					print(f"\n?️  VILLES EN MAJUSCULES")
					print(villes_majuscules)
					
					# AVANTAGES des lambda:
					# - Concis (une ligne)
					# - Parfait pour les petites opérations
					# - Utilisable directement comme argument
					
					# LIMITATIONS:
					# - Une seule expression
					# - Pas de documentation string
					# - Mois lisible pour des opérations complexes

Fonctions récursives

Une fonction récursive est une fonction qui s'appelle elle-même. Elle doit avoir un cas de base (condition d'arrêt) et un cas récursif qui réduit le problème.

fonctions_recursives.py
# Exemple classique : factorielle
					def factorielle(n):
					    """Calcule la factorielle de n de manière récursive"""
					    # Cas de base
					    if n == 0 or n == 1:
					        return 1
					    # Cas récursif
					    else:
					        return n * factorielle(n - 1)
					
					print(f"Factorielle de 5: {factorielle(5)}")  # 120
					print(f"Factorielle de 0: {factorielle(0)}")  # 1
					
					# Exemples pratiques dans un contexte marocain
					
					# 1. Calcul des générations d'une famille marocaine
					def compter_descendants(generation):
					    """
					    Calcule le nombre total de descendants après n générations
					    Hypothèse: chaque personne a 3 enfants en moyenne
					    """
					    # Cas de base: génération 0 (ancêtre unique)
					    if generation == 0:
					        return 1
					    # Cas récursif: 3 enfants par personne
					    else:
					        return 3 * compter_descendants(generation - 1)
					
					print(f"\n?‍?‍?‍? GÉNÉALOGIE MAROCAINE")
					for gen in range(1, 6):
					    descendants = compter_descendants(gen)
					    print(f"Génération {gen}: {descendants} descendants")
					
					# 2. Système de commission en cascade pour un réseau de vente marocain
					def calculer_commission_reseau(niveau, vente=1000):
					    """
					    Calcule les commissions en cascade dans un réseau de vente
					    Chaque niveau reçoit 10% et passe 5% au niveau supérieur
					    """
					    # Cas de base: niveau 0 (pas de commission supplémentaire)
					    if niveau == 0:
					        return vente * 0.10  # 10% de commission
					    
					    # Cas récursif: commission + part du niveau supérieur
					    commission_niveau = vente * 0.10
					    commission_superieur = calculer_commission_reseau(niveau - 1, vente) * 0.05
					    
					    return commission_niveau + commission_superieur
					
					print(f"\n? COMMISSIONS RÉSEAU DE VENTE")
					for niveau in range(4):
					    commission = calculer_commission_reseau(niveau)
					    print(f"Niveau {niveau}: {commission:.2f} DH de commission")
					
					# 3. Exploration d'une structure arborescente (organigramme d'entreprise marocaine)
					def compter_employes(departement):
					    """Compte récursivement le nombre d'employés dans un département"""
					    total = 0
					    
					    # Si c'est un employé individuel
					    if isinstance(departement, str):
					        return 1
					    
					    # Si c'est un département avec des sous-départements
					    for sous_departement in departement.values():
					        total += compter_employes(sous_departement)
					    
					    return total
					
					# Structure d'une entreprise marocaine
					entreprise_maroc = {
					    "Direction": {
					        "DG": "M. Alami",
					        "DAF": "Mme. Zahra"
					    },
					    "Commercial": {
					        "Ventes": ["Karim", "Fatima", "Mehdi"],
					        "Marketing": {
					            "Digital": ["Youssef", "Amina"],
					            "Traditionnel": ["Hassan"]
					        }
					    },
					    "Technique": ["Ahmed", "Samira", "Khalid", "Nadia"]
					}
					
					total_employes = compter_employes(entreprise_maroc)
					print(f"\n? EMPLOYÉS DANS L'ENTREPRISE: {total_employes}")
					
					# 4. Recherche dans une structure hiérarchique (système de fichiers marocain)
					def trouver_fichier(repertoire, nom_fichier, chemin_actuel=""):
					    """Recherche récursive d'un fichier dans une arborescence"""
					    
					    # Parcours des éléments du répertoire
					    for nom, contenu in repertoire.items():
					        nouveau_chemin = f"{chemin_actuel}/{nom}" if chemin_actuel else nom
					        
					        # Si on trouve le fichier
					        if nom == nom_fichier:
					            return nouveau_chemin
					        
					        # Si c'est un sous-répertoire, recherche récursive
					        if isinstance(contenu, dict):
					            resultat = trouver_fichier(contenu, nom_fichier, nouveau_chemin)
					            if resultat:
					                return resultat
					    
					    return None
					
					# Structure de fichiers d'une administration marocaine
					administration = {
					    "Ministère_Finance": {
					        "Budget": {
					            "2024": "budget_2024.pdf",
					            "2023": "budget_2023.pdf"
					        },
					        "Impôts": {
					            "TVA": "guide_tva.pdf",
					            "IR": "calcul_ir.xlsx"
					        }
					    },
					    "Ministère_Santé": {
					        "Vaccination": "plan_vaccination.pdf"
					    }
					}
					
					fichier_trouve = trouver_fichier(administration, "guide_tva.pdf")
					print(f"\n? FICHIER TROUVÉ: {fichier_trouve}")
					
					# ⚠️ IMPORTANT: Toujours avoir un cas de base pour éviter la récursion infinie!

Fonctions comme arguments (callbacks)

En Python, les fonctions sont des objets de première classe, ce qui signifie qu'elles peuvent être passées comme arguments à d'autres fonctions. Ces fonctions sont appelées "callbacks".

fonctions_callbacks.py
# Exemple de base: fonction qui accepte une autre fonction en paramètre
					def appliquer_operation(x, y, operation):
					    """Applique une opération à deux nombres"""
					    return operation(x, y)
					
					# Définition de différentes opérations
					def addition(a, b):
					    return a + b
					
					def multiplication(a, b):
					    return a * b
					
					# Utilisation avec différentes opérations
					resultat_add = appliquer_operation(5, 3, addition)
					resultat_mult = appliquer_operation(5, 3, multiplication)
					
					print(f"Addition: 5 + 3 = {resultat_add}")
					print(f"Multiplication: 5 * 3 = {resultat_mult}")
					
					# Exemples pratiques dans un contexte marocain
					
					# 1. Système de calcul de salaire avec différentes méthodes
					def calculer_salaire_net(salaire_brut, methode_calcul):
					    """Calcule le salaire net selon différentes méthodes"""
					    return methode_calcul(salaire_brut)
					
					# Différentes méthodes de calcul
					def methode_standard(brut):
					    """Méthode standard avec cotisations de base"""
					    cotisations = brut * 0.22  # 22% de cotisations
					    return brut - cotisations
					
					def methode_cadre(brut):
					    """Méthode pour cadres avec cotisations supplémentaires"""
					    cotisations = brut * 0.28  # 28% de cotisations
					    return brut - cotisations
					
					def methode_contractuel(brut):
					    """Méthode pour contractuels avec moins de cotisations"""
					    cotisations = brut * 0.15  # 15% de cotisations
					    return brut - cotisations
					
					print(f"\n? CALCULS DE SALAIRE NET")
					salaire_brut = 10000
					
					net_standard = calculer_salaire_net(salaire_brut, methode_standard)
					net_cadre = calculer_salaire_net(salaire_brut, methode_cadre)
					net_contractuel = calculer_salaire_net(salaire_brut, methode_contractuel)
					
					print(f"Standard: {net_standard:.2f} DH")
					print(f"Cadre: {net_cadre:.2f} DH")
					print(f"Contractuel: {net_contractuel:.2f} DH")
					
					# 2. Système de traitement de commandes avec différents modes de livraison
					def traiter_commande(commande, mode_livraison):
					    """Traite une commande avec un mode de livraison spécifique"""
					    print(f"\n? Commande de {commande['client']}")
					    print(f"Produits: {', '.join(commande['produits'])}")
					    
					    # Application du mode de livraison (callback)
					    frais_livraison = mode_livraison(commande)
					    
					    total = commande["montant"] + frais_livraison
					    print(f"Frais livraison: {frais_livraison} DH")
					    print(f"Total: {total} DH")
					    
					    return total
					
					# Différents modes de livraison
					def livraison_standard(commande):
					    """Livraison standard: 20 DH fixe"""
					    return 20
					
					def livraison_express(commande):
					    """Livraison express: 40 DH + 5% du montant"""
					    return 40 + (commande["montant"] * 0.05)
					
					def livraison_gratuite(commande):
					    """Livraison gratuite pour commandes > 200 DH"""
					    return 0 if commande["montant"] > 200 else 20
					
					# Commandes de test
					commande1 = {
					    "client": "Famille Alami",
					    "produits": ["Tajine", "Couscous"],
					    "montant": 150
					}
					
					commande2 = {
					    "client": "Restaurant Zahra",
					    "produits": ["Huile d'Argan", "Safran", "Dattes"],
					    "montant": 450
					}
					
					# Traitement avec différents modes
					traiter_commande(commande1, livraison_standard)
					traiter_commande(commande1, livraison_express)
					traiter_commande(commande2, livraison_gratuite)
					
					# 3. Système de validation de données avec différentes règles métier
					def valider_donnees(donnees, regles_validation):
					    """Valide des données selon un ensemble de règles"""
					    erreurs = []
					    
					    for regle in regles_validation:
					        resultat = regle(donnees)
					        if resultat:
					            erreurs.append(resultat)
					    
					    return erreurs
					
					# Règles de validation pour un formulaire marocain
					def valider_cin(donnees):
					    """Valide le format de la Carte d'Identité Nationale"""
					    cin = donnees.get("cin", "")
					    if not (cin.isdigit() and len(cin) == 8):
					        return "CIN invalide: doit contenir 8 chiffres"
					    return None
					
					def valider_telephone(donnees):
					    """Valide le numéro de téléphone marocain"""
					    tel = donnees.get("telephone", "")
					    if not (tel.startswith(("06", "07")) and len(tel) == 10 and tel.isdigit()):
					        return "Numéro de téléphone invalide"
					    return None
					
					def valider_age(donnees):
					    """Valide l'âge pour le vote (18 ans minimum)"""
					    age = donnees.get("age", 0)
					    if age < 18:
					        return "Âge insuffisant pour voter (18 ans minimum)"
					    return None
					
					# Données à valider
					formulaire = {
					    "cin": "1234567",  # Invalide: 7 chiffres au lieu de 8
					    "telephone": "0512345678",  # Invalide: commence par 05
					    "age": 16  # Invalide: moins de 18 ans
					}
					
					regles = [valider_cin, valider_telephone, valider_age]
					erreurs = valider_donnees(formulaire, regles)
					
					print(f"\n? VALIDATION DU FORMULAIRE")
					if erreurs:
					    print("Erreurs trouvées:")
					    for erreur in erreurs:
					        print(f"  - {erreur}")
					else:
					    print("✅ Toutes les validations sont passées")

Décorateurs : introduction

Les décorateurs sont des fonctions qui modifient le comportement d'autres fonctions. Ils permettent d'ajouter des fonctionnalités sans modifier le code original de la fonction.

decorateurs.py
# Syntaxe de base d'un décorateur
					def mon_decorateur(fonction):
					    def fonction_modifiee():
					        print("Avant l'appel de la fonction")
					        fonction()
					        print("Après l'appel de la fonction")
					    return fonction_modifiee
					
					@mon_decorateur
					def ma_fonction():
					    print("Fonction originale")
					
					# Appel
					ma_fonction()
					
					# Exemples pratiques dans un contexte marocain
					
					# 1. Décorateur de logging pour le suivi des transactions
					def logger_transactions(fonction):
					    """Décorateur pour logger les transactions bancaires"""
					    def fonction_loggee(compte, montant):
					        print(f"? [LOG] Début transaction: {fonction.__name__}")
					        print(f"   Compte: {compte}, Montant: {montant} DH")
					        
					        resultat = fonction(compte, montant)
					        
					        print(f"? [LOG] Transaction terminée: {resultat}")
					        return resultat
					    
					    return fonction_loggee
					
					@logger_transactions
					def deposer_argent(compte, montant):
					    """Dépose de l'argent sur un compte"""
					    print(f"? Dépôt de {montant} DH sur le compte {compte}")
					    return f"SUCCÈS: {montant} DH déposés"
					
					@logger_transactions
					def retirer_argent(compte, montant):
					    """Retire de l'argent d'un compte"""
					    print(f"? Retrait de {montant} DH du compte {compte}")
					    return f"SUCCÈS: {montant} DH retirés"
					
					print("? SYSTÈME BANCAIRE AVEC LOGGING")
					deposer_argent("Alaoui", 5000)
					retirer_argent("Benjelloun", 2000)
					
					# 2. Décorateur de validation pour les calculs fiscaux
					def valider_montant_positif(fonction):
					    """Valide que le montant est positif"""
					    def fonction_validee(montant):
					        if montant <= 0:
					            raise ValueError(f"Le montant doit être positif: {montant}")
					        return fonction(montant)
					    return fonction_validee
					
					@valider_montant_positif
					def calculer_tva(montant):
					    """Calcule la TVA marocaine (20%)"""
					    return montant * 0.20
					
					@valider_montant_positif
					def calculer_taxe_habitation(loyer):
					    """Calcule la taxe d'habitation (10%)"""
					    return loyer * 0.10
					
					print(f"\n? CALCULS FISCAUX AVEC VALIDATION")
					try:
					    tva = calculer_tva(100)
					    print(f"TVA sur 100 DH: {tva} DH")
					    
					    taxe = calculer_taxe_habitation(3000)
					    print(f"Taxe habitation sur 3000 DH: {taxe} DH")
					    
					    # Ceci va échouer
					    calculer_tva(-50)
					except ValueError as e:
					    print(f"❌ Erreur: {e}")
					
					# 3. Décorateur avec arguments: contrôle d'accès
					def controle_acces(niveau_requis):
					    """Décorateur avec argument pour le contrôle d'accès"""
					    def decorateur(fonction):
					        def fonction_controlee(utilisateur, *args, **kwargs):
					            if utilisateur.get("niveau", 0) >= niveau_requis:
					                return fonction(utilisateur, *args, **kwargs)
					            else:
					                return f"❌ Accès refusé. Niveau requis: {niveau_requis}"
					        return fonction_controlee
					    return decorateur
					
					# Application aux fonctions d'administration
					@controle_acces(niveau_requis=2)
					def voir_rapports(utilisateur):
					    """Affiche les rapports (niveau 2 requis)"""
					    return "? Affichage des rapports confidentiels"
					
					@controle_acces(niveau_requis=3)
					def modifier_parametres(utilisateur):
					    """Modifie les paramètres (niveau 3 requis)"""
					    return "⚙️  Modification des paramètres système"
					
					# Utilisateurs de test
					admin = {"nom": "Admin", "niveau": 3}
					gestionnaire = {"nom": "Gestionnaire", "niveau": 2}
					utilisateur = {"nom": "Utilisateur", "niveau": 1}
					
					print(f"\n? SYSTÈME DE CONTRÔLE D'ACCÈS")
					print(f"Admin - Rapports: {voir_rapports(admin)}")
					print(f"Admin - Paramètres: {modifier_parametres(admin)}")
					print(f"Gestionnaire - Rapports: {voir_rapports(gestionnaire)}")
					print(f"Gestionnaire - Paramètres: {modifier_parametres(gestionnaire)}")
					print(f"Utilisateur - Rapports: {voir_rapports(utilisateur)}")
					
					# 4. Décorateur de temporisation pour le profiling
					import time
					
					def mesurer_temps(fonction):
					    """Mesure le temps d'exécution d'une fonction"""
					    def fonction_mesuree(*args, **kwargs):
					        debut = time.time()
					        resultat = fonction(*args, **kwargs)
					        fin = time.time()
					        print(f"⏱️  {fonction.__name__} exécutée en {fin - debut:.4f} secondes")
					        return resultat
					    return fonction_mesuree
					
					@mesurer_temps
					def traitement_long(donnees):
					    """Simule un traitement long"""
					    time.sleep(0.5)  # Pause d'une demi-seconde
					    return f"Traitement de {len(donnees)} éléments terminé"
					
					print(f"\n⚡ PROFILING DE PERFORMANCE")
					resultat = traitement_long(list(range(1000)))
					print(resultat)
					
					# AVANTAGES DES DÉCORATEURS:
					# - Réutilisabilité du code
					# - Séparation des préoccupations
					# - Modification transparente du comportement
					# - Maintien du code original intact

8. Exercices Pratiques

Ces exercices vous permettront de mettre en pratique tous les concepts vus précédemment. Prenez le temps de les résoudre étape par étape et n'hésitez pas à expérimenter avec vos propres solutions.

Exercice 1 : Calculatrice simple

Objectif : Créer une calculatrice qui gère les opérations de base avec une interface conviviale et des fonctions modulaires.

exercice_calculatrice.py
# CALCULATRICE MAROCAINE - EXERCICE PRATIQUE
					#
					# Votre mission : Créer une calculatrice qui aide les commerçants marocains
					# à calculer leurs prix TTC, marges bénéficiaires et conversions de devises.
					
					# ÉNONCÉ :
					# 1. Créez les fonctions de base (addition, soustraction, multiplication, division)
					# 2. Ajoutez des fonctions spécialisées pour le commerce marocain
					# 3. Créez un menu interactif
					# 4. Gérez les erreurs (division par zéro, entrées invalides)
					
					# TODO 1: Fonctions de base
					def addition(a, b):
					    """Retourne la somme de a et b"""
					    # VOTRE CODE ICI
					    pass
					
					def soustraction(a, b):
					    """Retourne la différence entre a et b"""
					    # VOTRE CODE ICI
					    pass
					
					def multiplication(a, b):
					    """Retourne le produit de a et b"""
					    # VOTRE CODE ICI
					    pass
					
					def division(a, b):
					    """Retourne le quotient de a par b. Gère la division par zéro."""
					    # VOTRE CODE ICI (pensez à gérer l'erreur de division par zéro)
					    pass
					
					# TODO 2: Fonctions spécialisées pour le commerce marocain
					def calculer_prix_ttc(prix_ht):
					    """
					    Calcule le prix TTC à partir du prix HT
					    TVA marocaine: 20%
					    Retourne le prix TTC arrondi à 2 décimales
					    """
					    # VOTRE CODE ICI
					    pass
					
					def calculer_marge_beneficiaire(prix_achat, prix_vente):
					    """
					    Calcule la marge bénéficiaire en pourcentage
					    Formule: ((prix_vente - prix_achat) / prix_achat) * 100
					    Retourne le pourcentage arrondi à 2 décimales
					    """
					    # VOTRE CODE ICI
					    pass
					
					def convertir_devises(montant_dh, devise_cible="EUR"):
					    """
					    Convertit des Dirhams marocains vers d'autres devises
					    Taux de change (approximatifs):
					    - EUR: 1 DH = 0.09 €
					    - USD: 1 DH = 0.10 $
					    - GBP: 1 DH = 0.08 £
					    Retourne le montant converti arrondi à 2 décimales
					    """
					    # VOTRE CODE ICI
					    pass
					
					# TODO 3: Menu interactif
					def afficher_menu():
					    """Affiche le menu de la calculatrice"""
					    print("\n" + "?" * 50)
					    print("          CALCULATRICE MAROCAINE - COMMERCE & FINANCES")
					    print("?" * 50)
					    print("1.  Addition")
					    print("2.  Soustraction")
					    print("3.  Multiplication")
					    print("4.  Division")
					    print("5.  Calculer prix TTC (TVA 20%)")
					    print("6.  Calculer marge bénéficiaire")
					    print("7.  Convertir devises (DH → EUR/USD/GBP)")
					    print("0.  Quitter")
					    print("-" * 50)
					
					def demander_nombre(message):
					    """Demande un nombre à l'utilisateur avec gestion d'erreur"""
					    # VOTRE CODE ICI (gérer les entrées non numériques)
					    pass
					
					def executer_calculatrice():
					    """Fonction principale de la calculatrice"""
					    print("Bienvenue dans la Calculatrice Marocaine! ??")
					    
					    while True:
					        afficher_menu()
					        choix = input("Votre choix (0-7): ")
					        
					        # VOTRE CODE ICI : Implémenter la logique du menu
					        # Utiliser les fonctions que vous avez créées
					        # Gérer les erreurs d'entrée
					        
					        if choix == "0":
					            print("Merci d'avoir utilisé la Calculatrice Marocaine! Au revoir! ?")
					            break
					        else:
					            print("Fonctionnalité à implémenter...")
					
					# SOLUTION APPROCHE :
					# 1. Commencez par implémenter les fonctions de base (addition, etc.)
					# 2. Testez chaque fonction individuellement
					# 3. Implémentez les fonctions spécialisées
					# 4. Créez le menu interactif
					# 5. Ajoutez la gestion des erreurs
					
					# Exécutez la calculatrice (décommentez lorsque vous êtes prêt)
					# if __name__ == "__main__":
					#     executer_calculatrice()

Exercice 2 : Validation de données

Objectif : Créer un système de validation pour les données des clients marocains avec des règles métier spécifiques.

exercice_validation.py
# SYSTÈME DE VALIDATION DE DONNÉES CLIENT - EXERCICE PRATIQUE
					#
					# Votre mission : Créer un système qui valide les informations des clients
					# selon les standards et réglementations marocaines.
					
					# ÉNONCÉ :
					# 1. Créez des fonctions de validation individuelles
					# 2. Implémentez un validateur principal qui utilise toutes les règles
					# 3. Générez des rapports de validation détaillés
					# 4. Testez avec différents cas (valides et invalides)
					
					# RÈGLES DE VALIDATION POUR LE MAROC :
					# - CIN: 8 chiffres exactement
					# - Téléphone: commence par 06 ou 07, 10 chiffres
					# - Email: format valide, domaine accepté
					# - Âge: entre 18 et 120 ans
					# - Ville: dans la liste des villes marocaines
					
					# TODO 1: Fonctions de validation individuelles
					def valider_cin(cin):
					    """
					    Valide le format de la Carte d'Identité Nationale marocaine
					    - Doit contenir exactement 8 chiffres
					    - Ne doit contenir que des chiffres
					    Retourne: (True, "") si valide, (False, message_erreur) sinon
					    """
					    # VOTRE CODE ICI
					    pass
					
					def valider_telephone(telephone):
					    """
					    Valide le numéro de téléphone marocain
					    - Doit commencer par '06' ou '07'
					    - Doit contenir exactement 10 chiffres
					    - Ne doit contenir que des chiffres
					    Retourne: (True, "") si valide, (False, message_erreur) sinon
					    """
					    # VOTRE CODE ICI
					    pass
					
					def valider_email(email):
					    """
					    Valide l'adresse email
					    - Doit contenir un '@' et un '.'
					    - Le domaine doit être dans la liste des domaines acceptés
					    Domaines acceptés: ['gmail.com', 'yahoo.com', 'hotmail.com', 'outlook.com', 'maroc.ma']
					    Retourne: (True, "") si valide, (False, message_erreur) sinon
					    """
					    # VOTRE CODE ICI
					    pass
					
					def valider_age(age):
					    """
					    Valide l'âge du client
					    - Doit être un entier
					    - Doit être entre 18 et 120 ans
					    Retourne: (True, "") si valide, (False, message_erreur) sinon
					    """
					    # VOTRE CODE ICI
					    pass
					
					def valider_ville(ville):
					    """
					    Valide la ville de résidence
					    - Doit être dans la liste des villes marocaines principales
					    Villes acceptées: ['Casablanca', 'Rabat', 'Marrakech', 'Fès', 'Tanger', 'Salé', 'Meknès', 'Agadir']
					    - Insensible à la casse
					    Retourne: (True, "") si valide, (False, message_erreur) sinon
					    """
					    # VOTRE CODE ICI
					    pass
					
					# TODO 2: Validateur principal
					def valider_client(donnees_client):
					    """
					    Valide toutes les données d'un client
					    Retourne un dictionnaire avec:
					    - 'valide': True si toutes les validations passent, False sinon
					    - 'erreurs': liste des messages d'erreur
					    - 'details': dictionnaire avec le statut de chaque champ
					    """
					    resultat = {
					        "valide": True,
					        "erreurs": [],
					        "details": {}
					    }
					    
					    # VOTRE CODE ICI
					    # Utiliser les fonctions de validation individuelles
					    # Mettre à jour le résultat en fonction des validations
					    
					    return resultat
					
					# TODO 3: Générateur de rapports
					def generer_rapport_validation(resultat_validation, nom_client):
					    """
					    Génère un rapport de validation lisible
					    Affiche un résumé coloré (en utilisant des emojis) du statut de validation
					    """
					    # VOTRE CODE ICI
					    # Afficher un en-tête avec le nom du client
					    # Afficher le statut global (✅ Valide ou ❌ Invalide)
					    # Lister les erreurs si présentes
					    # Afficher les détails de chaque champ
					    pass
					
					# TODO 4: Programme principal de test
					def tester_validation():
					    """Teste le système de validation avec différents cas"""
					    
					    # Cas de test
					    cas_test = [
					        {
					            "nom": "Client Valide",
					            "cin": "12345678",
					            "telephone": "0612345678",
					            "email": "client@maroc.ma",
					            "age": 25,
					            "ville": "Casablanca"
					        },
					        {
					            "nom": "Client Invalide Multiple",
					            "cin": "1234567",  # Trop court
					            "telephone": "0512345678",  # Mauvais préfixe
					            "email": "invalide",  # Format incorrect
					            "age": 16,  # Trop jeune
					            "ville": "Paris"  # Ville non marocaine
					        }
					    ]
					    
					    # VOTRE CODE ICI : Tester chaque cas et générer les rapports
					    pass
					
					# BONUS : Créer une fonction pour saisir les données client interactivement
					def saisir_donnees_client():
					    """Permet à l'utilisateur de saisir les données d'un client"""
					    # VOTRE CODE ICI (optionnel)
					    pass
					
					# SOLUTION APPROCHE :
					# 1. Implémentez d'abord une fonction de validation à la fois
					# 2. Testez chaque fonction avec des valeurs valides et invalides
					# 3. Créez le validateur principal qui orchestre toutes les validations
					# 4. Implémentez le générateur de rapports pour un affichage clair
					
					# Exécutez les tests (décommentez lorsque vous êtes prêt)
					# if __name__ == "__main__":
					#     tester_validation()

Exercice 3 : Fonctions avec listes

Objectif : Manipuler des listes de données commerciales marocaines avec des fonctions spécialisées pour l'analyse et le traitement.

exercice_listes.py
# GESTION DE DONNÉES COMMERCIALES - EXERCICE PRATIQUE
					#
					# Votre mission : Créer un système de gestion de données pour un commerce marocain
					# avec des fonctions de manipulation et d'analyse de listes.
					
					# ÉNONCÉ :
					# 1. Créez des fonctions pour analyser les ventes
					# 2. Implémentez des fonctions de filtrage et de tri
					# 3. Développez des fonctions de transformation de données
					# 4. Générez des rapports statistiques
					
					# DONNÉES DE DÉPART :
					produits = [
					    {"nom": "Tajine céramique", "categorie": "artisanat", "prix": 150, "stock": 20, "ventes": 45},
					    {"nom": "Huile d'Argan", "categorie": "cosmétique", "prix": 200, "stock": 35, "ventes": 120},
					    {"nom": "Thé à la menthe", "categorie": "épicerie", "prix": 80, "stock": 50, "ventes": 200},
					    {"nom": "Tapis berbère", "categorie": "artisanat", "prix": 800, "stock": 5, "ventes": 8},
					    {"nom": "Safran", "categorie": "épicerie", "prix": 350, "stock": 15, "ventes": 25},
					    {"nom": "Lotion rose", "categorie": "cosmétique", "prix": 120, "stock": 25, "ventes": 60}
					]
					
					# TODO 1: Fonctions d'analyse basique
					def calculer_chiffre_affaires_total(liste_produits):
					    """
					    Calcule le chiffre d'affaires total
					    CA = prix * ventes pour chaque produit
					    Retourne le CA total
					    """
					    # VOTRE CODE ICI
					    pass
					
					def trouver_produit_plus_vendu(liste_produits):
					    """
					    Trouve le produit avec le plus grand nombre de ventes
					    Retourne le dictionnaire du produit
					    """
					    # VOTRE CODE ICI
					    pass
					
					def calculer_stock_total(liste_produits):
					    """
					    Calcule la valeur totale du stock
					    Valeur stock = prix * stock pour chaque produit
					    Retourne la valeur totale
					    """
					    # VOTRE CODE ICI
					    pass
					
					# TODO 2: Fonctions de filtrage
					def filtrer_par_categorie(liste_produits, categorie):
					    """
					    Filtre les produits par catégorie
					    Retourne une nouvelle liste contenant seulement les produits de la catégorie spécifiée
					    """
					    # VOTRE CODE ICI
					    pass
					
					def filtrer_stock_faible(liste_produits, seuil=10):
					    """
					    Filtre les produits avec un stock faible
					    Retourne les produits dont le stock est inférieur au seuil
					    """
					    # VOTRE CODE ICI
					    pass
					
					def filtrer_meilleurs_ventes(liste_produits, nombre=3):
					    """
					    Retourne les N produits les plus vendus
					    Tri décroissant par nombre de ventes
					    """
					    # VOTRE CODE ICI
					    pass
					
					# TODO 3: Fonctions de transformation
					def ajouter_prix_ttc(liste_produits):
					    """
					    Ajoute le prix TTC à chaque produit (TVA 20%)
					    Modifie la liste originale en ajoutant une clé 'prix_ttc' à chaque produit
					    Ne retourne rien (modification en place)
					    """
					    # VOTRE CODE ICI
					    pass
					
					def calculer_taux_rotation(liste_produits):
					    """
					    Calcule le taux de rotation pour chaque produit
					    Taux rotation = ventes / stock
					    Retourne une nouvelle liste avec le taux de rotation ajouté
					    """
					    # VOTRE CODE ICI
					    pass
					
					def classer_par_rentabilite(liste_produits):
					    """
					    Classe les produits par rentabilité (chiffre d'affaires)
					    Rentabilité = prix * ventes
					    Retourne une nouvelle liste triée par rentabilité décroissante
					    """
					    # VOTRE CODE ICI
					    pass
					
					# TODO 4: Génération de rapports
					def generer_rapport_complet(liste_produits):
					    """
					    Génère un rapport complet d'analyse des produits
					    Affiche:
					    - Chiffre d'affaires total et par catégorie
					    - Produits les plus vendus
					    - Alertes stock faible
					    - Meilleurs produits par rentabilité
					    """
					    # VOTRE CODE ICI
					    # Utilisez les fonctions précédentes pour générer un rapport structuré
					    pass
					
					def analyser_par_categorie(liste_produits):
					    """
					    Analyse les performances par catégorie
					    Retourne un dictionnaire avec pour chaque catégorie:
					    - Nombre de produits
					    - Chiffre d'affaires total
					    - Produit le plus vendu
					    - Valeur moyenne des produits
					    """
					    # VOTRE CODE ICI
					    pass
					
					# TODO 5: Programme de démonstration
					def executer_analyses():
					    """Exécute toutes les analyses et affiche les résultats"""
					    
					    print("? RAPPORT D'ANALYSE - COMMERCE MAROCAIN")
					    print("=" * 50)
					    
					    # VOTRE CODE ICI
					    # Appelez les différentes fonctions et affichez les résultats
					    # Utilisez des séparateurs et des titres pour organiser l'affichage
					    
					    # Exemple de structure:
					    # 1. Chiffres clés
					    # 2. Analyse par catégorie
					    # 3. Alertes et recommandations
					    # 4. Classements
					
					# BONUS : Fonction pour ajouter un nouveau produit
					def ajouter_produit(liste_produits):
					    """Permet d'ajouter un nouveau produit interactivement"""
					    # VOTRE CODE ICI (optionnel)
					    pass
					
					# SOLUTION APPROCHE :
					# 1. Commencez par les fonctions d'analyse simples
					# 2. Implémentez les fonctions de filtrage une par une
					# 3. Testez chaque fonction avec les données fournies
					# 4. Créez le rapport complet en assemblant toutes les analyses
					
					# Exécutez les analyses (décommentez lorsque vous êtes prêt)
					# if __name__ == "__main__":
					#     executer_analyses()

? Conseils pour réussir les exercices

  • Planifiez : Prenez le temps de comprendre l'énoncé avant de coder
  • Testez souvent : Vérifiez chaque fonction individuellement
  • Gérez les erreurs : Pensez aux cas limites (division par zéro, entrées invalides)
  • Documentez : Commentez votre code pour mieux le comprendre plus tard
  • Expérimentez : N'hésitez pas à essayer différentes approches

Rappel : Ces exercices reprennent tous les concepts vus dans les chapitres précédents. N'hésitez pas à revenir vers les sections théoriques si besoin !

Contact

📚 Cours à distance

Apprends à coder en Python, Java, C/C++
avec des cours à distance via Google Meet.

Appelez-maintenant
By Rachid Saad

Rejoignez notre communauté d'apprentissage à distance

Explorez nos cours à distance. Commencez votre apprentissage dès aujourd'hui!