python 计算两个字符串最长子串超级加速版

import json
import time
from multiprocessing import Pool, Manager, freeze_support
from numba import jit


import pandas as pd
from tqdm import tqdm


def data_set(dataset):
    for i, one_data in enumerate(tqdm(dataset)):
        one = one_data[4].replace('\n', '')
        yield i, one



def get_text(i, one, dataset_dict, dataset_list):
    max_length = 0
    two_text = ""
    max_seq = ""
    for j, two_data in enumerate(tqdm(dataset_dict["data"])):
        if i == j :
            continue
        two = two_data[4].replace('\n', '')
        if one == two:
            continue

        temp = longest_common_substring_difflib(one, two)

        if len(temp) > max_length:
            max_length = len(temp)
            two_text = two
            max_seq = temp
    dataset_list.append([one, two_text, max_length, max_seq])

import difflib


def longest_common_substring_difflib(str1, str2):
    # 创建一个SequenceMatcher对象
    sm = difflib.SequenceMatcher(None, str1, str2)

    # 找到最大的匹配部分
    match = sm.find_longest_match(0, len(str1), 0, len(str2))

    # 如果找到匹配，返回最长公共子串
    if match.size:
        return str1[match.a: match.a + match.size]
    else:
        return ""
@jit(nopython=True)
def longest_common_substring(str1, str2):
    if len(str1) < len(str2):
        str1, str2 = str2, str1
    dp = [0] * (len(str2) + 1)
    max_length = 0
    end_pos = 0

    for i in range(1, len(str1) + 1):
        prev = 0
        for j in range(1, len(str2) + 1):
            temp = dp[j]
            if str1[i - 1] == str2[j - 1]:
                dp[j] = prev + 1
                if dp[j] > max_length:
                    max_length = dp[j]
                    end_pos = i
            else:
                dp[j] = 0
            prev = temp

    longest_substring = str1[end_pos - max_length: end_pos]
    return longest_substring


if __name__ == '__main__':
    freeze_support()

    # 示例
    str1 = "ABCDEF"
    str2 = "BABCDF"
    print("最长公共子串是:", longest_common_substring(str1, str2))
    start_time=time.time()

    with open('唐诗.json', 'r', encoding='utf-8') as f:
        dataset = json.load(f)
    dataset_list = Manager().list()
    dataset_dict = Manager().dict()
    dataset_dict["data"] = dataset
    p_list = []
    datasetiter = data_set(dataset)
    pool = Pool(processes=7)
    for i, one in datasetiter:
        pool.apply_async(get_text, args=(i, one, dataset_dict, dataset_list))
    pool.close()
    pool.join()
    pd.to_pickle(list(dataset_list), "dataset_list.pkl")
    print(time.time()-start_time)
# import pandas as pd
# data=pd.read_pickle("dataset_list.pkl")
# data=[[iiii,i.split(iiii)[0],i.split(iiii)[1:],ii.split(iiii)[0],ii.split(iiii)[1:]] for i,ii,iii,iiii in data]
# # 计算data[0,1,3]  任何相似都可找到 一个下文 计算 data[2,4]相似都可以找到一个上文

这段代码的功能是找出数据集中每个文本与其他文本中最长的公共子串，保存在一个列表中。代码主要使用了difflib库和numba库。

• difflib库是用来处理文本之间的差异或相似性的库。在代码中，使用了difflib库的SequenceMatcher类和find_longest_match方法来计算最长的公共子串。

• numba库是用来加速Python代码的库。在代码中，使用了numba库的jit装饰器来对longest_common_substring函数进行即时编译，以提高运行速度。

代码流程如下：

1. 导入所需的库。
2. 定义一个函数data_set，用于生成数据集中的文本。
3. 定义一个函数get_text，用于计算每个文本与其他文本中的最长公共子串，并将结果保存在一个列表中。
4. 导入数据集。
5. 创建一个管理器，用于共享数据。
6. 创建进程池。
7. 对数据集中的每个文本，调用get_text函数进行计算。
8. 关闭进程池，并等待所有进程完成。
9. 将结果保存为pkl文件。
10. 打印运行时间。

代码中还有一段被注释掉的代码，是用来读取保存的结果文件并进行进一步处理的。