Poursuite de ligne pour les compréhensions de liste ou les expressions de générateur en python

Question

Comment êtes-vous censé décomposer une très longue liste de compréhension ?

[something_that_is_pretty_long for something_that_is_pretty_long in somethings_that_are_pretty_long]

J'ai aussi vu quelque part que les gens qui n'aiment pas utiliser "\" pour les lignes de rupture, mais n'ont jamais compris pourquoi. Quelle est la raison de cette attitude ?

Answer 1

[x
 for
 x
 in
 (1,2,3)
]

fonctionne bien, vous pouvez donc faire à peu près ce que vous voulez. Je préférerais personnellement

 [something_that_is_pretty_long
  for something_that_is_pretty_long
  in somethings_that_are_pretty_long]

La raison pour laquelle \ n'est pas très appréciée est qu'elle apparaît à la fin d'une ligne, où il ne ressort pas ou nécessite un remplissage supplémentaire, qui doit être corrigé lorsque la longueur des lignes change :

x = very_long_term                     \
  + even_longer_term_than_the_previous \
  + a_third_term

Dans ce cas, utilisez des parenthèses :

x = (very_long_term
     + even_longer_term_than_the_previous
     + a_third_term)

Answer 2

Je n'y suis pas opposé :

variable = [something_that_is_pretty_long
            for something_that_is_pretty_long
            in somethings_that_are_pretty_long]

Vous n'avez pas besoin \ dans ce cas. En général, je pense que les gens évitent \ parce que c'est légèrement laid, mais aussi parce que cela peut poser des problèmes si ce n'est pas la toute dernière chose sur la ligne (assurez-vous qu'aucun espace ne le suit). Je pense qu'il est préférable de l'utiliser plutôt que de ne pas le faire, afin de limiter la longueur des lignes.

Depuis \ n'est pas nécessaire dans le cas ci-dessus, ou pour les expressions entre parenthèses, je trouve en fait qu'il est assez rare que je doive l'utiliser.

Answer 3

Vous pouvez également utiliser des indentations multiples dans les cas où vous traitez une liste de plusieurs structures de données.

new_list = [
    {
        'attribute 1': a_very_long_item.attribute1,
        'attribute 2': a_very_long_item.attribute2,
        'list_attribute': [
            {
                'dict_key_1': attribute_item.attribute2,
                'dict_key_2': attribute_item.attribute2
            }
            for attribute_item
            in a_very_long_item.list_of_items
         ]
    }
    for a_very_long_item
    in a_very_long_list
    if a_very_long_item not in [some_other_long_item
        for some_other_long_item 
        in some_other_long_list
    ]
]

Remarquez comment il filtre également sur une autre liste en utilisant une instruction if. Il est également utile de placer l'instruction if sur sa propre ligne.

Answer 4

Je dirais que vous ne devriez pas utiliser une compréhension de liste dans ce cas, et plutôt utiliser une for boucle :

result = []
for something_that_is_pretty_long in somethings_that_are_pretty_long:
    result.append(something_that_is_pretty_long)

L'une des raisons d'utiliser les compréhensions de listes plutôt qu'une for boucle + .append() est qu'il peut être beaucoup plus concis que l'utilisation d'un fichier explicite for boucle. Toutefois, lorsque la compréhension de la liste doit être répartie sur plusieurs lignes, cette concision peut rendre l'expression extrêmement difficile à lire.

Bien que PEP8 n'interdise pas explicitement les compréhensions de listes multi-lignes, l'option Guide de style Python de Google exige que chaque partie de la compréhension d'une liste tienne sur une seule ligne (c'est moi qui souligne) :

2.7 Compréhensions et expressions génératrices

Bon à utiliser pour les cas simples. Chaque portion doit tenir sur une ligne Expression de mappage, clause for, expression de filtre. Les clauses for ou les expressions de filtrage multiples ne sont pas autorisées. Utilisez plutôt des boucles lorsque les choses deviennent plus compliquées.