python多进程最长子序列

代码

from multiprocessing import Process, Manager
import pandas as pd


from tqdm import tqdm


def get_head(seq):
    head = []
    for i in range(1, len(seq)):
        for j in range(0, len(seq), i):
            jj = j + i
            s = seq[j:jj]

            head.append(s)
    return head


def get_long(ii, jjj, total_data_dict, data_s):
    try:
        data_one = data_s["data"]
        # print(len(data_one))
        tree_head = get_head(data_one[ii])
        head = get_head(data_one[jjj])
        head = set(tree_head) & set(head)
        if len(head):
            hh = sorted(head, key=lambda x: len(x))[-1]
            total_data_dict["{}_{}".format(ii, jjj)] = hh
    except:
        pass


def run_gen_long(task, total_data, src_data, step):
    # print(len(src_data["data"]))
    for i in tqdm(task):
        jj = i + step
        get_long(i, jj, total_data, src_data)


if __name__ == '__main__':
    data = pd.read_pickle("data_sets.pandas_pickle")[:1000]
    data = {i: d for i, d in enumerate(data)}
    data_src = Manager().dict()
    # data_src =dict()
    data_src["data"] = data

    # total_data =dict()
    total_data = Manager().dict()
    # 最长相同子序列
    p_list = []
    work_num = 5
    for steps in tqdm(range(1, len(data))):
        task_list = list(range(0, len(data), steps))
        for task_start_id in range(0, len(task_list), len(task_list) // work_num):
            task_end_id = task_start_id + len(task_list) // work_num

            # run_gen_long(task_list[task_start_id:task_end_id], total_data, data_src, steps)
            p = Process(target=run_gen_long, args=(task_list[task_start_id:task_end_id], total_data, data_src, steps))
            p.start()
            p_list.append(p)
        for p in p_list:
            p.join()

    print()

解析

1. 导入了 pandas 库和 tqdm 库。
2. 定义了函数 get_head(seq)，根据传入的序列 seq，得到该序列中所有的子序列元素。
3. 定义了函数 get_long(ii, jjj, total_data_dict, data_s)，根据传入的参数，获取两个序列的最长相同子序列，并将其添加到 total_data_dict 字典中。
4. 定义了函数 run_gen_long(task, total_data, src_data, step)，根据传入的参数，对数据进行处理，将结果保存到 total_data 字典中。
5. 主程序先读取了一个 pandas_pickle 文件，然后定义了一个 Manager().dict() 字典类型的 data_src，并将读取的数据保存到该字典中。
6. 定义了一个 Manager().dict() 字典类型的 total_data 用于保存结果。
7. 使用进程池将任务拆分成若干个子任务，并使用多进程方式并行处理，结果保存在 total_data 中。
8. 最后输出一个空行。