按元素添加不同长度的列表

from itertools import zip_longest

c = [sum(i) for i in zip_longest(a, b, fillvalue=0)]

还有几个解决方案：

longer = a if len(a) >= len(b) else b
c = [x+y for x,y in zip(a,b)] + longer[min(len(a), len(b)):]

或一个命令（可读性较差的版本）：

c = [x+y for x,y in zip(a,b)] + (a if len(a) >= len(b) else b)[min(len(a), len(b)):]

长度约为 的数组的执行时间测量10^6：

In [110]: print(len(a), len(b))
1000000 1012345

In [104]: %timeit Sergey_Gornostaev(a, b)
267 ms ± 318 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)

In [105]: %timeit nick_gabpe(a, b)
200 ms ± 168 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)

In [106]: %timeit AtachiShadow1(a, b)
255 ms ± 558 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)

In [107]: %timeit AtachiShadow2(a, b)
239 ms ± 1.69 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

In [108]: %timeit AtachiShadow3(a, b)
200 ms ± 604 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)

In [109]: %timeit MaxU(a, b)
124 ms ± 1.26 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

设置：

from random import randint
a = [randint(0, 10**6) for _ in range(10**6)]
b = [randint(0, 10**6) for _ in range(10**6+12345)]

print(len(a), len(b))
# 1000000 1012345

def MaxU(a, b):
    return [x+y for x,y in zip(a,b)] + (a if len(a) >= len(b) else b)[min(len(a), len(b)):]

def nick_gabpe(a, b):
    c=[]
    for x, y in zip(a,b): 
       c+=[x+y]

    if len(a) > len(b):
       c+=a[len(a)-len(b)+1:]
    elif len(a) < len(b):
       c+=b[len(b)-len(a)+1:]
    return c

def Sergey_Gornostaev(a, b):
    return [sum(i) for i in zip_longest(a, b, fillvalue=0)]

def AtachiShadow1(a, b):
    c = []
    la = len(a)
    lb = len(b)
    maxab = max(la, lb)
    minab = min(la, lb)
    for i in range(maxab):
        if i >= minab:
            if la < lb:
                c.append(0+b[i])
            elif la > lb:
                c.append(a[i]+0)
        else:
            c.append(a[i]+b[i])
    return c

def AtachiShadow2(a, b):
    c = []
    la = len(a)
    lb = len(b)
    maxab = max(la, lb)
    minab = min(la, lb)
    for i in range(maxab):
        try:
            c.append(a[i]+b[i])
        except IndexError:
            if la < lb:
                c.append(0+b[i])
            elif la > lb:
                c.append(a[i]+0)
    return c

def AtachiShadow3(a, b):
    c=[]
    la = len(a)
    lb = len(b)
    for x, y in zip(a,b):
       c+=[x+y]
    if la > lb:
       c+=a[la-lb+1:]
    elif la < lb:
       c+=b[lb-la+1:]
    return c

非常感谢作者完成了一项相当酷的任务，我（作为初学者）弄清楚它是如何工作的非常有趣）消息很长，但我希望它易于阅读）））：

在评论zip和答案中建议，zip_longest我决定将它留给最后一个选项，然后在他们尝试自己解决这个问题之前。这就是我所做的。第一个选项是：

a = [1, 2, 3]
b = [4, 5, 6, 7, 8]
c = []

for i in range(max(len(a), len(b))):
    if i >= min(len(a), len(b)):
        if len(a) == i + 1 and len(a) < len(b):
            c.append(0 + b[i])
        else:
            c.append(a[i] + 0)
    else:
        c.append(a[i] + b[i])
print(c)

他当然会做他必须做的事。但是我又想到了一个更合乎逻辑（在我看来）的解决方案来解决这个循环。第二个选项是：

a = [1, 2, 3]
b = [4, 5, 6, 7, 8]
c = []
for i in range(max(len(a), len(b))):
    try:
        c.append(a[i] + b[i])
    except IndexError:
        if i >= min(len(a), len(b)):
            if len(a) == i + 1 and len(a) < len(b):
                c.append(0 + bbb[i])
            else:
                c.append(a[i] + 0)
print(c)

一方面，在我看来，直到较小的列表停止迭代，主体才会被执行try:。并且当较小的列表结束时，except IndexError将引发并执行错误主体。由于此选项也符合预期，因此在执行速度方面比较它们是合乎逻辑的。我使用timeit并得到以下结果：

Вариант №1 - 8.045603216 на 1000000 (1млн) повторений
Вариант №2 - 9.076056240 на 1000000 (1млн) повторений

我很惊讶。我希望它能try:消除循环内不必要if的执行，从而加快速度。但结果恰恰相反。之后，我决定将我的选项与 Sergey Gornostaev 的选项进行比较，并timeit第二次指出我的方法效率低下：

Вариант №1 - 8.045603216 на 1000000 (1млн) повторений
Вариант №2 - 9.076056240 на 1000000 (1млн) повторений
Sergey Gornostaev - 6.960991073 на 1000000 (1млн) повторений

再次证实了在stackoverflow上最常提供“经验丰富”的答案的想法））））谢尔盖·戈尔诺斯塔耶夫（Sergey Gornostaev）赢得了1秒））但我认为，标准库==优化代码。我去优化我的代码 - 在我的选项中，函数len(), max(), min()在循环的每次迭代中启动，但为什么我len(a)要问 5 次？））））我还认为这有点愚蠢，需要修复）） )) 将它们移到循环之前的变量并更正了逻辑if。

选项编号 1.1：

