Joindre des Tuples en Python

Les tuples Python sont des séquences immuables — une fois créés, vous ne pouvez pas ajouter, supprimer ou modifier leurs éléments. Joindre des tuples signifie créer un nouveau tuple qui combine le contenu de deux tuples ou plus. Parce que les tuples sont immuables, chaque opération de jointure retourne un nouveau tuple plutôt que de modifier les originaux.

Cette page couvre les principales façons de joindre des tuples en Python :

• Opérateur + — concaténer deux tuples ou plus
• Opérateur * — répéter un tuple un nombre fixe de fois
• Constructeur tuple() — construire un tuple à partir de n'importe quel itérable, utile pour combiner des séquences non-tuple

Joindre des tuples avec l'opérateur +

L'opérateur + concatène deux tuples en un seul nouveau tuple. Les éléments de l'opérande gauche viennent en premier, suivis de ceux de l'opérande droit. Aucun des tuples originaux n'est modifié.

Résultat :

(1, 2, 3, 4, 5, 6)

Joindre trois tuples ou plus

Chaînez l'opérateur + pour fusionner n'importe quel nombre de tuples en une seule expression :

Résultat :

(1, 2, 3, 4, 5, 6, 7, 8, 9)

Joindre des tuples avec des types mixtes

Les tuples peuvent contenir des valeurs de différents types, et + fonctionne de la même façon dans tous les cas :

t1 = (1, "hello", True)
t2 = (3.14, None)
result = t1 + t2
print(result)

Résultat :

(1, 'hello', True, 3.14, None)

Attention : les deux opérandes doivent être des tuples

Vous ne pouvez pas utiliser + pour concaténer un tuple avec une liste ou tout autre type — Python lève une TypeError. Convertissez d'abord l'autre séquence en tuple :

my_tuple = (1, 2, 3)
my_list = [4, 5, 6]

# This raises TypeError:
# result = my_tuple + my_list

# Correct — convert the list to a tuple first:
result = my_tuple + tuple(my_list)
print(result)

Résultat :

(1, 2, 3, 4, 5, 6)

Attention : syntaxe du tuple à un seul élément

Un tuple avec un seul élément nécessite une virgule finale. Sans elle, Python traite les parenthèses comme un regroupement, et non comme un littéral de tuple :

not_a_tuple = (42)    # int, not tuple
singleton   = (42,)   # tuple with one element

result = singleton + (1, 2)
print(result)

Résultat :

(42, 1, 2)

Répéter un tuple avec l'opérateur *

L'opérateur * répète un tuple un nombre donné de fois et retourne un nouveau tuple. Cela est utile lorsque vous avez besoin d'une séquence pré-remplie avec un motif répété.

t = ("a", "b")
result = t * 3
print(result)

Résultat :

('a', 'b', 'a', 'b', 'a', 'b')

L'entier peut apparaître des deux côtés : t * 3 et 3 * t produisent le même résultat. Multiplier par 0 ou un nombre négatif retourne un tuple vide.

t = (1, 2, 3)
print(t * 0)   # ()
print(t * 1)   # (1, 2, 3)

Résultat :

()
(1, 2, 3)

Construire un tuple combiné avec tuple()

Le constructeur intégré tuple() convertit n'importe quel itérable en tuple. Vous pouvez l'utiliser pour construire un tuple combiné à partir d'une liste assemblée par ajouts successifs, ce qui est plus efficace que des appels répétés à + dans une boucle.

parts = [1, 2, 3]
parts += [4, 5, 6]        # build up a list first
combined = tuple(parts)   # convert to tuple once
print(combined)

Résultat :

(1, 2, 3, 4, 5, 6)

Pourquoi éviter + dans une boucle

Chaque appel à + crée un nouvel objet tuple et copie tous les éléments. Lors de la jointure de nombreux tuples, cela entraîne O(n²) copies. La méthode efficace consiste à collecter tous les éléments dans une liste et à convertir une seule fois à la fin :

tuples = [(1, 2), (3, 4), (5, 6), (7, 8)]

# Inefficient — creates a new tuple on each iteration
result = ()
for t in tuples:
    result = result + t   # many intermediate copies

# Efficient — build a list, convert once
result = tuple(item for t in tuples for item in t)
print(result)

Résultat :

(1, 2, 3, 4, 5, 6, 7, 8)

Joindre vs. imbriquer des tuples

Il est facile d'imbriquer accidentellement des tuples au lieu de les joindre. L'opérateur + aplatit d'un niveau ; envelopper des tuples dans un nouveau tuple crée une structure imbriquée.

t1 = (1, 2)
t2 = (3, 4)

joined = t1 + t2      # flat: all four elements at the same level
nested = (t1, t2)     # two-element tuple of tuples

print("joined:", joined)
print("nested:", nested)

Résultat :

joined: (1, 2, 3, 4)
nested: ((1, 2), (3, 4))

Utilisez + lorsque vous voulez un résultat plat. Utilisez (t1, t2) lorsque vous souhaitez intentionnellement un tuple de tuples (par exemple, un tableau de lignes).

Choisir la bonne approche

Sujets connexes

• Python Tuples — créer, indexer et trancher des tuples
• Accéder aux tuples — indexation et découpage des éléments de tuple
• Mettre à jour des tuples — solutions de contournement pour modifier des tuples immuables
• Déstructurer des tuples — assigner des éléments de tuple à des variables
• Itérer sur des tuples — parcourir les éléments d'un tuple
• Méthodes de tuple — référence de count() et index()
• Joindre des listes — fusionner des listes avec +, extend(), et plus encore

Pratique