4

我想在不使用 numpy 的情况下逐个元素地对列表进行操作，例如，我想要add([1,2,3], [2,3,4]) = [3,5,7]and 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，但没有找到任何直接相关的内容。哪种方式更好？

4

5 回答 5

8

执行此操作的正常方法是使用mapor 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是 your 的 c 实现版本elementwiseoperation，其优点是具有标准名称、使用任何可迭代类型并且速度更快（在某些版本上；有关某些分析，请参阅@nathan 的答案）。

或者，您可以使用partialandmap来获得令人愉悦的无点风格：

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问题，如果您想访问每个项目，通常认为使用索引进行迭代是错误的。这样做的通常方法是直接迭代结构。使用ziporitertools.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)]
于 2013-07-11T14:11:22.887 回答
3

这可以通过使用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]
于 2013-07-11T14:12:54.873 回答
2

您可以使用 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) ]
于 2013-07-11T14:11:13.937 回答
1

性能比较

@Marcin 说map“会比列表理解更清洁、更高效”。我发现列表理解看起来更好，但这是一个品味问题。我也发现效率声明令人惊讶，我们可以测试它。

这是不同列表大小的比较；生成绘图的代码如下（请注意，这需要在 Jupyter 笔记本或至少在 IPython 中运行。此外，完成需要一些时间）。numpy并不能真正进行比较，因为 OP 需要与lists 一起使用，但我将其包括在内，因为如果您对性能感兴趣，那么值得知道替代方案是什么。

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

性能比较

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()
于 2018-07-25T19:38:07.130 回答
0

怎么样：

import operator

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

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

不，在这种情况下编写自己的函数是没有意义的。
只需使用mapandoperator因为你不会实现更好的东西。
任何包装器map都只是另一个要放在堆栈上的东西。
任何自己的实现都比内置解决方案慢。

于 2013-07-11T14:20:37.647 回答