> Concaténer, formater, découper, rechercher et encoder du texte en Python : toutes les opérations sur les chaînes (str) expliquées avec des exemples de code réels. *Source : https://coder-studio.com/tutoriels/manipuler-chaines-python/* --- [// Python](https://coder-studio.com/tutoriels/) # Manipuler les chaînes de caractères en Python Par **Kévin Papot** · publié le 25 août 2025 En Python, une chaîne de caractères (`str`) est une suite de symboles : lettres, chiffres, espaces, ponctuation. C’est le type que vous manipulez dès que vous traitez du texte — un nom d’utilisateur, un fichier CSV, une réponse d’API. La bonne nouvelle, c’est que Python offre une panoplie de méthodes très lisibles pour transformer ce texte. Point crucial à garder en tête : **une chaîne est immuable**. Aucune méthode ne modifie la chaîne d’origine ; elles renvoient toujours une **nouvelle** chaîne. Il faut donc récupérer le résultat dans une variable. Ce guide passe en revue, opération par opération, tout ce que vous ferez couramment avec du texte, avec un exemple exécutable à chaque fois. ## Créer une chaîne On délimite une chaîne par des guillemets simples ou doubles, indifféremment. Les triples guillemets permettent d’écrire sur plusieurs lignes. ``` simple = 'Bonjour' double = "Bonjour" multi = """Première ligne Deuxième ligne""" print(multi) ``` Pour insérer un guillemet dans la chaîne, choisissez l’autre type de délimiteur ou échappez-le avec `\`. ``` phrase = "Il a dit \"oui\"" autre = 'Il a dit "oui"' ``` ## Concaténer des chaînes ### Avec l’opérateur + L’opérateur `+` colle deux chaînes bout à bout. Attention, il n’accepte que des chaînes : un nombre doit être converti avec `str()`. ``` prenom = "Marie" nom = "Curie" complet = prenom + " " + nom print(complet) # Marie Curie age = 55 message = "Âge : " + str(age) ``` ### Répéter avec \* L’opérateur `*` répète une chaîne un nombre donné de fois. ``` ligne = "-" * 20 print(ligne) # -------------------- ``` ### Assembler une liste avec join() Pour concaténer les éléments d’une liste, `join()` est bien plus efficace que d’enchaîner des `+`. La chaîne sur laquelle on l’appelle sert de séparateur. ``` mots = ["Python", "est", "génial"] print(" ".join(mots)) # Python est génial print("-".join(mots)) # Python-est-génial ``` ## Formater avec les f-strings Les **f-strings** (préfixe `f`) sont la façon moderne et recommandée d’insérer des variables dans du texte. On place les expressions entre accolades. ``` nom = "Ada" age = 36 print(f"{nom} a {age} ans") # Ada a 36 ans ``` ### Calculs et formats dans l’accolade Une f-string évalue n’importe quelle expression, et accepte des spécificateurs de format après deux-points. ``` prix = 19.9 tva = 0.20 print(f"TTC : {prix * (1 + tva):.2f} €") # TTC : 23.88 € print(f"{1000000:,}".replace(",", " ")) # 1 000 000 ``` ### Aligner et remplir ``` for i in range(1, 4): print(f"{i:03d}") # 001, 002, 003 print(f"{'gauche':<10}|") # gauche | print(f"{'droite':>10}|") # droite| ``` ## Les méthodes de transformation ### Changer la casse ``` texte = "bonjour le monde" print(texte.upper()) # BONJOUR LE MONDE print(texte.title()) # Bonjour Le Monde print(texte.capitalize()) # Bonjour le monde print("CRIER".lower()) # crier ``` ### Nettoyer les espaces avec strip() `strip()` retire les espaces (et retours à la ligne) en début et fin de chaîne. `lstrip()` et `rstrip()` ne traitent qu’un seul côté. ``` saisie = " mon@email.fr \n" print(saisie.strip()) # 'mon@email.fr' ``` On peut aussi retirer des caractères précis en les passant en argument. ``` print("###titre###".strip("#")) # titre ``` ### Remplacer avec replace() `replace()` remplace toutes les occurrences d’un fragment par un autre. ``` texte = "chat, chat, chat" print(texte.replace("chat", "chien")) # chien, chien, chien print(texte.replace("chat", "chien", 1)) # chien, chat, chat ``` ## Découper une chaîne ### split() : diviser en liste `split()` découpe la chaîne selon un séparateur et renvoie une liste. Sans argument, il découpe sur les espaces (et ignore les espaces multiples). ``` csv = "nom;prenom;age" print(csv.split(";")) # ['nom', 'prenom', 'age'] phrase = "un deux trois" print(phrase.split()) # ['un', 'deux', 'trois'] ``` ### splitlines() : découper par ligne ``` bloc = "ligne 1\nligne 2\nligne 3" print(bloc.splitlines()) # ['ligne 1', 'ligne 2', 'ligne 3'] ``` ### partition() : couper en trois `partition()` découpe à la première occurrence du séparateur et renvoie un tuple (avant, séparateur, après). ``` email = "utilisateur@domaine.fr" print(email.partition("@")) # ('utilisateur', '@', 'domaine.fr') ``` ## Rechercher dans une chaîne ### Tester la présence avec in L’opérateur `in` répond par un booléen. C’est le test le plus simple et le plus lisible. ``` phrase = "le renard brun" print("renard" in phrase) # True print("loup" in phrase) # False ``` ### Localiser avec find() et index() `find()` renvoie la position de la première occurrence, ou `-1` si absente. `index()` fait pareil mais lève une `ValueError` en cas d’absence. ``` phrase = "le renard brun" print(phrase.find("renard")) # 3 print(phrase.find("loup")) # -1 ``` ### Tester le début et la fin `startswith()` et `endswith()` sont parfaits pour filtrer selon un préfixe ou une extension. ``` fichier = "rapport.pdf" print(fichier.endswith(".pdf")) # True print(fichier.startswith("rap")) # True ``` ### Compter les occurrences ``` print("banane".count("a")) # 3 ``` ## Le slicing : extraire une portion Le slicing extrait une sous-chaîne avec la syntaxe `chaine[début:fin:pas]`. La borne de fin est **exclue**. ``` mot = "développeur" print(mot[0]) # d (premier caractère) print(mot[0:4]) # déve print(mot[4:]) # loppeur print(mot[-1]) # r (dernier caractère) print(mot[-4:]) # eur ``` ### Inverser une chaîne Un pas négatif de `-1` parcourt la chaîne à l’envers. ``` print("bonjour"[::-1]) # ruojnob ``` ### Un caractère sur deux ``` print("abcdefgh"[::2]) # aceg ``` ## Tester le contenu d’une chaîne Ces méthodes renvoient un booléen selon la nature des caractères. Elles sont pratiques pour valider une saisie. ``` print("12345".isdigit()) # True : que des chiffres print("Python3".isalnum()) # True : lettres et chiffres print("hello".isalpha()) # True : que des lettres print(" ".isspace()) # True : que des espaces print("MOT".isupper()) # True : tout en majuscules ``` Exemple de validation d’un âge saisi au clavier : ``` saisie = "42" if saisie.isdigit(): age = int(saisie) print(f"Âge valide : {age}") else: print("Veuillez entrer un nombre") ``` ## Encodage et décodage Une chaîne (`str`) est une suite de caractères ; un fichier ou le réseau manipulent des **octets** (`bytes`). `encode()` transforme une chaîne en octets selon un encodage (UTF-8 par défaut), et `decode()` fait l’inverse. ``` texte = "café" octets = texte.encode("utf-8") print(octets) # b'caf\xc3\xa9' retour = octets.decode("utf-8") print(retour) # café ``` L’UTF-8 code les caractères accentués sur plusieurs octets : c’est pourquoi `"café"` occupe 5 octets pour 4 caractères. Utilisez toujours UTF-8 pour lire et écrire des fichiers texte afin d’éviter les caractères illisibles. ``` with open("notes.txt", "w", encoding="utf-8") as f: f.write("Résumé : préférence à l'été") ``` ## En résumé Manipuler du texte en Python repose sur quelques réflexes : les f-strings pour assembler et formater, `split()` / `join()` pour passer d’une chaîne à une liste et inversement, `strip()` et `replace()` pour nettoyer, le slicing pour extraire, et `in` / `startswith()` pour rechercher. Gardez toujours en tête l’immuabilité : récupérez le résultat de chaque méthode dans une variable. Avec ces outils, le traitement de chaînes devient rapide et lisible. ## À lire ensuite - [Les dictionnaires en Python : le guide complet](https://coder-studio.com/tutoriels/dictionnaires-python/) - [Les listes en Python : le guide complet](https://coder-studio.com/tutoriels/listes-python/) - [Les fonctions en Python](https://coder-studio.com/tutoriels/fonctions-python/)