Краткий вектор добавления в Python?

Я часто делаю векторное добавление списков Python.

Пример: у меня есть два списка:

a = [0.0, 1.0, 2.0]
b = [3.0, 4.0, 5.0]

Теперь я хочу добавить b в a, чтобы получить результат a = [3.0, 5.0, 7.0].

Обычно я заканчиваю так:

a[0] += b[0]
a[1] += b[1]
a[2] += b[2]

Есть ли эффективный стандартный способ сделать это с меньшим количеством ввода?

UPDATE: Можно предположить, что списки имеют длину 3 и содержат поплавки.

Ответы

Ответ 1

Я не думаю, что вы найдете более быстрое решение, чем 3 суммы, предложенные в вопросе. Преимущества numpy видны с большими векторами, а также если вам нужны другие операторы. numpy особенно полезен с матрицами, ведь это трюк с списками python.

Тем не менее, это еще один способ сделать это: D

In [1]: a = [1,2,3]

In [2]: b = [2,3,4]

In [3]: map(sum, zip(a,b))
Out[3]: [3, 5, 7]

Изменить: вы также можете использовать izip из itertools, версию генератора zip

In [5]: from itertools import izip

In [6]: map(sum, izip(a,b))
Out[6]: [3, 5, 7]

Ответ 2

В то время как Numeric - отличное решение и рекомендации по составлению списка, если вы действительно хотели создать новый список, я удивлен, что никто не предложил "один очевидный способ сделать это" - простой цикл for! Лучше всего:

for i, bi in enumerate(b): a[i] += bi

Также OK, sorta sorta:

for i in xrange(len(a)): a[i] += b[i]

Ответ 3

Если вам нужна эффективная векторная арифметика, попробуйте Numpy.

>>> import numpy
>>> a=numpy.array([0,1,2])
>>> b=numpy.array([3,4,5])
>>> a+b
array([3, 5, 7])
>>>

Или (спасибо, Andrew Jaffe),

>>> a += b
>>> a
array([3, 5, 7])
>>>

Ответ 4

Если вы считаете, что Numpy слишком переполнен, это должно быть очень быстро, потому что этот код работает в чистом C (map() и __add__() оба непосредственно реализованы в C):

a = [1.0,2.0,3.0]
b = [4.0,5.0,6.0]

c = map(float.__add__, a, b)

Или, альтернативно, если вы не знаете типы в списке:

import operator
c = map(operator.add, a, b)

Ответ 5

Как насчет этого:

a = [x+y for x,y in zip(a,b)]

Ответ 6

Или, если вы хотите использовать внешнюю библиотеку (и массивы с фиксированной длиной), используйте numpy, который имеет "+ =" и связанные операции для операций на месте.

import numpy as np
a = np.array([0, 1, 2])
b = np.array([3, 4, 5])
a += b

Ответ 7

[a [x] + b [x] для x в диапазоне (0, len (a))]

Ответ 8

Если вы после кратки, попробуйте...

vectors = [[0.0, 1.0, 2.0],[3.0, 4.0, 5.0]]
[sum(col) for col in zip(*vectors)]

Хотя я не могу говорить за это.

Ответ 9

В общем случае, имея список списков, вы можете сделать что-то вроде этого:

In [2]: import numpy as np

In [3]: a = np.array([[1, 1, 1], [2, 2, 2], [3, 3, 3],[4, 5, 6]])

In [4]: [sum(a[:,i]) for i in xrange(len(a[0]))]
Out[4]: [10, 11, 12]

Ответ 10

Вы можете создать функцию, которая получает размер массива, перебирает его и создает возвращаемый массив, который он возвращает.

Ответ 11

Улучшение (меньше потребления памяти) списка понятий

импортировать itertools a = [x + y для x, y в itertools.izip(a, b)]

Собственно, если вы не уверены, что a будет потребляться, я бы даже пошел с выражением генератора:

(x + y для x, y в itertools.izip(a, b))

Ответ 12

list(map(lambda x:x[0]+x[1], zip(a,b)))

Ответ 13

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