Python zip : tailles différentes et strict=True

Pourquoi zip tronque tes listes, quand strict=True lève une erreur et comment choisir zip_longest ou valider avant de traiter les paires en Python.

PythonPar
Publié le

Tu parcours deux listes ensemble, mais la dernière ligne n'apparaît jamais. Aucune exception : zip() s'est arrêté au bout de la liste la plus courte. Avant de corriger la boucle, décide ce que doit devenir une valeur sans partenaire.

En bref

En Python, zip(a, b) produit des tuples et s'arrête dès qu'une entrée est épuisée. Avec strict=True, disponible depuis Python 3.10, il lève une ValueError si les entrées ne s'épuisent pas ensemble, mais seulement pendant le parcours. Pour garder les éléments sans partenaire, utilise itertools.zip_longest() et choisis une valeur de remplacement. Si aucun traitement ne doit commencer avant cette vérification, consomme d'abord entièrement le résultat strict.

Pourquoi zip ignore le dernier élément ?

Un tuple a besoin d'une valeur de chaque entrée. Ici, C n'a aucun nombre correspondant : le résultat s'arrête après B.

pairs.py
keys = ["A", "B", "C"]values = [1, 2]print(list(zip(keys, values)))print(keys, values)
Terminal
$ python3 pairs.py[('A', 1), ('B', 2)]['A', 'B', 'C'] [1, 2]

Les listes restent intactes. zip() n'efface pas C et ne complète pas la seconde liste. C'est le parcours qui ne produit aucun tuple pour cette position. Avec trois entrées, la même règle s'applique dès que l'une des trois est épuisée.

Si les listes représentent les noms et notes des mêmes personnes, cette différence de longueur signale probablement une erreur en amont. Si tu veux volontairement traiter seulement leur préfixe commun, l'arrêt au plus court peut être exactement ton contrat.

Que faire d'une valeur sans partenaire ?

  • Préfixe commun voulu

    zip(a, b)

    Les éléments non appariés restent hors du résultat.

  • Données censées correspondre

    zip(a, b, strict=True)

    Épuiser le parcours pour détecter toute différence.

  • Toutes les valeurs comptent

    zip_longest(a, b)

    Définir le sens des valeurs de remplacement.

Que signifie une longueur différente ?

Quand strict=True lève son erreur ?

La vérification arrive quand on demande les tuples, pas à la création de l'objet. L'itérateur est paresseux : il attend que la boucle ou une conversion en liste le consomme.

strict.py
keys = ["A", "B", "C"]values = [1, 2]pairs = zip(keys, values, strict=True)print(type(pairs).__name__)seen = []try:    for pair in pairs:        seen.append(pair)except ValueError as error:    print(type(error).__name__ + ":", error)print(seen)
Terminal
$ python3 strict.pyzipValueError: zip() argument 2 is shorter than argument 1[('A', 1), ('B', 2)]

Les deux premières paires ont déjà été ajoutées à seen avant l'erreur. Le message numérote les arguments selon l'ordre de l'appel : ici, la seconde entrée est plus courte que la première. Inverser les entrées change ce diagnostic.

Une boucle interrompue par break après le premier tuple ne découvre donc pas nécessairement la différence de longueur. strict=True détecte un problème ; il n'annule pas les affichages, ajouts ou écritures déjà effectués.

Le contenu de seen pendant le parcours strict

Étape 1 sur 3

Avant la boucle

état
prêt
  1. seen[]

La création de zip n'a encore vérifié aucun élément.

Lire toutes les étapes
  1. 1. Avant la boucle

    état
    prêt
    1. seen[]

    La création de zip n'a encore vérifié aucun élément.

  2. 2. Après deux paires

    état
    parcours
    1. seen[('A', 1), ('B', 2)]

    Les ajouts ont eu lieu avant la demande suivante.

  3. 3. Après ValueError

    état
    erreur
    1. seen[('A', 1), ('B', 2)]

    L'exception ne retire pas les paires déjà ajoutées.

Comment vérifier avant de modifier le résultat ?

Pour des entrées finies qui tiennent en mémoire, matérialise toutes les paires strictes avant de modifier ta destination. Si la conversion échoue, l'instruction qui suit n'est pas exécutée.

validate.py
def collect_pairs(keys, values, saved):    pairs = list(zip(keys, values, strict=True))    saved.extend(pairs)
saved = []try:    collect_pairs(["A", "B", "C"], [1, 2], saved)except ValueError:    print("ValueError")print(saved)collect_pairs(["A", "B"], [1, 2], saved)print(saved)
Terminal
$ python3 validate.pyValueError[][('A', 1), ('B', 2)]

