Liste en compréhension

Une seule fois

Sans m'attarder trop en détails sur ce que sont les générateurs [4] il m'apparaît important de préciser quelques unes de leurs limitations. Tout d'abord un exemple :

>>> g = (i for i in range(10))
>>> list(g)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> list(g)
[]

Je tranforme ici un générateur en objet list une première fois, avec succès puisque j'obtiens l'intégralité des éléments. Lors de la seconde transformation, le résultat est une liste vide, car le générateur est arrivé au bout de son traitement. Il a été entièrement consommé et ne peut aller plus loin. Le résultat est donc une liste vide.

À chaque fois qu'une opération demande de parcourir le générateur, elle provoque son exécution. Cette exécution s'arrête si l'une de ces conditions est remplie :

• Le générateur arrive au bout de son traitement, il n'y a donc plus rien à exécuter (le générateur lèvera une exception StopIteration).
• Le parcours est arrêté manuellement, ce qui cesse mécaniquement d'exécuter le générateur.

En quelque sorte, le parcours consomme le générateur, et une fois consommé il n'y a donc plus rien. Cela peut être une source d'incompréhension et de bugs. Commençons par une liste :[5]

>>> l = list(range(10))
>>> l
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> 2 in l
True
>>> 2 in l
True

Lorsqu'un élément est présent dans une liste, en vérifier la présence ne change rien. C'est l'avantage d'avoir la liste en mémoire, permettant de vérifier la présence de données à tout instant. La liste existe en entier, et elle est capable de fournir des informations sur son contenu sans être altérée par cette opération.

Maintenant, voici ce qui se passe lorsque j'utilise un générateur à la place d'une liste :

>>> g = (i for i in range(10))
>>> 2 in g
True
>>> 2 in g
False

Lors du premier 2 in g, le générateur est consommé jusqu'à ce que l'opérateur in en arrête le parcours en trouvant l'élément recherché. Au second 2 in g, le générateur a déjà consommé les premiers éléments, et l'opérateur in continue donc de parcourir le générateur jusqu'à le consommer entièrement, sans jamais trouver le bon élément : il retourne donc False, et le générateur ne contient plus rien. En essayant de transformer le générateur en liste, cette dernière est vide :

>>> list(g)
[]

Il faut donc faire très attention lorsque vous manipulez un générateur, tant sa fonction est précise et son comportement particulier. Lorsque vous utilisez un itérable dans vos fonctions, assurez vous de bien réfléchir au comportement dont vous dépendez : s'il faut parcourir plusieurs fois, ou bien connaître la taille de l'itérable, ou encore s'il faut accéder directement à un élément par son index, alors ce n'est pas un générateur qu'il vous faut. C'est peut-être l'occasion de considérer une séquence ou un autre type de données ayant les bonnes propriétés pour votre usage.

Étape intermédiaire

Un avantage que je trouve au générateur est sa capacité à exprimer un traitement séquentiel tout en permettant un contrôl précis quant à l'éxécution des opérations de génération.

Si personne ne parcourt un générateur, il ne consomme presque pas de ressources (mémoire comme CPU). Cela en fait un candidat idéal pour générer des résultats intermédiaires, qu'il n'est pas nécessaire de parcourir plus d'une fois :

>>> raw_source = [
...     "arbre",
...     "banane",
...     None,
...     "chaise",
...     "",
...     "pizza",
... ]
>>>
>>> words = (word for word in raw_source if word)
>>> filtered_words = (word for word in words if len(word) > 5)
>>> ", ".join(filtered_words)
'banane, chaise'

Il y a deux générateurs :

• Le premier n'accepte que les éléments non vide (ni None ni une chaîne vide).
• Le second utilise cette liste pour filtrer sur les mots qui font plus de 5 caractères. [6]

La méthode str.join permet de joindre tous les mots de la liste par une virgule, donnant le résultat final 'banane, chaise'. La liste d'origine raw_source n'a été parcourue qu'une seule et unique fois, bien qu'au travers de plusieurs générateurs.

Une question de taille

Imaginez un cas peut-être plus concret, avec un long fichier CSV de plusieurs millions de lignes : stocker l'intégralité du fichier en mémoire n'est peut-être pas possible, ou bien consomme trop de ressources. Dans ce cas, le générateur permet d'effectuer une suite de traitements sur chaque ligne, et ce, sans jamais stocker l'intégralité du fichier en mémoire :

import csv

# open input & output CSV files
with (
    open('input.csv', newline='') as in_csv,
    open('output.csv', 'w', newline='') as out_csv,
):
    # get a reader and a writer on the CSV files
    reader = csv.reader(in_csv)
    writer = csv.writer(out_csv)
    # parse each line from the reader
    temporaries = (
        parse(line)
        for line in reader
        if line  # exclude empty lines
    )
    # apply a condition on the parsed lines
    temporary = (
        transform(line)
        for line in temporaries
        if apply_condition_on(line)
    )
    # write each lines
    writer.writerows(temporary)

Ce bloc de code mélange plusieurs choses : ouvrir des fichiers CSV pour la lecture et l'écriture (les objets reader et writer), appliquer plusieurs traitements (via des générateurs), puis sauvegarder le résultat (via la méthode writer.writerows()).

Le reader est un itérateur sur les lignes du fichier, qui permet de parcourir ce dernier ligne par ligne. J'utilise alors un premier générateur pour parcourir ce fichier et appliquer la fonction parse() sur chaque ligne qui ne soit pas vide (if line). Aucune opération n'est exécutée par le code à ce moment là, puisqu'il s'agit d'un générateur.

