Я часто делаю векторное добавление списков 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 и содержат поплавки.
Я не думаю, что вы найдете более быстрое решение, чем 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]
В то время как Numeric - отличное решение и рекомендации по составлению списка, если вы действительно хотели создать новый список, я удивлен, что никто не предложил "один очевидный способ сделать это" - простой цикл for! Лучше всего:
for i, bi in enumerate(b): a[i] += bi
Также OK, sorta sorta:
for i in xrange(len(a)): a[i] += b[i]
Если вам нужна эффективная векторная арифметика, попробуйте 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])
>>>
Если вы считаете, что 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)
Как насчет этого:
a = [x+y for x,y in zip(a,b)]
Или, если вы хотите использовать внешнюю библиотеку (и массивы с фиксированной длиной), используйте numpy, который имеет "+ =" и связанные операции для операций на месте.
import numpy as np
a = np.array([0, 1, 2])
b = np.array([3, 4, 5])
a += b
[a [x] + b [x] для x в диапазоне (0, len (a))]
Если вы после кратки, попробуйте...
vectors = [[0.0, 1.0, 2.0],[3.0, 4.0, 5.0]]
[sum(col) for col in zip(*vectors)]
Хотя я не могу говорить за это.
В общем случае, имея список списков, вы можете сделать что-то вроде этого:
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]
Вы можете создать функцию, которая получает размер массива, перебирает его и создает возвращаемый массив, который он возвращает.
Улучшение (меньше потребления памяти) списка понятий
импортировать itertools a = [x + y для x, y в itertools.izip(a, b)]
Собственно, если вы не уверены, что a будет потребляться, я бы даже пошел с выражением генератора:
(x + y для x, y в itertools.izip(a, b))
list(map(lambda x:x[0]+x[1], zip(a,b)))
a = map(lambda x, y: x + y, a, b)