Les chaînes Python : un guide complet

Les string sont l'un des types de données les plus utilisés en Python. Chaque fois que votre programme lit un fichier, affiche un message ou analyse une entrée, il travaille avec des string. Ce chapitre explique comment créer des string, les indexer et les découper, utiliser les méthodes intégrées et éviter les pièges courants.

Qu'est-ce qu'une string en Python ?

Une string est une séquence ordonnée et immuable de caractères Unicode. « Immuable » signifie que vous ne pouvez jamais modifier un caractère en place — toute opération qui semble modifier une string en crée en réalité une nouvelle. Les string peuvent contenir des lettres, des chiffres, de la ponctuation, des espaces ou tout caractère Unicode (y compris les emoji).

greeting = "Hello, world!"
print(type(greeting))  # <class 'str'>
print(len(greeting))   # 13

Créer des string

Python accepte trois styles de guillemets, tous équivalents :

single = 'Python'
double = "Python"
triple = """Python"""   # triple-double also works as '''Python'''

Guillemets simples et doubles

Utilisez celui qui permet d'éviter d'échapper le caractère guillemet à l'intérieur de la string :

message1 = "It's a great day"   # apostrophe is fine inside double quotes
message2 = 'She said "hello"'   # double quote is fine inside single quotes

String à guillemets triples (multilignes)

Les guillemets triples permettent à une string de s'étendre sur plusieurs lignes sans séquences d'échappement :

poem = """Roses are red,
Violets are blue,
Python is awesome,
And so are you."""
print(poem)

Résultat :

Roses are red,
Violets are blue,
Python is awesome,
And so are you.

Les string à guillemets triples sont aussi la façon conventionnelle d'écrire des docstrings — les blocs de documentation qui apparaissent en haut des fonctions, classes et modules.

Convertir d'autres types en string

Utilisez la fonction intégrée str() pour convertir n'importe quel objet en sa représentation sous forme de string :

num = 42
pi  = 3.14
flag = True

print(str(num))   # '42'
print(str(pi))    # '3.14'
print(str(flag))  # 'True'

Indexation des caractères

Python utilise une indexation à base zéro : le premier caractère se trouve à l'index 0. Vous pouvez aussi utiliser des index négatifs — -1 désigne le dernier caractère, -2 l'avant-dernier, et ainsi de suite.

Accéder à un index en dehors de la plage valide lève une IndexError.

Découper des string

Un découpage (slice) extrait une portion d'une string en utilisant la syntaxe s[start:stop:step].

s = "Hello, World!"

print(s[0:5])    # Hello     — characters at indexes 0–4
print(s[7:])     # World!    — from index 7 to the end
print(s[:5])     # Hello     — from the start to index 4
print(s[-6:])    # World!    — last 6 characters
print(s[::2])    # Hlo ol!   — every other character
print(s[::-1])   # !dlroW ,olleH  — reversed string

Pour une présentation approfondie de la syntaxe de découpage, consultez le chapitre Découper les string.

Concaténation et répétition de string

L'opérateur + joint deux string ; l'opérateur * répète une string un nombre donné de fois.

Pour une concaténation à grande échelle dans une boucle, utilisez str.join() plutôt que + — c'est nettement plus rapide car cela évite de créer des objets string intermédiaires :

words = ["one", "two", "three"]
result = ", ".join(words)
print(result)   # one, two, three

Répétition de string

Les opérateurs in et not in

Vérifiez si une sous-chaîne existe dans une string avec in ou not in :

text = "The quick brown fox"
print("quick" in text)      # True
print("slow"  in text)      # False
print("slow"  not in text)  # True

Longueur d'une string

len() renvoie le nombre de caractères dans une string :

s = "Python"
print(len(s))   # 6

empty = ""
print(len(empty))   # 0

Caractères d'échappement

Certains caractères ne peuvent pas être tapés littéralement dans une string. Python utilise un antislash \ pour introduire des séquences d'échappement :

print("Line one\nLine two")
# Line one
# Line two

print("Name:\tAlice")
# Name:	Alice

