有没有办法更快地运行这个 Python 片段？

Question

from collections import defaultdict
dct = defaultdict(list)
for n in range(len(res)):
    for i in indices_ordered:
        dct[i].append(res[n][i])

请注意，res 是长度为 5000 的 pandas Series 列表，indices_ordered 是长度为 20000 的字符串列表。在我的 Mac（2.3 GHz Intel Core i5 和 16 GB 2133 MHz LPDDR3 ) 运行此代码。我对 Python 很陌生，但我觉得更聪明的编码（可能更少循环）会有很大帮助。

---

编辑：

这是一个示例，说明如何创建数据（res 和 indices_ordered）以便能够在 sn-p 上运行（由于我找不到，它稍微更改为访问唯一字段而不是按字段名称如何使用字段名称构建内联系列）

import random, string, pandas
index_sz = 20000
res_sz = 5000
indices_ordered = [''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(10)) for i in range(index_sz)]
res = [pandas.Series([random.randint(0,10) for i in range(index_sz)], index = random.sample(indices_ordered, index_sz)) for i in range(res_sz)]

Answer 1

这里的问题是您对每个值都迭代 indices_ordered。只需删除indices_ordered。以数量级方式剥离它以测试时间：

import random
import string

import numpy as np
import pandas as pd

from collections import defaultdict


index_sz = 200
res_sz = 50
indices_ordered = [''.join(random.choice(string.ascii_uppercase + string.digits)
                   for _ in range(10)) for i in range(index_sz)]

res = [pd.Series([random.randint(0,10) for i in range(index_sz)],
                  index = random.sample(indices_ordered, index_sz))
       for i in range(res_sz)]


def your_way(res, indices_ordered):
    dct = defaultdict(list)
    for n in range(len(res)):
        for i in indices_ordered:
            dct[i].append(res[n][i])


def my_way(res):
    dct = defaultdict(list)
    for item in res:
        for string_item, value in item.iteritems():
            dct[string_item].append(value)

给予：

%timeit your_way(res, indices_ordered)
160 ms ± 5.45 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

%timeit my_way(res)
6.79 ms ± 47.2 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

这降低了整个方法的时间复杂度，因为您不必每次都通过indicies_ordered 并分配值，因此随着数据大小的增长，差异将变得更加明显。

只是增加一个数量级：

index_sz = 2000
res_sz = 500

给予：

%timeit your_way(res, indices_ordered)
17.8 s ± 999 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

%timeit my_way(res)
543 ms ± 9.07 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

Answer 2

编辑：现在测试数据可用，很明显下面的更改对运行时没有影响。所描述的技术仅在内部循环非常有效（大约 5-10 次 dict 查找）时才有效，通过删除一些上述查找使其更加高效。这里r[i] 项查找使其他任何东西都相形见绌数量级，因此优化根本无关紧要。

---

您的外循环需要 5000 次迭代，而您的内循环需要 20000 次迭代。这意味着您在 23 分钟内执行 1 亿次迭代，即每次迭代需要 13.8 μs。这并不快，即使在 Python 中也是如此。

我会尝试通过从内部循环中剥离任何不必要的工作来缩短运行时间。具体来说：

• 将for n in range(len(res)) 后跟res[n] 转换为for r in res。我不知道在 pandas 中查找项目的效率如何，但最好在外部循环中进行而不是在内部循环中进行。
• 将score 属性查找移至外部循环。
• 摆脱defaultdict 并预先创建列表并使用普通字典。
• 完全避免使用字典存储并直接处理列表，按顺序预先创建它们。只在最后创建一个字典。
• 缓存append列表方法的查找，提前准备内循环需要的(append, i)对。

以下是实现上述建议的代码：

# pre-create the lists
lsts = [[] for _ in range(len(indices_ordered))]
# prepare the pairs (appendfn, i)
fast_append = [(l.append, i)
               for (l, i) in zip(lsts, indices_ordered)]

for r in res:
    # pre-fetch res[n].score
    r_score = r.score
    for append, i in fast_append:
        append(r_score[i])

# finally, create the dict out of the lists
dct = {i: lst for (i, lst) in zip(indices_ordered, lsts)}

Answer 3

你真的应该使用DataFrame。

这是一种直接创建数据的方法：

import pandas as pd
import numpy as np
import random
import string
index_sz = 3
res_sz = 10

indices_ordered = [''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(3)) for i in range(index_sz)]

df = pd.DataFrame(np.random.randint(10, size=(res_sz, index_sz)), columns=indices_ordered)

无需对任何内容进行排序或索引。 DataFrame 基本上可以作为数组或字典访问。

它应该比同时使用默认字典、列表和系列要快得多。

df 现在看起来像：

>>> df
   7XQ  VTV  38Y
0    6    9    5
1    5    5    4
2    6    0    7
3    0    0    8
4    7    8    9
5    8    6    4
6    2    4    9
7    3    2    2
8    7    6    0
9    8    0    1

>>> df['7XQ']
0    6
1    5
2    6
3    0
4    7
5    8
6    2
7    3
8    7
9    8
Name: 7XQ, dtype: int64

>>> df['7XQ'][:5]
0    6
1    5
2    6
3    0
4    7
Name: 7XQ, dtype: int64

使用原始大小，此脚本输出5000 rows × 20000 columns DataFrame 在我的笔记本电脑上不到 3 秒。

Answer 4

在pd.Series 对象的输入列表中使用 pandas 魔法（两行代码）：

all_data = pd.concat([*res])
d = all_data.groupby(all_data.index).apply(list).to_dict() 

---

暗示动作：

• pd.concat([*res]) - 将所有系列连接成一个保留每个系列对象的索引 (pandas.concat)
• all_data.groupby(all_data.index).apply(list).to_dict() - 在all_data.index 上确定一组相同的索引标签值，然后将每个组值放入带有.apply(list) 的列表中，并最终将分组结果转换为字典.to_dict() (pandas.Series.groupby)