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

Les chaînes de caractères en Python : manipulation et méthodes essentielles

Ce tutoriel vous permettra de maîtriser la manipulation des chaînes de caractères (strings) en Python, un type de données fondamental pour traiter du texte. Vous découvrirez comment créer, modifier et formater des strings, utiliser les méthodes les plus utiles comme split(), join(), strip() et replace(), ainsi que les techniques de découpage (slicing) et de formatage moderne avec les f-strings. À la fin de ce cours, vous serez capable de manipuler efficacement du texte dans vos programmes Python

Qu'est-ce qu'une chaîne de caractères en Python ?

En Python, une chaîne de caractères (string) est une séquence immuable de caractères Unicode utilisée pour représenter du texte. C'est l'un des types de données les plus fondamentaux et utilisés dans le langage.

Définition et création de strings

Une chaîne de caractères en Python est une séquence ordonnée de caractères entourée de guillemets. Elle peut contenir des lettres, chiffres, symboles et espaces.

definition_strings.py
# Création de chaînes de caractères simples
					ville = "Casablanca"
					prenom = 'Mehdi'
					nom_complet = "Fatima Zahra"
					
					# Chaîne vide
					chaine_vide = ""
					
					# Chaîne avec des chiffres - toujours de type string
					code_postal = "20000"
					telephone = "+212612345678"
					
					# Vérification du type
					print(f"Type de 'ville' : {type(ville)}")
					print(f"Type de 'code_postal' : {type(code_postal)}")
					
					# Caractéristiques importantes des strings
					print(f"La chaîne '{ville}' a {len(ville)} caractères")
					print(f"Est-ce que '{prenom}' est alphabétique ? {prenom.isalpha()}")
					print(f"Est-ce que '{code_postal}' est numérique ? {code_postal.isdigit()}")

Les guillemets simples, doubles et triples

Python offre trois types de guillemets pour créer des chaînes de caractères, chacun avec ses avantages spécifiques.

guillemets_strings.py
# Guillemets simples
					adresse_simple = 'Rue Mohammed V, Rabat'
					phrase_simple = 'C\\'est un beau jour à Marrakech'
					
					# Guillemets doubles
					adresse_double = "Avenue Hassan II, Casablanca"
					phrase_double = "Il a dit : \"Bienvenue au Maroc\""
					
					# Utilisation pratique : choisir selon le contenu
					nom_restaurant = "Le Café 'Maure' de Tanger"  # Guillemets doubles pour inclure des simples
					citation = 'Le roi a déclaré : "Le Maroc avance"'  # Guillemets simples pour inclure des doubles
					
					# Guillemets triples pour les chaînes multilignes
					description_maroc = """Le Royaume du Maroc
					est un pays magnifique situé
					au nord-ouest de l'Afrique.
					Sa capitale administrative est Rabat,
					et sa plus grande ville est Casablanca."""
					
					# Guillemets triples simples
					recette = '''Tajine marocain :
					- Poulet
					- Oignons
					- Épices (cumin, curcuma, safran)
					- Olives et citron confit'''
					
					# Affichage des résultats
					print("Adresse (simple) :", adresse_simple)
					print("Adresse (double) :", adresse_double)
					print("\nDescription du Maroc :")
					print(description_maroc)
					print("\nRecette :")
					print(recette)

Les caractères d'échappement

Les caractères d'échappement permettent d'inclure des caractères spéciaux dans les chaînes en utilisant la barre oblique inversée (\).

caracteres_echappement.py
# Caractères d'échappement courants
					chemin_fichier = "C:\\Users\\Karim\\Documents\\maroc.txt"  # \\ pour un backslash
					citation_echappee = "Il a dit : \\"Le Maroc est beau\\""  # \" pour guillemets doubles
					chemin_unix = "/home/ahmed/dossier\\nfichier"  # \n ignoré car pas d'échappement
					
					# Chaînes brutes (raw strings) avec r
					chemin_raw = r"C:\Users\Karim\Documents\maroc.txt"  # Les backslashes sont littéraux
					regex_telephone = r"+212\\d{9}"  # Utile pour les expressions régulières
					
					# Caractères spéciaux utiles
					adresse_multiligne = "Complexe Al Massira\\nBoulevard Mohammed VI\\n30000 Fès"
					menu_restaurant = "Couscous\\t45 DH\\nTajine\\t50 DH\\nPastilla\\t60 DH"
					message_alerte = "Attention !\\a"  # \\a pour alerte (bell)
					
					# Affichage des résultats
					print("Chemin avec échappement :", chemin_fichier)
					print("Chemin raw :", chemin_raw)
					print("\nAdresse multiligne :")
					print(adresse_multiligne)
					print("\nMenu restaurant :")
					print(menu_restaurant)
					
					# Comparaison démonstrative
					print("\\n" * 2)  # Deux sauts de ligne
					print("=== COMPARAISON ÉCHAPPEMENT vs RAW ===")
					texte_normal = "Ligne1\\nLigne2\\tTabulation"
					texte_raw = r"Ligne1\\nLigne2\\tTabulation"
					
					print("Normal (échappement interprété) :")
					print(texte_normal)
					
					print("\\nRaw (échappement littéral) :")
					print(texte_raw)
					
					# Exemple pratique avec données marocaines
					formulaire = """Formulaire d'inscription :
					Nom : Alaoui\\t\\tPrénom : Fatima
					Ville : Marrakech\\tTéléphone : +2126\\\\*\\\\*\\\\*\\\\*\\\\*\\\\*\\\\*\\\\*
					Message : \\"Bienvenue au Maroc !\\""""
					
					print("\\n" + "="*50)
					print(formulaire)

Accéder aux caractères d'une chaîne

En Python, les chaînes de caractères sont des séquences immuables, ce qui signifie que vous pouvez accéder à leurs caractères individuels et à leurs sous-parties, mais pas les modifier directement.

L'indexation en Python

L'indexation permet d'accéder à un caractère spécifique d'une chaîne en utilisant sa position (index). Les indices commencent à 0 pour le premier caractère.

indexation_strings.py
# Indexation positive (de gauche à droite)
					ville = "Casablanca"
					print("Chaîne complète :", ville)
					print(f"Premier caractère (index 0) : '{ville[0]}'")
					print(f"Deuxième caractère (index 1) : '{ville[1]}'")
					print(f"Dernier caractère (index 9) : '{ville[9]}'")
					
					# Indexation négative (de droite à gauche)
					prenom = "Mehdi"
					print(f"\\nChaîne : {prenom}")
					print(f"Dernier caractère (index -1) : '{prenom[-1]}'")
					print(f"Avant-dernier (index -2) : '{prenom[-2]}'")
					print(f"Premier caractère (index -5) : '{prenom[-5]}'")
					
					# Application pratique avec des données marocaines
					nom_complet = "Fatima Zahra Alaoui"
					telephone = "+212612345678"
					
					print("\\n=== APPLICATIONS PRATIQUES ===")
					print(f"Initiales de {nom_complet} : {nom_complet[0]}.{nom_complet[7]}.{nom_complet[13]}.")
					print(f"Indicatif pays du {telephone} : {telephone[0:4]}")
					print(f"Numéro local : {telephone[4:]}")
					
					# Gestion des erreurs d'indexation
					try:
					    print(f"\\nTentative d'accès à l'index 10 de '{ville}' : {ville[10]}")
					except IndexError as e:
					    print(f"Erreur : {e}")
					
					# Parcours avec une boucle
					print("\\nParcours caractère par caractère :")
					for i, caractere in enumerate(ville):
					    print(f"  Index {i} : '{caractere}'")

