Concaténer des chaînes de caractères

La concaténation de chaînes est le processus qui consiste à joindre deux chaînes de caractères ou plus en une seule. Python offre plusieurs approches — du simple opérateur + à la méthode efficace join() — et choisir la bonne méthode a son importance pour la lisibilité et les performances.

Ce chapitre couvre :

• Les opérateurs + et +=
• La jointure d'une liste de chaînes avec join()
• L'intégration de valeurs avec les f-strings
• La répétition d'une chaîne avec *
• La concaténation de valeurs non-string (et le piège courant TypeError)
• Quand utiliser join() plutôt que +

Chapitres associés : Chaînes Python · Modifier des chaînes · Formater des chaînes · Méthodes de chaînes

Utiliser l'opérateur +

L'opérateur + est la façon la plus directe de joindre deux chaînes. Python crée une nouvelle chaîne contenant tous les caractères des deux opérandes dans l'ordre.

Concaténer deux chaînes avec +

Hello World

Vous pouvez enchaîner autant de chaînes que nécessaire dans une seule expression :

greeting = "Good" + " " + "morning" + ", " + "Python!"
print(greeting)

Good morning, Python!

Piège — seules les chaînes sont autorisées. L'opérateur + ne convertit pas automatiquement les autres types. Tenter de concaténer une chaîne et un nombre lève une TypeError :

age = 30
# This raises TypeError: can only concatenate str (not "int") to str
# message = "I am " + age + " years old."

# Correct: convert the number to a string first
message = "I am " + str(age) + " years old."
print(message)

I am 30 years old.

Appelez toujours str() sur une valeur non-string avant d'utiliser +.

Utiliser l'opérateur +=

L'opérateur += ajoute une chaîne à une variable existante. C'est un raccourci pour variable = variable + new_string et il est pratique lorsque vous construisez une chaîne étape par étape.

Construire une phrase de manière incrémentielle avec +=

Hello, World!

Un cas d'utilisation courant consiste à accumuler des lignes dans une boucle :

words = ["one", "two", "three"]
result = ""
for word in words:
    result += word + " "
print(result.strip())

one two three

Note sur les performances. L'utilisation répétée de += dans une boucle crée un nouvel objet string à chaque itération. Pour de petites listes, cela convient, mais pour de grandes collections, join() (voir ci-dessous) est nettement plus rapide.

Utiliser join() pour concaténer une liste de chaînes

str.join(iterable) joint toutes les chaînes d'un itérable en plaçant la chaîne sur laquelle elle est appelée entre chaque paire. C'est la manière idiomatique en Python de construire une chaîne à partir d'une collection.

Joindre des mots avec un séparateur espace

Hello World

Le séparateur peut être n'importe quoi — une virgule, un saut de ligne, ou même une chaîne vide :

letters = ["P", "y", "t", "h", "o", "n"]

print(", ".join(letters))   # comma-separated
print("".join(letters))     # no separator — merges into one word
print("\n".join(letters))   # one letter per line

P, y, t, h, o, n
Python
P
y
t
h
o
n

Pourquoi préférer join() à + dans les boucles ?

Chaque appel à + alloue une toute nouvelle chaîne. join() calcule la longueur totale une seule fois, alloue la mémoire une seule fois, et copie toutes les parties en un seul passage — le rendant O(n) plutôt que O(n²) pour les grandes entrées.

# Slow for large collections
parts = ["a"] * 10_000
result = ""
for p in parts:
    result += p   # 10,000 allocations

# Fast — single allocation
result = "".join(parts)

Utiliser les f-strings pour concaténer des valeurs

Les f-strings (disponibles depuis Python 3.6) vous permettent d'intégrer des variables et des expressions directement dans un littéral de chaîne sans aucun appel explicite à + ou str().

first_name = "Ada"
last_name  = "Lovelace"
birth_year = 1815

bio = f"{first_name} {last_name} was born in {birth_year}."
print(bio)

Ada Lovelace was born in 1815.

Les f-strings sont souvent plus lisibles que + lorsque vous mélangez plusieurs variables avec du texte littéral. Consultez le chapitre Formater des chaînes pour la syntaxe complète des f-strings et les options de formatage.

Répéter une chaîne avec *

L'opérateur * répète une chaîne un nombre donné de fois, ce qui constitue une alternative concise à une boucle de concaténation.

line = "-" * 20
print(line)

echo = "ha" * 3
print(echo)

--------------------
hahaha

Concaténation de chaînes sur plusieurs lignes

Python joint automatiquement les littéraux de chaînes adjacents apparaissant sur des lignes consécutives à l'intérieur de parenthèses — sans besoin de +. Cela est utile pour les longues chaînes codées en dur.

message = (
    "This is the first part. "
    "This is the second part. "
    "And this is the third."
)
print(message)

This is the first part. This is the second part. And this is the third.

Vous pouvez également répartir une longue concaténation sur plusieurs lignes avec un antislash :

long_url = "https://example.com/products" \
           "?category=books" \
           "&sort=price"
print(long_url)

https://example.com/products?category=books&sort=price

Choisir la bonne méthode

Pour plus d'opérations sur les chaînes, consultez Modifier des chaînes, Découper des chaînes et Méthodes de chaînes.

Pratique