Ce tutoriel a pour objectif d'enseigner aux développeurs Python les techniques essentielles de manipulation de fichiers texte, incluant l'ouverture, la lecture et l'écriture avec les fonctions natives du langage. Les apprenants découvriront comment utiliser la fonction open() avec ses différents modes, les méthodes read(), write() et readline(), ainsi que l'importance du gestionnaire de contexte with pour une gestion sûre des ressources. À travers des exemples pratiques et des cas d'usage concrets, vous maîtriserez les bonnes pratiques de gestion des fichiers en Python et éviterez les erreurs courantes comme les fuites de ressources.
La gestion des fichiers est une compétence essentielle en programmation Python, permettant de lire, écrire et manipuler des données persistantes. Cette capacité ouvre la porte à de nombreuses applications pratiques dans le contexte marocain, de l'automatisation administrative au traitement de données locales.
Python offre des outils puissants et simples pour la manipulation de fichiers, ce qui en fait un choix idéal pour de nombreux cas d'usage au Maroc :
# Exemples concrets d'utilisation des fichiers au Maroc # 1. Traitement de données administratives def traiter_donnees_cnas(): # Lecture des fichiers de la CNAS (Caisse Nationale de Sécurité Sociale) with open('declarations_cnas.csv', 'r', encoding='utf-8') as fichier: donnees = fichier.read() print("Traitement des déclarations sociales...") return donnees # 2. Gestion de fichiers clients pour entreprises marocaines def sauvegarder_clients_maroc(): clients = [ "Ahmed Alami,Casablanca,0650123456\n", "Fatima Zahra,Marrakech,0660987654\n", "Mehdi Benjelloun,Rabat,0675112233\n" ] with open('clients_maroc.txt', 'w', encoding='utf-8') as fichier: fichier.writelines(clients) print("Base de données clients sauvegardée") # 3. Analyse de données économiques locales def analyser_exportations(): # Lecture des données d'exportation marocaines try: with open('exportations_maroc_2024.json', 'r') as fichier: donnees_export = fichier.read() print("Analyse des exportations phosphates, agrumes, textile...") except FileNotFoundError: print("Fichier des exportations non trouvé") # Avantages de Python pour la gestion de fichiers : # - Syntaxe simple et lisible # - Gestion automatique de la fermeture des fichiers # - Support natif de l'UTF-8 (important pour l'arabe/français) # - Riches bibliothèques pour tous les formats # Exécution des exemples sauvegarder_clients_maroc() analyser_exportations()
Python peut manipuler une grande variété de formats de fichiers, particulièrement utiles dans l'écosystème numérique marocain :
# Démonstration des principaux formats supportés # 1. Fichiers texte (UTF-8 pour support arabe/français) def fichier_texte_bilingue(): contenu = """ Bienvenue à Casablanca - مرحبا بكم في الدار البيضاء Données économiques du Maroc - البيانات الاقتصادية للمغرب """ with open('rapport_bilingue.txt', 'w', encoding='utf-8') as f: f.write(contenu) print("Fichier bilingue créé avec support arabe/français") # 2. Fichiers CSV (idéal pour données tabulaires) import csv def creer_csv_marocain(): villes_maroc = [ ['Ville', 'Région', 'Population', 'Spécialité'], ['Casablanca', 'Casablanca-Settat', '3,359,818', 'Économie'], ['Fès', 'Fès-Meknès', '1,112,072', 'Artisanat'], ['Marrakech', 'Marrakech-Safi', '928,850', 'Tourisme'], ['Tanger', 'Tanger-Tétouan-Al Hoceïma', '947,952', 'Port'] ] with open('villes_maroc.csv', 'w', newline='', encoding='utf-8') as f: writer = csv.writer(f) writer.writerows(villes_maroc) print("Fichier CSV des villes marocaines créé") # 3. Fichiers JSON (échange de données structurées) import json def sauvegarder_donnees_json(): entreprises_maroc = { "OCP": { "secteur": "Phosphates", "ville": "Casablanca", "employes": 20000 }, "Maroc Telecom": { "secteur": "Télécommunications", "ville": "Rabat", "employes": 15000 } } with open('entreprises_maroc.json', 'w', encoding='utf-8') as f: json.dump(entreprises_maroc, f, ensure_ascii=False, indent=2) print("Données JSON des entreprises sauvegardées") # Types de fichiers supportés : # - Texte (.txt, .csv) avec encodage UTF-8 # - JSON pour données structurées # - XML pour documents structurés # - Binaires (images, PDF, Excel) # - Bases de données simples # Exécution fichier_texte_bilingue() creer_csv_marocain() sauvegarder_donnees_json()
Pour tirer le meilleur parti de ce tutoriel sur la gestion des fichiers en Python, voici les connaissances et outils recommandés :
# Script de vérification des prérequis import sys import os def verifier_prerequis(): print("=== VÉRIFICATION DES PRÉREQUIS POUR LE TUTORIEL ===\n") # 1. Version de Python version_python = sys.version_info print(f"1. Python version: {sys.version}") if version_python >= (3, 6): print(" ✓ Version de Python compatible") else: print(" ✗ Mettez à jour Python vers la version 3.6 ou supérieure") # 2. Environnement de développement print("\n2. Environnement de développement recommandé:") print(" - VS Code, PyCharm ou Jupyter Notebook") print(" - Terminal/CMD pour l'exécution de scripts") # 3. Connaissances Python requises print("\n3. Connaissances Python nécessaires:") prerequis = [ "Variables et types de données", "Structures de contrôle (if, for, while)", "Fonctions et portée des variables", "Gestion des exceptions (try/except)", "Manipulation des chaînes de caractères" ] for i, connaissance in enumerate(prerequis, 1): print(f" {i}. {connaissance}") # 4. Structure de dossiers recommandée pour le Maroc print("\n4. Structure de projet recommandée:") dossiers = [ "projet_maroc/", "projet_maroc/data/", # Pour les fichiers de données "projet_maroc/docs/", # Pour la documentation "projet_maroc/scripts/", # Pour les scripts Python "projet_maroc/output/" # Pour les résultats ] for dossier in dossiers: print(f" - {dossier}") # 5. Cas d'usage pratiques au Maroc print("\n5. Cas pratiques que nous aborderons:") cas_usage = [ "Gestion de fichiers clients entreprises marocaines", "Traitement de données administratives (CNSS, CNAS)", "Création de rapports bilingues (français/arabe)", "Manipulation de données géographiques villes marocaines", "Sauvegarde et restauration de configurations" ] for i, cas in enumerate(cas_usage, 1): print(f" {i}. {cas}") print("\n=== PRÊT À COMMENCER ===") print("Vous avez tous les prérequis ? Excellent !") print("Passons maintenant à la fonction open()...") # Vérification des prérequis système if not os.path.exists('projet_maroc'): print("Conseil: Créez le dossier 'projet_maroc' pour organiser vos fichiers") # Exécution de la vérification verifier_prerequis()
La fonction open() est la pierre angulaire de la gestion des fichiers en Python. Elle permet d'établir une connexion entre votre programme et un fichier sur le disque, ouvrant la porte à la lecture, l'écriture et la manipulation des données.
La fonction open() prend deux paramètres principaux : le chemin du fichier et le mode d'ouverture. Voici sa syntaxe complète :
# Syntaxe de base : open(fichier, mode='r', encoding=None) # Exemple 1: Ouverture simple en lecture fichier = open('villes_maroc.txt', 'r') print("Fichier ouvert avec succès!") fichier.close() # N'oubliez pas de fermer le fichier # Exemple 2: Ouverture avec encodage UTF-8 (recommandé pour le Maroc) fichier_utf8 = open('entreprises_casablanca.txt', 'r', encoding='utf-8') contenu = fichier_utf8.read() fichier_utf8.close() # Exemple 3: Paramètres optionnels fréquents # newline : contrôle les caractères de fin de ligne # errors : gestion des erreurs d'encodage fichier_avance = open( 'donnees_maroc.csv', 'r', encoding='utf-8', newline='', errors='ignore' ) # Structure recommandée pour les projets marocains def ouvrir_fichier_maroc(chemin, mode='r'): """Ouvre un fichier avec les paramètres adaptés au contexte marocain""" return open( chemin, mode, encoding='utf-8', errors='replace' # Remplace les caractères illisibles ) # Utilisation try: with ouvrir_fichier_maroc('clients_marrakech.txt') as f: print("Fichier ouvert avec les paramètres marocains optimisés") except FileNotFoundError: print("Fichier non trouvé - création recommandée")
Python propose plusieurs modes d'ouverture qui déterminent comment vous pouvez interagir avec le fichier. Chaque mode a des comportements spécifiques :
# Démonstration des différents modes d'ouverture avec exemples marocains # MODE 'r' - LECTURE (Read) print("=== MODE 'r' - LECTURE SEULE ===") try: with open('villes_imperiales.txt', 'r', encoding='utf-8') as f: contenu = f.read() print(f"Contenu lu: {contenu}") except FileNotFoundError: # Créons d'abord le fichier pour l'exemple with open('villes_imperiales.txt', 'w', encoding='utf-8') as f: f.write("Marrakech, Fès, Meknès, Rabat") print("Fichier créé pour la démonstration") # MODE 'w' - ÉCRITURE (Write) - ÉCRASE LE FICHIER EXISTANT print("\n=== MODE 'w' - ÉCRITURE (écrase) ===") with open('entreprises_maroc.txt', 'w', encoding='utf-8') as f: entreprises = ["OCP Group\n", "Maroc Telecom\n", "Attijariwafa Bank\n"] f.writelines(entreprises) print("Liste des entreprises marocaines sauvegardée") # MODE 'a' - AJOUT (Append) - AJOUTE À LA FIN print("\n=== MODE 'a' - AJOUT À LA FIN ===") with open('entreprises_maroc.txt', 'a', encoding='utf-8') as f: f.write("BMCE Bank\n") f.write("Yazaki Maroc\n") print("Nouvelles entreprises ajoutées") # MODE 'x' - CRÉATION EXCLUSIVE (eXclusive) print("\n=== MODE 'x' - CRÉATION EXCLUSIVE ===") try: with open('rapport_export_2024.txt', 'x', encoding='utf-8') as f: f.write("Rapport des exportations marocaines 2024\n") print("Nouveau rapport créé avec succès") except FileExistsError: print("Le rapport existe déjà - utilisation du mode 'w' pour écraser") with open('rapport_export_2024.txt', 'w', encoding='utf-8') as f: f.write("Rapport des exportations marocaines 2024 (mis à jour)\n") # Tableau récapitulatif des modes print(""" RÉCAPITULATIF DES MODES : 'r' : Lecture seule (fichier doit exister) 'w' : Écriture (crée ou écrase le fichier) 'a' : Ajout à la fin (crée le fichier si nécessaire) 'x' : Création exclusive (échoue si le fichier existe) """)
Python distingue les fichiers texte (traitement des caractères) des fichiers binaires (données brutes). Cette distinction est cruciale selon le type de fichier manipulé :
# Comparaison entre modes texte et binaire # MODE TEXTE (par défaut) - Traitement des caractères print("=== MODE TEXTE ===") # Création d'un fichier texte avec contenu bilingue contenu_bilingue = """ Données économiques du Maroc - البيانات الاقتصادية للمغرب Croissance: 4.5% - النمو: 4.5% Inflation: 2.1% - التضخم: 2.1% """ with open('economie_maroc.txt', 'w', encoding='utf-8') as f_texte: f_texte.write(contenu_bilingue) print("Fichier texte bilingue créé (UTF-8)") # Lecture en mode texte with open('economie_maroc.txt', 'r', encoding='utf-8') as f_texte: donnees = f_texte.read() print("Lecture mode texte:") print(donnees) # MODE BINAIRE - Données brutes (bytes) print("\n=== MODE BINAIRE ===") # Lecture du même fichier en mode binaire with open('economie_maroc.txt', 'rb') as f_binaire: donnees_brutes = f_binaire.read() print("Lecture mode binaire (premiers 50 bytes):") print(donnees_brutes[:50]) print(f"Type des données: {type(donnees_brutes)}") # Cas d'usage pratiques au Maroc pour le mode binaire print("\n=== CAS USAGE BINAIRE AU MAROC ===") # 1. Copie de fichiers images (photos de produits marocains) def copier_image_marocaine(source, destination): """Copie un fichier image (tapis, poterie, etc.)""" try: with open(source, 'rb') as src, open(destination, 'wb') as dest: dest.write(src.read()) print(f"Image copiée: {source} -> {destination}") except FileNotFoundError: print("Fichier source non trouvé") # 2. Sauvegarde de données binaires (certificats, signatures) def sauvegarder_signature(nom_fichier, donnees_signature): """Sauvegarde une signature numérique ou scan""" with open(nom_fichier, 'wb') as f: f.write(donnees_signature) print(f"Signature sauvegardée: {nom_fichier}") # Simulation de données binaires (exemple) donnees_exemple = b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00' sauvegarder_signature('signature_administrative.dat', donnees_exemple) # Tableau comparatif print(""" COMPARAISON MODES TEXTE vs BINAIRE : MODE TEXTE ('r', 'w', 'a') : - Traite les données comme des chaînes de caractères - Gère automatiquement l'encodage (UTF-8 recommandé) - Convertit les retours à la ligne selon l'OS - Idéal pour : documents, CSV, JSON, configurations MODE BINAIRE ('rb', 'wb', 'ab') : - Traite les données comme des bytes bruts - Aucune conversion d'encodage - Conserve exactement les données originales - Idéal pour : images, PDF, exécutables, données brutes """)
L'encodage est crucial pour la manipulation correcte des caractères, surtout dans un contexte multilingue comme le Maroc où l'arabe et le français coexistent :
# Importance de l'encodage dans le contexte marocain # PROBLÈME : Encodage incorrect (exemple typique) print("=== PROBLÈMES D'ENCODAGE ===") # Création d'un fichier avec des caractères arabes noms_arabes = "أحمد, فاطمة, محمد, خديجة, مصطفى" # MAUVAISE PRATIQUE : encodage par défaut (souvent Latin-1) try: with open('noms_arabes_mauvais.txt', 'w') as f: # Pas d'encoding spécifié f.write(noms_arabes) except UnicodeEncodeError as e: print(f"ERREUR d'encodage: {e}") print("→ Solution: spécifier encoding='utf-8'") # BONNE PRATIQUE : encodage UTF-8 explicit with open('noms_arabes_correct.txt', 'w', encoding='utf-8') as f: f.write(noms_arabes) print("Fichier créé avec encodage UTF-8 - SUCCÈS!") # COMPARAISON DES DIFFÉRENTS ENCODAGES print("\n=== COMPARAISON ENCODAGES ===") texte_bilingue = "Maroc المغرب - Casablanca الدار البيضاء" encodages_a_tester = [ ('utf-8', 'UTF-8 (Recommandé)'), ('utf-16', 'UTF-16'), ('latin-1', 'Latin-1 (ISO-8859-1)'), ('windows-1252', 'Windows-1252'), ('ascii', 'ASCII') ] for encodage, description in encodages_a_tester: nom_fichier = f'test_{encodage}.txt' try: with open(nom_fichier, 'w', encoding=encodage) as f: f.write(texte_bilingue) # Vérification de la lecture with open(nom_fichier, 'r', encoding=encodage) as f: contenu_lu = f.read() print(f"✓ {description}: SUCCÈS - '{contenu_lu}'") except UnicodeEncodeError: print(f"✗ {description}: ÉCHEC - Caractères non supportés") except UnicodeDecodeError: print(f"✗ {description}: ÉCHEC - Impossible de relire") # GESTION DES ERREURS D'ENCODAGE print("\n=== GESTION DES ERREURS D'ENCODAGE ===") texte_problematique = "Normal text → Caractère spécial: ñ et arabe: ء" strategies_erreurs = [ ('strict', 'Strict (défaut) - lève une exception'), ('ignore', 'Ignore - supprime les caractères problématiques'), ('replace', 'Replace - remplace par ?'), ('backslashreplace', 'BackslashReplace - utilise \\u escapes') ] for strategie, description in strategies_erreurs: nom_fichier = f'erreur_{strategie}.txt' try: with open(nom_fichier, 'w', encoding='ascii', errors=strategie) as f: f.write(texte_problematique) with open(nom_fichier, 'r', encoding='ascii') as f: contenu = f.read() print(f"• {description}: {contenu}") except UnicodeEncodeError: print(f"• {description}: Exception levée") # RECOMMANDATIONS POUR LE MAROC print(""" ? RECOMMANDATIONS ENCODAGE POUR LE MAROC : 1. TOUJOURS utiliser encoding='utf-8' pour : - Fichiers contenant de l'arabe - Fichiers bilingues français/arabe - Données avec des noms marocains 2. Utiliser errors='replace' pour : - Fichiers provenant de sources externes - Données corrompues ou d'encodage inconnu 3. Éviter les encodages régionaux : - Latin-1, Windows-1252 ne supportent pas l'arabe - ASCII est trop limité 4. Bonne pratique : with open('fichier.txt', 'r', encoding='utf-8', errors='replace') as f: """)
La lecture de fichiers texte est une opération fondamentale en Python. Plusieurs méthodes existent pour lire le contenu d'un fichier, chacune adaptée à des besoins spécifiques. Dans le contexte marocain, ces techniques sont essentielles pour traiter des données administratives, des listes de clients, ou des rapports bilingues.
La méthode read() permet de lire l'intégralité du contenu d'un fichier en une seule opération. C'est la méthode la plus simple mais elle charge tout le fichier en mémoire.
# Méthode read() - Lecture complète du fichier # Exemple 1: Lecture simple d'un fichier de villes marocaines print("=== LECTURE AVEC read() ===") # Création d'un fichier exemple avec des données marocaines villes_maroc = """ Casablanca - الدار البيضاء - Économique Rabat - الرباط - Administrative Marrakech - مراكش - Touristique Fès - فاس - Culturelle Tanger - طنجة - Portuaire """ # Écriture du fichier with open('villes_maroc.txt', 'w', encoding='utf-8') as f: f.write(villes_maroc) # Lecture avec read() - méthode basique with open('villes_maroc.txt', 'r', encoding='utf-8') as fichier: contenu_complet = fichier.read() print("Contenu complet du fichier:") print(contenu_complet) print(f"Nombre de caractères: {len(contenu_complet)}") # Exemple 2: read() avec paramètre de taille print("\n=== read() AVEC TAILLE LIMITÉE ===") with open('villes_maroc.txt', 'r', encoding='utf-8') as fichier: # Lecture des 50 premiers caractères debut = fichier.read(50) print(f"50 premiers caractères: {debut}") # Lecture de la suite suite = fichier.read(30) print(f"30 caractères suivants: {suite}") # Cas pratique: Lecture d'un fichier de configuration marocain print("\n=== CAS PRATIQUE: FICHIER DE CONFIGURATION ===") config_maroc = """ [Entreprise] nom = Société Marocaine de Développement ville = Casablanca devise = MAD langue = fr,ar [Paramètres] tva = 0.20 format_date = %d/%m/%Y encodage = utf-8 """ # Sauvegarde de la configuration with open('config_maroc.ini', 'w', encoding='utf-8') as f: f.write(config_maroc) # Lecture et traitement with open('config_maroc.ini', 'r', encoding='utf-8') as f: configuration = f.read() print("Configuration de l'entreprise marocaine:") print(configuration) # AVANTAGES de read() : # - Simple et rapide pour les petits fichiers # - Tout le contenu disponible en mémoire # - Idéal pour les traitements globaux # # INCONVÉNIENTS : # - Charge tout le fichier en mémoire # - Peut être lent pour les gros fichiers # - Consommation mémoire importante
La méthode readline() lit le fichier ligne par ligne, ce qui est utile pour traiter des fichiers séquentiellement sans charger tout le contenu en mémoire.
# Méthode readline() - Lecture ligne par ligne # Création d'un fichier de clients marocains clients_maroc = """ Ahmed|Alami|Casablanca|ahmed.alami@email.ma|+212612345678 Fatima|Zahra|Marrakech|fatima.zahra@email.ma|+212698765432 Mehdi|Benjelloun|Rabat|mehdi.benjelloun@email.ma|+212633445566 Khadija|Mansouri|Fès|khadija.mansouri@email.ma|+212655667788 Youssef|Chraibi|Tanger|youssef.chraibi@email.ma|+212677889900 """ with open('clients_maroc.csv', 'w', encoding='utf-8') as f: f.write(clients_maroc) print("=== LECTURE AVEC readline() ===") # Lecture ligne par ligne avec readline() with open('clients_maroc.csv', 'r', encoding='utf-8') as fichier: ligne_numero = 1 # Lecture de la première ligne ligne = fichier.readline() while ligne: # Tant qu'il y a des lignes à lire if ligne.strip(): # Ignorer les lignes vides print(f"Ligne {ligne_numero}: {ligne.strip()}") # Traitement des données client donnees = ligne.strip().split('|') if len(donnees) == 5: prenom, nom, ville, email, telephone = donnees print(f" → {prenom} {nom} - {ville} - {telephone}") ligne_numero += 1 ligne = fichier.readline() # Lire la ligne suivante # Exemple 2: Lecture sélective avec readline() print("\n=== LECTURE SÉLECTIVE ===") with open('clients_maroc.csv', 'r', encoding='utf-8') as fichier: # Lire seulement les 2 premières lignes premiere_ligne = fichier.readline().strip() deuxieme_ligne = fichier.readline().strip() print("Deux premiers clients:") print(f"1. {premiere_ligne}") print(f"2. {deuxieme_ligne}") # Cas pratique: Lecture d'un fichier de commandes print("\n=== FICHIER DE COMMANDES ===") commandes = """ CMD001|Ahmed Alami|Tapis berbère|4500 MAD|En cours CMD002|Fatima Zahra|Poterie de Fès|1200 MAD|Livrée CMD003|Mehdi Benjelloun|Thé à la menthe|350 MAD|Annulée CMD004|Khadija Mansouri|Huile d'argan|890 MAD|En cours """ with open('commandes_maroc.txt', 'w', encoding='utf-8') as f: f.write(commandes) # Traitement des commandes en cours seulement print("Commandes en cours de traitement:") with open('commandes_maroc.txt', 'r', encoding='utf-8') as fichier: ligne = fichier.readline() while ligne: if 'En cours' in ligne: donnees_commande = ligne.strip().split('|') print(f"→ {donnees_commande[0]}: {donnees_commande[2]} - {donnees_commande[3]}") ligne = fichier.readline()
La méthode readlines() retourne une liste contenant toutes les lignes du fichier. C'est pratique quand on besoin de travailler avec l'ensemble des lignes comme une collection.
# Méthode readlines() - Lecture de toutes les lignes dans une liste # Création d'un fichier de produits marocains produits_maroc = """ Argan|Huile|Cosmétique|120.50 Safran|Épice|Culinaire|85.00 Tapis|Artisanat|Décoration|450.00 Zellige|Artisanat|Décoration|75.30 Thé vert|Boisson|Alimentaire|45.25 Cuir|Artisanat|Maroquinerie|230.75 """ with open('produits_maroc.csv', 'w', encoding='utf-8') as f: f.write(produits_maroc) print("=== LECTURE AVEC readlines() ===") # Lecture avec readlines() - retourne une liste de lignes with open('produits_maroc.csv', 'r', encoding='utf-8') as fichier: toutes_lignes = fichier.readlines() print(f"Type de données: {type(toutes_lignes)}") print(f"Nombre de lignes: {len(toutes_lignes)}") print("\nContenu de la liste:") for i, ligne in enumerate(toutes_lignes, 1): print(f"Ligne {i}: {ligne.strip()}") # Traitement avancé avec readlines() print("\n=== TRAITEMENT DES PRODUITS ===") with open('produits_maroc.csv', 'r', encoding='utf-8') as fichier: lignes = fichier.readlines() # Filtrer les produits de la catégorie Artisanat produits_artisanat = [] prix_total = 0 for ligne in lignes: if ligne.strip(): # Ignorer les lignes vides nom, categorie, type_produit, prix = ligne.strip().split('|') prix_float = float(prix) if type_produit == 'Artisanat': produits_artisanat.append((nom, prix_float)) prix_total += prix_float print("Produits artisanaux marocains:") for produit, prix in produits_artisanat: print(f"→ {produit}: {prix} MAD") print(f"Prix total des produits artisanaux: {prix_total} MAD") # Exemple: Création d'un catalogue formaté print("\n=== CATALOGUE FORMATÉ ===") with open('produits_maroc.csv', 'r', encoding='utf-8') as fichier: lignes_produits = fichier.readlines() print("? CATALOGUE DE PRODUITS MAROCAINS") print("=" * 40) for ligne in lignes_produits: if ligne.strip(): nom, categorie, type_produit, prix = ligne.strip().split('|') print(f"• {nom}") print(f" Catégorie: {categorie}") print(f" Type: {type_produit}") print(f" Prix: {prix} MAD") print("-" * 30) # AVANTAGES de readlines() : # - Toutes les lignes disponibles dans une liste # - Facile à parcourir et manipuler # - Permet un accès aléatoire aux lignes # # INCONVÉNIENTS : # - Charge tout le fichier en mémoire # - Liste peut être grande pour les gros fichiers
L'approche la plus pythonique pour lire un fichier est d'utiliser une boucle for directement sur l'objet fichier. Cette méthode est efficace en mémoire et très lisible.
# Parcourir un fichier avec une boucle for - Méthode recommandée # Création d'un fichier d'événements culturels marocains evenements = """ Festival des Arts Populaires|Marrakech|15/06/2024|Culture Moussem des Fiançailles|Imilchil|10/09/2024|Tradition Festival du Film|Marrakech|01/12/2024|Cinéma Foire Internationale|Casablanca|15/04/2024|Économie Festival des Cerises|Sefrou|20/05/2024|Gastronomie Festival des Nomades|M'Hamid|25/10/2024|Culture """ with open('evenements_maroc.txt', 'w', encoding='utf-8') as f: f.write(evenements) print("=== PARCOURS AVEC BOUCLE for ===") # Méthode pythonique - boucle for directe sur le fichier with open('evenements_maroc.txt', 'r', encoding='utf-8') as fichier: print("Événements culturels au Maroc:") print("=" * 50) for numero_ligne, ligne in enumerate(fichier, 1): ligne = ligne.strip() if ligne: # Ignorer les lignes vides nom, ville, date, categorie = ligne.split('|') print(f"{numero_ligne}. {nom}") print(f" ? {ville} | ? {date} | ?️ {categorie}") print() # Exemple: Filtrage et traitement en temps réel print("=== FILTRAGE DES ÉVÉNEMENTS CULTURELS ===") with open('evenements_maroc.txt', 'r', encoding='utf-8') as fichier: evenements_culture = [] for ligne in fichier: ligne = ligne.strip() if ligne and 'Culture' in ligne: nom, ville, date, categorie = ligne.split('|') evenements_culture.append({ 'nom': nom, 'ville': ville, 'date': date, 'categorie': categorie }) print("Événements culturels uniquement:") for event in evenements_culture: print(f"? {event['nom']} à {event['ville']} le {event['date']}") # Cas pratique: Analyse de données touristiques print("\n=== STATISTIQUES TOURISTIQUES ===") # Création de données touristiques tourisme_maroc = """ Marrakech|Hôtel|5|450.00 Agadir|Résidence|3|280.50 Fès|Riad|4|320.75 Essaouira|Hôtel|4|380.00 Marrakech|Riad|5|520.25 Chefchaouen|Hôtel|3|295.00 """ with open('hebergements_maroc.txt', 'w', encoding='utf-8') as f: f.write(tourisme_maroc) # Analyse avec boucle for with open('hebergements_maroc.txt', 'r', encoding='utf-8') as fichier: total_prix = 0 compte_hebergements = 0 villes = {} for ligne in fichier: if ligne.strip(): ville, type_heb, etoiles, prix = ligne.strip().split('|') prix_float = float(prix) total_prix += prix_float compte_hebergements += 1 if ville in villes: villes[ville] += 1 else: villes[ville] = 1 # Affichage des statistiques print("? Statistiques des hébergements au Maroc:") print(f"Nombre total d'hébergements: {compte_hebergements}") print(f"Prix moyen: {total_prix/compte_hebergements:.2f} MAD") print("Répartition par ville:") for ville, count in villes.items(): print(f" {ville}: {count} hébergement(s)") # AVANTAGES de la boucle for : # - Méthode la plus pythonique # - Efficace en mémoire (lit ligne par ligne) # - Code clair et concis # - Idéal pour les gros fichiers # - Permet un traitement en temps réel
L'écriture de fichiers est tout aussi importante que la lecture en Python. Plusieurs méthodes permettent de créer, modifier et enrichir des fichiers texte, ce qui est essentiel pour générer des rapports, sauvegarder des données ou créer des logs dans des applications marocaines.
La méthode write() est la méthode fondamentale pour écrire du contenu dans un fichier. Elle permet d'écrire des chaînes de caractères et est utilisée avec le mode 'w' pour créer ou écraser des fichiers.
# Méthode write() - Création et écriture de fichiers print("=== CRÉATION DE FICHIERS AVEC write() ===") # Exemple 1: Création d'un fichier simple avec des données marocaines with open('regions_maroc.txt', 'w', encoding='utf-8') as fichier: fichier.write("Régions du Maroc:\n") fichier.write("Casablanca-Settat\n") fichier.write("Rabat-Salé-Kénitra\n") fichier.write("Marrakech-Safi\n") fichier.write("Fès-Meknès\n") fichier.write("Tanger-Tétouan-Al Hoceïma\n") print("Fichier 'regions_maroc.txt' créé avec succès!") # Exemple 2: Création d'un fichier bilingue français-arabe print("\n=== FICHIER BILINGUE ===") contenu_bilingue = """ Bienvenue au Maroc - مرحبا بكم في المغرب Villes impériales - المدن الإمبراطورية Marrakech - مراكش Fès - فاس Meknès - مكناس Rabat - الرباط """ with open('guide_touristique.txt', 'w', encoding='utf-8') as f: f.write(contenu_bilingue) print("Guide touristique bilingue créé avec support arabe!") # Exemple 3: Génération d'un rapport d'entreprise marocaine print("\n=== RAPPORT D'ENTREPRISE ===") def generer_rapport_entreprise(nom_entreprise, chiffre_affaires, ville): """Génère un rapport financier pour une entreprise marocaine""" rapport = f""" RAPPORT FINANCIER - {nom_entreprise} ================================ Entreprise: {nom_entreprise} Ville: {ville} Chiffre d'affaires: {chiffre_affaires:,.2f} MAD TVA (20%): {chiffre_affaires * 0.20:,.2f} MAD Date de génération: 2024 Ce rapport a été généré automatiquement. """ nom_fichier = f'rapport_{nom_entreprise.lower().replace(" ", "_")}.txt' with open(nom_fichier, 'w', encoding='utf-8') as f: f.write(rapport) return nom_fichier # Génération de rapports pour différentes entreprises entreprises = [ ("Maroc Telecom", 50000000, "Rabat"), ("OCP Group", 75000000, "Casablanca"), ("Attijariwafa Bank", 30000000, "Casablanca") ] for entreprise, ca, ville in entreprises: fichier = generer_rapport_entreprise(entreprise, ca, ville) print(f"Rapport généré: {fichier}") # ATTENTION: Le mode 'w' écrase le fichier existant print("\n=== ATTENTION MODE 'w' ===") # Premier écriture with open('test_ecrasement.txt', 'w', encoding='utf-8') as f: f.write("Premier contenu\n") # Deuxième écriture - écrase le premier contenu with open('test_ecrasement.txt', 'w', encoding='utf-8') as f: f.write("Deuxième contenu - le premier a été écrasé!\n") print("Le mode 'w' écrase toujours le contenu existant!")
Le mode 'a' (append) permet d'ajouter du contenu à la fin d'un fichier existant sans écraser le contenu précédent. C'est idéal pour les fichiers logs, les historiques ou l'accumulation de données.
# Mode append - Ajout de contenu sans écrasement print("=== MODE APPEND - AJOUT DE CONTENU ===") # Exemple 1: Système de log pour une application marocaine def ajouter_log(message, niveau="INFO"): """Ajoute une entrée de log avec timestamp""" from datetime import datetime timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") entree_log = f"[{timestamp}] [{niveau}] {message}\n" with open('application_maroc.log', 'a', encoding='utf-8') as fichier_log: fichier_log.write(entree_log) print(f"Log ajouté: {entree_log.strip()}") # Simulation d'utilisation de l'application ajouter_log("Application démarrée", "INFO") ajouter_log("Utilisateur Ahmed connecté", "INFO") ajouter_log("Paiement de 1500 MAD traité", "SUCCESS") ajouter_log("Erreur de connexion à la base de données", "ERROR") ajouter_log("Application arrêtée", "INFO") # Exemple 2: Registre de commandes pour une boutique en ligne marocaine print("\n=== REGISTRE DE COMMANDES ===") def enregistrer_commande(client, produit, prix, ville): """Enregistre une commande dans le registre""" from datetime import datetime date_commande = datetime.now().strftime("%d/%m/%Y") entree = f"{date_commande} | {client} | {produit} | {prix} MAD | {ville}\n" with open('commandes_boutique_maroc.txt', 'a', encoding='utf-8') as registre: registre.write(entree) print(f"Commande enregistrée: {entree.strip()}") # Enregistrement de plusieurs commandes commandes = [ ("Ahmed Alami", "Tapis berbère", 1200, "Casablanca"), ("Fatima Zahra", "Huile d'argan", 350, "Marrakech"), ("Mehdi Benjelloun", "Thé à la menthe", 85, "Rabat"), ("Khadija Mansouri", "Poterie de Fès", 450, "Fès") ] for client, produit, prix, ville in commandes: enregistrer_commande(client, produit, prix, ville) # Exemple 3: Journal de bord bilingue print("\n=== JOURNAL DE BORD BILINGUE ===") def ajouter_entree_journal(entree_fr, entree_ar): """Ajoute une entrée bilingue au journal""" from datetime import datetime date = datetime.now().strftime("%d/%m/%Y") entree = f""" --- Entrée du {date} --- FR: {entree_fr} AR: {entree_ar} """ with open('journal_bilingue.txt', 'a', encoding='utf-8') as journal: journal.write(entree) print(f"Nouvelle entrée ajoutée au journal: {entree_fr}") # Ajout d'entrées bilingues ajouter_entree_journal( "Lancement du nouveau projet de développement", "إطلاق مشروع التطوير الجديد" ) ajouter_entree_journal( "Réunion avec les clients de Casablanca", "اجتماع مع عملاء الدار البيضاء" ) # AVANTAGE du mode append : # - Conserve l'historique existant # - Idéal pour les logs et registres # - Crée le fichier s'il n'existe pas
La méthode writelines() permet d'écrire une liste de chaînes de caractères dans un fichier en une seule opération. C'est très efficace pour écrire des collections de données.
# Méthode writelines() - Écriture de listes de lignes print("=== MÉTHODE writelines() ===") # Exemple 1: Création d'une base de données d'employés marocains print("=== BASE DE DONNÉES EMPLOYÉS ===") employes = [ "ID|Nom|Prénom|Département|Salaire|Ville\n", "001|Alaoui|Ahmed|IT|15000|Casablanca\n", "002|Zahra|Fatima|RH|12000|Rabat\n", "003|Benjelloun|Mehdi|Finance|18000|Casablanca\n", "004|Mansouri|Khadija|Marketing|14000|Marrakech\n", "005|Chraibi|Youssef|IT|16000|Tanger\n" ] with open('employes_maroc.csv', 'w', encoding='utf-8') as f: f.writelines(employes) print("Base de données employés créée avec writelines()") # Exemple 2: Génération d'un menu de restaurant marocain print("\n=== MENU DE RESTAURANT MAROCAIN ===") plats_marocains = [ "?️ MENU TRADITIONNEL MAROCAIN\n", "=" * 35 + "\n", "ENTRÉES:\n", "- Salade marocaine: 25 MAD\n", "- Briouates: 30 MAD\n", "- Harira: 20 MAD\n", "\n", "PLATS PRINCIPAUX:\n", "- Couscous: 60 MAD\n", "- Tajine: 55 MAD\n", "- Pastilla: 70 MAD\n", "- Méchoui: 80 MAD\n", "\n", "DESSERTS:\n", "- Baghrir: 25 MAD\n", "- Chebakia: 30 MAD\n", "- Fruits de saison: 20 MAD\n" ] with open('menu_restaurant_marocain.txt', 'w', encoding='utf-8') as f: f.writelines(plats_marocains) print("Menu de restaurant marocain généré avec succès!") # Exemple 3: Génération dynamique avec liste en compréhension print("\n=== GÉNÉRATION DYNAMIQUE ===") # Liste de villes marocaines avec leurs spécialités villes_specialites = { "Marrakech": "Tourisme et artisanat", "Casablanca": "Économie et finance", "Fès": "Culture et religion", "Tanger": "Port et commerce", "Agadir": "Tourisme balnéaire", "Meknès": "Agriculture" } # Génération dynamique du contenu lignes_villes = ["VILLES MAROCAINES ET LEURS SPÉCIALITÉS\n", "=" * 45 + "\n"] for ville, specialite in villes_specialites.items(): ligne = f"• {ville}: {specialite}\n" lignes_villes.append(ligne) with open('villes_et_specialites.txt', 'w', encoding='utf-8') as f: f.writelines(lignes_villes) print("Fichier des villes et spécialités créé avec writelines()") # ATTENTION: writelines() n'ajoute pas automatiquement les retours à la ligne print("\n=== ATTENTION: RETOURS À LA LIGNE ===") # MAUVAIS: Sans retours à la ligne explicites mauvaises_lignes = ["Ligne 1", "Ligne 2", "Ligne 3"] with open('mauvais_format.txt', 'w', encoding='utf-8') as f: f.writelines(mauvaises_lignes) # BON: Avec retours à la ligne explicites bonnes_lignes = ["Ligne 1\n", "Ligne 2\n", "Ligne 3\n"] with open('bon_format.txt', 'w', encoding='utf-8') as f: f.writelines(bonnes_lignes) print("writelines() nécessite des '\\n' explicites pour les retours à la ligne")
La gestion des retours à la ligne est cruciale pour la lisibilité des fichiers. Python offre différentes approches pour contrôler précisément comment les lignes sont séparées.
# Gestion des retours à la ligne dans les fichiers print("=== GESTION DES RETOURS À LA LIGNE ===") # Exemple 1: Différentes méthodes pour les retours à la ligne print("=== MÉTHODES DE RETOUR À LA LIGNE ===") # Méthode 1: Utilisation de \n (recommandée) with open('methodes_retours.txt', 'w', encoding='utf-8') as f: f.write("Ligne 1 avec \\n\n") f.write("Ligne 2 avec \\n\n") f.write("Ligne 3 avec \\n\n") print("Fichier créé avec des retours à la ligne explicites (\\n)") # Méthode 2: Utilisation de triple quotes pour les blocs contenu_bloc = """ Ceci est un bloc de texte avec des retours à la ligne automatiques grâce aux triple quotes. """ with open('bloc_texte.txt', 'w', encoding='utf-8') as f: f.write(contenu_bloc) print("Bloc de texte créé avec triple quotes") # Exemple 2: Formatage de données tabulaires print("\n=== FORMATAGE TABULAIRE ===") # Données d'exportations marocaines exportations = [ ("Phosphates", "2024", "45.2", "Milliards MAD"), ("Textile", "2024", "32.8", "Milliards MAD"), ("Agrumes", "2024", "12.5", "Milliards MAD"), ("Automobile", "2024", "78.3", "Milliards MAD") ] # Création d'un rapport formaté lignes_rapport = [ "RAPPORT DES EXPORTATIONS MAROCAINES 2024\n", "=" * 60 + "\n", "Secteur".ljust(15) + "Année".ljust(10) + "Valeur".ljust(15) + "Unité\n", "-" * 60 + "\n" ] for secteur, annee, valeur, unite in exportations: ligne = secteur.ljust(15) + annee.ljust(10) + valeur.ljust(15) + unite + "\n" lignes_rapport.append(ligne) with open('rapport_exportations.txt', 'w', encoding='utf-8') as f: f.writelines(lignes_rapport) print("Rapport d'exportations formaté créé avec alignement des colonnes") # Exemple 3: Gestion des sauts de ligne selon les systèmes d'exploitation print("\n=== COMPATIBILITÉ MULTI-OS ===") # Création d'un fichier avec différents séparateurs de ligne contenu_universel = """ Ce fichier utilise des retours à la ligne universels. Il sera lisible sur: - Windows (\\r\\n) - Linux/Mac (\\n) - Anciens Mac (\\r) Python gère automatiquement la conversion selon l'OS. """ # Écriture avec gestion automatique des newlines with open('fichier_universel.txt', 'w', encoding='utf-8', newline='') as f: f.write(contenu_universel) print("Fichier créé avec compatibilité multi-OS") # Exemple 4: Création d'un fichier CSV avec séparateurs corrects print("\n=== FICHIER CSV AVEC SÉPARATEURS ===") import csv # Données de produits marocains produits = [ ["Produit", "Catégorie", "Prix (MAD)", "Région"], ["Huile d'Argan", "Cosmétique", "120.50", "Souss"], ["Safran", "Épice", "85.00", "Taliouine"], ["Tapis berbère", "Artisanat", "450.00", "Atlas"], ["Zellige", "Artisanat", "75.30", "Fès"] ] # Création du CSV avec gestion correcte des newlines with open('produits_maroc.csv', 'w', encoding='utf-8', newline='') as f: writer = csv.writer(f) writer.writerows(produits) print("Fichier CSV créé avec gestion professionnelle des retours à la ligne") # RÉSUMÉ DES BONNES PRATIQUES : print(""" ? BONNES PRATIQUES POUR LES RETOURS À LA LIGNE : 1. Utilisez toujours '\\n' pour les retours à la ligne explicites 2. Pour les blocs de texte, préférez les triple quotes 3. Avec writelines(), incluez '\\n' dans chaque élément de la liste 4. Pour les CSV, utilisez le module csv avec newline='' 5. Python convertit automatiquement '\\n' selon l'OS cible 6. Utilisez .ljust(), .rjust() ou .center() pour l'alignement """)
Le gestionnaire de contexte with est une fonctionnalité essentielle de Python qui simplifie la gestion des ressources comme les fichiers, les connexions réseau ou les verrous. Il garantit que les ressources sont correctement libérées, même en cas d'erreur.
Un gestionnaire de contexte est un objet qui définit les méthodes __enter__() et __exit__() permettant de gérer l'acquisition et la libération de ressources de manière propre et sécurisée.
# Comprendre les gestionnaires de contexte print("=== QU'EST-CE QU'UN GESTIONNAIRE DE CONTEXTE ? ===") # Exemple 1: Création d'un gestionnaire de contexte personnalisé pour une banque marocaine class GestionnaireSessionBancaire: """Gestionnaire de contexte pour une session bancaire sécurisée""" def __init__(self, nom_banque, utilisateur): self.nom_banque = nom_banque self.utilisateur = utilisateur self.session_active = False def __enter__(self): # Méthode appelée au début du bloc with print(f"? Ouverture de session à {self.nom_banque} pour {self.utilisateur}") self.session_active = True print("✅ Session sécurisée établie") return self # Retourne l'objet à utiliser dans le bloc def __exit__(self, exc_type, exc_val, exc_tb): # Méthode appelée à la fin du bloc with (même en cas d'erreur) print(f"? Fermeture sécurisée de la session à {self.nom_banque}") self.session_active = False if exc_type is not None: print(f"⚠️ Une erreur s'est produite: {exc_type.__name__}: {exc_val}") print("✅ Session fermée avec succès") return True # Empêche la propagation de l'exception def effectuer_operation(self, operation, montant): if not self.session_active: raise Exception("Session non active") print(f"? {operation} de {montant} DH effectuée avec succès") # Utilisation du gestionnaire de contexte personnalisé print("Utilisation du gestionnaire de contexte personnalisé:") with GestionnaireSessionBancaire("Attijariwafa Bank", "Ahmed Alami") as session: session.effectuer_operation("Dépôt", 5000) session.effectuer_operation("Retrait", 1000) # Exemple 2: Gestionnaire de contexte pour les transactions commerciales class GestionnaireTransaction: """Gestionnaire de contexte pour les transactions commerciales marocaines""" def __enter__(self): print("? Début de la transaction commerciale") print("? Enregistrement du début de transaction...") return "Transaction_2024_001" def __exit__(self, exc_type, exc_val, exc_tb): if exc_type is None: print("✅ Transaction complétée avec succès") else: print("❌ Transaction annulée en raison d'une erreur") print("? Fin de la transaction") # Utilisation print("\nTransaction commerciale:") with GestionnaireTransaction() as transaction_id: print(f"? Traitement de la transaction: {transaction_id}") print("? Vente de produits marocains en cours...") # CARACTÉRISTIQUES D'UN GESTIONNAIRE DE CONTEXTE : # - __enter__(): Préparation des ressources # - __exit__(): Nettoyage garanti (même avec erreurs) # - Gestion automatique des exceptions # - Code plus propre et sécurisé
L'utilisation de with pour les fichiers évite les fuites de ressources, garantit la fermeture des fichiers même en cas d'erreur, et rend le code plus lisible et maintenable.
# Pourquoi utiliser with pour les fichiers ? print("=== POURQUOI UTILISER 'with' POUR LES FICHIERS ? ===") # SCÉNARIO 1: Méthode traditionnelle (PROBLÉMATIQUE) print("SCÉNARIO 1 - MÉTHODE TRADITIONNELLE (RISQUÉE):") def methode_traditionnelle_risquee(): """Méthode risquée sans with - possibilité de fuite de ressources""" try: # Ouverture du fichier fichier = open('donnees_sensibles_maroc.txt', 'w', encoding='utf-8') # Écriture de données sensibles donnees_sensibles = [ "Clients CNSS: Ahmed Alami, Fatima Zahra, Mehdi Benjelloun\n", "Salaires: 15000, 12000, 18000 MAD\n", "Entreprises: OCP, Maroc Telecom, Attijariwafa Bank\n" ] fichier.writelines(donnees_sensibles) # Simulation d'une erreur (fichier pourrait ne pas être fermé) raise Exception("Erreur inattendue lors du traitement!") # Cette ligne pourrait ne jamais être exécutée en cas d'erreur fichier.close() except Exception as e: print(f"❌ Erreur: {e}") print("⚠️ Le fichier pourrait être resté ouvert!") # On oublie souvent de fermer le fichier dans le bloc except # SCÉNARIO 2: Méthode sécurisée avec with (RECOMMANDÉE) print("\nSCÉNARIO 2 - MÉTHODE AVEC 'with' (SÉCURISÉE):") def methode_avec_with_securisee(): """Méthode sécurisée avec with - fermeture garantie""" try: with open('donnees_sensibles_maroc_securise.txt', 'w', encoding='utf-8') as fichier: donnees_sensibles = [ "Clients CNSS: Ahmed Alami, Fatima Zahra, Mehdi Benjelloun\n", "Salaires: 15000, 12000, 18000 MAD\n", "Entreprises: OCP, Maroc Telecom, Attijariwafa Bank\n" ] fichier.writelines(donnees_sensibles) # Même avec une erreur, le fichier sera fermé automatiquement raise Exception("Erreur inattendue lors du traitement!") except Exception as e: print(f"❌ Erreur: {e}") print("✅ Le fichier a été fermé automatiquement malgré l'erreur!") # Test des deux méthodes print("Test de la méthode traditionnelle (risquée):") methode_traditionnelle_risquee() print("\nTest de la méthode avec 'with' (sécurisée):") methode_avec_with_securisee() # AVANTAGES DU 'with' POUR LES FICHIERS : print(""" ? AVANTAGES DE 'with' POUR LES FICHIERS : 1. ✅ FERMETURE GARANTIE : Le fichier est toujours fermé, même en cas d'erreur 2. ? CODE PLUS PROPRE : Pas besoin de blocs try/finally complexes 3. ? SÉCURITÉ : Évite les fuites de ressources et les fichiers laissés ouverts 4. ? LISIBILITÉ : Le code est plus clair et intentionnel 5. ? PERFORMANCE : Libération immédiate des ressources 6. ? MAINTENABILITÉ : Moins de code à tester et déboguer """) # Exemple concret: Gestion de fichiers de paie marocains print("\n=== EXEMPLE CONCRET: FICHIERS DE PAE MAROCAINS ===") def generer_bulletins_paie(employes): """Génère les bulletins de paie avec gestion sécurisée""" for i, employe in enumerate(employes, 1): nom_fichier = f'bulletin_{employe["nom"].replace(" ", "_")}.txt' # Avec 'with', on est sûr que chaque fichier sera fermé with open(nom_fichier, 'w', encoding='utf-8') as f: f.write(f"BULLETIN DE PAIE - {employe['nom']}\n") f.write(f"Salaire de base: {employe['salaire']} MAD\n") f.write(f"CNSS: {employe['salaire'] * 0.04} MAD\n") f.write(f"Net à payer: {employe['salaire'] * 0.96} MAD\n") print(f"✅ Bulletin généré: {nom_fichier}") # Données des employés marocains employes_maroc = [ {"nom": "Ahmed Alami", "salaire": 15000}, {"nom": "Fatima Zahra", "salaire": 12000}, {"nom": "Mehdi Benjelloun", "salaire": 18000} ] generer_bulletins_paie(employes_maroc)
La syntaxe with open() est la manière standard et recommandée d'ouvrir des fichiers en Python. Elle combine la simplicité d'utilisation avec la sécurité de la gestion des ressources.
# Syntaxe et utilisation de with open() print("=== SYNTAXE ET UTILISATION DE 'with open()' ===") # SYNTAXE DE BASE print("SYNTAXE DE BASE:") print("with open(fichier, mode, encoding) as variable:") print(" # Traitement du fichier") # Exemple 1: Lecture simple d'un fichier de villes marocaines print("\n--- EXEMPLE 1: LECTURE SIMPLE ---") # Création d'un fichier exemple villes_maroc = "Casablanca\nRabat\nMarrakech\nFès\nTanger\nAgadir\n" with open('villes_maroc.txt', 'w', encoding='utf-8') as f: f.write(villes_maroc) # Lecture avec with open() with open('villes_maroc.txt', 'r', encoding='utf-8') as fichier_villes: contenu = fichier_villes.read() print("Villes du Maroc:") print(contenu) # Exemple 2: Écriture avec formatage print("--- EXEMPLE 2: ÉCRITURE AVEC FORMATAGE ---") with open('entreprises_maroc_formate.txt', 'w', encoding='utf-8') as f: entreprises = [ ("OCP Group", "Phosphates", "75.2"), ("Maroc Telecom", "Télécoms", "45.8"), ("Attijariwafa Bank", "Banque", "32.1"), ("BMCE Bank", "Banque", "28.5") ] f.write("ENTREPRISES MAROCAINES - CHIFFRE D'AFFAIRES 2024\n") f.write("=" * 55 + "\n") for nom, secteur, ca in entreprises: ligne = f"{nom:.25} {secteur:.15} {ca} milliards MAD\n" f.write(ligne) print("Fichier formaté créé avec succès!") # Exemple 3: Multiple fichiers dans un seul bloc with print("--- EXEMPLE 3: MULTIPLES FICHIERS ---") # Copie d'un fichier avec deux gestionnaires de contexte with open('entreprises_maroc_formate.txt', 'r', encoding='utf-8') as source, \\ open('backup_entreprises.txt', 'w', encoding='utf-8') as destination: contenu = source.read() destination.write("BACKUP - " + contenu) print("Backup créé avec deux fichiers gérés simultanément!") # Exemple 4: Utilisation avec gestion d'erreurs print("--- EXEMPLE 4: GESTION D'ERREURS ---") def lire_fichier_securise(nom_fichier): """Lecture sécurisée avec gestion d'erreurs intégrée""" try: with open(nom_fichier, 'r', encoding='utf-8') as f: return f.read() except FileNotFoundError: print(f"❌ Fichier {nom_fichier} non trouvé") return None except PermissionError: print(f"❌ Permission refusée pour {nom_fichier}") return None # Test avec un fichier existant et un fichier inexistant contenu_existant = lire_fichier_securise('villes_maroc.txt') if contenu_existant: print("✅ Fichier existant lu avec succès") contenu_inexistant = lire_fichier_securise('fichier_inexistant.txt') # VARIATIONS DE SYNTAXE print(""" ? VARIATIONS DE SYNTAXE : 1. Syntaxe basique : with open('fichier.txt', 'r') as f: contenu = f.read() 2. Avec encodage UTF-8 (recommandé pour le Maroc) : with open('fichier.txt', 'r', encoding='utf-8') as f: contenu = f.read() 3. Multiple fichiers : with open('source.txt', 'r') as src, open('dest.txt', 'w') as dest: dest.write(src.read()) 4. Avec gestion d'erreurs : try: with open('fichier.txt', 'r') as f: contenu = f.read() except FileNotFoundError: print("Fichier non trouvé") """)
La fermeture automatique est l'avantage principal du gestionnaire de contexte with. Elle garantit que les fichiers sont correctement fermés, libérant ainsi les ressources système et évitant les corruptions de données.
# Fermeture automatique des fichiers avec with print("=== FERMETURE AUTOMATIQUE DES FICHIERS ===") # DÉMONSTRATION DE LA FERMETURE AUTOMATIQUE print("DÉMONSTRATION DE LA FERMETURE AUTOMATIQUE:") # Exemple 1: Vérification de la fermeture automatique print("--- EXEMPLE 1: VÉRIFICATION DE LA FERMETURE ---") def verifier_fermeture_automatique(): """Démontre que le fichier est fermé automatiquement""" print("Avant le bloc with...") with open('test_fermeture.txt', 'w', encoding='utf-8') as f: print("À l'intérieur du bloc with...") f.write("Test de fermeture automatique\n") print(f"Fichier ouvert? {not f.closed}") print("Après le bloc with...") print(f"Fichier fermé? Oui, automatiquement!") verifier_fermeture_automatique() # Exemple 2: Fermeture même avec des exceptions print("\n--- EXEMPLE 2: FERMETURE AVEC EXCEPTIONS ---") def test_fermeture_avec_exception(): """Test que le fichier est fermé même en cas d'erreur""" try: with open('transaction_importante.txt', 'w', encoding='utf-8') as f: f.write("Début de transaction importante...\n") # Simulation d'une erreur critique raise ValueError("Erreur système critique!") # Ce code ne sera jamais exécuté f.write("Fin de transaction\n") except ValueError as e: print(f"❌ Exception attrapée: {e}") print("✅ Le fichier a été fermé automatiquement malgré l'erreur!") test_fermeture_avec_exception() # Exemple 3: Comparaison avec/sans fermeture automatique print("\n--- EXEMPLE 3: COMPARAISON AVEC/SANS FERMETURE AUTOMATIQUE ---") import os import psutil # Nécessite: pip install psutil def obtenir_utilisation_memoire(): """Retourne l'utilisation mémoire actuelle""" process = psutil.Process(os.getpid()) return process.memory_info().rss / 1024 / 1024 # MB print("Test d'utilisation mémoire avec fermeture automatique:") memoire_avant = obtenir_utilisation_memoire() print(f"Mémoire avant: {memoire_avant:.2f} MB") # Traitement de nombreux fichiers avec fermeture automatique for i in range(100): with open(f'temp_file_{i}.txt', 'w') as f: f.write("Données temporaires" * 1000) memoire_apres = obtenir_utilisation_memoire() print(f"Mémoire après: {memoire_apres:.2f} MB") print(f"Différence: {memoire_apres - memoire_avant:.2f} MB") print("✅ Pas de fuite mémoire grâce à la fermeture automatique!") # Nettoyage des fichiers temporaires for i in range(100): try: os.remove(f'temp_file_{i}.txt') except FileNotFoundError: pass # Exemple 4: Importance pour les applications critiques print("\n--- EXEMPLE 4: APPLICATIONS CRITIQUES ---") class GestionnaireFichiersSecurise: """Gestionnaire sécurisé pour les fichiers sensibles marocains""" def sauvegarder_donnees_sensibles(self, donnees, nom_fichier): """Sauvegarde sécurisée avec fermeture garantie""" try: with open(nom_fichier, 'w', encoding='utf-8') as f: for ligne in donnees: f.write(ligne + '\n') print(f"✅ Données sauvegardées sécuritairement dans {nom_fichier}") except Exception as e: print(f"❌ Erreur lors de la sauvegarde: {e}") # Le fichier est automatiquement fermé même en cas d'erreur # Utilisation pour des données sensibles marocaines gestionnaire = GestionnaireFichiersSecurise() donnees_cnss = [ "CNSS - Données sensibles", "Employé: Ahmed Alami, Matricule: 001, Salaire: 15000 MAD", "Employé: Fatima Zahra, Matricule: 002, Salaire: 12000 MAD", "Employé: Mehdi Benjelloun, Matricule: 003, Salaire: 18000 MAD" ] gestionnaire.sauvegarder_donnees_sensibles(donnees_cnss, 'cnss_donnees_securisees.txt') # AVANTAGES DE LA FERMETURE AUTOMATIQUE print(""" ? AVANTAGES DE LA FERMETURE AUTOMATIQUE : 1. ? SÉCURITÉ : Évite les fichiers laissés ouverts accidentellement 2. ? INTÉGRITÉ : Garantit que les données sont correctement écrites 3. ? NETTOYAGE : Libère les ressources système automatiquement 4. ? PERFORMANCE : Évite l'accumulation de descripteurs de fichiers 5. ? ROBUSTESSE : Fonctionne même avec des exceptions imprévues 6. ? ÉVOLUTIVITÉ : Permet de traiter de nombreux fichiers sans souci ? CONSEIL : Utilisez TOUJOURS 'with open()' pour les fichiers ! """)
La gestion des erreurs est cruciale lorsqu'on travaille avec des fichiers en Python. Une gestion appropriée des exceptions permet de créer des applications robustes qui peuvent résister aux situations imprévues comme les fichiers manquants, les problèmes de permissions ou les erreurs d'encodage.
Plusieurs types d'exceptions peuvent survenir lors de la manipulation de fichiers. Comprendre ces erreurs est essentiel pour les anticiper et les gérer proprement.
# Les erreurs courantes avec les fichiers print("=== ERREURS COURANTES AVEC LES FICHIERS ===") # 1. FileNotFoundError - Fichier introuvable print("1. FileNotFoundError - Fichier introuvable") print("--------------------------------------------") def demonstration_file_not_found(): """Démontre l'erreur FileNotFoundError""" try: # Tentative de lecture d'un fichier qui n'existe pas with open('fichier_inexistant_maroc.txt', 'r', encoding='utf-8') as f: contenu = f.read() except FileNotFoundError as e: print(f"❌ FileNotFoundError: {e}") print("? Le fichier spécifié n'existe pas à l'emplacement donné") print("? Vérifiez le chemin et le nom du fichier") demonstration_file_not_found() # 2. PermissionError - Problème de permissions print("\n2. PermissionError - Problème de permissions") print("---------------------------------------------") def demonstration_permission_error(): """Démontre l'erreur PermissionError (simulation)""" try: # Simulation d'un fichier système protégé # En réalité, on créerait un fichier et on modifierait ses permissions print("Simulation d'un accès à un fichier système protégé...") print("Exemple: /etc/passwd sur Linux ou C:\\Windows\\system32 sur Windows") # Pour une vraie démonstration, vous pourriez créer un fichier et le rendre en lecture seule with open('fichier_protege_maroc.txt', 'w') as f: f.write("Fichier protégé - CNSS données sensibles") # Simulation d'une PermissionError raise PermissionError("[Errno 13] Permission non accordée: 'fichier_protege_maroc.txt'") except PermissionError as e: print(f"❌ PermissionError: {e}") print("? Vous n'avez pas les droits nécessaires pour accéder à ce fichier") print("? Vérifiez les permissions du fichier/dossier") demonstration_permission_error() # 3. IsADirectoryError - Essai d'ouvrir un dossier comme un fichier print("\n3. IsADirectoryError - Ouvrir un dossier comme fichier") print("-----------------------------------------------------") import os def demonstration_is_a_directory(): """Démontre l'erreur IsADirectoryError""" try: # Création d'un dossier pour l'exemple os.makedirs('dossier_maroc_exemple', exist_ok=True) # Tentative d'ouvrir le dossier comme un fichier with open('dossier_maroc_exemple', 'r') as f: contenu = f.read() except IsADirectoryError as e: print(f"❌ IsADirectoryError: {e}") print("? Vous essayez d'ouvrir un dossier comme s'il s'agissait d'un fichier") print("? Utilisez os.listdir() pour lister le contenu d'un dossier") demonstration_is_a_directory() # 4. UnicodeDecodeError - Problème d'encodage print("\n4. UnicodeDecodeError - Problème d'encodage") print("-------------------------------------------") def demonstration_unicode_error(): """Démontre l'erreur UnicodeDecodeError""" try: # Création d'un fichier avec encodage UTF-8 contenant de l'arabe texte_arabe = "نص عربي للاختبار" # Texte arabe de test with open('fichier_arabe_maroc.txt', 'w', encoding='utf-8') as f: f.write(texte_arabe) # Tentative de lecture avec le mauvais encodage with open('fichier_arabe_maroc.txt', 'r', encoding='latin-1') as f: contenu = f.read() except UnicodeDecodeError as e: print(f"❌ UnicodeDecodeError: {e}") print("? Problème de décodage des caractères") print("? Utilisez encoding='utf-8' pour les textes en arabe/français") print("? L'UTF-8 est l'encodage recommandé pour le Maroc") demonstration_unicode_error() # RÉSUMÉ DES ERREURS COURANTES print(""" ? RÉSUMÉ DES ERREURS COURANTES : FileNotFoundError : Fichier n'existe pas à l'emplacement spécifié PermissionError : Droits insuffisants pour accéder au fichier IsADirectoryError : Tentative d'ouvrir un dossier comme fichier UnicodeDecodeError : Problème d'encodage des caractères IOError : Erreur d'E/S générale (héritage de OSError) """)
La structure try-except permet de capturer et gérer les exceptions de manière contrôlée, empêchant l'arrêt brutal du programme et fournissant des messages d'erreur significatifs.
# Utilisation de try-except avec les fichiers print("=== UTILISATION DE TRY-EXCEPT AVEC LES FICHIERS ===") # Exemple 1: Gestion complète des erreurs pour un fichier de clients marocains print("1. GESTION COMPLÈTE POUR UN FICHIER DE CLIENTS") print("-----------------------------------------------") def lire_fichier_clients_securise(nom_fichier): """Lit un fichier de clients avec gestion complète des erreurs""" try: with open(nom_fichier, 'r', encoding='utf-8') as fichier: clients = [] for ligne_num, ligne in enumerate(fichier, 1): ligne = ligne.strip() if ligne: try: # Format attendu: Nom,Prénom,Ville,Téléphone nom, prenom, ville, telephone = ligne.split(',') clients.append({ 'nom': nom.strip(), 'prenom': prenom.strip(), 'ville': ville.strip(), 'telephone': telephone.strip() }) except ValueError: print(f"⚠️ Ligne {ligne_num} ignorée - format invalide: {ligne}") print(f"✅ {len(clients)} clients chargés avec succès") return clients except FileNotFoundError: print(f"❌ Fichier '{nom_fichier}' non trouvé") print("? Vérifiez le nom et l'emplacement du fichier") return [] except PermissionError: print(f"❌ Permission refusée pour '{nom_fichier}'") print("? Vérifiez les permissions du fichier") return [] except UnicodeDecodeError: print(f"❌ Erreur d'encodage dans '{nom_fichier}'") print("? Le fichier n'est pas en UTF-8. Essayez un autre encodage.") return [] except Exception as e: print(f"❌ Erreur inattendue: {e}") print("? Contactez le support technique") return [] # Test avec différents scénarios print("Test avec fichier existant:") clients = lire_fichier_clients_securise('clients_maroc.txt') print("\nTest avec fichier inexistant:") clients = lire_fichier_clients_securise('fichier_inexistant.txt') # Exemple 2: Gestion d'erreurs avec plusieurs types d'exceptions print("\n2. GESTION MULTIPLE D'EXCEPTIONS") print("-------------------------------") def manipuler_fichier_administratif(nom_fichier, operation='lecture'): """Manipule un fichier administratif avec gestion d'erreurs avancée""" try: if operation == 'lecture': with open(nom_fichier, 'r', encoding='utf-8') as f: return f.read() elif operation == 'ecriture': with open(nom_fichier, 'w', encoding='utf-8') as f: f.write("Données administratives marocaines\n") return "Écriture réussie" # Capture multiple d'exceptions except (FileNotFoundError, PermissionError) as e: print(f"❌ Erreur d'accès au fichier: {type(e).__name__}") print(f"? Message: {e}") return None except UnicodeDecodeError: print(f"❌ Erreur d'encodage dans {nom_fichier}") print("? Essayez avec un encodage différent") return None except Exception as e: print(f"❌ Erreur inattendue: {type(e).__name__}: {e}") return None # Test de la fonction resultat = manipuler_fichier_administratif('donnees_cnss.txt', 'lecture') if resultat is None: print("L'opération a échoué, mais le programme continue...") # Exemple 3: Utilisation de else et finally print("\n3. UTILISATION DE ELSE ET FINALLY") print("--------------------------------") def traiter_fichier_avec_log(nom_fichier): """Traite un fichier avec log complet utilisant else et finally""" fichier = None try: print(f"? Tentative d'ouverture de {nom_fichier}") fichier = open(nom_fichier, 'r', encoding='utf-8') contenu = fichier.read() except FileNotFoundError: print(f"❌ Fichier {nom_fichier} non trouvé") except PermissionError: print(f"❌ Permission refusée pour {nom_fichier}") else: # Ce bloc s'exécute seulement si aucune exception n'est levée print(f"✅ Fichier {nom_fichier} lu avec succès") print(f"? Taille du contenu: {len(contenu)} caractères") return contenu finally: # Ce bloc s'exécute toujours, même en cas d'exception print("? Nettoyage des ressources...") if fichier and not fichier.closed: fichier.close() print("✅ Fichier fermé") return None # Test traiter_fichier_avec_log('fichier_inexistant.txt') # STRUCTURE TRY-EXCEPT COMPLÈTE print(""" ? STRUCTURE TRY-EXCEPT COMPLÈTE : try: # Code susceptible de lever des exceptions with open('fichier.txt', 'r') as f: data = f.read() except FileNotFoundError: # Gestion spécifique print("Fichier non trouvé") except PermissionError: # Gestion spécifique print("Permission refusée") else: # Exécuté si aucune exception print("Succès!") finally: # Toujours exécuté print("Nettoyage") """)
Il est souvent préférable de vérifier l'existence d'un fichier avant de tenter de l'ouvrir. Cela permet d'éviter des exceptions et de fournir un comportement plus prévisible.
# Vérifier l'existence d'un fichier avant l'ouverture print("=== VÉRIFICATION DE L'EXISTENCE D'UN FICHIER ===") import os import pathlib # Méthode 1: Utilisation de os.path.exists() print("1. AVEC os.path.exists()") print("-----------------------") def verifier_et_lire_os(nom_fichier): """Vérifie l'existence avec os.path et lit le fichier""" if os.path.exists(nom_fichier): print(f"✅ Fichier '{nom_fichier}' existe") # Vérification supplémentaire: est-ce un fichier (et non un dossier)? if os.path.isfile(nom_fichier): print(f"? C'est bien un fichier") # Vérification des permissions if os.access(nom_fichier, os.R_OK): try: with open(nom_fichier, 'r', encoding='utf-8') as f: contenu = f.read() print(f"? Contenu lu: {len(contenu)} caractères") return contenu except UnicodeDecodeError: print(f"❌ Erreur d'encodage dans {nom_fichier}") else: print(f"❌ Pas de permission de lecture sur {nom_fichier}") else: print(f"❌ '{nom_fichier}' est un dossier, pas un fichier") else: print(f"❌ Fichier '{nom_fichier}' n'existe pas") return None # Test verifier_et_lire_os('fichier_inexistant.txt') # Méthode 2: Utilisation de pathlib (Python moderne) print("\n2. AVEC pathlib (MODERNE)") print("-----------------------") def verifier_et_lire_pathlib(nom_fichier): """Vérifie l'existence avec pathlib et lit le fichier""" chemin = pathlib.Path(nom_fichier) if chemin.exists(): print(f"✅ Fichier '{nom_fichier}' existe") if chemin.is_file(): print(f"? C'est bien un fichier") # Vérification des permissions avec pathlib if os.access(chemin, os.R_OK): try: contenu = chemin.read_text(encoding='utf-8') print(f"? Contenu lu: {len(contenu)} caractères") # Informations supplémentaires avec pathlib print(f"? Taille: {chemin.stat().st_size} octets") print(f"? Dernière modification: {chemin.stat().st_mtime}") return contenu except UnicodeDecodeError: print(f"❌ Erreur d'encodage dans {nom_fichier}") else: print(f"❌ Pas de permission de lecture sur {nom_fichier}") else: print(f"❌ '{nom_fichier}' est un dossier, pas un fichier") else: print(f"❌ Fichier '{nom_fichier}' n'existe pas") return None # Test verifier_et_lire_pathlib('fichier_inexistant.txt') # Méthode 3: Fonction utilitaire complète pour les applications marocaines print("\n3. FONCTION UTILITAIRE COMPLÈTE") print("-----------------------------") class GestionnaireFichiersMaroc: """Gestionnaire de fichiers avec vérifications complètes pour le contexte marocain""" def verifier_fichier(self, chemin_fichier): """Vérifie complètement un fichier avant utilisation""" if not os.path.exists(chemin_fichier): print(f"❌ Fichier '{chemin_fichier}' n'existe pas") return False if not os.path.isfile(chemin_fichier): print(f"❌ '{chemin_fichier}' n'est pas un fichier") return False if not os.access(chemin_fichier, os.R_OK): print(f"❌ Pas de permission de lecture sur '{chemin_fichier}'") return False # Vérification de la taille (éviter les fichiers vides ou trop gros) taille = os.path.getsize(chemin_fichier) if taille == 0: print(f"⚠️ Le fichier '{chemin_fichier}' est vide") return False if taille > 100 * 1024 * 1024: # 100 MB print(f"⚠️ Le fichier '{chemin_fichier}' est très volumineux ({taille/(1024*1024):.1f} MB)") # On pourrait demander confirmation à l'utilisateur print(f"✅ Fichier '{chemin_fichier}' vérifié avec succès") print(f"? Taille: {taille} octets") return True def lire_fichier_securise(self, chemin_fichier): """Lit un fichier après vérifications complètes""" if not self.verifier_fichier(chemin_fichier): return None try: # Essai avec UTF-8 (standard pour le Maroc) with open(chemin_fichier, 'r', encoding='utf-8') as f: return f.read() except UnicodeDecodeError: print(f"❌ Erreur UTF-8, tentative avec latin-1...") try: # Fallback sur latin-1 with open(chemin_fichier, 'r', encoding='latin-1') as f: return f.read() except Exception as e: print(f"❌ Erreur de lecture: {e}") return None # Utilisation gestionnaire = GestionnaireFichiersMaroc() # Création d'un fichier de test with open('test_verification.txt', 'w', encoding='utf-8') as f: f.write("Données de test pour la vérification\n") f.write("Client: Ahmed Alami, Ville: Casablanca\n") contenu = gestionnaire.lire_fichier_securise('test_verification.txt') if contenu: print(f"✅ Contenu lu: {contenu}") # COMPARAISON DES MÉTHODES print(""" ? COMPARAISON DES MÉTHODES DE VÉRIFICATION : os.path.exists() : Vérifie l'existence (fichier ou dossier) os.path.isfile() : Vérifie que c'est un fichier os.path.isdir() : Vérifie que c'est un dossier os.access() : Vérifie les permissions pathlib.Path.exists(): Approche orientée objet (moderne) ? RECOMMANDATION : Utilisez pathlib pour les nouveaux projets ? CONSEIL : Combinez vérification ET try-except pour une robustesse maximale """)
Une bonne gestion des erreurs suit des principes qui rendent le code plus robuste, maintenable et convivial pour les utilisateurs.
# Bonnes pratiques de gestion d'erreurs print("=== BONNES PRATIQUES DE GESTION D'ERREURS ===") # PRATIQUE 1: Être spécifique dans la capture des exceptions print("1. CAPTURE SPÉCIFIQUE DES EXCEPTIONS") print("------------------------------------") def mauvaise_pratique_generique(fichier): """MAUVAISE PRATIQUE: Capture trop générique""" try: with open(fichier, 'r') as f: return f.read() except Exception as e: # ❌ Trop générique! print(f"Erreur: {e}") return None def bonne_pratique_specifique(fichier): """BONNE PRATIQUE: Capture spécifique""" try: with open(fichier, 'r', encoding='utf-8') as f: return f.read() except FileNotFoundError: print(f"❌ Fichier '{fichier}' non trouvé. Vérifiez le chemin.") return None except PermissionError: print(f"❌ Permission refusée pour '{fichier}'. Vérifiez les droits.") return None except UnicodeDecodeError: print(f"❌ Erreur d'encodage dans '{fichier}'. Essayez un autre encodage.") return None except Exception as e: # Capture générique seulement pour les erreurs vraiment inattendues print(f"❌ Erreur inattendue: {type(e).__name__}: {e}") print("? Veuillez contacter le support technique") return None # PRATIQUE 2: Fournir des messages d'erreur utiles print("\n2. MESSAGES D'ERREUR UTILES") print("--------------------------") class GestionnaireErreursMaroc: """Gestionnaire d'erreurs avec messages contextuels pour le Maroc""" def traiter_fichier_cnss(self, fichier_cnss): """Traite un fichier CNSS avec messages d'erreur contextuels""" try: # Vérification préalable if not os.path.exists(fichier_cnss): raise FileNotFoundError( f"Le fichier CNSS '{fichier_cnss}' est introuvable.\\n\" f\"Vérifiez que le fichier existe dans le dossier spécifié.\\n\" f\"Si vous venez de le télécharger, assurez-vous qu'il est bien décompressé.\" ) if not os.access(fichier_cnss, os.R_OK): raise PermissionError( f"Impossible de lire le fichier CNSS '{fichier_cnss}'.\\n\" f\"Vérifiez que vous avez les droits de lecture sur ce fichier.\\n\" f\"Si le fichier est ouvert dans un autre programme, fermez-le d'abord.\" ) # Traitement du fichier with open(fichier_cnss, 'r', encoding='utf-8') as f: lignes = f.readlines() if not lignes: raise ValueError("Le fichier CNSS est vide. Vérifiez son contenu.") print(f"✅ Fichier CNSS traité avec succès: {len(lignes)} lignes") return lignes except (FileNotFoundError, PermissionError, ValueError) as e: print(f"\\n? ERREUR CNSS ?\" f\"\\n{'='*50}\" f\"\\n{e}\" f\"\\n{'='*50}\" f\"\\n? Conseil: Contactez le service informatique si le problème persiste.\") return [] # Test gestionnaire_erreurs = GestionnaireErreursMaroc() gestionnaire_erreurs.traiter_fichier_cnss('fichier_inexistant_cnss.txt') # PRATIQUE 3: Journalisation des erreurs print("\n3. JOURNALISATION DES ERREURS") print("---------------------------") import logging from datetime import datetime def configurer_logging(): """Configure le système de logging pour une application marocaine""" logging.basicConfig( level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', handlers=[ logging.FileHandler('application_maroc_errors.log', encoding='utf-8'), logging.StreamHandler() # Affiche aussi dans la console ] ) def traiter_fichier_avec_log(fichier): """Traite un fichier avec journalisation complète des erreurs""" logger = logging.getLogger('GestionFichiersMaroc') try: logger.info(f"Tentative de traitement du fichier: {fichier}") if not os.path.exists(fichier): raise FileNotFoundError(f"Fichier {fichier} non trouvé") with open(fichier, 'r', encoding='utf-8') as f: contenu = f.read() logger.info(f"Fichier {fichier} traité avec succès: {len(contenu)} caractères") return contenu except FileNotFoundError as e: logger.error(f"Fichier non trouvé: {fichier} - {e}") print(f"❌ Erreur: {e}. Vérifiez le nom du fichier.") return None except Exception as e: logger.exception(f"Erreur inattendue avec {fichier}") print(f"❌ Erreur inattendue. Voir les logs pour plus de détails.") return None # Configuration et test configurer_logging() traiter_fichier_avec_log('fichier_inexistant.txt') # RÉSUMÉ DES BONNES PRATIQUES print(""" ? BONNES PRATIQUES DE GESTION D'ERREURS : 1. ? SOYEZ SPÉCIFIQUE : Capturez des exceptions spécifiques plutôt que Exception 2. ? MESSAGES UTILES : Fournissez des messages d'erreur clairs et actionnables 3. ? JOURNALISATION : Logguez les erreurs pour le débogage et l'audit 4. ? RÉCUPÉRATION GRACIEUSE : Permettez à l'application de continuer si possible 5. ? TESTEZ LES ERREURS : Testez vos gestionnaires d'erreurs comme le code normal 6. ? ÉVITEZ LES BLOCS VIDES : Ne laissez jamais un bloc except vide 7. ? VÉRIFIEZ PRÉALABLEMENT : Utilisez os.path.exists() quand c'est approprié 8. ?️ UTILISEZ WITH : Profitez de la fermeture automatique des fichiers 9. ? CONTEXTE LOCAL : Adaptez les messages d'erreur au contexte marocain 10. ? DOCUMENTATION : Documentez les exceptions que vos fonctions peuvent lever """)
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!