Python 数据帧函数的并行化

任务是创建一个函数来

• 并行化

  pd.DataFrame.apply

  函数，方法是根据用户请求的分区数将行拆分为多个部分
• 允许将用户指定的函数传递到并行应用函数中

例如，给定文本输入，我已尝试：

from multiprocessing import Pool

import numpy as np
import pandas as pd

from nltk import word_tokenize

def apply_me(df_this):
    return df_this[0].astype(str).apply(word_tokenize)

def parallelize_apply(df, apply_me, num_partitions):
    df_split = np.array_split(df, num_partitions)
    pool = Pool(num_partitions)
    df = pd.concat(pool.map(apply_me, df_split))
    pool.close()
    pool.join
    return df

text = """Let's try something.
I have to go to sleep.
Today is June 18th and it is Muiriel's birthday!
Muiriel is 20 now.
The password is "Muiriel"."""

df = pd.DataFrame(text.split('\n'))

parallelize_apply(df, apply_me, 2)

[out]：

出[8]：

0                         [Let, 's, try, something, .]
1                      [I, have, to, go, to, sleep, .]
2    [Today, is, June, 18th, and, it, is, Muiriel, ...
3                            [Muiriel, is, 20, now, .]
4              [The, password, is, ``, Muiriel, '', .]
Name: 0, dtype: object

我的问题是是否有办法将

单词\u tokenize（）

函数放入

parallize\u apply（）

中，而不是将硬代码放入

apply\u me（）

函数中

---

为了简化函数，我尝试了：

from multiprocessing import Pool

import numpy as np
import pandas as pd

from nltk import word_tokenize

def apply_me(df_this, func):
    return df_this[0].astype(str).apply(func)

def parallelize_apply(df, func, num_partitions):
    df_split = np.array_split(df, num_partitions)
    with Pool(num_partitions) as pool:
        _apply_me = partial(apply_me, func=func)
        df = pd.concat(pool.map(_apply_me, df_split))
        pool.join
    return df.tolist()

text = """Let's try something.
I have to go to sleep.
Today is June 18th and it is Muiriel's birthday!
Muiriel is 20 now.
The password is "Muiriel"."""

df = pd.DataFrame(text.split('\n'))

parallelize_apply(df, word_tokenize, 6)

---

它实现了相同的输出，但是仍然需要一个中间函数

apply\u me

，以便

parallelize\u apply

按需要工作。有没有办法消除它？

通过消除

apply\u me

，您的目标是什么？您已经将

word\u tokenize

直接传递到

parallelize\u apply

。我不确定为什么需要存在

apply\u me

。当我在

parallelize\u apply

中用lambda函数替换它时，多处理对汇集lambda函数不是很满意。哦，这看起来像

picke/cpickle

垃圾。你应该在

joblib

中使用

dill

，或者更好地使用

dill

。是的，这是Python：没有真正的并行性，只是在不同的地址空间中有多个解释器。要跨越它们，您必须以某种方式传递信息。

apply（）

非常慢。在你给自己施加1000倍的减速后，并行化只会让你加速2-10倍。不要这样做。对于给定的示例，请改用

df.str.split（）

——这是一个向量化操作，它的作用大致相同，但速度极快。如果您真的不能这样做，那么在创建Pandas结构之前，只需使用类似于

concurrent.futures.ProcessPoolExecutor.map（word\u tokenize，text）

。