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
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.
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.
# 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()}")
Python offre trois types de guillemets pour créer des chaînes de caractères, chacun avec ses avantages spécifiques.
# 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 permettent d'inclure des caractères spéciaux dans les chaînes en utilisant la barre oblique inversée (\).
# 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)
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 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 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 permet d'extraire des sous-chaînes en spécifiant un intervalle d'indices avec la syntaxe [start:stop:step].
# 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 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.
# 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}")
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 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.
# 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)
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.
# 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
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 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}")
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.
Les méthodes de casse permettent de standardiser le formatage du texte, essentiel pour la validation des données et l'affichage cohérent.
# 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()}")
Les méthodes de nettoyage suppriment les espaces superflus et autres caractères de ponctuation, cruciales pour le traitement des données utilisateur.
# 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)
Ces méthodes permettent de localiser, compter et remplacer du texte dans les chaînes, essentielles pour le traitement et la transformation de contenu.
# 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)")
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.
# 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 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 (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.
# 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() est plus ancienne que les f-strings mais reste très utilisée. Elle offre une grande flexibilité avec différents styles de positionnement.
# 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)
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.
# 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")
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.
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.
# 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}")
Cet exercice montre comment créer un système de génération de messages personnalisés pour différentes situations courantes au Maroc.
# 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}")
Cet exercice montre comment analyser du texte pour en extraire des statistiques utiles, avec des applications pratiques dans le contexte marocain.
# 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']}'")
Apprends à coder en Python, Java, C/C++
avec des cours à distance via Google Meet.
Explorez nos cours à distance. Commencez votre apprentissage dès aujourd'hui!