Comment permettre à la méthode list append() de retourner la nouvelle liste ?

Question

Je veux faire quelque chose comme ça :

myList = [10, 20, 30]
yourList = myList.append(40)

Malheureusement, list append ne retourne pas la liste modifiée.

Alors, comment puis-je permettre append pour retourner la nouvelle liste ?

Answer 1

N'utilisez pas l'append mais la concaténation à la place :

yourList = myList + [40]

Cela renvoie un nouveau liste ; myList ne seront pas affectés. Si vous avez besoin de myList affecté également soit utiliser .append() de toute façon, puis assignez yourList séparément de (une copie de) myList .

Answer 2

En python 3, vous pouvez créer une nouvelle liste en déballant l'ancienne et en ajoutant un nouvel élément :

a = [1,2,3]
b = [*a,4] # b = [1,2,3,4] 

quand vous le faites :

myList + [40]

Vous avez en fait 3 listes.

Answer 3

Malheureusement, aucune des réponses données ici ne résout exactement la question posée. Voici une approche simple :

lst = [1, 2, 3]
lst.append(4) or lst  # the returned value here would be the OP's `yourList`
# [1, 2, 3, 4]

On peut se demander s'il est vraiment nécessaire de faire cela, par exemple si quelqu'un a besoin d'améliorer l'utilisation de la RAM, de faire des micro-benchmarks, etc. qui le sont, généralement inutile. Cependant, il arrive que quelqu'un "demande vraiment ce qui a été demandé" (je ne sais pas si c'est le cas ici) et la réalité est plus diverse que ce que nous pouvons connaître. Voici donc un usage (inventé car hors contexte)... Au lieu de faire ça :

dic = {"a": [1], "b": [2], "c": [3]}

key, val = "d", 4  # <- example
if key in dic:
    dic[key].append(val)
else:
    dic[key] = [val]
dic
#  {'a': [1], 'b': [2], 'c': [3], 'd': [4]}

key, val = "b", 5  # <- example
if key in dic:
    dic[key].append(val)
else:
    dic[key] = [val]
dic
#  {'a': [1], 'b': [2, 5], 'c': [3], 'd': [4]}

On peut utiliser l'expression OR ci-dessus à chaque fois qu'une expression est nécessaire (au lieu d'une déclaration) :

key, val = "d", 4  # <- example
dic[key] = dic[key].append(val) or dic[key] if key in dic else [val]
#  {'a': [1], 'b': [2], 'c': [3], 'd': [4]}

key, val = "b", 5  # <- example
dic[key] = dic[key].append(val) or dic[key] if key in dic else [val]
#  {'a': [1], 'b': [2, 5], 'c': [3], 'd': [4]}

Ou, de manière équivalente, lorsqu'il n'y a pas falsy dans les listes, on peut essayer dic.get(key, <default value>) d'une meilleure manière.

Answer 4

list.append est un élément intégré et ne peut donc pas être modifié. Mais si vous êtes prêt à utiliser autre chose que append vous pouvez essayer + :

In [106]: myList = [10,20,30]

In [107]: yourList = myList + [40]

In [108]: print myList
[10, 20, 30]

In [109]: print yourList
[10, 20, 30, 40]

Bien sûr, l'inconvénient est qu'une nouvelle liste est créée, ce qui prend beaucoup plus de temps que append

J'espère que cela vous aidera

Answer 5

Essayez d'utiliser itertools.chain(myList, [40]) . Cela retournera un générateur sous forme de séquence, plutôt que d'allouer une nouvelle liste. Essentiellement, cela renvoie tous les éléments du premier itérable jusqu'à ce qu'il soit épuisé, puis passe à l'itérable suivant, jusqu'à ce que tous les itérables soient épuisés.