Le slicing (découpage) de chaînes

Le slicing permet d'extraire des sous-chaînes en spécifiant un intervalle d'indices avec la syntaxe [start:stop:step].

slicing_strings.py
# Slicing de base
					ville = "Marrakech"
					print(f"Chaîne originale : '{ville}'")
					print(f"Premiers 3 caractères [0:3] : '{ville[0:3]}'")
					print(f"Du 4ème au dernier [3:] : '{ville[3:]}'")
					print(f"Jusqu'au 6ème caractère [:6] : '{ville[:6]}'")
					print(f"Du 2ème au 7ème [2:7] : '{ville[2:7]}'")
					
					# Slicing avec indices négatifs
					nom_complet = "Mohammed Benali"
					print(f"\\nNom complet : '{nom_complet}'")
					print(f"Les 3 derniers caractères [-3:] : '{nom_complet[-3:]}'")
					print(f"Tous sauf les 3 derniers [:-3] : '{nom_complet[:-3]}'")
					print(f"Du 3ème avant la fin au dernier [-3:] : '{nom_complet[-3:]}'")
					
					# Slicing avec step (pas)
					adresse = "Avenue Mohammed V"
					print(f"\\nAdresse : '{adresse}'")
					print(f"Un caractère sur deux [::2] : '{adresse[::2]}'")
					print(f"Un caractère sur trois [::3] : '{adresse[::3]}'")
					print(f"Inverser la chaîne [::-1] : '{adresse[::-1]}'")
					
					# Cas pratiques marocains
					cin = "AB123456"
					date_naissance = "15/08/1990"
					code_ville = "50000"
					
					print("\\n=== APPLICATIONS PRATIQUES ===")
					print(f"CIN {cin} - Lettres : '{cin[:2]}', Chiffres : '{cin[2:]}'")
					print(f"Date {date_naissance} - Jour : '{date_naissance[:2]}', Mois : '{date_naissance[3:5]}', Année : '{date_naissance[6:]}'")
					print(f"Code postal {code_ville} - Région : '{code_ville[0]}', Ville : '{code_ville[1:3]}'")
					
					# Slicing avancé avec step négatif
					phrase = "Maroc"
					print(f"\\nSlicing avancé sur '{phrase}' :")
					print(f"  [4:1:-1] : '{phrase[4:1:-1]}'")
					print(f"  [::-2] : '{phrase[::-2]}'")
					print(f"  [3:0:-2] : '{phrase[3:0:-2]}'")

La longueur d'une chaîne avec len()

La fonction len() retourne le nombre de caractères dans une chaîne, ce qui est essentiel pour valider les données et éviter les erreurs d'indexation.

longueur_strings.py
# Utilisation basique de len()
					villes_maroc = ["Casablanca", "Rabat", "Fès", "Marrakech", "Tanger"]
					
					print("Longueur des noms de villes marocaines :")
					for ville in villes_maroc:
					    print(f"  '{ville}' : {len(ville)} caractères")
					
					# Validation de données avec len()
					print("\\n=== VALIDATION DE DONNÉES ===")
					
					def valider_telephone_maroc(telephone):
					    # Un numéro marocain doit avoir 13 caractères avec l'indicatif
					    if len(telephone) == 13 and telephone.startswith("+212"):
					        return True, "Numéro valide"
					    elif len(telephone) == 10 and telephone.startswith("0"):
					        return True, "Numéro valide (format local)"
					    else:
					        return False, "Format de numéro invalide"
					
					# Tests de validation
					numeros_test = ["+212612345678", "0612345678", "+21261234", "612345678"]
					
					for num in numeros_test:
					    est_valide, message = valider_telephone_maroc(num)
					    print(f"  {num} ({len(num)} caractères) : {message}")
					
					# Utilisation de len() avec indexation sécurisée
					print("\\n=== INDEXATION SÉCURISÉE ===")
					
					def extraire_sous_chaine_securise(chaine, debut, fin):
					    # S'assure que les indices sont dans les limites
					    longueur = len(chaine)
					    debut = max(0, min(debut, longueur))
					    fin = max(0, min(fin, longueur))
					    return chaine[debut:fin]
					
					noms_marocains = ["Amina", "Youssef", "Khadija", "Hassan"]
					
					for nom in noms_marocains:
					    # Essayer d'extraire les 3 premiers caractères, même si le nom est court
					    sous_chaine = extraire_sous_chaine_securise(nom, 0, 3)
					    print(f"  '{nom}' ({len(nom)} caractères) → 3 premiers : '{sous_chaine}'")
					
					# Application : formatage de texte avec longueur fixe
					print("\\n=== FORMATAGE AVEC LONGUEUR FIXE ===")
					
					produits = [
					    ("Couscous", "45 DH"),
					    ("Tajine poulet", "60 DH"),
					    ("Thé à la menthe", "15 DH"),
					    ("Pastilla", "75 DH")
					]
					
					print("Menu Restaurant Marocain :")
					print("-" * 30)
					for produit, prix in produits:
					    espace = " " * (20 - len(produit))  # Calcul des espaces pour aligner
					    print(f"{produit}{espace}{prix}")

Les opérations de base sur les chaînes

Python offre plusieurs opérations fondamentales pour manipuler les chaînes de caractères, permettant de combiner, répéter et rechercher du texte de manière intuitive et efficace.

La concaténation avec l'opérateur +

La concaténation permet d'assembler plusieurs chaînes de caractères en une seule en utilisant l'opérateur +. C'est l'équivalent de "coller" des morceaux de texte ensemble.

