Créer une liste de tuples à partir de plusieurs listes et tuples en Python

Utilisez list(zip(values_a, values_b, ...)) pour associer les valeurs situées à la même position et matérialiser le résultat en liste de tuples. La fonction intégrée zip() accepte les listes, les tuples et les autres itérables ; c’est donc généralement la façon la plus claire de combiner des valeurs correspondantes en Python.

Cet article utilise Python 3.14.7 et couvre les entrées de même longueur, le comportement par défaut avec des longueurs différentes, la validation stricte et la conservation de chaque ligne lorsqu’une entrée est plus longue.

Ce que renvoie zip()

Chaque élément produit par zip() est un tuple contenant une valeur de chaque entrée. L’objet zip est paresseux : il produit les tuples pendant l’itération au lieu de stocker tout le résultat. Enveloppez-le dans list() lorsqu’il faut une liste de tuples matérialisée, imprimable, indexable ou réutilisable.

Les entrées peuvent mélanger listes et tuples. L’association est positionnelle : les premières valeurs sont combinées, puis les deuxièmes, et ainsi de suite. La longueur du tuple correspond au nombre d’itérables fournis.

Créer une liste de tuples avec des entrées de même longueur

L’exemple suivant combine une liste de nombres et un tuple de lettres. list(zip(...)) consomme l’itérateur paresseux et renvoie la liste de tuples demandée.

values = list(zip([1, 2, 3], ("a", "b", "c")))
print(values)

Sortie :

[(1, 'a'), (2, 'b'), (3, 'c')]

Avec des entrées de même longueur, le résultat contient un tuple par position. L’opération ne nécessite aucun paquet tiers et la liste de sortie utilise un espace proportionnel au nombre de tuples produits. Si une seule itération suffit, conservez l’objet zip paresseux au lieu de le matérialiser.

Traiter les entrées de longueurs différentes

Par défaut, zip() s’arrête dès que l’entrée la plus courte est épuisée. C’est pratique si les valeurs supplémentaires doivent être ignorées, mais cela peut masquer des données manquantes lorsque toutes les entrées devraient avoir la même longueur. Utilisez strict=True lorsque l’égalité des longueurs est une invariance. Python lève alors ValueError dès qu’une entrée est plus courte ou plus longue.

try:
    list(zip([1, 2, 3], ("a", "b"), strict=True))
except ValueError as error:
    print(type(error).__name__, str(error))

Sortie :

ValueError zip() argument 2 is shorter than argument 1

L’option strict=True est disponible à partir de Python 3.10. Elle convient aux enregistrements qui doivent rester alignés ; gérez le ValueError ou validez les entrées avant de continuer.

Conserver chaque ligne avec itertools.zip_longest()

Lorsque le résultat doit inclure les positions de l’entrée la plus longue, utilisez itertools.zip_longest() plutôt que zip(). Les positions manquantes sont remplies par None, sauf si vous fournissez un fillvalue. Choisissez un marqueur impossible à confondre avec une valeur réelle.

Par exemple, list(itertools.zip_longest(first, second, fillvalue="missing")) conserve toutes les positions et marque la valeur absente par "missing". C’est le comportement approprié si la troncature à l’entrée la plus courte supprimait une ligne.

Construire la liste manuellement pour un contrôle explicite

La méthode manuelle avec des index est utile lorsque les entrées doivent être validées précisément comme objets list ou tuple, ou lorsque des règles personnalisées doivent accompagner l’association. Le remplacement exécutable convert = lambda *args: [] if not all(isinstance(value, (list, tuple)) for value in args) else [tuple(value[index] for value in args) for index in range(min((len(value) for value in args), default=0))] conserve la validation et s’arrête à l’entrée la plus courte. Pour les quatre valeurs d’exemple, il renvoie [(1.1, 'H', True, 100), (2.2, 'E', False, 200), (3.3, 'L', False, 300)].

La fonction refuse un argument dont le type n’est ni list ni tuple, puis s’arrête à l’entrée la plus courte. Avec m comme longueur minimale et n comme nombre d’entrées, elle prend O(m * n) et utilise O(m * n) d’espace pour le résultat matérialisé.

Choisir la méthode appropriée

Utilisez list(zip(...)) pour une association positionnelle ordinaire et un résultat matérialisé. Utilisez zip() paresseux lorsqu’une seule itération suffit. Utilisez strict=True si des longueurs différentes indiquent des données invalides, et itertools.zip_longest() avec un remplissage explicite lorsqu’aucune ligne ne doit être perdue. La méthode manuelle sert de solution de repli pour une validation ou un indexage personnalisé.