在没有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 s一起工作，但是我将其包括在内是因为，如果您对性能感兴趣，那么值得一试。 / p>

如您所见，基于效率的考虑，没有理由偏爱一种方法。

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上的任何包装器只是堆叠的另一个东西 任何自己的实现都比内置解决方案慢。