Ajouter la somme des valeurs de deux listes dans la nouvelle liste

J'ai les deux listes suivantes:

first = [1,2,3,4,5]
second = [6,7,8,9,10]

Maintenant, je veux ajouter les éléments de ces deux listes dans une nouvelle liste.

la sortie doit être

third = [7,9,11,13,15]

La zipfonction est utile ici, utilisée avec une compréhension de liste.

[x + y for x, y in zip(first, second)]

Si vous avez une liste de listes (au lieu de seulement deux listes):

lists_of_lists = [[1, 2, 3], [4, 5, 6]]
[sum(x) for x in zip(*lists_of_lists)]
# -> [5, 7, 9]

À partir de documents

import operator
list(map(operator.add, first,second))

En supposant que les deux listes aet bont même longueur, vous n'avez pas besoin zip, numpy ou toute autre chose.

Python 2.x et 3.x:

[a[i]+b[i] for i in range(len(a))]

Le comportement par défaut dans numpy est d'ajouter un composant

import numpy as np
np.add(first, second)

quelles sorties

array([7,9,11,13,15])

Cela s'étend à n'importe quel nombre de listes:

[sum(sublist) for sublist in itertools.izip(*myListOfLists)]

Dans votre cas, myListOfListsserait[first, second]

Essayez le code suivant:

first = [1, 2, 3, 4]
second = [2, 3, 4, 5]
third = map(sum, zip(first, second))

Le moyen simple et rapide de le faire est:

three = [sum(i) for i in zip(first,second)] # [7,9,11,13,15]

Vous pouvez également utiliser numpy sum:

from numpy import sum
three = sum([first,second], axis=0) # array([7,9,11,13,15])

first = [1, 2, 3, 4, 5]
second = [6, 7, 8, 9, 10]
three = map(lambda x,y: x+y,first,second)
print three



Output 
[7, 9, 11, 13, 15]

solution monotouche

list(map(lambda x,y: x+y, a,b))

Ma réponse est répétée avec celle de Thiru qui y a répondu le 17 mars à 9h25.

C'était plus simple et plus rapide, voici ses solutions:

Le moyen simple et rapide de le faire est:

 three = [sum(i) for i in zip(first,second)] # [7,9,11,13,15]

Vous pouvez également utiliser numpy sum:

 from numpy import sum
 three = sum([first,second], axis=0) # array([7,9,11,13,15])

Vous avez besoin de numpy!

import numpy as np
a = [1,2,3,4,5]
b = [6,7,8,9,10]
c = list(np.array(a) + np.array(b))
print c
# [7, 9, 11, 13, 15]

Si vous avez un nombre inconnu de listes de même longueur, vous pouvez utiliser la fonction ci-dessous.

Ici, le * args accepte un nombre variable d'arguments de liste (mais ne fait la somme que du même nombre d'éléments dans chacun). Le * est à nouveau utilisé pour décompresser les éléments de chacune des listes.

def sum_lists(*args):
    return list(map(sum, zip(*args)))

a = [1,2,3]
b = [1,2,3]  

sum_lists(a,b)

Production:

[2, 4, 6]

Ou avec 3 listes

sum_lists([5,5,5,5,5], [10,10,10,10,10], [4,4,4,4,4])

Production:

[19, 19, 19, 19, 19]

Vous pouvez utiliser zip(), qui "entrelacera" les deux tableaux ensemble, puis map(), qui appliquera une fonction à chaque élément dans un itérable:

>>> a = [1,2,3,4,5]
>>> b = [6,7,8,9,10]
>>> zip(a, b)
[(1, 6), (2, 7), (3, 8), (4, 9), (5, 10)]
>>> map(lambda x: x[0] + x[1], zip(a, b))
[7, 9, 11, 13, 15]

Voici une autre façon de procéder. Nous utilisons la fonction interne __add__ de python:

class SumList(object):
    def __init__(self, this_list):
        self.mylist = this_list

    def __add__(self, other):
        new_list = []
        zipped_list = zip(self.mylist, other.mylist)
        for item in zipped_list:
            new_list.append(item[0] + item[1])
        return SumList(new_list)

    def __repr__(self):
        return str(self.mylist)

list1 = SumList([1,2,3,4,5])
list2 = SumList([10,20,30,40,50])
sum_list1_list2 = list1 + list2
print(sum_list1_list2)

Production

[11, 22, 33, 44, 55]

Si vous souhaitez ajouter également le reste des valeurs dans les listes, vous pouvez l'utiliser (cela fonctionne dans Python3.5)

def addVectors(v1, v2):
    sum = [x + y for x, y in zip(v1, v2)]
    if not len(v1) >= len(v2):
        sum += v2[len(v1):]
    else:
        sum += v1[len(v2):]

    return sum


#for testing 
if __name__=='__main__':
    a = [1, 2]
    b = [1, 2, 3, 4]
    print(a)
    print(b)
    print(addVectors(a,b))

    first = [1,2,3,4,5]
    second = [6,7,8,9,10]
    #one way
    third = [x + y for x, y in zip(first, second)]
    print("third" , third) 
    #otherway
    fourth = []
    for i,j in zip(first,second):
        global fourth
        fourth.append(i + j)
    print("fourth" , fourth )
#third [7, 9, 11, 13, 15]
#fourth [7, 9, 11, 13, 15]

Voici une autre façon de le faire. Cela fonctionne très bien pour moi.

N=int(input())
num1 = list(map(int, input().split()))
num2 = list(map(int, input().split()))
sum=[]

for i in range(0,N):
  sum.append(num1[i]+num2[i])

for element in sum:
  print(element, end=" ")

print("")

j = min(len(l1), len(l2))
l3 = [l1[i]+l2[i] for i in range(j)]

Peut-être l'approche la plus simple:

first = [1,2,3,4,5]
second = [6,7,8,9,10]
three=[]

for i in range(0,5):
    three.append(first[i]+second[i])

print(three)

Si vous considérez vos listes comme un tableau numpy, vous devez les additionner facilement:

import numpy as np

third = np.array(first) + np.array(second)

print third

[7, 9, 11, 13, 15]

Que faire si vous avez une liste avec une longueur différente, alors vous pouvez essayer quelque chose comme ça (en utilisant zip_longest)

from itertools import zip_longest  # izip_longest for python2.x

l1 = [1, 2, 3]
l2 = [4, 5, 6, 7]

>>> list(map(sum, zip_longest(l1, l2, fillvalue=0)))
[5, 7, 9, 7]

Vous pouvez utiliser cette méthode mais cela ne fonctionnera que si les deux listes sont de la même taille:

first = [1, 2, 3, 4, 5]
second = [6, 7, 8, 9, 10]
third = []

a = len(first)
b = int(0)
while True:
    x = first[b]
    y = second[b]
    ans = x + y
    third.append(ans)
    b = b + 1
    if b == a:
        break

print third