Елементно додавання 2 списків?

У мене зараз:

list1 = [1, 2, 3]
list2 = [4, 5, 6]

Я хочу мати:

[1, 2, 3]
 +  +  +
[4, 5, 6]
|| || ||
[5, 7, 9]

Просто додавання елементів з двох списків.

Я точно можу повторити два списки, але я не хочу цього робити.

Який найбільш піфонічний спосіб зробити це?

Використовувати mapз operator.add:

>>> from operator import add
>>> list( map(add, list1, list2) )
[5, 7, 9]

або zipзі списком розуміння:

>>> [sum(x) for x in zip(list1, list2)]
[5, 7, 9]

Порівняння часу:

>>> list2 = [4, 5, 6]*10**5
>>> list1 = [1, 2, 3]*10**5
>>> %timeit from operator import add;map(add, list1, list2)
10 loops, best of 3: 44.6 ms per loop
>>> %timeit from itertools import izip; [a + b for a, b in izip(list1, list2)]
10 loops, best of 3: 71 ms per loop
>>> %timeit [a + b for a, b in zip(list1, list2)]
10 loops, best of 3: 112 ms per loop
>>> %timeit from itertools import izip;[sum(x) for x in izip(list1, list2)]
1 loops, best of 3: 139 ms per loop
>>> %timeit [sum(x) for x in zip(list1, list2)]
1 loops, best of 3: 177 ms per loop

Інші наводили приклади, як це зробити в чистому пітоні. Якщо ви хочете зробити це з масивами зі 100 000 елементами, слід використовувати numpy:

In [1]: import numpy as np
In [2]: vector1 = np.array([1, 2, 3])
In [3]: vector2 = np.array([4, 5, 6])

Зробити додаток, що сприймає стихію, зараз настільки банально

In [4]: sum_vector = vector1 + vector2
In [5]: print sum_vector
[5 7 9]

так само, як у Matlab.

Час порівняння з найшвидшою версією Ашвіні:

In [16]: from operator import add
In [17]: n = 10**5
In [18]: vector2 = np.tile([4,5,6], n)
In [19]: vector1 = np.tile([1,2,3], n)
In [20]: list1 = [1,2,3]*n
In [21]: list2 = [4,5,6]*n
In [22]: timeit map(add, list1, list2)
10 loops, best of 3: 26.9 ms per loop

In [23]: timeit vector1 + vector2
1000 loops, best of 3: 1.06 ms per loop

Так це швидше на 25 фактор! Але використовуйте те, що відповідає вашій ситуації. Для простої програми ви, мабуть, не хочете встановлювати numpy, тому використовуйте стандартний python (і я вважаю версію Генрі найбільш пітонічною). Якщо ви стикаєтеся з серйозним скороченням кількості, нехай numpyзаймається важким підйомом. Для швидкісних виродків: здається, що нумерований розчин швидше починається навколо n = 8.

[a + b for a, b in zip(list1, list2)]

Як описано іншими, швидке, а також ефективне для простору рішення використовує numpy (np) із вбудованою функцією векторного маніпулювання:

1. З нумізкою

x = np.array([1,2,3])
y = np.array([2,3,4])
print x+y

2. З вбудованими модулями

2.1 лямбда

list1=[1, 2, 3]
list2=[4, 5, 6]
print map(lambda x,y:x+y, list1, list2)

Зверніть увагу, що map () підтримує декілька аргументів.

2.2 розуміння поштових записів та списку

list1=[1, 2, 3]
list2=[4, 5, 6]
print [x + y for x, y in zip(list1, list2)]

Простіше використовувати numpyз моєї думки:

import numpy as np
list1=[1,2,3]
list2=[4,5,6]
np.add(list1,list2)

Результати:

Детальну інформацію про параметри див. Тут: numpy.add

Можливо, "самий пітонічний спосіб" повинен включати обробку випадку, коли list1 та list2 не мають однакового розміру. Застосування деяких із цих методів спокійно дасть вам відповідь. Підхід numpet повідомить вас, швидше за все, про ValueError.

