Python 中列表列表的动态初始化

Question

假设我想创建一个函数，该函数接受多个以整数作为值的列表的列表，但每个列表可以具有不同的大小。例如，以下列表列表作为输入参数：

[[1,2,3,4],[5,6,7],[8,9]]

，但其他输入参数可以是：

[1,2],[3,4,5,6],[7,8,9],[10,11,12,13]

然后我想返回另一个列表列表，其中列表的数量与输入相同，但每个列表上的元素数量不同，因为我想做某种算法来删除每个列表的一些元素。

是否可以使用Python以动态方式初始化函数内的列表列表？我只能考虑先创建固定数量、固定大小的列表。

Answer 1

我假设你有一个

list of list: input_list

作为输入，并且你想输出

lists of lists: possibility

具有的可能性：

• input_list

的每个整数
• 与

  input_list

  相同数量的内部列表：k

您可以获取“possibility”子列表长度的可能性，然后用“input_list”的整数对每个子列表进行充电。 设 `possibility` 子列表的长度为： `filling_possibility = [len_1, len_2, ..., len_k]`。\ 我们也可以这样写 f = (x_1, x_2, ..., x_k)

设 n 为整数个数。我们想要每个整数，所以：
n = x_0 + x_1 + ... + x_k

我们可以指出：
n = x_0 + (x_1 + ... + x_k)
n = x_0 + x_1 + (x_2 + ... + x_k)
等等

我们知道如何求解 n = x_0，因此我们可以使用递归：

def resolve_equation(n, k):
    def find_solutions_recursive(target, k, current_solution):
        if k == 1:
            current_solution.append(target)
            solutions.append(tuple(current_solution))
            current_solution.pop()
        else:
            for x in range(target + 1):
                current_solution.append(x)
                find_solutions_recursive(target - x, k - 1, current_solution)
                current_solution.pop()

    solutions = []
    find_solutions_recursive(n, k, [])
    return solutions

input_list = [[1, 2, 3, 4], [5, 6, 7], [8, 9]]
n = sum(map(len, input_list))
k = len(input_list)
filling_possibilities = resolve_equation(n, k)

print(filling_possibilities)

现在我们用

filling_possibility

的整数列表的排列来对每个

input_list

进行充电。
可以使用 itertools 来描述排列：

import itertools

integers = sum(input_list, [])
integers_distributions = itertools.permutations(integers)

print(list(integers_distributions))

以及收费部分，对于与

input_list

相同的整数分布：

filling = filling_possibilities[0]
# Distribute integers to the current `possibility`
possibility = [[] for _ in range(k)]
# the index in the list of integers `distribution`
i = 0
for sublist_len, sublist in zip(filling, possibility):
    sublist.extend(integers[i:i+sublist_len])
    i += sublist_len

print(possibility)

全部混合在一起：

import itertools

def resolve_equation(n, k):
    def find_solutions_recursive(target, k, current_solution):
        if k == 1:
            current_solution.append(target)
            solutions.append(tuple(current_solution))
            current_solution.pop()
        else:
            for x in range(target + 1):
                current_solution.append(x)
                find_solutions_recursive(target - x, k - 1, current_solution)
                current_solution.pop()

    solutions = []
    find_solutions_recursive(n, k, [])
    return solutions

def mix_integers(input_list):
    n = sum(map(len, input_list))
    k = len(input_list)
    filling_possibilities = resolve_equation(n, k)
    integers = sum(input_list, [])

    possibilities = []
    for filling in filling_possibilities:
        # `integers_distributions` is exhausted on every iteration (generator)
        integers_distributions = itertools.permutations(integers)
        for distribution in integers_distributions:
            # Distribute integers to the current `possibility`
            possibility = [[] for _ in range(k)]
            # i is the index in the list of integers `distribution`
            i = 0
            for sublist_len, sublist in zip(filling, possibility):
                sublist.extend(distribution[i:i+sublist_len])
                i += sublist_len
            possibilities.append(possibility)
    return possibilities

mixed = mix_integers([[1, 2, 3], [4], [5, 6, 7]])
print(mixed)

但是它非常慢。你可以用

[[1, 2, 3, 4], [5, 6, 7], [8, 9]]

尝试一下。