concatenation_strings.py
# Concaténation basique
					prenom = "Fatima"
					nom = "Zahra"
					nom_complet = prenom + " " + nom
					print("Nom complet :", nom_complet)
					
					# Concaténation avec différents éléments
					ville = "Casablanca"
					pays = "Maroc"
					adresse_complete = ville + ", " + pays
					print("Adresse :", adresse_complete)
					
					# Concaténation multiple
					message = "Bienvenue à " + ville + ", ville emblématique du " + pays
					print("Message :", message)
					
					# Application pratique : génération de profils utilisateurs
					print("\n=== PROFILS UTILISATEURS MAROCAINS ===")
					
					utilisateurs = [
					    ("Mehdi", "Alaoui", "Rabat"),
					    ("Khadija", "Benjelloun", "Fès"),
					    ("Youssef", "Amrani", "Marrakech")
					]
					
					for prenom, nom, ville in utilisateurs:
					    profil = "Nom: " + nom + " " + prenom + " | Ville: " + ville + " | Pays: Maroc"
					    print(profil)
					
					# Attention : la concaténation avec des types différents
					age = 25
					# profil_erreur = "Âge: " + age  # Erreur : TypeError
					profil_correct = "Âge: " + str(age)  # Conversion nécessaire
					print("\n" + profil_correct)
					
					# Concaténation avec accumulation
					ingredients = ["Poulet", "Oignons", "Épices", "Olives", "Citron"]
					recette_tajine = "Recette Tajine: "
					for i, ingredient in enumerate(ingredients):
					    if i == 0:
					        recette_tajine += ingredient
					    else:
					        recette_tajine += ", " + ingredient
					print("\n" + recette_tajine)

La répétition avec l'opérateur *

L'opérateur * permet de répéter une chaîne de caractères un nombre spécifié de fois, ce qui est utile pour créer des séparateurs, des motifs ou du contenu répétitif.

repetition_strings.py
# Répétition basique
					separateur = "-" * 20
					print("Séparateur :", separateur)
					
					applaudissements = "?" * 5
					print("Bravo ! " + applaudissements)
					
					# Application : création de motifs décoratifs
					motif_marocain = "ⵣ " * 10
					print("\nMotif décoratif marocain :")
					print(motif_marocain)
					
					# Utilisation pratique : génération de menus
					print("\n=== MENU RESTAURANT MAROCAIN ===")
					titre = " RESTAURANT CASA DELICE "
					bordures = "═" * (len(titre) + 4)
					print("╔" + bordures + "╗")
					print("║  " + titre + "  ║")
					print("╚" + bordures + "╝")
					
					# Répétition pour créer des progressions
					print("\nProgression du chargement :")
					for i in range(1, 6):
					    progression = "█" * i + "░" * (5 - i)
					    print(f"  {progression} {i*20}%")
					
					# Application créative : pyramide de caractères
					print("\nPyramide marocaine :")
					for i in range(1, 6):
					    espaces = " " * (6 - i)
					    etoiles = "★" * (2 * i - 1)
					    print(espaces + etoiles)
					
					# Répétition avec des chaînes complexes
					motif_berbere = "ⵀⵁ " * 8
					print("\nMotif berbère :")
					print(motif_berbere)
					
					# Attention : la répétition avec 0 ou nombres négatifs
					vide = "texte" * 0
					print(f"\nRépétition ×0 : '{vide}' (chaîne vide)")
					# negatif = "texte" * -1  # Erreur : retourne une chaîne vide

Vérifier la présence d'un texte avec 'in'

L'opérateur 'in' permet de vérifier si une sous-chaîne est présente dans une chaîne, retournant True si trouvée, False sinon. C'est essentiel pour la recherche et la validation de contenu.

recherche_in_strings.py
# Recherche basique avec 'in'
					texte = "Bienvenue au Maroc, pays de contrastes et de beauté"
					
					print("Texte :", texte)
					print(f"'Maroc' dans le texte ? {'Maroc' in texte}")
					print(f"'France' dans le texte ? {'France' in texte}")
					print(f"'MAROC' dans le texte ? {'MAROC' in texte}'")  # Sensible à la casse
					
					# Application pratique : validation de villes marocaines
					print("\n=== VALIDATION DE VILLES MAROCAINES ===")
					
					def est_ville_marocaine(ville):
					    villes_maroc = ["Casablanca", "Rabat", "Fès", "Marrakech", "Tanger", 
					                   "Agadir", "Meknès", "Oujda", "Tétouan", "Safi"]
					    return ville in villes_maroc
					
					villes_test = ["Casablanca", "Paris", "Marrakech", "Londres", "Fès"]
					
					for ville in villes_test:
					    print(f"  {ville:12} → Ville marocaine ? {est_ville_marocaine(ville)}")
					
					# Recherche dans des textes plus complexes
					print("\n=== ANALYSE DE TEXTES ===")
					
					descriptions = [
					    "Le tajine est un plat traditionnel marocain",
					    "Le couscous est originaire du Maghreb",
					    "La tour Eiffel se trouve à Paris",
					    "Marrakech est connue pour sa place Jemaa el-Fna"
					]
					
					mots_cles_maroc = ["maroc", "Marrakech", "tajine", "couscous", "Maghreb"]
					
					for desc in descriptions:
					    contient_maroc = any(mot in desc.lower() for mot in mots_cles_maroc)
					    print(f"  '{desc}'")
					    print(f"  → Relatif au Maroc ? {contient_maroc}\n")
					
					# Utilisation avec 'not in'
					print("=== VÉRIFICATION D'EXCLUSION ===")
					
					nom_utilisateur = "admin_maroc"
					caracteres_interdits = ["!", "@", "#", "$", " "]
					
					nom_valide = all(caractere not in nom_utilisateur for caractere in caracteres_interdits)
					print(f"Nom d'utilisateur '{nom_utilisateur}' valide ? {nom_valide}")
					
					# Application avancée : filtrage de produits
					print("\n=== FILTRAGE DE PRODUITS MAROCAINS ===")
					
					produits = [
					    "Tajine de poulet marocain",
					    "Huile d'olive de Fès",
					    "Thé vert de Chine",
					    "Couscous royal marocain",
					    "Fromage français",
					    "Miel de l'Atlas"
					]
					
					produits_marocains = [p for p in produits if "maroc" in p.lower() or "fès" in p.lower() or "atlas" in p.lower()]
					
					print("Produits marocains :")
					for produit in produits_marocains:
					    print(f"  ✓ {produit}")

Les méthodes essentielles de manipulation

Python fournit un riche ensemble de méthodes intégrées pour manipuler les chaînes de caractères. Ces méthodes permettent de transformer, nettoyer, rechercher et restructurer le texte de manière efficace.

Modifier la casse : upper(), lower(), capitalize()

Les méthodes de casse permettent de standardiser le formatage du texte, essentiel pour la validation des données et l'affichage cohérent.

