Comment ajouter un entier à chaque élément d'une liste?

Si j'ai list=[1,2,3]et je veux ajouter 1à chaque élément pour obtenir la sortie [2,3,4], comment pourrais-je faire cela?

Je suppose que j'utiliserais une boucle for mais je ne sais pas exactement comment.

new_list = [x+1 for x in my_list]

>>> mylist = [1,2,3]
>>> [x+1 for x in mylist]
[2, 3, 4]
>>>

list-comprehensions python .

Les autres réponses sur la compréhension des listes sont probablement le meilleur pari pour une addition simple, mais si vous avez une fonction plus complexe que vous deviez appliquer à tous les éléments, la carte peut être un bon choix.

Dans votre exemple, ce serait:

>>> map(lambda x:x+1, [1,2,3])
[2,3,4]

si vous souhaitez utiliser numpy, il existe une autre méthode comme suit

import numpy as np
list1 = [1,2,3]
list1 = list(np.asarray(list1) + 1)

Edit: ce n'est pas en place

Tout d'abord, n'utilisez pas le mot «liste» pour votre variable. Cela fait de l'ombre au mot-clé list.

Le meilleur moyen est de le faire en place en utilisant l'épissage, notez que le [:]désigne une épissure:

>>> _list=[1,2,3]
>>> _list[:]=[i+1 for i in _list]
>>> _list
[2, 3, 4]

>>> [x.__add__(1) for x in [1, 3, 5]]
3: [2, 4, 6]

Mon intention ici est d'exposer si l'élément de la liste est un entier, il prend en charge diverses fonctions intégrées.

Python 2+:

>>> mylist = [1,2,3]
>>> map(lambda x: x + 1, mylist)
[2, 3, 4]

Python 3+:

>>> mylist = [1,2,3]
>>> list(map(lambda x: x + 1, mylist))
[2, 3, 4]

import numpy as np

np.add([1, 2, 3], 1).tolist()

qui donne

[2, 3, 4]

Je suis tombé sur une façon pas si efficace, mais unique de le faire. Donc, le partager entre tous Et oui, cela nécessite un espace supplémentaire pour une autre liste.

from operator import add
test_list1 = [4, 5, 6, 2, 10]
test_list2 = [1] * len(test_list1)

res_list = list(map(add, test_list1, test_list2))

print(test_list1)
print(test_list2)
print(res_list)

#### Output ####
[4, 5, 6, 2, 10]
[1, 1, 1, 1, 1]
[5, 6, 7, 3, 11]

list = [1,2,3,4,5]

for index in range(5):
      list[index] = list[index] +1

print(list)

Bon nombre des réponses ci-dessus sont très bonnes. J'ai également vu des réponses étranges qui feront l'affaire. En outre, la dernière réponse vue était par une boucle normale. Cette volonté de donner des réponses m'amène à itertoolset numpy, qui fera le même travail d'une manière différente.

Ici, je présente différentes façons de faire le travail, sans réponse ci-dessus.

import operator
import itertools

x = [3, 5, 6, 7]

integer = 89

"""
Want more vairaint can also use zip_longest from itertools instead just zip
"""
#lazy eval
a = itertools.starmap(operator.add, zip(x, [89] * len(x))) # this is not subscriptable but iterable
print(a)
for i in a:
  print(i, end = ",")


# prepared list
a = list(itertools.starmap(operator.add, zip(x, [89] * len(x)))) # this returns list
print(a)



# With numpy (before this, install numpy if not present with `pip install numpy`)
import numpy

res = numpy.ones(len(x), dtype=int) * integer + x # it returns numpy array
res = numpy.array(x) + integer # you can also use this, infact there are many ways to play around
print(res)
print(res.shape) # prints structure of array, i.e. shape

# if you specifically want a list, then use tolist

res_list = res.tolist()
print(res_list)

Production

>>> <itertools.starmap object at 0x0000028793490AF0> # output by lazy val
>>> 92,94,95,96,                                     # output of iterating above starmap object
>>> [92, 94, 95, 96]                                 # output obtained by casting to list
>>>                   __
>>> # |\ | |  | |\/| |__| \ /
>>> # | \| |__| |  | |     |
>>> [92 94 95 96]                                    # this is numpy.ndarray object
>>> (4,)                                             # shape of array
>>> [92, 94, 95, 96]                                 # this is a list object (doesn't have a shape)

Ma seule raison de souligner l'utilisation de numpyest qu'il faut toujours faire de telles manipulations avec des bibliothèques comme numpy car il est performant pour les très grands tableaux.