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.
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.
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.
# 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")
L'utilisation des fonctions apporte de nombreux avantages qui améliorent la qualité et la maintenabilité de vos programmes :
# 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
La programmation modulaire avec des fonctions permet de découper un programme complexe en petites parties plus simples à gérer :
# 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()
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.
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é.
# 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()
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é.
# 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
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.
# 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 (:)
Voyons maintenant un exemple complet qui rassemble tous les concepts pour créer une fonction utile dans un contexte marocain.
# 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()
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.
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.
# 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")
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.
# 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")
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.
# 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)
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.
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.
# 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")
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.
# 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")
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 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", "
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.
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.
# 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 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.
# 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 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.
# 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
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.
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.
# 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
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.
# 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!
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".
# 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")
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.
# 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
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.
Objectif : Créer une calculatrice qui gère les opérations de base avec une interface conviviale et des fonctions modulaires.
# 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()
Objectif : Créer un système de validation pour les données des clients marocains avec des règles métier spécifiques.
# 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()
Objectif : Manipuler des listes de données commerciales marocaines avec des fonctions spécialisées pour l'analyse et le traitement.
# 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()
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 !
Apprends à coder en Python, Java, C/C++
avec des cours à distance via Google Meet.
Explorez nos cours à distance. Commencez votre apprentissage dès aujourd'hui!