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

Tutoriel Python
Lecture et écriture de fichiers texte avec open() et with

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.

Sommaire du Chapitre
Introduction à la gestion des fichiers en Python Pourquoi manipuler des fichiers en Python Les types de fichiers supportés Prérequis pour suivre ce tutoriel Comprendre la fonction open() en Python Syntaxe de base de open() Les différents modes d'ouverture (r, w, a, x) Les modes binaires et texte Le paramètre encoding pour les fichiers texte Lire des fichiers texte avec Python Ouvrir et lire un fichier avec read() Lire ligne par ligne avec readline() Lire toutes les lignes avec readlines() Parcourir un fichier avec une boucle for Écrire dans des fichiers texte Créer et écrire dans un fichier avec write() Ajouter du contenu avec le mode append Écrire plusieurs lignes avec writelines() Gérer les retours à la ligne Le gestionnaire de contexte with Qu'est-ce qu'un gestionnaire de contexte Pourquoi utiliser with pour les fichiers Syntaxe et utilisation de with open() Fermeture automatique des fichiers Gestion des erreurs et exceptions Les erreurs courantes (FileNotFoundError, PermissionError) Utiliser try-except avec les fichiers Vérifier l'existence d'un fichier avant l'ouverture Bonnes pratiques de gestion d'erreurs Manipulations avancées de fichiers Déplacer le curseur avec seek() Connaître la position avec tell() Lire et écrire simultanément (mode r+) Travailler avec des fichiers volumineux Chemins de fichiers et module os Chemins relatifs vs chemins absolus Utiliser os.path pour manipuler les chemins Introduction à pathlib pour Python moderne Créer des dossiers avec os.makedirs() Exemples pratiques et cas d'usage Lire un fichier de configuration Créer un fichier de log Traiter un fichier de données texte Copier le contenu d'un fichier vers un autre Bonnes pratiques et optimisations Toujours utiliser with pour ouvrir des fichiers Choisir le bon mode d'ouverture Gérer l'encodage correctement (UTF-8) Éviter de charger de gros fichiers en mémoire Exercices pratiques Exercice 1 : lire et compter les mots d'un fichier Exercice 2 : créer un carnet d'adresses Exercice 3 : filtrer et copier des lignes spécifiques Solutions commentées

Introduction à la gestion des fichiers en Python

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.

Pourquoi manipuler des fichiers en Python

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 :

exemple_utilisations.py
# 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()

Les types de fichiers supportés

Python peut manipuler une grande variété de formats de fichiers, particulièrement utiles dans l'écosystème numérique marocain :

formats_fichiers.py
# 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()

Prérequis pour suivre ce tutoriel

Pour tirer le meilleur parti de ce tutoriel sur la gestion des fichiers en Python, voici les connaissances et outils recommandés :

verification_prerequis.py
# 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()

Comprendre la fonction open() en Python

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.

Syntaxe de base de open()

La fonction open() prend deux paramètres principaux : le chemin du fichier et le mode d'ouverture. Voici sa syntaxe complète :

syntaxe_open.py
# 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")

Les différents modes d'ouverture (r, w, a, x)

Python propose plusieurs modes d'ouverture qui déterminent comment vous pouvez interagir avec le fichier. Chaque mode a des comportements spécifiques :

modes_ouverture.py
# 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)
					""")

Les modes binaires et texte

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é :

modes_binaires_texte.py
# 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
					""")

Le paramètre encoding pour les fichiers texte

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 :

encodage_fichiers.py
# 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:
					""")

Lire des fichiers texte avec Python

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.

Ouvrir et lire un fichier avec read()

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.

methode_read.py
# 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

Lire ligne par ligne avec readline()

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.

methode_readline.py
# 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()

Lire toutes les lignes avec readlines()

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.

methode_readlines.py
# 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

Parcourir un fichier avec une boucle for

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.

boucle_for_fichier.py
# 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

Écrire dans des fichiers texte

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.

Créer et écrire dans un fichier avec write()

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.

methode_write.py
# 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!")

Ajouter du contenu avec le mode append

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.py
# 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

Écrire plusieurs lignes avec writelines()

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.

methode_writelines.py
# 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")

Gérer 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.

retours_ligne.py
# 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

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.

Qu'est-ce qu'un gestionnaire de contexte

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.

gestionnaire_contexte.py
# 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é

Pourquoi utiliser with pour les fichiers

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_with.py
# 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)

Syntaxe et utilisation de with open()

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_with_open.py
# 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é")
					""")

Fermeture automatique des fichiers

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.py
# 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 !
					""")

Gestion des erreurs et exceptions

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.

Les erreurs courantes (FileNotFoundError, PermissionError)

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.

erreurs_courantes.py
# 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)
					""")

Utiliser try-except avec les fichiers

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.

try_except_fichiers.py
# 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")
					""")

Vérifier l'existence d'un fichier avant l'ouverture

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.

verification_existence.py
# 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
					""")

Bonnes pratiques de gestion d'erreurs

Une bonne gestion des erreurs suit des principes qui rendent le code plus robuste, maintenable et convivial pour les utilisateurs.

bonnes_pratiques.py
# 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
					""")
Contact

📚 Cours à distance

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

Appelez-maintenant
By Rachid Saad

Rejoignez notre communauté d'apprentissage à distance

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