Cette fonction laisse saved intact quand les longueurs diffèrent. Elle stocke toutefois toutes les paires intermédiaires : ce choix coûte de la mémoire. Pour de simples listes, vérifier leurs longueurs avant la boucle évite cette copie, à condition qu'elles ne changent pas entre vérification et parcours.

Pour des générateurs ou des fichiers, la consommation peut elle-même avoir des effets. Construire la liste ne rembobine pas les entrées et ne transforme pas les traitements suivants en transaction. Sur un flux infini, cette validation complète ne se termine pas.

Comment conserver toutes les valeurs avec zip_longest ?

itertools.zip_longest() continue jusqu'à l'épuisement de l'entrée la plus longue. Il remplace les valeurs manquantes par None, ou par le fillvalue choisi.

longest.py
from itertools import zip_longest
keys = ["A", "B", "C"]values = [1, 2]print(list(zip_longest(keys, values)))print(list(zip_longest(keys, values, fillvalue=0)))
Terminal
$ python3 longest.py[('A', 1), ('B', 2), ('C', None)][('A', 1), ('B', 2), ('C', 0)]

Le zéro de la dernière paire vient du remplacement ; il n'existait pas dans values. Ne choisis pas zéro si « absent » et « valeur nulle » doivent rester distincts. Si None est aussi une valeur possible des données, une sentinelle dédiée permet de distinguer ces cas par identité.

Peut-on récupérer les éléments restants d'un itérateur ?

Ne compte pas sur zip() pour préserver chaque élément non produit. Il demande les valeurs aux entrées de gauche à droite ; un appel peut consommer une valeur de la première avant de découvrir que la seconde est épuisée.

iterators.py
left = iter([10, 20])right = iter([1])print(list(zip(left, right)))print(list(left))print(list(right))
Terminal
$ python3 iterators.py[(10, 1)][][]

Le nombre 20 a été demandé à left, mais aucun tuple n'a pu être produit avec lui. Les deux itérateurs sont épuisés. Cela ne contredit pas l'exemple des listes : les listes peuvent être reparcourues, alors que ces objets itérateurs avancent à chaque lecture. Un objet zip lui-même se consomme aussi une seule fois.

Comment passer des lignes aux colonnes ?

zip(*rows, strict=True) reçoit chaque ligne comme une entrée séparée. Il regroupe les caractères de même position : chaque tuple devient une colonne, de haut en bas.

grid.py
rows = ["cat", "owl"]print(list(zip(*rows, strict=True)))print(list(zip([], [], strict=True)))print(list(zip(strict=True)))try:    print(list(zip("cat", "ox", strict=True)))except ValueError as error:    print(type(error).__name__ + ":", error)
Terminal
$ python3 grid.py[('c', 'o'), ('a', 'w'), ('t', 'l')][][]ValueError: zip() argument 2 is shorter than argument 1

L'astérisque déplie la liste de lignes en arguments. Sans lui, la liste serait une seule entrée et tu obtiendrais des tuples contenant chacun une ligne entière. Ici, les deux chaînes ont trois caractères ; trois colonnes sont donc produites. Des lignes vides de même longueur donnent un résultat vide, comme un appel sans entrée.

L'exercice attend des chaînes pour les colonnes, alors que zip() produit des tuples. Il demande aussi de conserver les espaces, de gérer une grille vide et de ne pas modifier les lignes. À toi de faire cette adaptation ; des boucles indexées conviennent aussi.

Python

transpose_rows

8-bit

Transpose une grille de texte : vérifie les grilles rectangulaires, les colonnes d'espaces et les entrées vides, en gardant les lignes d'origine intactes.

Ouvrir l'exercice

Si ton problème porte plutôt sur les lignes qui changent ensemble, regarde la copie de listes imbriquées. Pour ordonner les enregistrements une fois associés, passe au tri à plusieurs critères.

Questions fréquentes

strict=True existe-t-il en Python 3.9 ?

Non, cet argument a été ajouté en Python 3.10. Sur des listes en 3.9, vérifie les longueurs avant le parcours ; sur des itérateurs, il faut une autre stratégie de validation.

strict=True vérifie-t-il les valeurs ?

Non. Deux listes de même longueur peuvent contenir des données incompatibles ou mal ordonnées. Le contrôle porte sur leur épuisement simultané.

Peut-on utiliser zip avec une seule entrée ?

Oui. Chaque élément produit est un tuple à une valeur. Sans entrée, le résultat est vide, même avec strict=True.

zip_longest fonctionne-t-il sur des flux infinis ?

Oui, mais il continue tant qu'une entrée fournit des valeurs. Limite explicitement le parcours si tu veux obtenir un résultat fini.

Sources

À toi d'écrire le code.