Ajout de l'élément de listes dans une compréhension de liste

J'ai une liste, disons, a = [[1,2],[3,4],[5,6]]

Je veux ajouter la chaîne 'a' de chaque élément dans la liste a.

Lorsque j'utilise:

 a = [x.append('a') for x in a]

il retourne [None,None,None].

Mais si j'utilise:

a1 = [x.append('a') for x in a]

puis il fait quelque chose de bizarre.

a, mais pas a1 est [[1,2,'a'],[3,4,'a'],[5,6,'a']].

Je ne comprends pas pourquoi le premier appel renvoie [None, None, None] ni pourquoi la seconde changements sur a au lieu de a1.

OriginalL'auteur ariel | 2010-03-24

  1. 24

    list.append mutation de la liste elle-même et renvoie None. Interprétations de la liste sont pour stocker le résultat, ce qui n'est pas ce que vous voulez dans ce cas, si vous voulez juste changer les listes initiales.

    >>> x = [[1, 2], [3, 4], [5, 6]]
>>> for sublist in x:
...     sublist.append('a')
...
>>> x
[[1, 2, 'a'], [3, 4, 'a'], [5, 6, 'a']]

    OriginalL'auteur Mike Graham

  2. 10

    Comme d'autres l'ont dit, append mutation de la liste elle-même, et vous ne devriez pas l'affecter à une variable. L'exécution des modifications de ses données, de manière efficace la mise à jour de tout le monde le pointe du doigt.

    Mais, il y a un truc que j'utilise quand je veux faire des trucs dans une fonctionnelle* en route alors que la mutation des objets existants (plutôt que d'en construire de nouveaux, dans ce cas, l' a=[x + ['a'] for x in a], ou plus précisément la x + ['a']).

    Donc, si vous êtes assez courageux, vous pouvez aussi le faire:

    >>> a=[[1,2],[3,4],[5,6]]
>>> a=[x.append('a') or x for x in a]
>>> a
[[1, 2, 'a'], [3, 4, 'a'], [5, 6, 'a']]

    Cela fonctionne parce que append retourne None, et la or continue sur pour effectuer une recherche de la vérité-valeur de y, qui x est (c'est un list avec au moins ce qui a été ajouté).

    Pourquoi ai-je besoin?

    Dire que vous avez une liste et que vous souhaitez insérer certains de ses membres à une nouvelle liste, et de mettre à jour les références en conséquence:

    De sorte que vous disposez de la liste all:

    >>> all = [[], [], [], []]

    Certains de il est inséré et mis à jour à une nouvelle liste x:

    >>> x = [i.append('x') or i for i in all[:2]]
>>> x
[['x'], ['x']]

    Certains de all est également inséré et mis à jour pour la liste y:

    >>> y = [i.append('y') or i for i in all[1:3]]

    all est mis à jour:

    >>> all
[['x'], ['x', 'y'], ['y'], []]

    Mais x est également mis à jour:

    >>> x
[['x'], ['x', 'y']]

    Et y est généré comme prévu:

    >>> y
[['x', 'y'], ['y']]

    Dans l'ensemble, pour les tâches simples, je vous recommande d'utiliser un for de la boucle de mise à jour de manière explicite. C'est ce qui est considéré comme pythonic.

    Techniquement parlant, si vous aviez accès à la liste de la classe, vous pouvez faire de cette fonction:

    def more_functional_append(self, x):
    self.append(x)
    return self
    • programmation fonctionnelle est basé sur toutes les déclarations qui font essentiellement une chose, et ne pas avoir d'effets secondaires (donc, pas de mutation et de retour). append n'est pas très pratique puisqu'il se transforme une liste (pure programmation fonctionnelle a seulement des objets immuables) et ne renvoie pas une raison pour passer à d'autres actions (fonctions). En utilisant les concepts de la programmation fonctionnelle, vous pouvez créer de superbes gros one-liners que personne ne peut lire, aussi connu comme la "sécurité de l'emploi" ou de "mauvais code".
    J'ai un point de vue différent sur cette réponse de nos jours donc, si vous lisez ceci s'il vous plaît commentaire afin que je puisse les mettre à jour. Il y a un manque de fonctionnalités de base pour la programmation fonctionnelle, ici, qui est immutabiliity et je dois étendre sur ce point.
    Je suis curieux de connaître votre point de nouvelles perspectives.
    mes idées nouvelles sont que, sans l'immuabilité de son tout simplement trop complexe. La valeur par défaut doit être immuable (et python a certaines solutions comme frozenset et tuple) - mais son vraiment manque de ne pas avoir un frozendict et n'ayant pas l'immuable versions en tant que par défaut. Je n'aime pas vraiment cette réponse depuis son très étrange, pour python.

    OriginalL'auteur Reut Sharabani

  3. 8

    Pour le premier cas, la raison pour laquelle il renvoie [None, None, None] est parce que le list.append fonction renvoie None, et c'est ce qu'il stocke dans la liste.

    Dans le second cas, c'est parce que la liste est mutable, et à chaque fois que vous ajoutez de la valeur, de la liste d'origine est modifié.

    Ce que vous avez besoin est un non-lieu ajout de l'opérateur, tels que +. c'est à dire [x + ['a'] for x in a].

    OriginalL'auteur sykora

  4. 3

    (C'est une combinaison de réponses par Mike Graham et sykora):

    Si vous souhaitez simplement modifier les valeurs en place, essayez un régulier pour une boucle, et pas une compréhension de liste:

    for sublist in a:
    sublist.append('a')

    Si vous voulez laisser un seul, et mettre le résultat dans la plage a1:

    a1 = [sublist + ['a'] for sublist in a]

    Comme ils ont expliqué, append modifie la liste, mais ne renvoie Aucun, alors que + laisse la seule liste, mais retourne une nouvelle liste ci-jointe.

    Qui doit être a1 = [sous-liste + ['un'] pour la sous-a]. Note crochets autour de "a".
    Oups. Fixe. Merci.

    OriginalL'auteur Oddthinking

  5. 2

    Vous pouvez utiliser la liste de plus à l'intérieur d'une compréhension de liste, comme suit:

    a = [x + ['a'] pour x dans]

    Ce qui donne le résultat souhaité pour un. On pourrait le rendre plus efficace dans ce cas par l'affectation de ['a'] à un nom de variable avant la boucle, mais cela dépend de ce que vous voulez faire.

    OriginalL'auteur Bud

  6. 0

    quitter le a = et sur le côté effet sur a:

    [x.append('a') for x in a] 
print a
    S'il vous plaît, non. Jeter une compréhension de liste juste d'utiliser ses effets secondaires est mauvais; votre suggestion fonctionne, mais c'est mal vu comme similaires map utilisation a été mal vu. Explicite est mieux que implicites; utiliser une boucle plutôt que d'une compréhension de liste.

    OriginalL'auteur Ruggero Turra

  7. 0

    Dans la première affectation de la valeur de votre compréhension de liste un Attribut d'Erreur, 'NoneType' object n'a pas d'attribut 'append', permet d'expliquer pourquoi votre liste, un, sera chargé avec Aucune(s). Pour obtenir ma console pour lancer l'erreur, j'ai utilisé x comme une variable de la liste de compréhension et aussi de l'itérateur. 

    Traceback (most recent call last):
x = [x.append('a') for x in a]
AttributeError: 'NoneType' object has no attribute 'append'

    Ensuite, j'ai repris l'un de x et il a jeté la même erreur. 

    Traceback (most recent call last):
a = [x.append('a') for x in a]
AttributeError: 'NoneType' object has no attribute 'append'

    OriginalL'auteur Rider