现在我有用列表表示的vector3值。是否有一种像vector3值一样减去其中2个的方法,例如
[2,2,2] - [1,1,1] = [1,1,1]
我应该使用元组吗?
如果没有定义这些类型的这些操作数,我可以自己定义吗?
如果不行,我应该创建一个新的vector3类吗?
这里有一个替代列表推导式的方法。Map函数同时迭代列表(后面的参数),并将它们的元素作为参数传递给函数(第一个参数)。它返回生成的列表。
import operator
map(operator.sub, a, b)
这段代码因为语法少(更美观),而且对于长度为5的列表来说显然快了40%(请参见bobince的评论)。 不过,两种解决方案都能工作。
如果你的列表是a和b,你可以这样做:
map(int.__sub__, a, b)
不过你可能不应该这样做。没有人会知道它的意思。
map(float.__sub__, a, b)
可以解决问题。感谢您的提示! - S3DEVimport operator map(operator.sub, a, b)
更快吗? - zheyuanWangimport numpy as np
a = [2,2,2]
b = [1,1,1]
np.subtract(a,b)
[m - n for m,n in zip(a,b)]
已经提出了许多解决方案。
如果速度很重要,这里是对不同解决方案在速度方面的评估(从最快到最慢)
import timeit
import operator
a = [2,2,2]
b = [1,1,1] # we want to obtain c = [2,2,2] - [1,1,1] = [1,1,1
%timeit map(operator.sub, a, b)
176 ns ± 7.18 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
%timeit map(int.__sub__, a, b)
179 ns ± 4.95 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
%timeit map(lambda x,y: x-y, a,b)
189 ns ± 8.1 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
%timeit [a_i - b_i for a_i, b_i in zip(a, b)]
421 ns ± 18.4 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
%timeit [x - b[i] for i, x in enumerate(a)]
452 ns ± 17.2 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each
%timeit [a[i] - b[i] for i in range(len(a))]
530 ns ± 16.7 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
%timeit list(map(lambda x, y: x - y, a, b))
546 ns ± 16.1 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
%timeit np.subtract(a,b)
2.68 µs ± 80.9 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
%timeit list(np.array(a) - np.array(b))
2.82 µs ± 113 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
%timeit np.matrix(a) - np.matrix(b)
12.3 µs ± 437 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
使用map
显然是最快的。
令人惊讶的是,numpy
是最慢的。原来将列表a
和b
首先转换为numpy
数组的代价是一个瓶颈,超过了向量化带来的任何效率收益。
%timeit a = np.array([2,2,2]); b=np.array([1,1,1])
1.55 µs ± 54.9 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
a = np.array([2,2,2])
b = np.array([1,1,1])
%timeit a - b
417 ns ± 12.8 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
class Vector( object ):
def __init__(self, *data):
self.data = data
def __repr__(self):
return repr(self.data)
def __add__(self, other):
return tuple( (a+b for a,b in zip(self.data, other.data) ) )
def __sub__(self, other):
return tuple( (a-b for a,b in zip(self.data, other.data) ) )
Vector(1, 2, 3) - Vector(1, 1, 1)
对于那些曾经在Pycharm上编程的人来说,它也会使其他人复苏。
import operator
Arr1=[1,2,3,45]
Arr2=[3,4,56,78]
print(list(map(operator.sub,Arr1,Arr2)))
class Vector:
def __init__(self, data):
self.data = data
def __repr__(self):
return repr(self.data)
def __add__(self, other):
data = []
for j in range(len(self.data)):
data.append(self.data[j] + other.data[j])
return Vector(data)
x = Vector([1, 2, 3])
print x + x
print(list(map(operator.sub, a, b)))
。 - amc