methodes_casse.py
# Méthodes de base pour modifier la casse
					ville = "casablanca"
					nom = "MEHDI"
					phrase = "le maroc est un beau pays"
					
					print("=== TRANSFORMATIONS DE CASSE ===")
					print(f"Original: '{ville}' → upper(): '{ville.upper()}'")
					print(f"Original: '{nom}' → lower(): '{nom.lower()}'")
					print(f"Original: '{phrase}' → capitalize(): '{phrase.capitalize()}'")
					print(f"Original: '{phrase}' → title(): '{phrase.title()}'")
					
					# Application pratique : normalisation de données utilisateur
					print("\n=== NORMALISATION DE DONNÉES ===")
					
					saisies_utilisateurs = [
					    "  fatima zahra  ",
					    "mOhAmMeD",
					    "alAoui",
					    "bENJELLOUN"
					]
					
					print("Normalisation des noms marocains :")
					for saisie in saisies_utilisateurs:
					    nom_normalise = saisie.strip().title()
					    print(f"  '{saisie}' → '{nom_normalise}'")
					
					# Utilisation dans la validation
					print("\n=== VALIDATION INSENSIBLE À LA CASSE ===")
					
					def est_ville_marocaine(ville):
					    villes_maroc = ["casablanca", "rabat", "fès", "marrakech", "tanger"]
					    return ville.lower().strip() in villes_maroc
					
					tests_villes = ["Casablanca", "  RABAT  ", "Paris", "fÈs"]
					
					for ville_test in tests_villes:
					    print(f"  '{ville_test}' → Ville marocaine ? {est_ville_marocaine(ville_test)}")
					
					# Méthodes avancées de casse
					print("\n=== MÉTHODES AVANCÉES ===")
					
					texte_arabe = "المغرب"  # "Maroc" en arabe
					print(f"Texte arabe: '{texte_arabe}'")
					print(f"isupper(): {texte_arabe.isupper()}")
					print(f"islower(): {texte_arabe.islower()}")
					print(f"istitle(): {texte_arabe.istitle()}")

Nettoyer les espaces : strip(), lstrip(), rstrip()

Les méthodes de nettoyage suppriment les espaces superflus et autres caractères de ponctuation, cruciales pour le traitement des données utilisateur.

nettoyage_espaces.py
# Méthodes de nettoyage des espaces
					donnees_sales = [
					    "  Fatima Zahra  ",
					    "\tMohammed\n",
					    "   Casablanca   ",
					    "\n\nKhadija\r"
					]
					
					print("=== NETTOYAGE DES ESPACES ===")
					for donnee in donnees_sales:
					    print(f"Avant: '{donnee}'")
					    print(f"strip(): '{donnee.strip()}'")
					    print(f"lstrip(): '{donnee.lstrip()}'")
					    print(f"rstrip(): '{donnee.rstrip()}'\n")
					
					# Nettoyage avec caractères personnalisés
					print("=== NETTOYAGE AVANCÉ ===")
					
					numero_sale = "***+212612345678***"
					email_sale = "  contact@maroc.ma  "
					cin_sale = "AB123456!!"
					
					print(f"Numéro sale: '{numero_sale}'")
					print(f"strip('*'): '{numero_sale.strip('*')}'")
					print(f"Email sale: '{email_sale}'")
					print(f"strip(): '{email_sale.strip()}'")
					print(f"CIN sale: '{cin_sale}'")
					print(f"rstrip('!'): '{cin_sale.rstrip('!')}'")
					
					# Application pratique : nettoyage de données de formulaire
					print("\n=== NETTOYAGE DE FORMULAIRE ===")
					
					def nettoyer_formulaire(donnees):
					    return {
					        champ: valeur.strip() 
					        for champ, valeur in donnees.items()
					    }
					
					formulaire_sale = {
					    "nom": "  Alaoui  ",
					    "prenom": "  Mehdi  ",
					    "ville": "Casablanca   ",
					    "telephone": "  +212612345678  "
					}
					
					formulaire_propre = nettoyer_formulaire(formulaire_sale)
					print("Formulaire nettoyé :")
					for champ, valeur in formulaire_propre.items():
					    print(f"  {champ}: '{valeur}'")
					
					# Nettoyage de texte multiligne
					print("\n=== NETTOYAGE MULTILIGNE ===")
					
					description_sale = """
					    Le Maroc est un pays magnifique
					    avec une riche culture et histoire.
					    Ses villes comme Marrakech et Fès
					    attirent des touristes du monde entier.
					"""
					
					lignes_propres = [ligne.strip() for ligne in description_sale.split('\n') if ligne.strip()]
					description_propre = ' '.join(lignes_propres)
					
					print("Description nettoyée :")
					print(description_propre)

Rechercher et remplacer : find(), replace(), count()

Ces méthodes permettent de localiser, compter et remplacer du texte dans les chaînes, essentielles pour le traitement et la transformation de contenu.

recherche_remplacement.py
# Méthodes de recherche et remplacement
					texte = "Le Maroc est un pays du Maghreb. Le Maroc a une culture riche."
					
					print("=== RECHERCHE ET REMPLACEMENT ===")
					print(f"Texte: '{texte}'")
					print(f"find('Maroc'): {texte.find('Maroc')}")
					print(f"find('Maroc', 10): {texte.find('Maroc', 10)}")  # Recherche à partir de l'index 10
					print(f"find('France'): {texte.find('France')}'")  # Retourne -1 si non trouvé
					print(f"count('Maroc'): {texte.count('Maroc')}")
					print(f"count(' '): {texte.count(' ')}' (espaces)")
					print(f"replace('Maroc', 'Royaume du Maroc'): '{texte.replace('Maroc', 'Royaume du Maroc')}'")
					
					# Application pratique : correction automatique
					print("\n=== CORRECTION AUTOMATIQUE ===")
					
					def corriger_texte(texte):
					    corrections = {
					        "marroc": "maroc",
					        "casablanca": "Casablanca",
					        "rabat": "Rabat",
					        "  ": " "  # Double espace → simple espace
					    }
					    
					    texte_corrige = texte
					    for erreur, correction in corrections.items():
					        texte_corrige = texte_corrige.replace(erreur, correction)
					    
					    return texte_corrige
					
					texte_avec_erreurs = "Je vis à  casablanca  au marroc, près de rabat."
					texte_corrige = corriger_texte(texte_avec_erreurs)
					
					print(f"Original: '{texte_avec_erreurs}'")
					print(f"Corrigé:  '{texte_corrige}'")
					
					# Recherche avancée avec index() vs find()
					print("\n=== COMPARAISON find() vs index() ===")
					
					ville = "Marrakech"
					
					print(f"find('r'): {ville.find('r')}")
					print(f"index('r'): {ville.index('r')}")
					
					try:
					    position = ville.index('x')
					    print(f"index('x'): {position}")
					except ValueError as e:
					    print(f"index('x'): Erreur - {e}")
					
					print(f"find('x'): {ville.find('x')}' (retourne -1 sans erreur)")
					
					# Application : analyse de fréquence
					print("\n=== ANALYSE DE FRÉQUENCE ===")
					
					description = "Le Maroc a des montagnes, des déserts, des plages. Le Maroc est diversifié."
					mots_cles = ["Maroc", "montagnes", "déserts", "plages", "diversifié"]
					
					print("Fréquence des mots-clés :")
					for mot in mots_cles:
					    frequence = description.lower().count(mot.lower())
					    print(f"  '{mot}': {frequence} occurrence(s)")

Diviser et assembler : split() et join()

Ces méthodes complémentaires permettent de décomposer les chaînes en listes et de reconstruire des chaînes à partir de listes, fondamentales pour le traitement de données textuelles.

