在沒有numpy（python）的列表上進行元素操作的正確樣式

Question

我想在不使用numpy的情況下逐個元素地操作列表，例如，我想add([1,2,3], [2,3,4]) = [3,5,7]和mult([1,1,1],[9,9,9]) = [9,9,9] ，但我不確定哪種方式是被認為是'正確'的風格。

我提出的兩個解決方案是

def add(list1,list2):
    list3 = []
    for x in xrange(0,len(list1)):
        list3.append(list1[x]+list2[x])
    return list3

def mult(list1, list2):
    list3 = []
    for x in xrange(0,len(list1)):
        list3.append(list1[x]*list2[x])
    return list3

def div(list1, list2):
    list3 = []
    for x in xrange(0,len(list1)):
        list3.append(list1[x]/list2[x])
    return list3

def sub(list1, list2):
    list3 = []
    for x in xrange(0,len(list1)):
        list3.append(list1[x]-list2[x])
    return list3

每個操作員都有一個單獨的功能

和

def add(a,b)
    return a+b
def mult(a,b)
    return a*b
def div(a,b)
    return a/b
def sub(a,b)
    return a-b
def elementwiseoperation(list1, list2, function):
    list3 = []
    for x in xrange(0,len(list1)):
        list3.append(function(list1[x],list2[x]))
    return list3

其中定義了所有基本函數，並且我有一個單獨的函數可以在每個元素上使用它們。 我瀏覽了PEP8，但沒有發現任何直接相關的內容。 哪種方式更好？

Answer 1

執行此操作的常規方法是使用map或itertools.imap ：

import operator
multiadd = lambda a,b: map(operator.add, a,b)
print multiadd([1,2,3], [2,3,4]) #=> [3, 5, 7]

Ideone： http ：//ideone.com/yRLHxW

map是elementwiseoperation的c實現版本，具有標准名稱的優點，可以處理任何可迭代類型並且速度更快（在某些版本上;請參閱@ nathan的回答以進行一些分析）。

或者，您可以使用partial和map來獲得令人愉悅的無點樣式：

import operator
import functools

multiadd = functools.partial(map, operator.add)
print multiadd([1,2,3], [2,3,4]) #=> [3, 5, 7]

Ideone： http ：//ideone.com/BUhRCW

無論如何，你已經完成了函數式編程的第一步。 我建議你閱讀這個主題。

作為樣式的一般問題，如果要訪問每個項目，通常使用range迭代迭代通常被認為是錯誤的。 通常的做法是直接迭代結構。 使用zip或itertools.izip並行迭代：

for x in l:
    print l

for a,b in zip(l,k):
    print a+b

迭代創建列表的常用方法是不使用append ，而是使用列表解析：

[a+b for a,b in itertools.izip(l,k)]

Answer 2

這可以通過使用map和operator模塊來完成：

>>> from operator import add,mul
>>> map(add, [1,2,3], [2,3,4])
[3, 5, 7]
>>> map(mul, [1,1,1],[9,9,9])
[9, 9, 9]

Answer 3

您可以使用zip：

sum = [x+y for x,y in zip (list1, list2) ]
diff = [x-y for x,y in zip (list1, list2) ]
mult = [x*y for x,y in zip (list1, list2) ]
div = [x/y for x,y in zip (list1, list2) ]

Answer 4

績效比較

@Marcin說， map “比清單理解更清潔，更有效”。 我發現列表理解看起來更好，但這是一個品味問題。 效率聲明我也覺得很驚訝，而且我們可以測試一下。

這是不同列表大小的比較; 下面生成繪圖的代碼（請注意，這需要在Jupyter筆記本或至少IPython中運行。此外，它需要一些時間才能完成）。 numpy並不是真的可以進行比較，因為OP需要與list一起工作，但我把它包括在內，因為如果你對性能感興趣，那么值得知道替代方案是什么。

正如您所看到的，基於效率問題，沒有理由支持一種方法而不是另一種方法。

import numpy as np
import operator
import matplotlib.pyplot as plt
%matplotlib inline

lc_mean = []  # list comprehension
lc_std = []
map_mean = []
map_std = []
np_mean = []
np_std = []

for n in range(1, 8):
    l1 = np.random.rand(10 ** n)
    l2 = np.random.rand(10 ** n)

    np_time = %timeit -o l1 + l2
    np_mean.append(np_time.average)
    np_std.append(np_time.stdev)

    l1 = l1.tolist()
    l2 = l2.tolist()

    lc_time = %timeit -o [x + y for x, y in zip(l1, l2)]
    lc_mean.append(lc_time.average)
    lc_std.append(lc_time.stdev)

    map_time = %timeit -o list(map(operator.add, l1, l2))
    map_mean.append(map_time.average)
    map_std.append(map_time.stdev)

list_sizes = [10 ** n for n in range(1, 8)]
plt.figure(figsize=(8, 6))

np_mean = np.array(np_mean)
plt.plot(list_sizes, np_mean, label='np')
plt.fill_between(list_sizes, np_mean - np_std, np_mean + np_std, alpha=0.5)

lc_mean = np.array(lc_mean)
plt.plot(list_sizes, lc_mean, label='lc')
plt.fill_between(list_sizes, lc_mean - lc_std, lc_mean + lc_std, alpha=0.5)

map_mean = np.array(map_mean)
plt.plot(list_sizes, map_mean, label='map')
plt.fill_between(list_sizes, map_mean - map_std, map_mean + map_std, alpha=0.5)

plt.loglog()
plt.xlabel('List Size')
plt.ylabel('Time (s)')
plt.title('List Comprehension vs Map Add (vs numpy)')
plt.legend()

Answer 5

怎么樣：

import operator

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

sum = map(operator.add, a, b)
mul = map(operator.mul, a, b)

不，在這種情況下編寫自己的函數是沒有意義的。
只需使用map和operator因為你不會更好地實現任何東西。
map上的任何包裝器只是堆疊的另一個東西。
任何自己的實現都比內置解決方案慢。