Ensuite, j'applique la fonction transform() à chaque ligne valide d'après la fonction apply_condition_on(). Là encore, aucune exécution de code, puisqu'il s'agit à nouveau d'un générateur.

En fin de course, j'appelle la méthode writer.writerows() sur mon dernier générateur, provoquant son exécution : chaque ligne lue va être traitée puis écrite dans le fichier de sortie, et ce, sans jamais la conserver en mémoire une fois écrite. De fait, il n'y a jamais plus d'une ligne stockée en mémoire lors du parcours du fichier d'entrée et de son traitement.

Imaginons alors que ce fichier pèse plusieurs Go, le traitement sera peut-être long, il ne consommera cependant pas plus que la mémoire requise pour stocker une seule ligne de ce fichier !

Sucre syntaxique

Comme tout ceci n'est que du sucre syntaxique sur la boucle for-in, il est tout à fait possible d'écrire la même chose sans générateur :

import csv

# open input & output CSV files
with (
    open('input.csv', newline='') as in_csv,
    open('output.csv', 'w', newline='') as out_csv,
):
    # get a reader and a writer on the CSV files
    reader = csv.reader(in_csv)
    writer = csv.writer(out_csv)
    # parse each line from the reader
    for line in reader:
        if line:  # exclude empty lines
            temporary = parse(line)
            # apply a condition on the parsed lines
            if apply_condition_on(temporary):
                temporary = transform(temporary)
                # write one line
                writer.writerow(transform(temporary))

Ce n'est donc pas une question du nombre de lignes de code, puisque la version avec des for-in prend moins de place.

Je trouve la version avec générateur plus simple à lire, car séquentielle, là où la version avec une boucle et plusieurs conditions imbriquées est un peu plus difficile à suivre pour moi. C'est à la fois une question d'habitude, et une question du nombre d'opérations à garder en tête à chaque itération. [7] Cependant, je vous laisse seul juge sur cet aspect là.

Là où l'avantage me semble plus concret, c'est qu'il est plus facile de modifier le premier code en intervenant au milieu des traitements, avec ou sans découpage du code, là où ce sera plus complexe avec cette seconde structure. La seconde structure demande de savoir où placer le nouveau code, au bon niveau d'imbrication, là où la première structure avec les générateurs permet d'intercaler des modifications plus aisément.

D'ailleurs, pourquoi se contenter d'en parler, lorsque je peux le montrer avec du code :

import csv

def parse_all(lines):
    """Apply ``parse`` to each valid line in ``lines``."""
    return (
        parse(line)
        for line in lines
        if line
    )

def transform_all(lines):
    """Apply ``transform`` to each valid line in ``lines``."""
    return (
        transform(line)
        for line in parse_lines(reader)
        if apply_condition_on(line)
    )

# open input & output CSV files
with (
    open('input.csv', newline='') as in_csv,
    open('output.csv', 'w', newline='') as out_csv,
):
    # get a reader and a writer on the CSV files
    reader = csv.reader(in_csv)
    writer = csv.writer(out_csv)
    # parse and transform
    temporary = parse_all(reader)
    temporary = transform_all(temporary)
    # write each lines
    writer.writerows(temporary)

Ici, il est tout à fait possible d'ajouter une nouvelle fonction entre ces deux lignes :

temporary = parse_all(reader)
# ici, par exemple : temporary = new_function(temporary)
temporary = transform_all(temporary)

Outre la possibilité d'intervenir dans le code, et de le factoriser, un autre avantage est qu'au lieu d'avoir une seule énorme boucle de traitement de l'information, il y a maintenant deux fonctions qui peuvent être testée unitairement, pour en prouver le comportement :

• parse_all accepte n'importe quel itérable, pas seulement un CSV, et retourne un générateur qu'il est possible d'inspecter aussi.
• transform_all fonctionne de la même façon, en acceptant un itérable et en retournant à son tour un générateur.

Cela veut aussi dire qu'il est plus simple d'ajouter ou de retirer des traitements intermédiaires avant ou après les appels à parse_all et transform_all. [8]

Tuple

La classe tuple fonctionne comme une version immuable de la classe list. Pour générer un tuple, le plus simple est de transformer une expression de générateur en tuple :

>>> tuple(i**2 for i in range(10))
(0, 1, 4, 9, 16, 25, 36, 49, 64, 81)

Notez l'absence de parenthèses ou de crochets superflus.

Set

La classe set dispose de propriétés intéressantes, puisque c'est une liste dont tous les éléments sont uniques. Il n'est pas nécessaire de lui fournir un itérable où les éléments sont déjà uniques, la classe set s'en occupera elle même. Contrairement à la classe tuple il est possible d'utiliser directement la syntaxe des listes en compréhension en utilisant des accolades :

>>> {i**2 for i in range(10)}
{0, 1, 64, 4, 36, 9, 16, 49, 81, 25}

Vous noterez à l'occasion qu'un objet set n'est pas ordonné.

Mapping

La classe dict (et ses divers dérivés) permet de déclarer des mappings de type (clé, élément), et d'accéder à un élément non pas via son index, mais via sa clé. Tout comme les objets de la classe set, il est possible d'utiliser une syntaxe similaire aux listes en compréhension :

>>> {i: i**2 for i in range(10)}
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}