division_assemblage.py
# Méthodes split() et join()
					phrase = "Le Maroc est un pays magnifique"
					csv_data = "Mehdi,Alaoui,Casablanca,30"
					url = "www.maroc-tourisme.ma/ville/marrakech"
					
					print("=== DIVISION ET ASSEMBLAGE ===")
					print(f"Phrase: '{phrase}'")
					print(f"split(): {phrase.split()}")
					print(f"split(' '): {phrase.split(' ')}")
					print(f"Données CSV: '{csv_data}'")
					print(f"split(','): {csv_data.split(',')}")
					print(f"URL: '{url}'")
					print(f"split('/'): {url.split('/')}")
					
					# Reconstruction avec join()
					mots = phrase.split()
					print(f"\\nMots divisés: {mots}")
					print(f"join(' '): '{' '.join(mots)}'")
					print(f"join('-'): '{'-'.join(mots)}'")
					print(f"join(', '): '{', '.join(mots)}'")
					
					# Application pratique : traitement de données
					print("\n=== TRAITEMENT DE DONNÉES ===")
					
					donnees_utilisateurs = [
					    "Fatima Zahra|Alaoui|Casablanca|25",
					    "Mehdi|Benjelloun|Rabat|30",
					    "Khadija|Amrani|Fès|28"
					]
					
					print("Profils utilisateurs formatés :")
					for donnee in donnees_utilisateurs:
					    prenom, nom, ville, age = donnee.split('|')
					    profil_formate = f"{prenom} {nom} ({age} ans) - {ville}"
					    print(f"  {profil_formate}")
					
					# split() avec maxsplit
					print("\n=== SPLIT AVEC MAXSPLIT ===")
					
					chemin = "maroc/ville/casablanca/quartier/maarif"
					print(f"Chemin: '{chemin}'")
					print(f"split('/'): {chemin.split('/')}")
					print(f"split('/', 1): {chemin.split('/', 1)}")
					print(f"split('/', 2): {chemin.split('/', 2)}")
					
					# Application avancée : génération de HTML
					print("\n=== GÉNÉRATION DE HTML ===")
					
					mots_cles = ["Maroc", "tourisme", "voyage", "culture"]
					balises_meta = '<meta name="keywords" content="' + ', '.join(mots_cles) + '">'
					
					print("Balise meta générée :")
					print(balises_meta)
					
					# splitlines() pour le traitement multiligne
					print("\n=== TRAITEMENT MULTILIGNE ===")
					
					adresse_multiligne = """Rue Mohammed V
					Casablanca 20000
					Maroc"""
					
					lignes = adresse_multiligne.splitlines()
					print("Adresse ligne par ligne :")
					for i, ligne in enumerate(lignes, 1):
					    print(f"  Ligne {i}: '{ligne}'")
					
					adresse_ligne_unique = ' - '.join(lignes)
					print(f"\\nAdresse sur une ligne: '{adresse_ligne_unique}'")

Le formatage de chaînes en Python

Le formatage de chaînes permet d'insérer dynamiquement des valeurs dans du texte. Python offre trois méthodes principales, chacune avec ses avantages et cas d'usage spécifiques.

Les f-strings (méthode moderne)

Les f-strings (formatted string literals) sont la méthode la plus récente et recommandée pour le formatage en Python. Elles offrent une syntaxe concise et lisible introduite dans Python 3.6.

f_strings_maroc.py
# Syntaxe de base des f-strings
					prenom = "Fatima"
					nom = "Zahra"
					age = 25
					ville = "Casablanca"
					
					# Formatage simple
					message = f"Bonjour, je m'appelle {prenom} {nom}"
					print(message)
					
					# Expressions dans les f-strings
					description = f"Je suis {prenom} {nom}, j'ai {age} ans et je vis à {ville}."
					print(description)
					
					# Opérations mathématiques
					prix_tajine = 45
					quantite = 3
					total = f"Le tajine coûte {prix_tajine} DH. Pour {quantite} tajines : {prix_tajine * quantite} DH"
					print(total)
					
					# Application pratique : génération de profils
					print("\n=== PROFILS MAROCAINS ===")
					
					utilisateurs = [
					    {"prenom": "Mehdi", "nom": "Alaoui", "ville": "Rabat", "age": 30},
					    {"prenom": "Khadija", "nom": "Benjelloun", "ville": "Fès", "age": 28},
					    {"prenom": "Youssef", "nom": "Amrani", "ville": "Marrakech", "age": 35}
					]
					
					for user in utilisateurs:
					    profil = f"• {user['prenom']} {user['nom']} | {user['age']} ans | {user['ville']}"
					    print(profil)
					
					# Formatage avancé avec f-strings
					print("\n=== FORMATAGE AVANCÉ ===")
					
					temperature = 23.456789
					population = 37500000
					taux_croissance = 0.025
					
					# Formatage de nombres
					print(f"Température à Marrakech : {temperature:.1f}°C")  # 1 décimale
					print(f"Population du Maroc : {population:,}")  # Séparateurs de milliers
					print(f"Taux de croissance : {taux_croissance:.2%}")  # Pourcentage
					
					# Alignement et padding
					produits = [
					    ("Couscous", 45),
					    ("Tajine", 60),
					    ("Pastilla", 75),
					    ("Thé à la menthe", 15)
					]
					
					print("\nMenu Restaurant Marocain :")
					for produit, prix in produits:
					    print(f"  {produit:<15} : {prix:>5} DH")  # Alignement gauche et droite
					
					# Appels de méthodes dans les f-strings
					nom_complet = "mohammed alaoui"
					print(f"\nNom formaté : {nom_complet.title()}")
					print(f"En majuscules : {nom_complet.upper()}")

La méthode format()

La méthode format() est plus ancienne que les f-strings mais reste très utilisée. Elle offre une grande flexibilité avec différents styles de positionnement.

