Chaînes de caractères en Python : guide débutant

Les chaînes de caractères, souvent appelées strings, font partie des types les plus utilisés en Python. Dès que vous affichez un message, lisez une saisie clavier, traitez un nom de fichier, analysez une phrase ou préparez un texte pour l’écran, vous manipulez des chaînes.

Pour un débutant, ce sujet est essentiel, car il relie la programmation à des cas très concrets : nettoyer une entrée utilisateur, vérifier si un mot est présent, remplacer une partie d’un texte, découper une phrase en morceaux ou construire une sortie lisible.

Dans ce tutoriel, vous allez apprendre les bases utiles et pratiques pour travailler avec du texte en Python. Nous verrons comment créer une chaîne, accéder à ses caractères, la découper, rechercher une information, remplacer du contenu et formater un résultat final. Chaque étape s’appuie sur des exemples simples afin de vous aider à comprendre ce que fait le code et à le réutiliser dans vos propres exercices.

Prérequis

Savoir exécuter un script Python simple.
Connaître les variables et la fonction print().
Avoir une installation de Python fonctionnelle sur votre machine.

Matériel nécessaire

Python 3 installé
Un éditeur de texte ou un IDE simple
Un terminal ou l’interpréteur Python

Étapes

1
Comprendre ce qu’est une chaîne de caractères

Une chaîne de caractères représente du texte. En Python, elle s’écrit entre guillemets simples ou doubles.
python
```
message = "Bonjour"
nom = 'Alice'
print(message)
print(nom)
```
Ces deux écritures sont valides. Le choix dépend souvent de la lisibilité. Par exemple, si votre texte contient déjà une apostrophe, les guillemets doubles peuvent être plus pratiques.
python
```
texte = "C'est une chaîne"
print(texte)
```
Une chaîne est une suite ordonnée de caractères. Cela signifie que chaque lettre, espace ou symbole occupe une position.
python
```
mot = "Python"
print(mot[0])
print(mot[1])
print(mot[5])
```
Dans cet exemple, mot[0] affiche le premier caractère. En Python, l’indexation commence à 0. Le dernier caractère de "Python" est donc à la position 5.
Vous pouvez aussi utiliser des index négatifs pour partir de la fin.
python
```
mot = "Python"
print(mot[-1])
print(mot[-2])
```
-1 représente le dernier caractère, -2 l’avant-dernier, et ainsi de suite.
Enfin, il est utile de connaître la longueur d’une chaîne grâce à len().
python
```
mot = "Python"
print(len(mot))
```
Cette fonction retourne le nombre total de caractères, y compris les espaces et les signes de ponctuation.
2
Découper une chaîne avec l’indexation et le slicing

En Python, on peut extraire une partie d’une chaîne grâce au slicing. La forme générale est :
python
```
chaine[debut:fin]
```
La position debut est incluse, mais la position fin est exclue.
python
```
mot = "Python"
print(mot[0:2])
print(mot[2:6])
```
Le premier exemple renvoie "Py" et le second "thon".
Si vous omettez le début, Python part du commencement. Si vous omettez la fin, Python va jusqu’au dernier caractère.
python
```
mot = "Python"
print(mot[:3])
print(mot[3:])
```
Vous pouvez aussi copier toute la chaîne.
python
```
mot = "Python"
copie = mot[:]
print(copie)
```
Le slicing accepte également un pas :
python
```
mot = "Python"
print(mot[::2])
```
Ici, Python prend un caractère sur deux.
Un cas très utile consiste à inverser une chaîne :
python
```
mot = "Python"
print(mot[::-1])
```
Ce type de découpage est pratique pour isoler un préfixe, une extension de fichier, une partie de code ou un morceau de phrase.
3
Découper du texte avec split()

Quand on parle de découper un texte en plusieurs morceaux, la méthode split() est souvent la plus utile. Elle transforme une chaîne en liste de sous-chaînes.
python
```
phrase = "Python est simple"
mots = phrase.split()
print(mots)
```
Sans argument, split() découpe selon les espaces.
Vous pouvez aussi préciser un séparateur.
python
```
donnees = "pomme,poire,banane"
fruits = donnees.split(",")
print(fruits)
```
Ici, la virgule sert de point de découpe.
Autre exemple avec une date :
python
```
date = "2026-07-30"
parties = date.split("-")
print(parties)
```
Vous obtenez une liste contenant l’année, le mois et le jour sous forme de texte.
Il est ensuite possible de récupérer chaque élément.
python
```
date = "2026-07-30"
annee, mois, jour = date.split("-")
print(annee)
print(mois)
print(jour)
```
Cette technique est pratique si le nombre d’éléments attendus est connu.
La méthode split() peut aussi limiter le nombre de découpes.
python
```
texte = "nom:Jean Dupont"
resultat = texte.split(":", 1)
print(resultat)
```
Ici, la coupe se fait une seule fois, ce qui permet de préserver le reste du texte tel quel.
4
Reconstruire du texte avec join()

