Python：从该类内部对作为类的数据成员的函数进行多处理的有效解决方法

Question

当处理作为类的数据成员的函数时（由于酸洗问题），我知道关于多重处理模块的局限性的各种
讨论。

但是，是否存在另一个模块或多处理中的任何变通方法，该模块允许类似以下的内容（特别是在不强制将函数定义并行应用到类外部的情况下）？

class MyClass():

    def __init__(self):
        self.my_args = [1,2,3,4]
        self.output  = {}

    def my_single_function(self, arg):
        return arg**2

    def my_parallelized_function(self):
        # Use map or map_async to map my_single_function onto the
        # list of self.my_args, and append the return values into
        # self.output, using each arg in my_args as the key.

        # The result should make self.output become
        # {1:1, 2:4, 3:9, 4:16}


foo = MyClass()
foo.my_parallelized_function()
print foo.output

注意：我可以通过移到my_single_function类之外并将类似的内容传递foo.my_args给mapormap_async命令来轻松地做到这一点。但这将功能的并行执行推到的实例之外MyClass。

对于我的应用程序（并行处理一个大型数据查询，该查询可检索，联接和清除数据的每月横截面，然后将它们附加到此类横截面的较长时间序列中），在此应用程序 内部
具有此功能非常重要 类，
因为我的程序的不同用户将以不同的时间间隔，不同的时间增量，要收集的数据的不同子集等等实例化该类的不同实例，所有这些都应与该实例相关联。

因此，我希望并行化工作也可以由实例完成，因为它拥有与并行化查询相关的所有数据，并且尝试编写一些绑定到某些参数并位于外部的hacky包装函数实在是愚蠢的类（特别是因为此类函数将是非泛型的。它将需要类内部的各种详细信息。）

Answer 1

史蒂文·贝萨德（Steven Bethard
）发布了一种允许对方法进行腌制/解腌的方法。您可以这样使用它：

import multiprocessing as mp
import copy_reg
import types

def _pickle_method(method):
    # Author: Steven Bethard
    # http://bytes.com/topic/python/answers/552476-why-cant-you-pickle-instancemethods
    func_name = method.im_func.__name__
    obj = method.im_self
    cls = method.im_class
    cls_name = ''
    if func_name.startswith('__') and not func_name.endswith('__'):
        cls_name = cls.__name__.lstrip('_')
    if cls_name:
        func_name = '_' + cls_name + func_name
    return _unpickle_method, (func_name, obj, cls)

def _unpickle_method(func_name, obj, cls):
    # Author: Steven Bethard
    # http://bytes.com/topic/python/answers/552476-why-cant-you-pickle-instancemethods
    for cls in cls.mro():
        try:
            func = cls.__dict__[func_name]
        except KeyError:
            pass
        else:
            break
    return func.__get__(obj, cls)

# This call to copy_reg.pickle allows you to pass methods as the first arg to
# mp.Pool methods. If you comment out this line, `pool.map(self.foo, ...)` results in
# PicklingError: Can't pickle <type 'instancemethod'>: attribute lookup
# __builtin__.instancemethod failed

copy_reg.pickle(types.MethodType, _pickle_method, _unpickle_method)

class MyClass(object):

    def __init__(self):
        self.my_args = [1,2,3,4]
        self.output  = {}

    def my_single_function(self, arg):
        return arg**2

    def my_parallelized_function(self):
        # Use map or map_async to map my_single_function onto the
        # list of self.my_args, and append the return values into
        # self.output, using each arg in my_args as the key.

        # The result should make self.output become
        # {1:1, 2:4, 3:9, 4:16}
        self.output = dict(zip(self.my_args,
                               pool.map(self.my_single_function, self.my_args)))

然后

pool = mp.Pool()   
foo = MyClass()
foo.my_parallelized_function()

产量

print foo.output
# {1: 1, 2: 4, 3: 9, 4: 16}