methode_format_maroc.py
# Méthode format() - différents styles
					prenom = "Karim"
					nom = "Amrani"
					ville = "Tanger"
					
					print("=== MÉTHODE FORMAT() ===")
					
					# Style positionnel
					message1 = "Je m'appelle {} {} et je vis à {}.".format(prenom, nom, ville)
					print("Positionnel :", message1)
					
					# Style avec indices
					message2 = "Ville : {2}, Prénom : {0}, Nom : {1}".format(prenom, nom, ville)
					print("Avec indices :", message2)
					
					# Style avec mots-clés
					message3 = "Bienvenue {prenom} {nom} de {ville}!".format(
					    prenom=prenom, nom=nom, ville=ville
					)
					print("Avec mots-clés :", message3)
					
					# Application : génération de fiches produits
					print("\n=== FICHES PRODUITS MAROCAINS ===")
					
					artisanat_marocain = [
					    {"produit": "Tapis berbère", "region": "Atlas", "prix": 1200, "stock": 5},
					    {"produit": "Poterie de Fès", "region": "Fès", "prix": 350, "stock": 12},
					    {"produit": "Lanterne marocaine", "region": "Marrakech", "prix": 280, "stock": 8}
					]
					
					for article in artisanat_marocain:
					    fiche = "Produit: {produit:<20} | Région: {region:<10} | Prix: {prix:>6} DH | Stock: {stock:>2}".format(
					        **article
					    )
					    print(fiche)
					
					# Formatage avancé avec format()
					print("\n=== FORMATAGE NUMÉRIQUE ===")
					
					superficie = 446550
					population = 37500000
					pib_par_habitant = 3250.75
					
					infos_maroc = """
					Statistiques du Maroc :
					• Superficie : {superficie:,} km²
					• Population : {population:,} habitants
					• PIB/habitant : {pib:.2f} USD
					• Densité : {densite:.1f} hab/km²
					""".format(
					    superficie=superficie,
					    population=population,
					    pib=pib_par_habitant,
					    densite=population / superficie
					)
					
					print(infos_maroc)
					
					# Formatage de dates et heures
					from datetime import datetime
					
					date_actuelle = datetime.now()
					evenement = "Festival des Roses"
					ville_evenement = "Kelaa M'Gouna"
					
					annonce = "Prochain {evenement} à {ville} le {date:%d/%m/%Y}".format(
					    evenement=evenement,
					    ville=ville_evenement,
					    date=date_actuelle
					)
					
					print(annonce)
					
					# Méthode format() avec dictionnaire
					print("\n=== FORMATAGE AVEC DICTIONNAIRE ===")
					
					client = {
					    "nom": "Belhaj",
					    "prenom": "Amina",
					    "telephone": "+212612345678",
					    "ville": "Agadir"
					}
					
					carte_visite = """
					CARTE DE VISITE
					---------------
					Nom : {nom}
					Prénom : {prenom}
					Téléphone : {telephone}
					Ville : {ville}
					---------------
					""".format(**client)
					
					print(carte_visite)

L'ancienne méthode avec %

La méthode avec l'opérateur % est la plus ancienne et est inspirée du langage C. Bien que dépréciée pour les nouveaux projets, elle reste présente dans du code legacy.

methode_pourcent_maroc.py
# Méthode avec opérateur %
					prenom = "Hassan"
					nom = "El Fassi"
					age = 40
					ville = "Meknès"
					
					print("=== MÉTHODE AVEC % ===")
					
					# Formatage basique
					message1 = "Je m'appelle %s %s" % (prenom, nom)
					print("Basique :", message1)
					
					# Formatage avec plusieurs variables
					message2 = "Nom: %s, Prénom: %s, Âge: %d, Ville: %s" % (nom, prenom, age, ville)
					print("Multiple :", message2)
					
					# Formatage avec dictionnaire
					message3 = "Bonjour %(prenom)s %(nom)s de %(ville)s!" % {
					    "prenom": prenom,
					    "nom": nom,
					    "ville": ville
					}
					print("Avec dict :", message3)
					
					# Application : système de facturation ancien
					print("\n=== SYSTÈME DE FACTURATION ===")
					
					facture_template = """
					FACTURE N° %s
					Client: %s
					Date: %s
					Montant: %.2f DH
					TVA: %.1f%%
					Total TTC: %.2f DH
					"""
					
					numero_facture = "FAC-2024-001"
					client = "Restaurant Dar Tajine"
					date = "15/03/2024"
					montant_ht = 1250.50
					tva_taux = 20.0
					montant_ttc = montant_ht * (1 + tva_taux / 100)
					
					facture = facture_template % (numero_facture, client, date, montant_ht, tva_taux, montant_ttc)
					print(facture)
					
					# Spécificateurs de format courants
					print("=== SPÉCIFICATEURS DE FORMAT ===")
					
					temperature = 23.567
					population = 850000
					taux_remplissage = 0.756
					
					print("Température à Oujda : %.1f°C" % temperature)
					print("Population de Safi : %d habitants" % population)
					print("Taux de remplissage : %.1f%%" % (taux_remplissage * 100))
					print("Notation scientifique : %.2e" % population)
					
					# Comparaison des trois méthodes
					print("\n=== COMPARAISON DES MÉTHODES ===")
					
					produit = "Couscous"
					prix = 45.5
					quantite = 3
					
					# Méthode % (ancienne)
					message_pourcent = "%d %s coûtent %.2f DH" % (quantite, produit, prix * quantite)
					
					# Méthode format()
					message_format = "{} {} coûtent {:.2f} DH".format(quantite, produit, prix * quantite)
					
					# Méthode f-string (moderne)
					message_fstring = f"{quantite} {produit} coûtent {prix * quantite:.2f} DH"
					
					print("Avec %    :", message_pourcent)
					print("Avec format :", message_format)
					print("Avec f-string:", message_fstring)
					
					# Recommandations
					print("\n=== RECOMMANDATIONS ===")
					print("• F-strings : Méthode recommandée (Python 3.6+)")
					print("• format()  : Bonne alternative, très flexible")
					print("• %         : À éviter dans les nouveaux projets")

Exercices pratiques et cas d'usage

Ces exercices pratiques vous permettront de consolider vos connaissances sur les chaînes de caractères en Python à travers des cas concrets inspirés de situations réelles au Maroc.

Nettoyer une saisie utilisateur

Le nettoyage des saisies utilisateur est essentiel pour garantir la qualité des données. Cet exercice montre comment normaliser différents types d'informations typiquement marocaines.

