在Python中查找元组列表平均值的最快方法是什么，每个元组包含一对命名元组？ 将numpy作为numpy导入 从集合导入namedtuple 从随机导入随机 吸烟者=名字双倍（“吸烟者”[“女性”、“男性”]） 非吸烟者=姓名双倍（“非吸烟者”[“女性”、“男性”]） LST=[（吸烟者（随机（），随机（）），不吸烟者（随机（），随机（））对于范围（100）内的i）

所以我有一个很长的列表，其中的元素是元组。每个元组包含一对命名的元组。找到此列表平均值的最快方法是什么？理想情况下，结果仍然是相同的结构，即吸烟者（女性=w，男性=x），不吸烟者（女性=y，男性=z））

grizzly=吸烟者（np.平均值（[a.女性代表a，b在LST]），np.平均值（[a.男性代表a，b在LST]））
panda=非制造者（np.平均值（[b.女性代表a，b在LST]），np.平均值（[b.男性代表a，b在LST]））
结果=（灰熊，熊猫）

np。mean

必须将列表转换为数组，这需要时间。Python

sum

节省时间：

In [6]: %%timeit
   ...: grizzly = Smoker(np.mean([a.Female for a,b in LST]),np.mean([a.Male for
   ...: a,b in LST]))
   ...: panda = Nonsmoker(np.mean([b.Female for a,b in LST]),np.mean([b.Male for
   ...:  a,b in LST]))
   ...: result = (grizzly, panda)
   ...: 
   ...: 
158 µs ± 597 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

In [9]: %%timeit
   ...: n=len(LST)
   ...: grizzly = Smoker(sum([a.Female for a,b in LST])/n,sum([a.Male for a,b in
   ...:  LST])/n)
   ...: panda = Nonsmoker(sum([b.Female for a,b in LST])/n,sum([b.Male for a,b i
   ...: n LST])/n)
   ...: result = (grizzly, panda)
   ...: 
   ...: 
46.2 µs ± 37.4 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

两者产生相同的

结果

（在小ε内）：

如果可以在一个数组（可能是（n，4）形状）中收集值，那么平均值会很快。有一次，这可能不值得-

In [11]: M = np.array([(a.Female, a.Male, b.Female, b.Male) for a,b in LST])
In [12]: np.mean(M, axis=0)
Out[12]: array([0.53836953, 0.54938544, 0.49134546, 0.47143788])

In [13]: timeit M = np.array([(a.Female, a.Male, b.Female, b.Male) for a,b in LST])
128 µs ± 1.22 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
In [14]: timeit np.mean(M, axis=0)
21.9 µs ± 371 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

由于命名元组可以像常规元组一样访问，因此我们可以直接从

LST

创建数组：

In [16]: np.array(LST).shape
Out[16]: (100, 2, 2)
In [17]: np.array(LST).mean(axis=0)
Out[17]: 
array([[0.53836953, 0.54938544],
       [0.49134546, 0.47143788]])

但时机并不令人鼓舞：

In [18]: timeit np.array(LST).mean(axis=0)
1.26 ms ± 7.92 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

我还可以从列表中创建一个结构化数组，其中包含嵌套的数据类型：

In [26]: dt = np.dtype([('Smoker', [('Female','f'),('Male','f')]),('Nonsmoker',[
    ...: ('Female','f'),('Male','f')])])
In [27]: M=np.array(LST,dt)
In [28]: M['Smoker']['Female'].mean()
Out[28]: 0.53836954

奇怪的是，时间安排相对较好：

In [29]: timeit M=np.array(LST,dt)
40.6 µs ± 243 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

但我必须分别取每个平均值，否则首先将其转换为非结构化数组

我可以使用

视图

或

recfunctions

实用程序从结构化数组生成（n，4）浮点数组：

In [53]: M1 = M.view([('f0','f',(4,))])['f0']
In [54]: M1.shape
Out[54]: (100, 4)
In [55]: M2=rf.structured_to_unstructured(M)

---

使用基本python

sum

和list

len

可能比

np.mean

更有效。你可能无法避免列表理解。你可能想考虑<代码>唯一、计数＝NUMPY、唯一（A，RealStActual= TRUE）< /C>作为GRIZZL/熊猫结果中的计数函数，但是对于最有效率的方法，我不能确定。@ HPaulJ我希望StutoFoobe会给我惊喜。但是谢谢！

In [53]: M1 = M.view([('f0','f',(4,))])['f0']
In [54]: M1.shape
Out[54]: (100, 4)
In [55]: M2=rf.structured_to_unstructured(M)