试图加速我编写的一些代码：python

因此，我编写了以下代码，以产生对我有用的特性的成对分区，我正在尝试并行化一个源于这些分区的输出的程序

注：r和n几乎是任意的，但它们往往在2到16之间

from itertools import combinations_with_replacement

def conjugate(p1):
    p = list(p1)
    if p == []:
        return p1
    else:
        l = len(p)
        conj =  [l]*p[-1]
        for i in xrange(l-1,0,-1):
            conj.extend([i]*(p[i-1] - p[i]))
        return conj

def dominates(p1,p2):
    sum1 = 0
    sum2 = 0
    min_length = min(len(p1), len(p2))
    if min_length == 0:
        return len(p1) >= len(p2)

    for i in range(min_length):
        sum1 += p1[i]
        sum2 += p2[i]
        if sum2 > sum1:
            return False
    return bool(sum(p1) >= sum(p2))


def partition_lists(r,n):
    half = n*r/2
    combDict = {}
    for a in range(half,n*r+1):
        combDict[a] = []
    for a in combinations_with_replacement(range(0,n+1),r):
        if sum(a) >= half:
            combDict[sum(a)].append(list(reversed(a)))
    for key,item in combDict.iteritems():
        for i in range(len(item)):
            for j in range(len(item)):
                rp = [2*n - 2*a for a in item[i]]
                cp = [2*n - 2*a for a in item[j]]
                rpN = filter(lambda a: a != 0, reversed(rp))
                cpN = filter(lambda a: a != 0, reversed(cp))
                if dominates(conjugate(rpN),cpN):
                    yield item[i],item[j]

前两个函数是实心函数，但在后一个函数中使用。 最后一个函数生成我称之为“重”矩阵的行和列之和，并基于这些值，计算“轻”矩阵（rp，cp）的行和列之和，然后测试优势度，查看轻矩阵是否可行，其中轻矩阵的权重仅为重矩阵一半的0和1。 问题是我生成了大量的数据，当我深入到支配函数和共轭函数时，我得到了大约一半的数据。有没有办法更快地完成这项工作，或者更快地删除不必要的数据？

---

还有一种方法可以并行化另一个函数，该函数将在分区列表的输出上运行更多进程吗？

您能解释一下您使用此代码的上下文吗？什么是重矩阵和轻矩阵。你到底想用它们做什么？这是什么领域？如果我们能提供更多的帮助，这是可能的。