nettoyage_saisie_maroc.py
# Fonctions de nettoyage pour données marocaines
					def nettoyer_nom(nom):
					    """Nettoie et formate un nom marocain"""
					    return nom.strip().title()
					
					def nettoyer_telephone(telephone):
					    """Nettoie et standardise un numéro de téléphone marocain"""
					    tel_propre = telephone.strip().replace(" ", "").replace("-", "").replace(".", "")
					    
					    # Conversion des formats locaux vers format international
					    if tel_propre.startswith("0") and len(tel_propre) == 10:
					        return "+212" + tel_propre[1:]
					    elif tel_propre.startswith("212") and len(tel_propre) == 12:
					        return "+" + tel_propre
					    elif tel_propre.startswith("+212") and len(tel_propre) == 13:
					        return tel_propre
					    else:
					        return None  # Format invalide
					
					def nettoyer_ville(ville):
					    """Nettoie et valide une ville marocaine"""
					    villes_maroc = {
					        "casablanca", "rabat", "fes", "marrakech", "tanger",
					        "agadir", "meknes", "oujda", "tetouan", "safi",
					        "kenitra", "eljadida", "nador", "settat", "berrechid"
					    }
					    
					    ville_propre = ville.strip().lower()
					    if ville_propre in villes_maroc:
					        return ville_propre.title()
					    else:
					        return None  # Ville non reconnue
					
					# Test des fonctions de nettoyage
					print("=== NETTOYAGE DE SAISIES UTILISATEUR ===")
					
					saisies_test = [
					    {
					        "nom": "  fatima zahra  ",
					        "telephone": "06 12 34 56 78",
					        "ville": "CASABLANCA"
					    },
					    {
					        "nom": "mehdi  ",
					        "telephone": "+212-612-345-678",
					        "ville": "  rabat  "
					    },
					    {
					        "nom": "khadija benjelloun",
					        "telephone": "00212612345678",
					        "ville": "paris"  # Ville non marocaine
					    }
					]
					
					for i, saisie in enumerate(saisies_test, 1):
					    print(f"\n--- Utilisateur {i} ---")
					    print(f"Original: Nom='{saisie['nom']}', Tél='{saisie['telephone']}', Ville='{saisie['ville']}'")
					    
					    nom_propre = nettoyer_nom(saisie['nom'])
					    tel_propre = nettoyer_telephone(saisie['telephone'])
					    ville_propre = nettoyer_ville(saisie['ville'])
					    
					    print(f"Nettoyé:  Nom='{nom_propre}', Tél='{tel_propre}', Ville='{ville_propre}'")
					    
					    # Validation des résultats
					    erreurs = []
					    if tel_propre is None:
					        erreurs.append("Numéro de téléphone invalide")
					    if ville_propre is None:
					        erreurs.append("Ville non reconnue au Maroc")
					    
					    if erreurs:
					        print(f"⚠️  Erreurs: {', '.join(erreurs)}")
					    else:
					        print("✅ Données valides")
					
					# Fonction utilitaire pour nettoyer un formulaire complet
					def nettoyer_formulaire_marocain(formulaire):
					    """Nettoie un formulaire complet avec données marocaines"""
					    resultat = {}
					    
					    # Nettoyage des champs
					    resultat['nom_complet'] = nettoyer_nom(formulaire.get('nom_complet', ''))
					    resultat['telephone'] = nettoyer_telephone(formulaire.get('telephone', ''))
					    resultat['ville'] = nettoyer_ville(formulaire.get('ville', ''))
					    resultat['email'] = formulaire.get('email', '').strip().lower()
					    
					    # Validation
					    resultat['valide'] = all([
					        resultat['nom_complet'],
					        resultat['telephone'],
					        resultat['ville'],
					        '@' in resultat['email']
					    ])
					    
					    return resultat
					
					# Test du nettoyage de formulaire
					formulaire_test = {
					    'nom_complet': '  karim alaoui  ',
					    'telephone': '0612345678',
					    'ville': 'marrakech',
					    'email': '  KARIM.ALAOUI@GMAIL.COM  '
					}
					
					resultat = nettoyer_formulaire_marocain(formulaire_test)
					print(f"\n=== RÉSULTAT NETTOYAGE FORMULAIRE ===")
					for champ, valeur in resultat.items():
					    print(f"{champ:<15}: {valeur}")

Créer un générateur de messages personnalisés

Cet exercice montre comment créer un système de génération de messages personnalisés pour différentes situations courantes au Maroc.

generateur_messages_maroc.py
# Générateur de messages personnalisés pour contexte marocain
					class GenerateurMessagesMaroc:
					    def __init__(self):
					        self.templates = {
					            "bienvenue": [
					                "Ahlan wa sahlan {prenom} ! Bienvenue à {ville}, la perle du Maroc.",
					                "Marhaba {prenom} ! Heureux de vous accueillir dans notre belle ville de {ville}.",
					                "Bienvenue {prenom} à {ville} ! Que votre séjour soit rempli de découvertes."
					            ],
					            "reservation": [
					                "Cher {prenom}, votre réservation à l'hôtel {hotel} de {ville} est confirmée.",
					                "Madame/Monsieur {nom}, nous confirmons votre séjour du {date} à {hotel}.",
					                "Réservation validée pour {prenom} {nom} à l'hôtel {hotel}, {ville}."
					            ],
					            "festival": [
					                "Ne manquez pas le {festival} à {ville} ! Du {date_debut} au {date_fin}.",
					                "Venez célébrer le {festival} dans la magnifique ville de {ville}.",
					                "Festival {festival} à {ville} : une expérience culturelle unique !"
					            ],
					            "commande": [
					                "Merci {prenom} pour votre commande de {produit}. Livraison prévue à {ville}.",
					                "Commande #{numero} confirmée pour {prenom} {nom}. Produit: {produit}.",
					                "Votre {produit} sera livré à {adresse}, {ville}. Merci {prenom} !"
					            ]
					        }
					    
					    def generer_message(self, type_message, **kwargs):
					        """Génère un message personnalisé selon le type"""
					        if type_message not in self.templates:
					            return "Type de message non reconnu"
					        
					        # Sélection aléatoire d'un template
					        import random
					        template = random.choice(self.templates[type_message])
					        
					        # Remplacement des variables
					        try:
					            message = template.format(**kwargs)
					            return message
					        except KeyError as e:
					            return f"Variable manquante: {e}"
					
					    def generer_carte_visite(self, nom, prenom, poste, entreprise, telephone, ville):
					        """Génère une carte de visite formatée"""
					        carte = f"""
					        ╔══════════════════════════════╗
					        ║         CARTE DE VISITE      ║
					        ╠══════════════════════════════╣
					        ║ {prenom} {nom:<20} ║
					        ║ {poste:<26} ║
					        ║                              ║
					        ║ {entreprise:<26} ║
					        ║ {ville:<26} ║
					        ║ {telephone:<26} ║
					        ╚══════════════════════════════╝
					        """
					        return carte
					
					# Utilisation du générateur
					generateur = GenerateurMessagesMaroc()
					
					print("=== GÉNÉRATEUR DE MESSAGES PERSONNALISÉS ===")
					
					# Messages de bienvenue
					print("\n--- Messages de bienvenue ---")
					for i in range(3):
					    message = generateur.generer_message(
					        "bienvenue",
					        prenom="Fatima",
					        ville="Marrakech"
					    )
					    print(f"{i+1}. {message}")
					
					# Messages de réservation
					print("\n--- Messages de réservation ---")
					reservations = [
					    {"prenom": "Mehdi", "nom": "Alaoui", "hotel": "La Mamounia", "ville": "Marrakech", "date": "15/04/2024"},
					    {"prenom": "Khadija", "nom": "Benjelloun", "hotel": "Sofitel", "ville": "Rabat", "date": "20/04/2024"}
					]
					
					for reservation in reservations:
					    message = generateur.generer_message("reservation", **reservation)
					    print(f"• {message}")
					
					# Messages de festivals
					print("\n--- Annonces de festivals ---")
					festivals = [
					    {"festival": "Festival des Roses", "ville": "Kelaa M'Gouna", "date_debut": "01/05/2024", "date_fin": "05/05/2024"},
					    {"festival": "Festival des Musiques Sacrées", "ville": "Fès", "date_debut": "25/05/2024", "date_fin": "02/06/2024"}
					]
					
					for festival in festivals:
					    message = generateur.generer_message("festival", **festival)
					    print(f"? {message}")
					
					# Génération de carte de visite
					print("\n--- Cartes de visite ---")
					carte = generateur.generer_carte_visite(
					    nom="Amrani",
					    prenom="Youssef",
					    poste="Directeur Commercial",
					    entreprise="Maroc Telecom",
					    telephone="+212 612 345 678",
					    ville="Casablanca"
					)
					print(carte)
					
					# Génération en batch
					print("\n--- Génération en batch ---")
					commandes = [
					    {"type": "commande", "prenom": "Ali", "produit": "Tapis berbère", "ville": "Fès", "numero": "CMD-001"},
					    {"type": "commande", "prenom": "Nadia", "produit": "Poterie bleue", "ville": "Safi", "adresse": "Rue Mohammed V"}
					]
					
					for commande in commandes:
					    type_msg = commande.pop("type")
					    message = generateur.generer_message(type_msg, **commande)
					    print(f"? {message}")