Après avoir découpé du texte, on a souvent besoin de le reconstruire. La méthode join() sert à relier plusieurs chaînes avec un séparateur.
python
```
mots = ["Python", "est", "utile"]
phrase = " ".join(mots)
print(phrase)
```
Le séparateur est ici un espace. Vous pouvez choisir un autre caractère.
python
```
lettres = ["P", "y", "t", "h", "o", "n"]
mot = "-".join(lettres)
print(mot)
```
Le résultat contient des tirets entre chaque élément.
join() est particulièrement utile après un nettoyage ou une transformation de mots.
python
```
mots = ["python", "est", "clair"]
majuscules = [mot.upper() for mot in mots]
phrase = " ".join(majuscules)
print(phrase)
```
On reconstruit ici une phrase à partir d’une liste de mots transformés.
Il faut retenir que join() s’applique sur la chaîne séparatrice, et non directement sur la liste.
5
Rechercher du texte avec in, find() et count()

Pour vérifier si un texte contient un mot ou un caractère, l’opérateur in est la solution la plus simple.
python
```
phrase = "Python est agréable"
print("Python" in phrase)
print("Java" in phrase)
```
Le résultat est un booléen : True ou False.
Si vous avez besoin de connaître la position d’une sous-chaîne, utilisez find().
python
```
phrase = "Bonjour Python"
position = phrase.find("Python")
print(position)
```
Si le texte est trouvé, find() renvoie l’index de départ. Sinon, la méthode renvoie -1.
python
```
phrase = "Bonjour Python"
print(phrase.find("Java"))
```
Vous pouvez aussi compter combien de fois un élément apparaît avec count().
python
```
texte = "banana"
print(texte.count("a"))
print(texte.count("na"))
```
Ces outils sont pratiques pour valider une saisie, rechercher un mot-clé, détecter un séparateur ou analyser rapidement une chaîne.
6
Remplacer du texte avec replace()

La méthode replace() permet de substituer une partie d’une chaîne par une autre.
python
```
texte = "Bonjour Paul"
nouveau = texte.replace("Paul", "Marie")
print(nouveau)
```
Le texte d’origine n’est pas modifié ; le résultat est une nouvelle chaîne.
Vous pouvez remplacer un caractère, un mot ou une suite de caractères.
python
```
texte = "2026/07/30"
texte_corrige = texte.replace("/", "-")
print(texte_corrige)
```
Il est aussi possible de limiter le nombre de remplacements.
python
```
texte = "un un un"
resultat = texte.replace("un", "deux", 2)
print(resultat)
```
Dans ce cas, seuls les deux premiers éléments trouvés sont remplacés.
replace() est utile pour nettoyer des données, corriger un format, masquer une information ou harmoniser une sortie texte.
7
Modifier la casse et nettoyer les espaces

Python fournit plusieurs méthodes utiles pour transformer l’apparence d’une chaîne.
python
```
texte = "Python"
print(texte.lower())
print(texte.upper())
```
lower() convertit en minuscules et upper() en majuscules.
La méthode capitalize() met en majuscule la première lettre de la chaîne.
python
```
texte = "python est utile"
print(texte.capitalize())
```
Pour retirer des espaces inutiles au début et à la fin, utilisez strip().
python
```
nom = "  Alice  "
print(nom.strip())
```
Vous pouvez également supprimer seulement à gauche avec lstrip() ou seulement à droite avec rstrip().
Ces méthodes sont très utiles lorsque vous récupérez une entrée utilisateur.
python
```
saisie = "  Bonjour  "
propre = saisie.strip().lower()
print(propre)
```
Ici, on supprime les espaces superflus puis on convertit le texte en minuscules. Ce type d’enchaînement est courant dans les scripts de débutant.
8
Tester le contenu d’une chaîne

Il est souvent utile de vérifier la nature d’un texte avant de l’utiliser. Certaines méthodes renvoient un booléen selon le contenu de la chaîne.
python
```
print("Python".isalpha())
print("Python3".isalpha())
```
isalpha() vérifie si la chaîne contient uniquement des lettres.
python
```
print("123".isdigit())
print("12a".isdigit())
```
isdigit() vérifie si la chaîne contient uniquement des chiffres.
python
```
print("bonjour".islower())
print("BONJOUR".isupper())
```
Ces tests peuvent servir à valider une saisie simple avant un traitement plus poussé.
Exemple :
python
```
code = "12345"
if code.isdigit():
    print("Code valide")
else:
    print("Le code doit contenir seulement des chiffres")
```
Pour un débutant, ces méthodes évitent d’écrire des vérifications longues pour des cas fréquents.
9
Formater du texte avec f-strings

Le formatage consiste à construire une chaîne lisible en y insérant des valeurs. En Python, les f-strings sont une solution simple et claire.
python
```
nom = "Alice"
age = 25
message = f"Bonjour {nom}, vous avez {age} ans."
print(message)
```
La chaîne commence par la lettre f, puis les variables sont placées entre accolades. Dans ce tutoriel, les accolades sont échappées pour respecter la contrainte d’affichage.
Les f-strings rendent le code plus lisible que des concaténations répétées.
python
```
produit = "clavier"
prix = 49
print(f"Le produit {produit} coûte {prix} euros.")
```
Vous pouvez aussi insérer le résultat d’expressions simples.
python
```
a = 4
b = 7
print(f"La somme de {a} et {b} est {a + b}.")
```
Le formatage est particulièrement utile pour afficher des messages clairs, générer des lignes de rapport ou présenter des résultats à l’utilisateur.
10
Combiner plusieurs techniques dans un exemple complet

