La vue qui se consomme : map, zip, filter, et le générateur épuisé The view that consumes itself: map, zip, filter, and the exhausted generator

map(), zip(), filter() ne sont pas des listes déguisées : ce sont des vues paresseuses, des itérateurs au sens strict du №10, épuisés dès qu'on les a parcourus une fois. Réutiliser l'un d'eux ne lève aucune erreur — il rend juste « vide », en silence, comme s'il n'avait jamais rien contenu. Le seul antidote : list(), et son prix en mémoire. map(), zip(), filter() aren't disguised lists: they're lazy views, iterators in №10's strict sense, exhausted the moment you've walked them once. Reusing one raises no error — it just goes 'empty', silently, as if it never held anything. The one antidote: list(), and its price in memory.

Audience
Dev qui a déjà passé le même map() à deux fonctions et obtenu un résultat vide sans comprendre Dev who's passed the same map() to two functions and gotten an empty result without understanding why
ChapitresChapters
5
LectureReading
≈ 18 min
NiveauLevel
●●○○
Date
Juil 2026 Jul 2026

Itérateursmap/zip/filterGénérateurs

SommaireContents ·
№ 01CadrageFraming3 min

map() ne transforme rien. Il promet de transformer, un élément à la fois.map() transforms nothing. It promises to transform, one element at a time.

Les numéros précédents ont montré la paresse à travers l'itérateur écrit à la main et le générateur avec yield. Ce dernier numéro du volume referme la boucle en montrant que map(), zip() et filter() — trois fonctions natives que tout le monde utilise depuis toujours — obéissent exactement au même protocole. map(str.upper, noms) ne convertit aucune chaîne : elle retourne un objet map, un itérateur qui n'a encore rien fait. La conversion n'a lieu qu'élément par élément, au fil du for — jamais avant, jamais toute d'un coup.The previous issues showed laziness through the hand-written iterator and the yield-based generator. This volume's closing issue rounds the loop by showing that map(), zip() and filter() — three built-in functions everyone has always used — obey exactly the same protocol. map(str.upper, noms) converts no string: it returns a map object, an iterator that has done nothing yet. The conversion only happens element by element, as the for loop runs — never before, never all at once.

map() est une vue, pas un résultatmap() is a view, not a result
noms = ["ana", "bo", "cyril"]

maj = map(str.upper, noms)     # AUCUN nom n'est encore mis en majuscules
print(type(maj))                # <class 'map'> — pas une liste
print(maj)                      # <map object at 0x...> — rien à afficher, c'est une vue

for m in maj:                   # SEULEMENT MAINTENANT str.upper() tourne, un par un
    print(m)                    # 'ANA', 'BO', 'CYRIL'
Le sous-réflexe du numéroThis issue's sub-reflex

Face à map(), zip() ou filter(), ne demande jamais « qu'est-ce qu'il contient ? » mais « combien de fois vais-je le parcourir ? » Une fois : laisse-le tel quel. Plus d'une fois : matérialise-le.Facing map(), zip() or filter(), never ask "what does it hold?" but "how many times will I walk it?" Once: leave it as is. More than once: materialize it.

Trois fonctions, un seul protocoleThree functions, one protocol

map, zip et filter ne sont pas des cas particuliers à retenir séparément : ce sont trois façades sur le même protocole itérateur du №10 — __iter__ qui retourne self, __next__ qui avance, StopIteration à la fin.map, zip and filter aren't special cases to memorize separately: they're three façades over №10's same iterator protocol — __iter__ returning self, __next__ advancing, StopIteration at the end.

№ 02La surpriseThe surprise4 min

Ces trois familières sont des itérateurs — pas des itérables. La nuance du №10 s'applique.These three familiar faces are iterators — not iterables. №10's nuance applies.

Le №10 a posé le test qui distingue les deux : iter(x) is x. Appliqué à map, zip et filter, il répond True à chaque fois — ce sont déjà leur propre itérateur, au même titre que le générateur du №11 ou la classe Compteur écrite à la main. Aucune liste sous le capot, aucun cache, aucune reparcourabilité. Et comme tout itérateur, ils ont leurs propres subtilités de comportement — zip(), en particulier, s'arrête au plus court des itérables qu'on lui donne, sans un mot pour signaler le déséquilibre.№10 laid out the test that tells them apart: iter(x) is x. Applied to map, zip and filter, it answers True every time — they're already their own iterator, exactly like №11's generator or the hand-written Compteur class. No list underneath, no cache, no re-walkability. And like any iterator, they have their own behavioral quirks — zip(), in particular, stops at the shortest of the iterables it's given, without a word about the mismatch.

Les trois sont déjà leur propre itérateurAll three are already their own iterator
m = map(str.upper, ["a", "b"])
z = zip([1, 2], ["x", "y"])
f = filter(None, [0, 1, 2, ""])