Приклад:

import numpy as np
>>> list1 = [ 1, 2 ]
>>> list2 = [ 1, 2, 3]
>>> list3 = [ 1 ]
>>> [a + b for a, b in zip(list1, list2)]
[2, 4]
>>> [a + b for a, b in zip(list1, list3)]
[2]
>>> a = np.array (list1)
>>> b = np.array (list2)
>>> a+b
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: operands could not be broadcast together with shapes (2) (3)

Який результат ви могли б хотіти, якби це було у функції у вашій проблемі?

З цим просто numpy.add()

import numpy

list1 = numpy.array([1, 2, 3])
list2 = numpy.array([4, 5, 6])
result = numpy.add(list1, list2) # result receive element-wise addition of list1 and list2
print(result)
array([5, 7, 9])

Дивіться док. Тут

Якщо ви бажаєте отримати список пітона:

result.tolist()

Це буде працювати для 2 або більше списків; ітерація за допомогою списку списків, але з використанням нумерованого додавання для обробки елементів кожного списку

import numpy as np
list1=[1, 2, 3]
list2=[4, 5, 6]

lists = [list1, list2]
list_sum = np.zeros(len(list1))
for i in lists:
   list_sum += i
list_sum = list_sum.tolist()    

[5.0, 7.0, 9.0]

Можливо, це пітонічно і трохи корисно, якщо у вас є невідома кількість списків і нічого не імпортувати.

Поки списки однакової довжини, ви можете використовувати функцію нижче.

Тут * args приймає змінну кількість аргументів списку (але сумує лише однакову кількість елементів у кожному).

* Знову використовується у поверненому списку для розпакування елементів у кожному зі списків.

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

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

sum_lists(a,b)

Вихід:

[2, 4, 6]

Або з 3 списками

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

Вихід:

[19, 19, 19, 19, 19]

Використовуйте карту з функцією лямбда:

>>> map(lambda x, y: x + y, list1, list2)
[5, 7, 9]

Я ще не приурочила його, але підозрюю, що це буде досить швидко:

import numpy as np
list1=[1, 2, 3]
list2=[4, 5, 6]

list_sum = (np.add(list1, list2)).tolist()

[5, 7, 9]

Якщо вам потрібно обробляти списки різних розмірів, не хвилюйтеся! Чудовий модуль itertools охопив вас:

>>> from itertools import zip_longest
>>> list1 = [1,2,1]
>>> list2 = [2,1,2,3]
>>> [sum(x) for x in zip_longest(list1, list2, fillvalue=0)]
[3, 3, 3, 3]
>>>

У Python 2 zip_longestназивається izip_longest.

Дивіться також цю відповідну відповідь та прокоментуйте інше питання .

[list1[i] + list2[i] for i in range(len(list1))]

Хоча, власне питання не хоче повторювати список, щоб отримати результат, але всі запропоновані рішення роблять саме це під кришкою!

Для оновлення: Ви не можете додати два вектори, не вивчивши всіх векторних елементів. Отже, алгоритмічна складність більшості цих рішень є Big-O (n). Де n - розмірність вектора.

Отже, з алгоритмічної точки зору, використання циклу для ітераційного генерування отриманого списку є логічним і пітонічним. Однак, крім того, цей метод не має накладних витрат на виклик чи імпорт будь-якої додаткової бібліотеки.

# Assumption: The lists are of equal length.
resultList = [list1[i] + list2[i] for i in range(len(list1))]

Терміни, які тут демонструються / обговорюються, залежать від системи та впровадження, і не можуть бути надійним показником для вимірювання ефективності операції. У будь-якому випадку велика складність О операції додавання вектора є лінійною, тобто O (n).

a_list = []
b_list = []
for i in range(1,100):
    a_list.append(random.randint(1,100))

for i in range(1,100):
    a_list.append(random.randint(101,200))
[sum(x) for x in zip(a_list , b_list )]