Voici un petit exemple qui combine découpage, nettoyage, recherche et formatage.
python
```
ligne = "  pomme, banane, orange  "

propre = ligne.strip()
fruits = propre.split(",")
fruits_nettoyes = [fruit.strip().capitalize() for fruit in fruits]

print(f"Nombre d'éléments : {len(fruits_nettoyes)}")
print("Liste finale :")
for fruit in fruits_nettoyes:
    print(f"- {fruit}")
```
Décomposons ce code :
- strip() enlève les espaces au début et à la fin.
- split(",") découpe la chaîne selon les virgules.
- Chaque élément est nettoyé avec strip() puis mis en forme avec capitalize().
- len() compte le nombre d’éléments obtenus.
- Les f-strings servent à afficher le résultat de manière lisible.
Ce type d’exercice représente bien les tâches simples mais fréquentes en programmation : recevoir du texte, le nettoyer, en extraire des données, puis produire une sortie propre.
Autre exemple orienté recherche et remplacement :
python
```
phrase = "python est simple, python est pratique"
phrase = phrase.replace("python", "Python")
print(phrase)
print("pratique" in phrase)
print(phrase.count("Python"))
```
On standardise ici l’écriture du mot, puis on vérifie la présence d’un terme et son nombre d’occurrences.

Erreurs fréquentes & dépannage

Confondre chaîne et liste : split() renvoie une liste, pas une chaîne. Si vous voulez reconstruire une phrase, utilisez join().
Oublier que les chaînes sont indexées à partir de 0 : le premier caractère est à l’index 0.
Penser que replace() modifie la chaîne d’origine : il renvoie une nouvelle chaîne, qu’il faut souvent stocker dans une variable.
Mal utiliser find() : si le texte n’est pas trouvé, le résultat est -1.
Négliger les espaces : une saisie utilisateur peut contenir des espaces inutiles ; strip() est souvent nécessaire.
Oublier la sensibilité à la casse : "python" et "Python" ne sont pas identiques.

Astuces & pour aller plus loin

Nettoyez souvent les entrées utilisateur avec un enchaînement simple comme strip().lower().
Utilisez in pour un test de présence rapide et lisible.
Préférez les f-strings pour afficher des messages clairs avec des variables.
Testez vos chaînes avec de petits print() intermédiaires pour voir le résultat de chaque transformation.
Quand vous manipulez une phrase complexe, décomposez le travail : nettoyer, découper, transformer, reconstruire.

Questions fréquentes

Quelle différence entre split() et join() ?

split() découpe une chaîne en plusieurs éléments. join() fait l’inverse : il relie plusieurs chaînes pour former un nouveau texte.

Comment savoir si un mot existe dans une phrase ?

Vous pouvez utiliser in pour vérifier une présence simple, par exemple "Python" in phrase. Si vous avez besoin de la position, utilisez find().

Pourquoi mon remplacement ne change rien dans la variable initiale ?

Parce qu’une méthode comme replace() renvoie une nouvelle chaîne. Il faut récupérer le résultat, par exemple texte = texte.replace("a", "b").

Comment supprimer les espaces avant et après un texte ?

Utilisez strip(). Si vous voulez agir seulement d’un côté, vous pouvez employer lstrip() ou rstrip().

Comment afficher une variable dans une phrase ?

Les f-strings sont très pratiques : nom = "Alice" puis print(f"Bonjour {nom}").

Conclusion

Manipuler des chaînes de caractères est une compétence de base en Python. En apprenant à découper un texte, rechercher une information, remplacer un fragment et formater un message, vous couvrez déjà une grande partie des besoins courants d’un programme débutant.

Les méthodes vues dans ce tutoriel sont simples à retenir, mais surtout très utiles dans la pratique. Elles servent aussi bien dans de petits exercices que dans des scripts plus concrets : traitement de saisies, nettoyage de données textuelles, analyse de contenu ou génération d’affichages lisibles.

Le plus efficace pour progresser est de pratiquer sur de petites phrases, de tester chaque méthode séparément, puis de les combiner. Avec un peu d’entraînement, la manipulation du texte en Python deviendra un réflexe naturel.

Chaînes de caractères en Python : guide débutant

Prérequis

Matériel nécessaire

Étapes

Comprendre ce qu’est une chaîne de caractères

Découper une chaîne avec l’indexation et le slicing

Découper du texte avec split()

Reconstruire du texte avec join()

Rechercher du texte avec in, find() et count()

Remplacer du texte avec replace()

Modifier la casse et nettoyer les espaces

Tester le contenu d’une chaîne

Formater du texte avec f-strings

Combiner plusieurs techniques dans un exemple complet