path = "C:\\Users\\Alice"
print(path)   # C:\Users\Alice

Pour désactiver entièrement le traitement des échappements, préfixez la string avec r pour créer une raw string — utile pour les expressions régulières et les chemins Windows :

pattern = r"\d+\.\d+"   # treated literally, no escaping needed
print(pattern)           # \d+\.\d+

Consultez le chapitre Caractères d'échappement pour la liste complète.

Mise en forme des string

Python offre plusieurs façons d'intégrer des valeurs de variables dans des string.

f-strings (recommandées — Python 3.6+)

Une f-string est préfixée par f ou F. Les expressions à l'intérieur de {} sont évaluées au moment de l'exécution :

name = "Alice"
age  = 30
print(f"My name is {name} and I am {age} years old.")
# My name is Alice and I am 30 years old.

# Expressions work too
print(f"Next year I'll be {age + 1}.")   # Next year I'll be 31.

Méthode str.format()

Mise en forme avec le symbole % (ancienne méthode)

L'ancien code Python utilise la mise en forme avec %. Vous la rencontrerez encore, mais les f-strings sont la préférence moderne :

print("Hello, %s!" % "Dave")   # Hello, Dave!
print("Pi ≈ %.2f" % 3.14159)   # Pi ≈ 3.14

Pour une présentation complète des options de mise en forme, consultez les chapitres Mise en forme des string et f-Strings.

Méthodes de string courantes

Le type str de Python est livré avec des dizaines de méthodes intégrées. Les plus fréquemment utilisées sont présentées ci-dessous.

Conversion de casse

s = "Hello, World!"
print(s.upper())       # HELLO, WORLD!
print(s.lower())       # hello, world!
print(s.capitalize())  # Hello, world!
print(s.title())       # Hello, World!
print(s.swapcase())    # hELLO, wORLD!

Recherche et comptage

s = "hello, world"
print(s.find("o"))       # 4   — index of first 'o', or -1 if not found
print(s.rfind("o"))      # 8   — index of last 'o'
print(s.count("l"))      # 3   — total occurrences of 'l'
print(s.startswith("he")) # True
print(s.endswith("ld"))   # True

Remplacer des sous-chaînes

s = "I like cats. Cats are great."
print(s.replace("cats", "dogs"))
# I like dogs. Cats are great.   (only lowercase 'cats' replaced)

print(s.replace("cats", "dogs").replace("Cats", "Dogs"))
# I like dogs. Dogs are great.

Supprimer les espaces

padded = "  hello  "
print(padded.strip())    # 'hello'   — both ends
print(padded.lstrip())   # 'hello  ' — left end only
print(padded.rstrip())   # '  hello' — right end only

Découper et joindre

csv = "apple,banana,cherry"
items = csv.split(",")
print(items)   # ['apple', 'banana', 'cherry']

print(" | ".join(items))   # apple | banana | cherry

Vérifier le contenu d'une string

Pour la référence complète, consultez le chapitre Méthodes de string.

Immuabilité des string — un piège courant

Les string ne peuvent pas être modifiées en place. Tenter d'assigner une valeur à un index lève une TypeError :

s = "hello"
# s[0] = "H"   # TypeError: 'str' object does not support item assignment

Pour modifier une partie d'une string, construisez-en une nouvelle :

s = "hello"
s = "H" + s[1:]   # slice off everything after index 0 and prepend "H"
print(s)           # Hello

La variable s pointe désormais vers un objet string différent — la string originale "hello" est inchangée (et sera collectée par le ramasse-miettes si rien d'autre n'y fait référence).

String vs bytes

Une string Python (str) contient du texte Unicode. Lorsque vous avez besoin de données binaires brutes — par exemple pour écrire dans un fichier en mode binaire ou envoyer des données sur un réseau — utilisez bytes à la place :

b = b"hello"          # bytes literal
s = b.decode("utf-8") # bytes → str
b2 = s.encode("utf-8") # str → bytes
print(type(b))   # <class 'bytes'>
print(type(s))   # <class 'str'>

Pratique