Python 使用*args和指定的列表索引对列表求和

我之前在Stack Overflow上发布了一个问题，询问如何组合由整数值组成的列表，同时对各个索引（）处的值求和。我从@pault那里得到了一个很好的答案，但现在我想知道是否可以在函数中使用

*args

来添加任意数量的列表

例如，我可以有4个列表（或任意数量）：

我想将列表

b

、

c

和

d

插入

a

中的指定索引中。所以我可以说，在

a[2]

处插入list

b

，

c

在

a[2]

处插入

d

在

a[5]

处插入。结果将是

[01151921]

这是我目前使用的代码（归功于@pault）：

---

要点是在任何索引处向

a

添加任意数量的列表，同时保持

a

的长度不变，因此，例如，如果我在

a[6]

处添加列表

b

，结果将是

[0,1,2,3,4,5,8,11]

。我认为我最大的问题是将列表与我希望插入的索引相关联，因此，例如，让列表

b

进入

a[3]

，并指定列表

c

进入

a[4]

，等等。同时保持列表

a

的长度不变，因此，可能需要与

**kwargs

进行一些配对？类似于，

{'list'：'index'}

？我真的不知道该怎么办。我正在使用Python 3.4.3

我按要求做了这个函数。但是我没有使用

*args

，因为我只是认为这会使代码在这个用例中变得不那么清晰。在这里，我们有明确的命名，代码似乎符合您的要求

def combine(refList, listsToAdd, indexes):
    lenRef = len(refList)

    #   Navigating through lists you want to add.
    for listToAdd, startIndex in zip(listsToAdd, indexes):
        #   We'll need a break point later.
        lenToAdd = len(listToAdd)

        #   Setting index of the list to add numbers from.
        count = 0

        #   Going from the start index, until the end of our original list.
        for refIdx in range(startIndex, lenRef):
            #   If we reach the end of our toAdd list... break.
            if count >= lenToAdd:
                break
            refList[refIdx] += listToAdd[count]
            count += 1

    return refList

if __name__ == '__main__':
    a = [0, 1, 2, 3, 4, 5, 6, 7]
    b = [2, 4, 6, 8, 10, 12]
    c = [1, 1, 1, 1, 1]
    d = [2, 2, 2, 2, 2]

    newList = combine(a, listsToAdd=[b, c, d], indexes=[2, 2, 5])
    print newList
    # outputs : [0, 1, 5, 8, 11, 16, 19, 21]

---

如果我正确理解了您的问题，您需要做的就是将

listb

放入列表列表中

要对

组合

进行最少的更改，请使用迭代

列表b

的每个项目和每个索引，这两个项目现在都应该是列表列表列表：

def combine(lista, listb, index_in_list_a_to_start_insert):
    if isinstance(listb[0], list):  # check if the first item in listb
                                    # is a list; check for empty lists
        for actual_list_b, actual_insert_index in zip(listb, index_in_list_a_to_start_insert):
            lista = combine(lista, actual_list_b, actual_insert_index)
        return lista

    newb = [0]*index_in_list_a_to_start_insert + listb
    max_len = max(len(lista), len(newb))
    newa = lista if len(lista) >= max_len else lista + [0]*(max_len-len(lista))
    newb = newb if len(newb) >= max_len else newb + [0]*(max_len-len(newb))

    return [a + b for a, b in zip(newa,newb)][0:len(a)]

并使用上面的示例列表：

>>> a = [0, 1, 2, 3, 4, 5, 6, 7]
>>> b = [2, 4, 6, 8, 10, 12]
>>> c = [1, 1, 1, 1, 1]
>>> d = [2, 2, 2, 2, 2]
>>>
>>> combine(a, [b, c], [3, 4])
[0, 1, 2, 5, 9, 12, 15, 18]
>>>

您需要为listb和索引列表添加更多的isinstance（）检查，以确保两者都是列表或两者都不是列表，并且长度相同，最短的一个确定了

zip

的结果

def combine(lista, listb, index_in_list_a_to_start_insert):
    if isinstance(listb[0], list):  # check if the first item in listb
                                    # is a list; check for empty lists
        for actual_list_b, actual_insert_index in zip(listb, index_in_list_a_to_start_insert):
            lista = combine(lista, actual_list_b, actual_insert_index)
        return lista

    newb = [0]*index_in_list_a_to_start_insert + listb
    max_len = max(len(lista), len(newb))
    newa = lista if len(lista) >= max_len else lista + [0]*(max_len-len(lista))
    newb = newb if len(newb) >= max_len else newb + [0]*(max_len-len(newb))

    return [a + b for a, b in zip(newa,newb)][0:len(a)]

>>> a = [0, 1, 2, 3, 4, 5, 6, 7]
>>> b = [2, 4, 6, 8, 10, 12]
>>> c = [1, 1, 1, 1, 1]
>>> d = [2, 2, 2, 2, 2]
>>>
>>> combine(a, [b, c], [3, 4])
[0, 1, 2, 5, 9, 12, 15, 18]
>>>