Python中元组上的元素操作

在Python3中是否有允许对元组执行元素操作的内置函数？如果不是，执行这些操作的“pythonic”方式是什么

示例：我想取

a

和

b

之间的百分比差异，并将它们与某个阈值

th

进行比较

>>> a = (1, 2, 4)
>>> b = (1.1, 2.1, 4.1)
>>> # compute pd = 100*abs(a-b)/a = (10.0, 5.0, 2.5)
>>> th = 3
>>> # test threshold: pd < th => (False, False, True)

>a=（1,2,4）
>>>b=（1.1,2.1,4.1）
>>>#计算pd=100*abs（a-b）/a=（10.0,5.0,2.5）
>>>th=3
>>>#测试阈值：pd（假、假、真）

我不知道有这样的操作，也许Python的一些函数式编程功能会起作用（map？reduce？），但组合一个（或生成器，如果不需要列表的话）：

[100*abs(j-b[i])/j < 3 for i,j in enumerate(a)]
[False, False, True]

[100*abs（j-b[i]）/j<3表示枚举（a）中的i，j]
[假，假，真]

感谢@delnan为原始、更明确/详细的版本指出了一个非常好的简化：

[True if 100*abs(j-b[i])/j < 3 else False for i,j in enumerate(a)]

[如果100*abs（j-b[i]）为真/j<3如果枚举（a）中的i，j为假]

没有内置方法，但有一种非常简单的方法：

[f(aItem, bItem) for aItem, bItem in zip(a, b)]

。其中，

f

是您希望在元素方面应用的函数。对于您的情况：

[100*abs(aItem - bItem)/aItem < 3 for aItem, bItem in zip(a, b)]

[100*abs（aItem-bItem）/aItem<3对于aItem，邮政编码为bItem（a，b）]

---

如果您发现自己经常这样做，特别是对于长元组，您可能想看看

Numpy

，它提供了一个功能齐全的向量操作系统，其中许多常见的向量函数（基本操作、trig函数等）以元素方式应用。

我想说，python方法是通过列表理解：

当

a=（1,2,4）

和

b=（1.1,2.1,4.1）

然后，在一行中：

TEST = [100*abs(a[i]-b[i])/a[i] > th for i in range(len(A))]

映射函数

>>> a = (1, 2, 4)
>>> b = (1.1, 2.1, 4.1)
>>> map(lambda a,b: 100*abs(a-b)/a < 3, a, b)
[False, False, True]

>a=（1,2,4）
>>>b=（1.1,2.1,4.1）
>>>图（λa，b:100*abs（a-b）/a<3，a，b）
[假，假，真]

编辑

当然，您可以使用列表理解，而不是地图，就像BrenBarn所做的那样

编辑2已删除zip，感谢DSM指出不需要zip

def PCTRORE（已观察到，预期）：
def pctError(observed, expected):
    return (observed-expected)/expected * 100.0

a = (1, 2, 4)
b = (1.1, 2.1, 4.1)
th = 3

pctErrors = map(lambda t:pctError(*t), zip(a,b))
# returns [-9.091, -4.76, -2.44]

map(lambda x: x < th, pctErrors)
[x < th for x in pctErrors]
# both return [True, True, True]

# or if you always need absolute % errors
map(lambda x: abs(x) < th, pctErrors)
[abs(x) < th for x in pctErrors]
# both return [False, False, True]

回报率（观察到的预期）/预期*100.0
a=（1,2,4）
b=（1.1,2.1,4.1）
th=3
pctErrors=map（lambda t:pctError（*t），zip（a，b））
#返回值[-9.091，-4.76，-2.44]
地图（λx:x

为什么不使用NumPy

import numpy as np
a = np.array([1,2,4])
b = np.array([1.1, 2.1, 4.1])

pd = 100*abs(a-b)/a # result: array([ 10. ,   5. ,   2.5])
th = 3
pd < th # result: array([False, False,  True], dtype=bool)

将numpy导入为np
a=np.数组（[1,2,4]）
b=np.数组（[1.1,2.1,4.1]）
pd=100*abs（a-b）/a#结果：数组（[10,5,2.5]）
th=3
pd

我们是在谈论地图功能吗？加上拉链<如果100*abs（j-b[i]）/j<3则为真，否则为假->

100*abs（j-b[i]）/j<3

@delnan Ah。。知道了！！非常好。。谢谢，我会更新答案。@delnan

bool

似乎没有必要。事实上，我以为你输入了

True

和

False

来遵循“显式优于隐式”规则。我经常想知道在这种情况下该怎么办。@Levon是的，

bool

是不必要的，我被绊倒了一秒钟。你不需要

zip

；您可以编写

map（lambda，b:100*abs（a-b）/a<3，a，b）

。[请注意，此函数接受两个参数，而不是一个2元组。]

map（lambda（a，b）：100*abs（a-b）/a<3，a，b）

=>

TypeError:（）只接受一个参数（给定2个）

@DSM可以但可能不应该。我讨厌允许通过重载将另一个高阶函数合并到另一个函数的快捷方式（在LINQ中非常常见，例如

.First（cond）

而不是

.Where（cond）.First（）

），因为我从来都不知道隐含了哪个操作（map？zip？filter？其他什么？。

map（lambda，b）：100*abs（a-b）/a<3，（a，b））

=>

值错误：太多的值无法解包

@bpgergo:请重新阅读我的评论，尤其是括号中的部分。这将评估A和B的笛卡尔乘积上的fn，而不是元素。