a = [1, 2, 3]
b = [4, 5, 6, 7, 8]
c = []
la = len(a)
lb = len(b)
maxab = max(la, lb)
minab = min(la, lb)
for i in range(maxab):
    if i >= minab:
        if la < lb:
            c.append(0+b[i])
        elif la > lb:
            c.append(a[i]+0)
    else:
        c.append(a[i]+b[i])
print(c)

选项编号 2.1：

a = [1, 2, 3]
b = [4, 5, 6, 7, 8]
c = []
la = len(a)
lb = len(b)
maxab = max(la, lb)
minab = min(la, lb)
for i in range(maxab):
    try:
        c.append(a[i]+b[i])
    except IndexError:
        if la < lb:
            c.append(0+b[i])
        elif la > lb:
            c.append(a[i]+0)
print(c)

是的，优化工作：

Вариант №1.1 - 4.774997384 на 1000000 (1млн) повторений
Вариант №2.1 - 5.907061396 на 1000000 (1млн) повторений
Sergey Gornostaev - 6.960991073 на 1000000 (1млн) повторений

由于代码的正确编写，速度几乎提高了两倍。并且这两个选项都比建议的库更快）））

当我正要对我的答案进行另一次编辑时，作者的答案出现了：

a = [1,2,3]
b = [4,5,6,7,8]
c=[]
for x, y in zip(a,b): 
   c+=[x+y]

if len(a) > len(b):
   c+=a[len(a)-len(b)+1:]
elif len(a) < len(b):
   c+=b[len(b)-len(a)+1:]
print(c)

什么timeit？粉碎，所有以前的选项）））：

Вариант №1.1 - 4.774997384 на 1000000 (1млн) повторений
Вариант №2.1 - 5.907061396 на 1000000 (1млн) повторений
Sergey Gornostaev - 6.960991073 на 1000000 (1млн) повторений
Автор - 3.151485595 на 1000000 (1млн) повторений

在我的“快速”优化版本之前获得 1.5 秒的增益。在一个问题中第二次很好地回答 CO 的想法得到了证实））））））

但！在作者自己的答案中更酷的是使用zip. 在 Sergey Gornostaev 的回答和我的变体中，使用了更大列表的概念，也就是说，for它会执行与更大列表中的元素一样多的循环 - 这很糟糕。一个主要问题 - 如果其中一个列表为空会发生什么？这就是：

a = []
Вариант №1.1 - 4.960243867 на 1000000 (1млн) повторений
Вариант №2.1 - 7.668313717 на 1000000 (1млн) повторений
Sergey Gornostaev - 6.865756772 на 1000000 (1млн) повторений
Автор - 1.848900008 на 1000000 (1млн) повторений

什么转折！！！选项 1.1 保持不变（每个错误 0.2）。但是变体 #2.1 ( try except) 完全失败了 - 由于 ，现在a = []每次迭代都会for导致except，这增加了执行时间。与 1.1 一样，Sergey Gornostaev 变体的执行时间没有改变（每个错误 0.1）。但是作者的回答表现得淋漓尽致，它比任何“一杯糖”都要酷（来自关于“这是一个转弯”的漫画）））））在“长名单”的最快版本上几乎是3倍的优势！但这还不是全部！）））我记得стандартная библиотека == оптимизированный код，但作者的代码没有优化一点））））函数len(a)，len(b)每次执行被调用两次。所以它们可以在开始时计算一次，然后使用变量））：

a = [1,2,3]
b = [4,5,6,7,8]
c=[]
la = len(a)
lb = len(b)
for x, y in zip(a,b):
   c+=[x+y]
if la > lb:
   c+=a[la-lb+1:]
elif la < lb:
   c+=b[lb-la+1:]

这就是它所说的timeit：

a = [1,2,3]:
не оптимизированный код автора - 3.138068215
оптимизированный код автора - 2.908475165

a = []:
не оптимизированный код автора - 1.909198691
оптимизированный код автора - 1.642370166

优化代码的增益为 0.25 秒。这已经是“长列表”代码的 3 倍优势！这很棒））））

附言

1.所有测量都是在同一台电脑上进行的，并且在大致相同的条件下（只有旁边打开的Chrome会有所不同），因此不同逻辑执行的时间比例在不同的计算机上会有所不同计算机，这里只显示了逻辑执行的近似相对速度。

2.我不是专业人士，甚至不是业余爱好者，timeit我在写答案时正在谷歌搜索。到目前为止，“脚本小子”的概念更适用于我，但我正在学习）））））这就是为什么，我认为我对这个问答的研究将包含错误和不准确之处。如果更有经验的程序员告诉我他们，我会很高兴））））。

3.再次非常感谢问题任务的作者以及那些回答和评论它的人，我很高兴对我的失败感到惊讶，并且从中学习也很高兴））

4.给定的测量值和每 100 万次重复的差异可能会引发一个合乎逻辑的问题，即是否值得进行蒸汽浴，因为差异如此之小，尤其是因为我们谈论的是 Python 而不是 C++。而且我认为每个人都会自己决定是否值得））））））））至少对于热身来说，这是可以做到的）

好吧，让我们编写我们的自行车：

a = [1,2,3]
b = [4,5,6,7,8]
c=[]
for x, y in zip(a,b): 
   c+=[x+y]

if len(a) > len(b):
   c+=a[len(a)-len(b)+1:]
elif len(a) < len(b):
   c+=b[len(b)-len(a)+1:]

print(c) # [5, 7, 9, 6, 7, 8]

但是选项，可能不是最快的，而是最短的：

a = [1,2,3]
b = [4,5,6,7,8]
ml = min(len(a), len(b))
с = [x + y for x, y in zip(a,b)] + a[ml:] + b[ml:]