Python（v3.7.7）多处理？对于.issubset

我有一个问题，我有一个数字的输入文件，我正在转换为每行数字的列表。分组如下

从该列表中，我使用原始列表itertools.combinations中的数据生成另一个列表，该列表包含以下所有组合的子集

到目前为止，代码运行速度非常快，但下一个部分。issubset是我遇到问题的地方，此时所有数据都在现有列表中，因此我不认为这是I/O问题：

我想创建一个直方图，跟踪不仅匹配给定输入行，而且匹配文件中任何位置的每个子集

所有_子集的长度为12157823

输入_文件的长度为1079

下面的示例仅针对输入文件组的一条记录检查所有_子集的每个元素，这很好，但针对整个批次运行时需要很长时间

    # The all_subsets list (combinations)
    #                 is already created and in-place ahead of this code
    histogram = {}
    for group in input_list:
        group = group.split()           # converts input string into list
        group = list(map(int, group))
        print(group) # [17, 22, 36, 37, 52]

        for subset in all_subsets:
            #
            # This next if statement is the bottleneck
            #                      --is parallelization an option?
            #
            if(set(subset).issubset(set(group))):        # ***
                subset = tuple(subset)
                if subset not in histogram:
                    histogram[subset] = 1
                else:
                    histogram[subset] = histogram[subset] + 1 
        print(histogram)    
        """                   { ( 17, 22, 36, 37, 52 ): 1,
                                ( 17, 22, 36, 37 ):     1,
                                ( 17, 22, 36, 52 ):     1,
                                ( 17, 22, 37, 52 ):     1,
                                ( 17, 36, 37, 52 ):     1,
                                ( 22, 36, 37, 52 ):     1,
                                ( 17, 22, 36 ):         1,
                                ( 17, 22, 37 ):         1,
                                ( 17, 22, 52 ):         1,
                                ( 17, 36, 37 ):         1,
                                ( 17, 36, 52 ):         1,
                                ( 17, 37, 52 ):         1,
                                ( 22, 36, 37 ):         1,
                                ( 22, 36, 52 ):         1,
                                ( 22, 37, 52 ):         1,
                                ( 36, 37, 52 ):         1,
                                ( 17, 22 ):             1,
                                ( 17, 36 ):             1,
                                ( 17, 37 ):             1,
                                ( 17, 52 ):             1,
                                ( 22, 36 ):             1,
                                ( 22, 37 ):             1,
                                ( 22, 52 ):             1,
                                ( 36, 37 ):             1,
                                ( 36, 52 ):             1,
                                ( 37, 52 ):             1,
                                ( 17, ):                1,
                                ( 22, ):                1,
                                ( 36, ):                1,
                                ( 37, ):                1,
                                ( 52, ):                1
                              }
        """

---

A尽可能使用惰性生成器而不是列表。B预先创建子集并将其存储为集合。C将负载分为多个进程，并对尖端进行扫描。A&B让我提高了一些效率，但C是我不太了解的地方，无法正确地做到这一点。我会继续尝试一些东西，但是如果您有任何好的例子，可以将嵌套迭代传递给多处理，同时适当地更新字典，我很乐意看到它。我找不到这样的例子。如果所有的子集都是预先计算的，并且是只读的，那么将它们放在共享内存中，并将输入分割成几个块，每个块分别送入一个单独的进程。是否可以避免扫描整个子集列表，并通过查找确定输入行是否为超集？i、 e.要使子集列表成为一组可哈希的子集元组？这样您就可以使用in运算符。换句话说：如果每个输入行都是一个子集，即它不包含外来元素，那么它必须作为一个子集出现在所有可能的子集列表中，您不必检查它是否是一个超集您是对的！我能够按照您描述的方式修改内容，避免将内容作为超集进行查找。我需要做更多的研究，更好地处理多处理模块，以便在下次需要时做好更好的准备。谢谢你帮我重新思考我的问题。我很高兴能帮上忙。这几天我没有时间，如果可能的话，我会研究多重处理。将问题留待讨论，以便其他人可以尽可能使用惰性生成器而不是列表。B预先创建子集并将其存储为集合。C将负载分为多个进程，并对尖端进行扫描。A&B让我提高了一些效率，但C是我不太了解的地方，无法正确地做到这一点。我会继续尝试一些东西，但是如果您有任何好的例子，可以将嵌套迭代传递给多处理，同时适当地更新字典，我很乐意看到它。我找不到这样的例子。如果所有的子集都是预先计算的，并且是只读的，那么将它们放在共享内存中，并将输入分割成几个块，每个块分别送入一个单独的进程。是否可以避免扫描整个子集列表，并通过查找确定输入行是否为超集？i、 e.要使子集列表成为一组可哈希的子集元组？这样您就可以使用in运算符。换句话说：如果每个输入行都是一个子集，即它不包含外来元素，那么它必须作为一个子集出现在所有可能的子集列表中，您不必检查它是否是一个超集您是对的！我能够按照您描述的方式修改内容，避免将内容作为超集进行查找。我需要做更多的研究，更好地处理多处理模块，以便在下次需要时做好更好的准备。谢谢你帮我重新思考我的问题。我很高兴能帮上忙。这几天我没有时间，如果可能的话，我会研究多重处理。把这个问题留待讨论，这样其他人也可以做出贡献