print(iter(m) is m)     # True
print(iter(z) is z)     # True
print(iter(f) is f)     # True
# les trois sont DÉJÀ leur propre itérateur — comme le générateur du №11,
# comme le Compteur du №10 : __iter__ retourne self, épuisé une fois pour toutes

Aucune surprise de conception ici : map, zip, filter sont volontairement construits comme des itérateurs, pas comme des itérables. C'est un choix de la bibliothèque standard, cohérent avec le principe de paresse — retourner une liste obligerait à tout calculer d'un coup, ce qu'ils sont précisément conçus pour éviter.No design surprise here: map, zip, filter are deliberately built as iterators, not iterables. It's a standard-library choice, consistent with the laziness principle — returning a list would force computing everything at once, exactly what they're designed to avoid.

Trois noms différents, un seul comportement de fond. Ce qui vaut pour un générateur vaut pour map, zip et filter.Three different names, one underlying behavior. What holds for a generator holds for map, zip and filter.
№ 03La mécaniqueThe mechanics5 min

Empiler map() et filter() ne construit jamais de liste intermédiaire.Stacking map() and filter() never builds an intermediate list.

La preuve la plus directe de la paresse : glisser un print() dans la fonction transformée, et observer qu'il ne s'affiche qu'au compte-gouttes, un appel de next() à la fois — jamais tous en bloc à la création de la vue. Cette paresse se compose : empiler filter() dans map() ne fabrique aucune liste intermédiaire filtrée avant de la transformer. Un seul nombre traverse tout le pipeline à chaque tour de for, de bout en bout, avant que le suivant ne commence son propre trajet.The most direct proof of laziness: slip a print() into the transformed function, and watch it fire in a trickle, one next() call at a time — never all at once when the view is created. This laziness composes: stacking filter() inside map() builds no intermediate filtered list before transforming it. A single number travels the whole pipeline on each for turn, start to finish, before the next one begins its own trip.

Le calcul se répartit un appel de next() à la foisThe computation spreads one next() call at a time
def carre_bruyant(x):
    print(f"calcule {x}")
    return x * x

vue = map(carre_bruyant, [1, 2, 3])
print("vue créée")           # rien de "calcule" ne s'est encore affiché

premier = next(vue)           # affiche "calcule 1", puis renvoie 1
print(premier)
# "calcule 2" et "calcule 3" n'ont toujours pas eu lieu — un élément à la fois

« vue créée » s'affiche avant tout « calcule » — la construction de map() ne touche à rien. Chaque next() ne calcule que l'élément qu'il rend, jamais un de plus, jamais un de moins."vue créée" prints before any "calcule" — building map() touches nothing. Each next() only computes the element it returns, never one more, never one less.

Le réflexe en une ligneThe reflex in one line

Empiler des vues paresseuses ne coûte rien tant qu'on ne les tire pas. La facture — le calcul, pas la mémoire — n'arrive qu'à la consommation.Stacking lazy views costs nothing until you pull them. The bill — computation, not memory — only arrives at consumption.

№ 04Le piègeThe trap4 min

Passer une vue à une fonction ne la protège pas d'être vidée par sa première ligne.Passing a view into a function doesn't protect it from being drained by its first line.

Le piège qui referme le volume est le même que celui effleuré au №10, mais dans son incarnation la plus commune : une fonction reçoit un paramètre qui ressemble à une collection, et l'utilise plusieurs fois en pensant relire la même donnée à chaque appel. Si l'argument reçu est une vue paresseuse — map, zip, filter, un générateur — la première utilisation la vide, et toutes les suivantes trouvent une coquille vide, sans un mot d'avertissement. Le paramètre n'a pas de type qui distingue « liste » de « vue épuisable » : à l'intérieur de la fonction, les deux se ressemblent, jusqu'à ce que l'une des deux se comporte différemment.The trap that closes this volume is the same one brushed against in №10, but in its most common form: a function receives a parameter that looks like a collection, and uses it several times assuming it re-reads the same data on each call. If the argument received is a lazy view — map, zip, filter, a generator — the first use drains it, and every following one finds an empty shell, with no warning. The parameter has no type distinguishing 'list' from 'exhaustible view': inside the function, the two look alike, until one of them behaves differently.

sum() vide l'argument avant que max() n'y touchesum() drains the argument before max() reaches it
def rapport(valeurs):
    print("total :", sum(valeurs))
    print("maximum :", max(valeurs))     # valeurs déjà vidé par sum()
    print("nombre :", len(list(valeurs)))  # 0 — plus rien à compter

carres = map(lambda x: x * x, [1, 2, 3])
rapport(carres)
# total : 14
# ValueError: max() iterable argument is empty
# la fonction n'a rien fait de mal : "valeurs" est un paramètre qui reçoit
# la MÊME vue, épuisée après le premier passage dedans