Analyser une phrase (compter mots et lettres)

Cet exercice montre comment analyser du texte pour en extraire des statistiques utiles, avec des applications pratiques dans le contexte marocain.

analyse_texte_maroc.py
# Analyseur de texte avec contexte marocain
					class AnalyseurTexteMaroc:
					    def __init__(self):
					        self.villes_maroc = {
					            "casablanca", "rabat", "fès", "fes", "marrakech", "tanger",
					            "agadir", "meknès", "meknes", "oujda", "tétouan", "tetouan",
					            "safi", "kenitra", "eljadida", "nador", "settat", "berrechid"
					        }
					        
					        self.mots_cles_maroc = {
					            "maroc", "marocaine", "marocain", "maghreb", "atlas",
					            "sahara", "couscous", "tajine", "menthe", "thé",
					            "sultan", "roi", "islam", "arabe", "berbère", "amazigh"
					        }
					    
					    def analyser_phrase(self, phrase):
					        """Analyse complète d'une phrase"""
					        # Nettoyage de la phrase
					        phrase_propre = phrase.strip().lower()
					        
					        # Statistiques de base
					        mots = phrase_propre.split()
					        nombre_mots = len(mots)
					        nombre_caracteres = len(phrase_propre.replace(" ", ""))
					        nombre_phrases = phrase.count('.') + phrase.count('!') + phrase.count('?')
					        
					        # Analyse des mots
					        mots_uniques = set(mots)
					        mots_longueur = [len(mot) for mot in mots]
					        mot_plus_long = max(mots, key=len) if mots else ""
					        mot_plus_court = min(mots, key=len) if mots else ""
					        
					        # Détection du contexte marocain
					        villes_trouvees = [mot.title() for mot in mots if mot in self.villes_maroc]
					        mots_cles_trouves = [mot for mot in mots if mot in self.mots_cles_maroc]
					        
					        # Fréquence des lettres
					        frequence_lettres = {}
					        for lettre in phrase_propre:
					            if lettre.isalpha():
					                frequence_lettres[lettre] = frequence_lettres.get(lettre, 0) + 1
					        
					        # Résultats
					        resultat = {
					            "phrase_originale": phrase,
					            "statistiques": {
					                "mots_total": nombre_mots,
					                "mots_uniques": len(mots_uniques),
					                "caracteres": nombre_caracteres,
					                "phrases": nombre_phrases,
					                "longueur_moyenne_mot": sum(mots_longueur) / len(mots_longueur) if mots_longueur else 0,
					                "mot_plus_long": mot_plus_long,
					                "mot_plus_court": mot_plus_court
					            },
					            "contexte_marocain": {
					                "villes": villes_trouvees,
					                "mots_cles": mots_cles_trouves,
					                "est_lie_au_maroc": len(villes_trouvees) > 0 or len(mots_cles_trouves) > 0
					            },
					            "frequence_lettres": dict(sorted(frequence_lettres.items(), key=lambda x: x[1], reverse=True))
					        }
					        
					        return resultat
					    
					    def generer_rapport(self, analyse):
					        """Génère un rapport détaillé de l'analyse"""
					        stats = analyse["statistiques"]
					        contexte = analyse["contexte_marocain"]
					        
					        rapport = f"""
					? RAPPORT D'ANALYSE DE TEXTE
					{'=' * 40}
					Phrase analysée : "{analyse['phrase_originale']}"
					
					STATISTIQUES GÉNÉRALES
					• Mots total : {stats['mots_total']}
					• Mots uniques : {stats['mots_uniques']}
					• Caractères (sans espaces) : {stats['caracteres']}
					• Phrases détectées : {stats['phrases']}
					• Longueur moyenne des mots : {stats['longueur_moyenne_mot']:.1f} caractères
					• Mot le plus long : "{stats['mot_plus_long']}"
					• Mot le plus court : "{stats['mot_plus_court']}"
					
					CONTEXTE MAROCAIN
					• Lié au Maroc : {'✅ OUI' if contexte['est_lie_au_maroc'] else '❌ NON'}
					• Villes mentionnées : {', '.join(contexte['villes']) if contexte['villes'] else 'Aucune'}
					• Mots-clés marocains : {', '.join(contexte['mots_cles']) if contexte['mots_cles'] else 'Aucun'}
					
					FRÉQUENCE DES LETTRES (Top 5)
					"""
					        
					        # Ajout des lettres les plus fréquentes
					        top_lettres = list(analyse["frequence_lettres"].items())[:5]
					        for lettre, count in top_lettres:
					            rapport += f"• '{lettre}' : {count} occurrence(s)\n"
					        
					        return rapport
					
					# Utilisation de l'analyseur
					analyseur = AnalyseurTexteMaroc()
					
					print("=== ANALYSE DE PHRASES MAROCAINES ===")
					
					# Phrases de test
					phrases_test = [
					    "Le Maroc est un pays magnifique avec des villes comme Casablanca, Rabat et Marrakech.",
					    "J'adore le couscous et le tajine, plats traditionnels marocains.",
					    "Paris est la capitale de la France, une belle ville européenne.",
					    "Le festival de Fès attire des visiteurs du monde entier chaque année!",
					    "Les montagnes de l'Atlas et le désert du Sahara sont des trésors naturels du Maroc."
					]
					
					for i, phrase in enumerate(phrases_test, 1):
					    print(f"\n{'#' * 50}")
					    print(f"ANALYSE {i}")
					    print(f"{'#' * 50}")
					    
					    analyse = analyseur.analyser_phrase(phrase)
					    rapport = analyseur.generer_rapport(analyse)
					    print(rapport)
					
					# Analyse comparative
					print("\n=== ANALYSE COMPARATIVE ===")
					
					textes_comparaison = [
					    "Casablanca économique business finance",
					    "Marrakech tourisme souk médina artisanat",
					    "Fès culture histoire université spiritualité"
					]
					
					print("Comparaison des textes par ville :")
					for texte in textes_comparaison:
					    analyse = analyseur.analyser_phrase(texte)
					    stats = analyse["statistiques"]
					    print(f"\n{texte}:")
					    print(f"  • Mots: {stats['mots_total']}, Caractères: {stats['caracteres']}")
					    print(f"  • Longueur moyenne: {stats['longueur_moyenne_mot']:.1f}")
					    print(f"  • Mot le plus long: '{stats['mot_plus_long']}'")
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!