Ce chapitre vous apprendra à manipuler efficacement les chaînes de caractères, élément fondamental de tout programme Python. Vous découvrirez les méthodes de formatage, les techniques de recherche et remplacement, ainsi que les expressions régulières. Ces compétences vous permettront de traiter et transformer du texte avec précision dans vos applications.
Les chaînes de caractères (strings) sont un type de données fondamental en Python qui permettent de représenter et manipuler du texte. Elles sont immutables et offrent une riche panoplie de méthodes pour les traiter.
Une chaîne de caractères est une séquence ordonnée de caractères. En Python, les chaînes sont des objets qui appartiennent à la classe str et sont immutables (non modifiables après création).
# Une chaîne de caractères est une séquence de caractères chaine = "Bonjour le monde" # Type de la variable print(type(chaine)) ## Les chaînes sont des séquences, on peut itérer dessus for caractere in "Python": print(caractere) # Output: # P # y # t # h # o # n
Il existe plusieurs façons de créer des chaînes de caractères en Python. La plus simple est d'utiliser des guillemets simples ou doubles.
# Création avec des guillemets simples chaine1 = 'Hello' # Création avec des guillemets doubles chaine2 = "World" # Chaîne vide chaine_vide = "" print("Chaîne vide:", chaine_vide, "Longueur:", len(chaine_vide)) # Conversion d'autres types en chaîne nombre = 42 chaine_nombre = str(nombre) print("Nombre en chaîne:", chaine_nombre, "Type:", type(chaine_nombre)) # Utilisation du constructeur str() chaine_constructeur = str(3.14) print("Avec constructeur:", chaine_constructeur)
Python supporte différents types de guillemets pour définir des chaînes de caractères, chacun avec ses particularités.
# Guillemets simples - pratique pour les chaînes contenant des doubles quotes chaine_simple = 'Il a dit "Bonjour"' print(chaine_simple) # Guillemets doubles - pratique pour les chaînes contenant des apostrophes chaine_double = "C'est l'heure du Python" print(chaine_double) # Guillemets triples (simples ou doubles) - pour les chaînes multilignes chaine_multiligne = """Ceci est une chaîne qui s'étend sur plusieurs lignes""" print(chaine_multiligne) # Guillemets triples pour les docstrings (documentation de fonctions) def ma_fonction(): """Ceci est une docstring. Elle décrit ce que fait la fonction. """ return 42 # Utilisation d'échappement pour inclure des guillemets chaine_echappee = "Il a dit \"C'est générique\"" print(chaine_echappee) # Alternative sans échappement chaine_alternative = 'Il a dit "C' + "'" + 'est générique"' print(chaine_alternative)
Les chaînes de caractères en Python possèdent plusieurs propriétés essentielles qui déterminent leur comportement et leur utilisation. Comprendre ces propriétés est crucial pour manipuler efficacement le texte en Python.
Les chaînes de caractères en Python sont immutables, ce qui signifie qu'elles ne peuvent pas être modifiées après leur création. Toute opération qui semble modifier une chaîne crée en réalité une nouvelle chaîne.
# Démonstration de l'immutabilité des chaînes chaine = "Python" # Tentative de modification directe (provoque une erreur) # chaine[0] = "J" # TypeError: 'str' object does not support item assignment # Pour "modifier" une chaîne, on doit créer une nouvelle chaîne nouvelle_chaine = "J" + chaine[1:] print("Originale:", chaine) # Python print("Modifiée:", nouvelle_chaine) # Jython # Vérification que l'identité mémoire a changé print("Même objet?", chaine is nouvelle_chaine) # False # Les méthodes de chaînes retournent de nouvelles chaînes chaine_maj = chaine.upper() print("Originale:", chaine) # Python print("En majuscules:", chaine_maj) # PYTHON # Conséquence sur la performance # La concaténation répétée dans une boucle est inefficace resultat = "" for i in range(1000): resultat += str(i) # Crée une nouvelle chaîne à chaque itération # Alternative plus efficace avec une liste parties = [] for i in range(1000): parties.append(str(i)) resultat = "".join(parties) # Une seule création de chaîne
Les chaînes de caractères sont des séquences ordonnées, ce qui permet d'accéder à leurs caractères individuels par leur position (index). L'indexation commence à 0 pour le premier caractère.
# Indexation positive (de gauche à droite) chaine = "Python" print("Premier caractère:", chaine[0]) # P print("Deuxième caractère:", chaine[1]) # y print("Troisième caractère:", chaine[2]) # t print("Dernier caractère:", chaine[5]) # n # Indexation négative (de droite à gauche) print("Dernier caractère:", chaine[-1]) # n print("Avant-dernier:", chaine[-2]) # o print("Premier caractère:", chaine[-6]) # P # Tentative d'accès hors limites try: print(chaine[10]) # IndexError: string index out of range except IndexError as e: print("Erreur:", e) # Parcours d'une chaîne caractère par caractère print("Parcours avec for:") for caractere in chaine: print(caractere, end=" ") # P y t h o n print("\nParcours avec index:") for i in range(len(chaine)): print(f"chaine[{i}] = {chaine[i]}") # Vérification d'appartenance print("'P' dans chaine:", 'P' in chaine) # True print("'z' dans chaine:", 'z' in chaine) # False print("'thon' dans chaine:", 'thon' in chaine) # True
La fonction intégrée len() permet de déterminer le nombre de caractères contenus dans une chaîne. C'est une opération très courante et rapide en Python.
# Utilisation de len() avec différentes chaînes chaine_vide = "" chaine_simple = "Hello" chaine_espaces = " " chaine_speciale = "Café" # Caractères accentués chaine_emoji = "Python ?" # Avec emoji print(f"'{chaine_vide}' a une longueur de {len(chaine_vide)}") # 0 print(f"'{chaine_simple}' a une longueur de {len(chaine_simple)}") # 5 print(f"'{chaine_espaces}' a une longueur de {len(chaine_espaces)}") # 3 print(f"'{chaine_speciale}' a une longueur de {len(chaine_speciale)}") # 4 print(f"'{chaine_emoji}' a une longueur de {len(chaine_emoji)}") # 8 (7 caractères + 1 emoji) # Applications pratiques de len() mot_de_passe = "secret123" # Validation de longueur if len(mot_de_passe) < 8: print("Le mot de passe est trop court") else: print("Longueur de mot de passe acceptable") # Parcours sécurisé avec connaissance de la longueur texte = "Bonjour" for i in range(len(texte)): print(f"Caractère à l'index {i}: {texte[i]}") # Comparaison de longueurs chaine1 = "court" chaine2 = "beaucoup plus long" if len(chaine1) > len(chaine2): print(f"'{chaine1}' est plus long que '{chaine2}'") else: print(f"'{chaine2}' est plus long que '{chaine1}'") # Attention: len() compte les caractères, pas les mots phrase = "Python est génial" print(f"'{phrase}' a {len(phrase)} caractères et {len(phrase.split())} mots")
Les opérations de base sur les chaînes de caractères incluent la concaténation (assemblage), la répétition et la comparaison. Ces opérations fondamentales sont essentielles pour manipuler efficacement le texte en Python.
La concaténation est l'opération qui consiste à assembler plusieurs chaînes de caractères en une seule. En Python, on peut utiliser l'opérateur + ou la méthode join().
# Concaténation avec l'opérateur + prenom = "Jean" nom = "Dupont" nom_complet = prenom + " " + nom print(nom_complet) # Jean Dupont # Concaténation avec des littéraux message = "Bonjour " + prenom + ", comment allez-vous?" print(message) # Bonjour Jean, comment allez-vous? # Concaténation avec des variables de différents types age = 25 info = prenom + " a " + str(age) + " ans" print(info) # Jean a 25 ans # Concaténation avec la méthode join() (plus efficace pour plusieurs chaînes) mots = ["Python", "est", "un", "langage", "puissant"] phrase = " ".join(mots) print(phrase) # Python est un langage puissant # Join avec un séparateur différent chemin = "/".join(["dossier", "sous-dossier", "fichier.txt"]) print(chemin) # dossier/sous-dossier/fichier.txt # Attention: l'opérateur + crée une nouvelle chaîne à chaque utilisation # Ce qui peut être inefficace pour de nombreuses concaténations resultat = "" for i in range(10): resultat += str(i) # Peu efficace pour de grandes boucles print(resultat) # 0123456789 # Méthode plus efficace avec une liste et join() parties = [] for i in range(10): partes.append(str(i)) resultat = "".join(parties) # Beaucoup plus efficace print(resultat) # 0123456789
L'opérateur * permet de répéter une chaîne de caractères un certain nombre de fois. C'est utile pour créer des séparateurs, des motifs ou des chaînes de remplissage.
# Répétition simple avec l'opérateur * separateur = "-" * 20 print(separateur) # -------------------- # Création de motifs motif = "*-" * 10 print(motif) # *-*-*-*-*-*-*-*-*-*- # Répétition de séquences plus complexes applaudissements = "?" * 5 print(applaudissements) # ????? # Utilisation pratique pour l'alignement de texte titre = "RAPPORT" largeur = 30 espaces_avant = " " * ((largeur - len(titre)) // 2) ligne = espaces_avant + titre print(ligne) # Création d'une bordure bordure = "#" * largeur print(bordure) print(ligne) print(bordure) # Répétition avec 0 ou nombre négatif vide = "abc" * 0 print("Chaîne vide:", vide, "Longueur:", len(vide)) # Chaîne vide: Longueur: 0 # La répétition avec un nombre négatif retourne une chaîne vide vide_neg = "abc" * -5 print("Répétition négative:", vide_neg, "Longueur:", len(vide_neg)) # Longueur: 0 # Combinaison de concaténation et répétition indentation = " " * 3 + "→ " texte = "élément de liste" print(indentation + texte) # → élément de liste
Python permet de comparer des chaînes de caractères à l'aide des opérateurs de comparaison standards. Les comparaisons sont effectuées caractère par caractère selon l'ordre lexicographique (ordre du dictionnaire).
# Comparaisons de base chaine1 = "apple" chaine2 = "banana" print("apple == banana:", chaine1 == chaine2) # False print("apple != banana:", chaine1 != chaine2) # True print("apple < banana:", chaine1 < chaine2) # True (a vient avant b) print("apple > banana:", chaine1 > chaine2) # False # Comparaison avec la même chaîne print("apple == apple:", chaine1 == "apple") # True # Comparaison sensible à la casse minusc = "python" majusc = "PYTHON" print("python == PYTHON:", minusc == majusc) # False print("python.lower() == PYTHON.lower():", minusc.lower() == majusc.lower()) # True # Comparaison de chaînes avec préfixes communs print("abc < abcd:", "abc" < "abcd") # True (abc est plus court) print("abc < abd:", "abc" < "abd") # True (c vient avant d) # Ordre lexicographique (comme dans un dictionnaire) mots = ["zèbre", "abeille", "chat", "banane"] mots_tries = sorted(mots) print("Mots triés:", mots_tries) # ['abeille', 'banane', 'chat', 'zèbre'] # Comparaison avec des nombres (conversion implicite impossible) try: resultat = "10" > 5 # TypeError: '>' not supported between instances of 'str' and 'int' except TypeError as e: print("Erreur:", e) # Comparaison correcte avec conversion explicite nombre_str = "10" nombre_int = 5 print("10 > 5 (en nombre):", int(nombre_str) > nombre_int) # True # Comparaisons avec opérateurs multiples chaine = "python" print("'p' <= chaine <= 'z':", 'p' <= chaine <= 'z') # True print("'a' <= chaine <= 'm':", 'a' <= chaine <= 'm') # False
L'indexation et le découpage sont des techniques fondamentales pour accéder et extraire des portions spécifiques d'une chaîne de caractères en Python.
Python permet d'accéder aux caractères d'une chaîne via deux systèmes d'indexation :
texte = "Python" # Indexation positive (commence à 0) # P y t h o n # 0 1 2 3 4 5 premier = texte[0] # 'P' deuxieme = texte[1] # 'y' dernier = texte[5] # 'n' # Indexation négative (commence à -1 depuis la fin) # P y t h o n # -6 -5 -4 -3 -2 -1 dernier_neg = texte[-1] # 'n' avant_dernier = texte[-2] # 'o' premier_neg = texte[-6] # 'P'
Le slicing permet d'extraire une sous-chaîne en utilisant la syntaxe [début:fin:pas] :
phrase = "Programmation Python" # Syntaxe : [début:fin] (fin non incluse) sous_chaine = phrase[0:11] # "Programmation" langage = phrase[13:19] # "Python" # Omission du début (par défaut 0) debut = phrase[:11] # "Programmation" # Omission de la fin (par défaut jusqu'au bout) fin = phrase[13:] # "Python" # Copie complète copie = phrase[:] # "Programmation Python" # Avec des index négatifs sans_dernier = phrase[:-1] # "Programmation Pytho" trois_derniers = phrase[-3:] # "hon"
Le paramètre 'pas' permet de contrôler l'intervalle entre les caractères extraits :
alphabet = "ABCDEFGHIJKLMNOP" # Pas de 2 (prendre un caractère sur deux) un_sur_deux = alphabet[:10:2] # "ACEGI" # Pas de 3 un_sur_trois = alphabet[::3] # "ADGJMP" # Pas négatif (pour inverser) inverse = alphabet[::-1] # "PONMLKJIHGFEDCBA" # Inverser une portion portion_inverse = alphabet[3:8:-1] # "" (vide car logique incorrecte) portion_inverse_correcte = alphabet[8:3:-1] # "IHGFE" # Pas de 2 en arrière arriere_deux = alphabet[::-2] # "PNLJHFDB"
Voici des exemples concrets d'utilisation du slicing dans des situations réelles :
# Extraction d'informations d'une chaîne formatée date = "2024-03-15" annee = date[:4] # "2024" mois = date[5:7] # "03" jour = date[8:] # "15" # Nettoyage de données email = " utilisateur@domaine.com " nom_utilisateur = email.strip()[:email.find("@")] # Extraction avant @ domaine = email.strip()[email.find("@")+1:] # Extraction après @ # Manipulation de texte phrase = "Bonjour tout le monde" premiere_moitie = phrase[:len(phrase)//2] # "Bonjour to" deuxieme_moitie = phrase[len(phrase)//2:] # "ut le monde" # Vérifications avec slicing url = "https://www.example.com/page" est_https = url[:5] == "https" # True extension = url[-4:] # "page" (pas d'extension ici) # Création de patterns mot = "DEVELOPPEMENT" lettres_paires = mot[1::2] # "EELPEENT" lettres_impaires = mot[::2] # "DVLOPEMN" # Palindrome check mot_test = "radar" est_palindrome = mot_test == mot_test[::-1] # True
Python offre plusieurs méthodes pour transformer les chaînes de caractères, permettant de modifier leur casse, supprimer les espaces superflus ou remplacer des parties de la chaîne.
Les méthodes de modification de casse permettent de changer la capitalisation des caractères dans une chaîne. Ces méthodes retournent toujours une nouvelle chaîne sans modifier l'originale.
# Méthodes de modification de casse chaine = "python est un langage de programmation" # upper() - Convertit toute la chaîne en majuscules majuscules = chaine.upper() print("upper():", majuscules) # PYTHON EST UN LANGAGE DE PROGRAMMATION # lower() - Convertit toute la chaîne en minuscules texte_mixte = "PyThOn EsT GéNial" minuscules = texte_mixte.lower() print("lower():", minuscules) # python est génial # title() - Convertit la première lettre de chaque mot en majuscule titre = chaine.title() print("title():", titre) # Python Est Un Langage De Programmation # capitalize() - Convertit seulement la première lettre de la chaîne en majuscule capitalise = chaine.capitalize() print("capitalize():", capitalise) # Python est un langage de programmation # swapcase() - Inverse la casse de tous les caractères inverse = "PyThOn".swapcase() print("swapcase():", inverse) # pYtHoN # Cas particuliers avec des caractères Unicode texte_unicode = "café au lait" print("Unicode upper:", texte_unicode.upper()) # CAFÉ AU LAIT # Les méthodes de casse ne modifient pas la chaîne originale print("Original après upper:", chaine) # python est un langage de programmation # Application pratique: normalisation pour la comparaison utilisateur_saisie = "Admin" utilisateur_db = "admin" if utilisateur_saisie.lower() == utilisateur_db.lower(): print("Utilisateur valide (comparaison insensible à la casse)") else: print("Utilisateur invalide") # Application: formatage de noms propres nom_mal_formate = "jean-pierre dupont" nom_formate = nom_mal_formate.title() print("Nom formaté:", nom_formate) # Jean-Pierre Dupont
Les méthodes de suppression d'espaces permettent de nettoyer les chaînes en enlevant les espaces superflus au début, à la fin ou des deux côtés. Elles sont particulièrement utiles pour le traitement des entrées utilisateur.
# Méthodes de suppression d'espaces chaine_avec_espaces = " Hello World! " # strip() - Supprime les espaces des deux côtés nettoyee = chaine_avec_espaces.strip() print(f"'{chaine_avec_espaces}' -> strip() -> '{nettoyee}'") # 'Hello World!' # lstrip() - Supprime les espaces seulement à gauche (début) gauche = chaine_avec_espaces.lstrip() print(f"'{chaine_avec_espaces}' -> lstrip() -> '{gauche}'") # 'Hello World! ' # rstrip() - Supprime les espaces seulement à droite (fin) droite = chaine_avec_espaces.rstrip() print(f"'{chaine_avec_espaces}' -> rstrip() -> '{droite}'") # ' Hello World!' # Suppression de caractères spécifiques chaine_speciale = "***Hello!***" sans_etoiles = chaine_speciale.strip("*") print(f"'{chaine_speciale}' -> strip('*') -> '{sans_etoiles}'") # 'Hello!' chaine_mixte = " ** Hello ** " nettoyee_mixte = chaine_mixte.strip() # Enlève seulement les espaces print(f"'{chaine_mixte}' -> strip() -> '{nettoyee_mixte}'") # '** Hello **' nettoyee_complete = chaine_mixte.strip().strip("*").strip() # Enlève espaces puis * puis espaces print(f"'{chaine_mixte}' -> multiples strips -> '{nettoyee_complete}'") # 'Hello' # Application pratique: nettoyage d'entrées utilisateur email_saisi = " USER@EXAMPLE.COM " email_normalise = email_saisi.strip().lower() print(f"Email normalisé: '{email_normalise}'") # 'user@example.com' # Traitement de données CSV ligne_csv = " Alice, 25, Ingenieur \n" champs = [champ.strip() for champ in ligne_csv.strip().split(",")] print("Champs nettoyés:", champs) # ['Alice', '25', 'Ingenieur'] # Les méthodes de suppression ne modifient pas la chaîne originale print("Original après strip:", f"'{chaine_avec_espaces}'") # ' Hello World! ' # Attention: strip() enlève aussi les tabulations et retours à la ligne chaine_avec_whitespace = "\t\n Hello \t\n" nettoyee_whitespace = chaine_avec_whitespace.strip() print(f"Whitespace: '{chaine_avec_whitespace}' -> '{nettoyee_whitespace}'") # 'Hello'
La méthode replace() permet de remplacer toutes les occurrences d'une sous-chaîne par une autre dans une chaîne. Elle est très utile pour la modification et le nettoyage de texte.
# Méthode replace() chaine = "J'aime le Java et le JavaScript" # Remplacer une sous-chaîne par une autre remplacee = chaine.replace("Java", "Python") print(f"'{chaine}' -> replace('Java', 'Python') -> '{remplacee}'") # J'aime le Python et le PythonScript # Remplacer avec un nombre limité d'occurrences remplacee_limitee = chaine.replace("Java", "Python", 1) print(f"'{chaine}' -> replace('Java', 'Python', 1) -> '{remplacee_limitee}'") # J'aime le Python et le JavaScript # Remplacer des caractères individuels texte = "café" sans_accents = texte.replace("é", "e") print(f"'{texte}' -> replace('é', 'e') -> '{sans_accents}'") # 'cafe' # Supprimer des caractères (remplacer par une chaîne vide) numero_telephone = "+33 (0)1 23 45 67 89" numero_nettoye = numero_telephone.replace(" ", "").replace("(", "").replace(")", "").replace("-", "") print(f"Téléphone nettoyé: '{numero_nettoye}'") # '+330123456789' # Application: correction d'erreurs courantes texte_avec_erreurs = "J'ai recu votre message. C'etait genial!" texte_corrige = texte_avec_erreurs.replace("recu", "reçu").replace("etait", "était").replace("genial", "génial") print(f"Texte corrigé: '{texte_corrige}'") # J'ai reçu votre message. C'était génial! # Application: formatage de texte texte_markdown = "# Titre **important**" texte_html = texte_markdown.replace("# ", "<h1>").replace("**", "<strong>") print(f"HTML: '{texte_html}'") # '<h1>Titre <strong>important<strong>' # La méthode replace() est sensible à la casse texte = "Python python PYTHON" remplace = texte.replace("python", "Java") print(f"'{texte}' -> replace('python', 'Java') -> '{remplace}'") # 'Python Java PYTHON' # Pour un remplacement insensible à la casse, on peut utiliser une approche différente import re texte = "Python python PYTHON" remplace_insensible = re.sub("python", "Java", texte, flags=re.IGNORECASE) print(f"Remplacement insensible: '{remplace_insensible}'") # 'Java Java Java' # replace() ne modifie pas la chaîne originale print("Original après replace:", chaine) # J'aime le Java et le JavaScript
Python offre de nombreuses méthodes pour rechercher des éléments dans les chaînes et vérifier leurs propriétés, facilitant l'analyse et la validation de données textuelles.
Python propose plusieurs méthodes pour localiser des sous-chaînes dans une chaîne :
texte = "Python est un langage de programmation puissant" # Méthode find() - retourne l'index ou -1 si non trouvé position = texte.find("langage") # 15 non_trouve = texte.find("Java") # -1 # find() avec positions de début et fin position_limitee = texte.find("de", 10, 30) # 23 # Méthode index() - similaire à find() mais lève une exception index_trouve = texte.index("Python") # 0 # texte.index("Java") # ValueError: substring not found # Opérateur 'in' - retourne True/False contient = "programmation" in texte # True ne_contient_pas = "Java" in texte # False # Recherche depuis la fin avec rfind() et rindex() texte_double = "Python langage Python" derniere_position = texte_double.rfind("Python") # 15 premiere_position = texte_double.find("Python") # 0
Ces méthodes permettent de vérifier si une chaîne commence ou se termine par une sous-chaîne spécifique :
fichier = "document.pdf" url = "https://www.python.org" nom = "Mr. Dupont" # Vérification du début avec startswith() est_https = url.startswith("https") # True est_monsieur = nom.startswith("Mr.") # True est_madame = nom.startswith("Mme") # False # Vérification de la fin avec endswith() est_pdf = fichier.endswith(".pdf") # True est_org = url.endswith(".org") # True est_com = url.endswith(".com") # False # Vérification avec plusieurs possibilités (tuple) extensions_images = (".jpg", ".png", ".gif", ".bmp") photo = "vacation.jpg" est_image = photo.endswith(extensions_images) # True protocoles = ("http://", "https://", "ftp://") site = "ftp://files.example.com" est_protocole_valide = site.startswith(protocoles) # True # Avec positions de début et fin chemin = "/home/user/documents/file.txt" commence_par_home = chemin.startswith("home", 1) # True (à partir de l'index 1)
Ces méthodes permettent de tester la nature des caractères composant une chaîne :
# Tests de base nombre = "12345" lettres = "Python" mixte = "Python3" espaces = " " vide = "" # isdigit() - vérifie si tous les caractères sont des chiffres print(nombre.isdigit()) # True print(lettres.isdigit()) # False print(mixte.isdigit()) # False # isalpha() - vérifie si tous les caractères sont des lettres print(lettres.isalpha()) # True print(nombre.isalpha()) # False print(mixte.isalpha()) # False # isalnum() - vérifie si tous les caractères sont alphanumérique print(mixte.isalnum()) # True print(lettres.isalnum()) # True print(nombre.isalnum()) # True # Autres tests utiles phrase = "Hello World" minuscules = "hello" majuscules = "HELLO" titre = "Hello World" # isspace() - vérifie si tous les caractères sont des espaces print(espaces.isspace()) # True print(phrase.isspace()) # False # islower() - vérifie si tous les caractères sont en minuscules print(minuscules.islower()) # True print(majuscules.islower()) # False # isupper() - vérifie si tous les caractères sont en majuscules print(majuscules.isupper()) # True print(minuscules.isupper()) # False # istitle() - vérifie si la chaîne est en format titre print(titre.istitle()) # True print(minuscules.istitle()) # False # Exemples pratiques de validation code_postal = "75001" nom_utilisateur = "user123" mot_de_passe = "MonMotDePasse" est_code_postal_valide = code_postal.isdigit() and len(code_postal) == 5 est_nom_utilisateur_valide = nom_utilisateur.isalnum() contient_lettres = any(c.isalpha() for c in mot_de_passe) contient_majuscule = any(c.isupper() for c in mot_de_passe)
Python offre plusieurs méthodes puissantes pour diviser des chaînes en éléments plus petits ou pour assembler plusieurs éléments en une seule chaîne. Ces opérations sont essentielles pour le traitement de texte et la manipulation de données.
La méthode split() permet de diviser une chaîne en une liste d'éléments selon un séparateur :
# Division avec séparateur par défaut (espaces) phrase = "Bonjour le monde Python" mots = phrase.split() print(mots) # ['Bonjour', 'le', 'monde', 'Python'] # Division avec un séparateur spécifique fruits = "pomme,banane,orange,kiwi" liste_fruits = fruits.split(",") print(liste_fruits) # ['pomme', 'banane', 'orange', 'kiwi'] # Limiter le nombre de divisions texte = "un-deux-trois-quatre" result = texte.split("-", 2) # Divise seulement 2 fois print(result) # ['un', 'deux', 'trois-quatre'] # Division par lignes texte_multiligne = "Ligne 1\nLigne 2\nLigne 3" lignes = texte_multiligne.split("\n") print(lignes) # ['Ligne 1', 'Ligne 2', 'Ligne 3']
La méthode join() est l'inverse de split() : elle assemble une liste de chaînes en une seule chaîne :
# Assemblage avec un séparateur mots = ["Python", "est", "fantastique"] phrase = " ".join(mots) print(phrase) # "Python est fantastique" # Assemblage avec virgules fruits = ["pomme", "banane", "orange"] liste_csv = ",".join(fruits) print(liste_csv) # "pomme,banane,orange" # Assemblage sans séparateur lettres = ["P", "y", "t", "h", "o", "n"] mot = "".join(lettres) print(mot) # "Python" # Assemblage avec saut de ligne lignes = ["Première ligne", "Deuxième ligne", "Troisième ligne"] texte_final = "\n".join(lignes) print(texte_final) # Première ligne # Deuxième ligne # Troisième ligne
Les méthodes partition() et rpartition() divisent une chaîne en exactement 3 parties :
# partition() - divise depuis le début email = "utilisateur@exemple.com" avant, sep, apres = email.partition("@") print(f"Avant: '{avant}'") # Avant: 'utilisateur' print(f"Séparateur: '{sep}'") # Séparateur: '@' print(f"Après: '{apres}'") # Après: 'exemple.com' # rpartition() - divise depuis la fin chemin = "/home/user/documents/fichier.txt" repertoire, sep, nom_fichier = chemin.rpartition("/") print(f"Répertoire: '{repertoire}'") # Répertoire: '/home/user/documents' print(f"Nom fichier: '{nom_fichier}'") # Nom fichier: 'fichier.txt' # Cas où le séparateur n'existe pas texte = "pas de séparateur" avant, sep, apres = texte.partition("|") print(f"Avant: '{avant}'") # Avant: 'pas de séparateur' print(f"Séparateur: '{sep}'") # Séparateur: '' print(f"Après: '{apres}'") # Après: '' # Exemple pratique : analyse d'URL url = "https://www.exemple.com/page?param=valeur" base, sep, params = url.partition("?") print(f"URL de base: {base}") # URL de base: https://www.exemple.com/page print(f"Paramètres: {params}") # Paramètres: param=valeur
Python propose plusieurs méthodes pour formater des chaînes de caractères, permettant d'insérer des variables et de contrôler leur présentation. Chaque méthode a ses avantages selon le contexte d'utilisation.
L'opérateur % est la méthode de formatage la plus ancienne, inspirée du langage C :
# Formatage de base avec % nom = "Alice" age = 25 message = "Je m'appelle %s et j'ai %d ans" % (nom, age) print(message) # Je m'appelle Alice et j'ai 25 ans # Spécificateurs de format courants entier = 42 flottant = 3.14159 texte = "Python" print("Entier: %d" % entier) # Entier: 42 print("Flottant: %f" % flottant) # Flottant: 3.141590 print("Texte: %s" % texte) # Texte: Python print("Hexadécimal: %x" % entier) # Hexadécimal: 2a # Contrôle de la précision pi = 3.14159265359 print("Pi avec 2 décimales: %.2f" % pi) # Pi avec 2 décimales: 3.14 print("Pi avec 4 décimales: %.4f" % pi) # Pi avec 4 décimales: 3.1416 # Formatage avec dictionnaire personne = {"nom": "Bob", "age": 30, "ville": "Paris"} info = "%(nom)s, %(age)d ans, habite à %(ville)s" % personne print(info) # Bob, 30 ans, habite à Paris
La méthode format() offre plus de flexibilité et de lisibilité que l'opérateur % :
# Formatage de base avec format() nom = "Claire" age = 28 message = "Je m'appelle {} et j'ai {} ans".format(nom, age) print(message) # Je m'appelle Claire et j'ai 28 ans # Formatage avec index template = "Le {1} coûte {0} euros" prix_message = template.format(15.50, "livre") print(prix_message) # Le livre coûte 15.5 euros # Formatage avec noms produit = "Produit: {nom}, Prix: {prix} €, Stock: {stock}" info_produit = produit.format(nom="Ordinateur", prix=899.99, stock=5) print(info_produit) # Produit: Ordinateur, Prix: 899.99 €, Stock: 5 # Formatage avec objets et attributs class Point: def __init__(self, x, y): self.x = x self.y = y p = Point(3, 4) coord = "Point: ({0.x}, {0.y})".format(p) print(coord) # Point: (3, 4) # Formatage avec dictionnaire donnees = {"nom": "Python", "version": 3.9} info = "Langage: {nom}, Version: {version}".format(**donnees) print(info) # Langage: Python, Version: 3.9
Les f-strings, introduites en Python 3.6, offrent la syntaxe la plus moderne et lisible :
# F-strings de base nom = "David" age = 35 message = f"Je m'appelle {nom} et j'ai {age} ans" print(message) # Je m'appelle David et j'ai 35 ans # Expressions dans les f-strings x = 10 y = 5 resultat = f"La somme de {x} et {y} est {x + y}" print(resultat) # La somme de 10 et 5 est 15 # Appel de méthodes dans les f-strings texte = "python" formatted = f"Texte en majuscules: {texte.upper()}" print(formatted) # Texte en majuscules: PYTHON # Formatage de nombres prix = 1234.5678 devise = f"Prix: {prix:.2f} €" print(devise) # Prix: 1234.57 € # Formatage avec objets class Personne: def __init__(self, nom, profession): self.nom = nom self.profession = profession p = Personne("Marie", "Développeuse") presentation = f"{p.nom} est {p.profession.lower()}" print(presentation) # Marie est développeuse # F-strings multilignes nom_complet = "Jean Dupont" email = "jean.dupont@email.com" carte_visite = f""" Nom: {nom_complet} Email: {email} Statut: {'Actif' if True else 'Inactif'} """ print(carte_visite)
Python offre de nombreuses options pour contrôler précisément l'affichage des données :
# Alignement et largeur de champ nom = "Python" print(f"Gauche: '{nom:<15}'") # Gauche: 'Python ' print(f"Centré: '{nom:^15}'") # Centré: ' Python ' print(f"Droite: '{nom:>15}'") # Droite: ' Python' # Remplissage avec caractères personnalisés titre = "MENU" print(f"{titre:=^20}") # ========MENU======== print(f"{titre:-^20}") # --------MENU-------- print(f"{titre:*^20}") # ********MENU******** # Formatage des nombres nombre = 1234567.89 print(f"Séparateurs de milliers: {nombre:,}") # 1,234,567.89 print(f"Notation scientifique: {nombre:.2e}") # 1.23e+06 print(f"Pourcentage: {0.75:.1%}") # 75.0% # Zéros de tête pour les nombres numero = 42 print(f"Numéro: {numero:05d}") # Numéro: 00042 print(f"Hexadécimal: 0x{numero:04x}") # Hexadécimal: 0x002a # Formatage des dates et heures from datetime import datetime maintenant = datetime.now() print(f"Date: {maintenant:%d/%m/%Y}") print(f"Heure: {maintenant:%H:%M:%S}") print(f"Complet: {maintenant:%A %d %B %Y à %H:%M}") # Tableau formaté produits = [ ("Pomme", 1.50, 120), ("Banane", 0.80, 85), ("Orange", 2.20, 200) ] print(f"{'Produit':<10} {'Prix':>8} {'Stock':>8}") print("-" * 30) for nom, prix, stock in produits: print(f"{nom:<10} {prix:>8.2f} {stock:>8d}")
Python permet d'utiliser des caractères spéciaux dans les chaînes grâce aux séquences d'échappement. Il existe également des méthodes pour traiter les chaînes brutes et gérer l'Unicode.
Les séquences d'échappement permettent d'insérer des caractères spéciaux dans les chaînes :
# Séquences d'échappement courantes print("Ligne 1\nLigne 2") # \n = saut de ligne # Ligne 1 # Ligne 2 print("Nom:\tPrénom") # \t = tabulation # Nom: Prénom print("Il a dit: \"Bonjour!\"") # \" = guillemet double # Il a dit: "Bonjour!" print('Elle a dit: \'Salut!\'') # \' = guillemet simple # Elle a dit: 'Salut!' print("Chemin: C:\\Users\\Documents") # \\ = antislash littéral # Chemin: C:\Users\Documents # Autres séquences utiles print("Retour\rchariot") # \r = retour chariot print("Avant\bArrière") # \b = retour arrière print("Signal\a") # \a = signal sonore (bell) print("Saut\fde page") # \f = saut de page print("Tab\vverticale") # \v = tabulation verticale # Caractères par code ASCII/Unicode print("\101\102\103") # Codes octaux: ABC print("\x41\x42\x43") # Codes hexadécimaux: ABC # Création d'un menu formaté menu = """ ====== MENU PRINCIPAL ====== 1.\tNouveau fichier 2.\tOuvrir fichier 3.\tEnregistrer 4.\tQuitter ============================ Votre choix: """ print(menu)
Les chaînes brutes (raw strings) traitent les antislashs comme des caractères littéraux :
# Comparaison chaîne normale vs raw string normale = "C:\nouveau\texte\fichier.txt" brute = r"C:\nouveau\texte\fichier.txt" print("Normale:", normale) # Interprète \n et \t comme séquences print("Brute:", brute) # Garde les antislashs littéralement # Utilisation pour les chemins Windows chemin_windows = r"D:\Mes Documents\Projets\Python\script.py" print(chemin_windows) # Expressions régulières (très utile avec raw strings) import re # Sans raw string (difficile à lire) pattern1 = "\\d+\\.\\d+" # Pour matcher des nombres décimaux # Avec raw string (plus lisible) pattern2 = r"\d+\.\d+" # Même résultat, plus clair texte = "Le prix est 19.99 euros" resultat = re.search(pattern2, texte) print(f"Prix trouvé: {resultat.group()}") # Prix trouvé: 19.99 # Raw strings pour documentation/templates template_sql = r""" SELECT * FROM users WHERE name LIKE '%{name}%' AND age > {min_age} ORDER BY created_at DESC; """ requete = template_sql.format(name="Jean", min_age=18) print(requete)
Python 3 gère nativement l'Unicode, permettant d'utiliser des caractères de toutes les langues :
# Caractères Unicode directs print("Français: Bonjour! ??") print("Español: ¡Hola! ??") print("中文: 你好! ??") print("العربية: مرحبا! ??") print("Русский: Привет! ??") # Caractères Unicode par code print("\u0048\u0065\u006c\u006c\u006f") # Hello print("\u03B1\u03B2\u03B3") # αβγ (grec) print("\u2764\uFE0F") # ❤️ (cœur rouge) # Symboles mathématiques et scientifiques formule = "E = mc² (où c ≈ 3×10⁸ m/s)" print(formule) mathematiques = "∀x ∈ ℝ: √x² = |x| ∧ π ≈ 3.14159" print(mathematiques) # Émojis et symboles modernes statut = "✅ Terminé | ⚠️ Attention | ❌ Erreur | ? En cours" print(statut) # Fonctions utiles pour Unicode caractere = "é" print(f"Caractère: {caractere}") print(f"Code Unicode: {ord(caractere)}") # Code Unicode: 233 print(f"Nom Unicode: {caractere.encode('unicode_escape').decode()}") # Conversion inverse code = 233 print(f"Code {code} = '{chr(code)}'") # Code 233 = 'é' # Normalisation Unicode (important pour les comparaisons) import unicodedata texte1 = "café" # é comme un seul caractère texte2 = "cafe\u0301" # e + accent aigu combiné print(f"Texte 1: {texte1} (longueur: {len(texte1)})") print(f"Texte 2: {texte2} (longueur: {len(texte2)})") print(f"Égaux? {texte1 == texte2}") # False! # Normalisation pour comparaison correcte norm1 = unicodedata.normalize('NFC', texte1) norm2 = unicodedata.normalize('NFC', texte2) print(f"Après normalisation: {norm1 == norm2}") # True!
Cette section présente des exercices pratiques et des applications concrètes pour maîtriser la manipulation des chaînes de caractères en Python.
La validation de données textuelles est essentielle dans de nombreuses applications. Voici des exemples de validation courante :
# Validation d'une adresse email def valider_email(email): if "@" not in email: return False parties = email.split("@") if len(parties) != 2: return False nom, domaine = parties return len(nom) > 0 and "." in domaine # Validation d'un numéro de téléphone français def valider_telephone_fr(numero): # Supprimer les espaces et tirets numero = numero.replace(" ", "").replace("-", "") # Vérifier que c'est uniquement des chiffres if not numero.isdigit(): return False # Vérifier la longueur if len(numero) == 10 and numero.startswith("0"): return True return False # Validation d'un mot de passe fort def valider_mot_de_passe(mdp): if len(mdp) < 8: return False, "Trop court (minimum 8 caractères)" if not any(c.isupper() for c in mdp): return False, "Doit contenir une majuscule" if not any(c.islower() for c in mdp): return False, "Doit contenir une minuscule" if not any(c.isdigit() for c in mdp): return False, "Doit contenir un chiffre" return True, "Mot de passe valide"
Le nettoyage de texte est crucial pour le traitement de données textuelles :
# Nettoyer un texte : supprimer les caractères indésirables def nettoyer_texte(texte): # Supprimer les espaces en début/fin texte = texte.strip() # Remplacer les espaces multiples par un seul while " " in texte: texte = texte.replace(" ", " ") # Supprimer les caractères de ponctuation ponctuation = "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~" for p in ponctuation: texte = texte.replace(p, "") return texte # Compter les mots dans un texte def compter_mots(texte): texte_nettoye = nettoyer_texte(texte.lower()) mots = texte_nettoye.split() compteur = {} for mot in mots: compteur[mot] = compteur.get(mot, 0) + 1 return compteur # Extraire les mots-clés (mots de plus de 4 lettres) def extraire_mots_cles(texte): texte_nettoye = nettoyer_texte(texte.lower()) mots = texte_nettoye.split() mots_cles = [mot for mot in mots if len(mot) > 4] return list(set(mots_cles)) # Supprimer les doublons # Censurer des mots interdits def censurer_texte(texte, mots_interdits): for mot in mots_interdits: etoiles = "*" * len(mot) texte = texte.replace(mot, etoiles) return texte
Traitement et formatage de données personnelles comme les noms et adresses :
# Formater un nom proprement def formater_nom(nom_complet): # Nettoyer et diviser le nom parties = nom_complet.strip().split() # Mettre en forme : première lettre majuscule, reste minuscule nom_formate = " ".join([partie.capitalize() for partie in parties]) return nom_formate # Extraire le prénom et le nom de famille def extraire_prenom_nom(nom_complet): parties = formater_nom(nom_complet).split() if len(parties) >= 2: prenom = parties[0] nom = " ".join(parties[1:]) return prenom, nom return parties[0], "" # Créer des initiales def generer_initiales(nom_complet): parties = formater_nom(nom_complet).split() initiales = "".join([partie[0].upper() for partie in parties]) return initiales # Formater une adresse def formater_adresse(numero, rue, ville, code_postal): # Formater chaque partie rue_formatee = rue.title() ville_formatee = ville.upper() code_postal = code_postal.strip() # Assembler l'adresse adresse = f"{numero} {rue_formatee}\n{code_postal} {ville_formatee}" return adresse # Extraire le code postal d'une adresse def extraire_code_postal(adresse): mots = adresse.split() for mot in mots: if mot.isdigit() and len(mot) == 5: return mot return None
Voici des projets complets utilisant les chaînes de caractères :
# Projet 1: Générateur de mots de passe import random import string def generer_mot_de_passe(longueur=12, inclure_majuscules=True, inclure_chiffres=True, inclure_symboles=True): caracteres = string.ascii_lowercase if inclure_majuscules: caracteres += string.ascii_uppercase if inclure_chiffres: caracteres += string.digits if inclure_symboles: caracteres += "!@#$%^&*" mot_de_passe = "".join(random.choice(caracteres) for _ in range(longueur)) return mot_de_passe # Projet 2: Analyseur de texte simple def analyser_texte(texte): # Statistiques de base nb_caracteres = len(texte) nb_caracteres_sans_espaces = len(texte.replace(" ", "")) nb_mots = len(texte.split()) nb_phrases = texte.count(".") + texte.count("!") + texte.count("?") nb_paragraphes = texte.count("\n\n") + 1 # Retourner un dictionnaire avec les statistiques return { "caracteres": nb_caracteres, "caracteres_sans_espaces": nb_caracteres_sans_espaces, "mots": nb_mots, "phrases": nb_phrases, "paragraphes": nb_paragraphes, "mots_par_phrase": nb_mots / nb_phrases if nb_phrases > 0 else 0 } # Projet 3: Convertisseur de casse def convertir_casse(texte, type_casse): conversions = { "snake_case": lambda t: t.lower().replace(" ", "_"), "camelCase": lambda t: t.split()[0].lower() + "".join(mot.capitalize() for mot in t.split()[1:]), "PascalCase": lambda t: "".join(mot.capitalize() for mot in t.split()), "kebab-case": lambda t: t.lower().replace(" ", "-"), "SCREAMING_SNAKE_CASE": lambda t: t.upper().replace(" ", "_") } if type_casse in conversions: return conversions[type_casse](texte) return texte
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!