La fonction rapport est écrite comme si valeurs était une liste ordinaire — trois lectures indépendantes. C'est l'appelant, en passant une vue plutôt qu'une liste, qui déclenche le piège ; la fonction elle-même est innocente et pourtant coupable, selon ce qu'on lui donne.The rapport function is written as if valeurs were an ordinary list — three independent reads. It's the caller, by passing a view instead of a list, that triggers the trap; the function itself is innocent yet at fault, depending on what it's handed.

Le contre-emploiThe counter-use

Ne matérialise pas une fonction qui ne parcourt son argument qu'une fois — une fonction comme total = sum(valeurs) seule accepte n'importe quelle vue sans jamais la pénaliser. Le list() défensif n'a de sens que face à un usage réellement multiple.Don't materialize a function that only walks its argument once — a function like a lone total = sum(valeurs) accepts any view without ever penalizing it. Defensive list() only makes sense against genuinely repeated use.

Le réflexe qui clôt le volumeThe reflex that closes the volume

Avant d'écrire une seconde lecture d'un paramètre, demande : est-ce une liste, ou pourrait-ce être une vue déjà passée ailleurs ? Dans le doute, list() une fois, au bon endroit.Before writing a second read of a parameter, ask: is this a list, or could it be a view already passed elsewhere? When in doubt, list() it once, at the right spot.

№ 05Bilan & éditoWrap-up & editorial2 min

Itérateurs & générateurs, refermé : la paresse est un contrat, pas un détail d'implémentation.Iterators & generators, closed: laziness is a contract, not an implementation detail.

Trois numéros pour une seule idée creusée sous trois angles : produire une valeur à la demande coûte moins de mémoire qu'en garder la liste complète, mais engage à ne la parcourir qu'une fois. Le №10 a posé le protocole (__iter__, __next__, StopIteration) et sa distinction cardinale, itérable contre itérateur. Le №11 a montré comment yield génère ce protocole depuis une fonction ordinaire, sans un attribut d'instance. Ce numéro a montré que ce n'est pas une curiosité de code exotique : map, zip, filter — les fonctions les plus banales de Python — vivent sous la même règle, avec le même piège au bout.Three issues for one idea dug from three angles: producing a value on demand costs less memory than keeping the full list, but commits you to walking it only once. №10 laid out the protocol (__iter__, __next__, StopIteration) and its cardinal distinction, iterable versus iterator. №11 showed how yield generates that protocol from a plain function, without a single instance attribute. This issue showed it's not an exotic curiosity: map, zip, filter — Python's most ordinary functions — live under the same rule, with the same trap at the end.

NuméroIssueCe qu'il a poséWhat it established
№ 10Le protocole __iter__/__next__/StopIteration ; itérable (reparcourable) contre itérateur (épuisé une fois).The __iter__/__next__/StopIteration protocol; iterable (re-walkable) vs iterator (exhausted once).
№ 11yield génère ce protocole sans classe ni attribut ; état gelé dans le cadre d'exécution du générateur ; paresse jusqu'à l'infini.yield generates that protocol with no class or attribute; state frozen in the generator's frame; laziness all the way to infinity.
№ 12map/zip/filter sont ce même protocole, sous un nom banal ; l'argument passé une fois se vide, sans erreur.map/zip/filter are that same protocol, under an ordinary name; the argument passed once drains, with no error.
La paresse ne se voit jamais dans la syntaxe. Elle ne se voit que dans le nombre de fois où tu oses parcourir.Laziness never shows in the syntax. It only shows in how many times you dare to walk it.
Mot de l'éditeurFrom the editor

Le Vol. IV a exploré un axe : quand une valeur est-elle produite ? Le suivant en explore un autre : quand un nom est-il lu ?Vol. IV explored one axis: when is a value produced? The next one explores another: when is a name read?

Le Vol. I posait déjà la question de la résolution de nom — à quel objet un nom est lié. Le Vol. V la rouvre, mais dans le temps : un nom lu à l'intérieur d'une fonction n'est pas toujours résolu au moment où on le lit à l'œil. Python cherche un nom dans quatre portées, dans un ordre précis — Local, Enclosing, Global, Built-in — et une simple assignation, même plus bas dans le code, peut faire basculer tout un nom du global au local, avant même que la ligne ne s'exécute.Vol. I already raised the question of name resolution — which object a name is bound to. Vol. V reopens it, but in time: a name read inside a function isn't always resolved at the moment your eye reads it. Python searches for a name across four scopes, in a precise order — Local, Enclosing, Global, Built-in — and a mere assignment, even further down in the code, can flip an entire name from global to local, before the line even runs.

Prochain numéro : LEGB, la résolution des noms. Local, Enclosing, Global, Built-in ; l'UnboundLocalError qui surgit quand une assignation rend un nom local sans qu'on l'ait voulu ; lecture contre écriture d'un nom. Ouverture du Vol. V.Next issue: LEGB, name resolution. Local, Enclosing, Global, Built-in; the UnboundLocalError that appears when an assignment makes a name local without meaning to; reading versus writing a name. Opening Vol. V.