我有以下两个列表：

first = [1,2,3,4,5]
second = [6,7,8,9,10]

现在，我想将这两个列表中的项目添加到新列表中。

输出应该是

third = [7,9,11,13,15]

此zip功能在此处有用，可与列表推导一起使用。

[x + y for x, y in zip(first, second)]

如果您有一个列表列表（而不是两个列表）：

lists_of_lists = [[1, 2, 3], [4, 5, 6]]
[sum(x) for x in zip(*lists_of_lists)]
# -> [5, 7, 9]

来自文档

import operator
list(map(operator.add, first,second))

假设两个列表a，并b具有相同的长度，你不需要压缩，numpy的或其他任何东西。

Python 2.x和3.x：

[a[i]+b[i] for i in range(len(a))]

numpy中的默认行为是逐组件添加

import numpy as np
np.add(first, second)

哪个输出

array([7,9,11,13,15])

这可以扩展到任意数量的列表：

[sum(sublist) for sublist in itertools.izip(*myListOfLists)]

在你的情况下，myListOfLists将[first, second]

尝试以下代码：

first = [1, 2, 3, 4]
second = [2, 3, 4, 5]
third = map(sum, zip(first, second))

执行此操作的简单方法和快速方法是：

three = [sum(i) for i in zip(first,second)] # [7,9,11,13,15]

另外，您可以使用numpy sum：

from numpy import sum
three = sum([first,second], axis=0) # array([7,9,11,13,15])

first = [1, 2, 3, 4, 5]
second = [6, 7, 8, 9, 10]
three = map(lambda x,y: x+y,first,second)
print three



Output 
[7, 9, 11, 13, 15]

一线解决方案

list(map(lambda x,y: x+y, a,b))

Thiru在3月17日9:25回答了我的问题。

这更加简单快捷，这是他的解决方案：

执行此操作的简单方法和快速方法是：

 three = [sum(i) for i in zip(first,second)] # [7,9,11,13,15]

另外，您可以使用numpy sum：

 from numpy import sum
 three = sum([first,second], axis=0) # array([7,9,11,13,15])

您需要numpy！

import numpy as np
a = [1,2,3,4,5]
b = [6,7,8,9,10]
c = list(np.array(a) + np.array(b))
print c
# [7, 9, 11, 13, 15]

如果未知数量的相同长度的列表，则可以使用以下功能。

在这里，* args接受可变数量的列表参数（但每个参数仅求和相同数量的元素）。再次使用*来解压缩每个列表中的元素。

def sum_lists(*args):
    return list(map(sum, zip(*args)))

a = [1,2,3]
b = [1,2,3]  

sum_lists(a,b)

输出：

[2, 4, 6]

或有3个清单

sum_lists([5,5,5,5,5], [10,10,10,10,10], [4,4,4,4,4])

输出：

[19, 19, 19, 19, 19]

您可以使用zip()，将两个数组“交织”在一起，然后使用map()，它将对一个可迭代对象中的每个元素应用一个函数：

>>> a = [1,2,3,4,5]
>>> b = [6,7,8,9,10]
>>> zip(a, b)
[(1, 6), (2, 7), (3, 8), (4, 9), (5, 10)]
>>> map(lambda x: x[0] + x[1], zip(a, b))
[7, 9, 11, 13, 15]

这是另一种方法。我们利用python的内部__add__函数：

class SumList(object):
    def __init__(self, this_list):
        self.mylist = this_list

    def __add__(self, other):
        new_list = []
        zipped_list = zip(self.mylist, other.mylist)
        for item in zipped_list:
            new_list.append(item[0] + item[1])
        return SumList(new_list)

    def __repr__(self):
        return str(self.mylist)

list1 = SumList([1,2,3,4,5])
list2 = SumList([10,20,30,40,50])
sum_list1_list2 = list1 + list2
print(sum_list1_list2)

输出量

[11, 22, 33, 44, 55]

如果您还想添加列表中的其余值，则可以使用它（在Python3.5中有效）

def addVectors(v1, v2):
    sum = [x + y for x, y in zip(v1, v2)]
    if not len(v1) >= len(v2):
        sum += v2[len(v1):]
    else:
        sum += v1[len(v2):]

    return sum


#for testing 
if __name__=='__main__':
    a = [1, 2]
    b = [1, 2, 3, 4]
    print(a)
    print(b)
    print(addVectors(a,b))

    first = [1,2,3,4,5]
    second = [6,7,8,9,10]
    #one way
    third = [x + y for x, y in zip(first, second)]
    print("third" , third) 
    #otherway
    fourth = []
    for i,j in zip(first,second):
        global fourth
        fourth.append(i + j)
    print("fourth" , fourth )
#third [7, 9, 11, 13, 15]
#fourth [7, 9, 11, 13, 15]

这是另一种方法。它对我来说很好。

N=int(input())
num1 = list(map(int, input().split()))
num2 = list(map(int, input().split()))
sum=[]

for i in range(0,N):
  sum.append(num1[i]+num2[i])

for element in sum:
  print(element, end=" ")

print("")

j = min(len(l1), len(l2))
l3 = [l1[i]+l2[i] for i in range(j)]

也许是最简单的方法：

first = [1,2,3,4,5]
second = [6,7,8,9,10]
three=[]

for i in range(0,5):
    three.append(first[i]+second[i])

print(three)

如果您将列表视为numpy数组，则需要轻松对其求和：

import numpy as np

third = np.array(first) + np.array(second)

print third

[7, 9, 11, 13, 15]

如果您有不同长度的列表怎么办，那么您可以尝试这样的操作（使用zip_longest）

from itertools import zip_longest  # izip_longest for python2.x

l1 = [1, 2, 3]
l2 = [4, 5, 6, 7]

>>> list(map(sum, zip_longest(l1, l2, fillvalue=0)))
[5, 7, 9, 7]

您可以使用此方法，但仅当两个列表的大小相同时，该方法才有效：

first = [1, 2, 3, 4, 5]
second = [6, 7, 8, 9, 10]
third = []

a = len(first)
b = int(0)
while True:
    x = first[b]
    y = second[b]
    ans = x + y
    third.append(ans)
    b = b + 1
    if b == a:
        break

print third

我有一个数字列表，例如[1,2,3,4,5...]，我想计算(1+2)/2第二个，(2+3)/2第三个， (3+4)/2等等。我怎样才能做到这一点？

我想将第一个数字与第二个数字相加并除以2，然后将第二个数字与第三个数字相加并除以2，依此类推。

另外，如何求和数字列表？

a = [1, 2, 3, 4, 5, ...]

是吗：

b = sum(a)
print b

得到一个号码？

这对我不起作用。

问题1：因此，您想要（元素0 +元素1）/ 2，（元素1 +元素2）/ 2，…等等。

我们列出两个列表：除第一个元素之外的每个元素中的一个，除最后一个元素之外的每个元素中的一个。然后，我们想要的平均值是从两个列表中得出的每对平均值。我们zip过去常常从两个列表中取对。

我假设即使输入值是整数，您也希望在结果中看到小数。默认情况下，Python会进行整数除法：它会丢弃余数。要完全划分事物，我们需要使用浮点数。幸运的是，将int除以浮点数将产生一个浮点数，因此我们仅将其2.0用作除数而不是2。

从而：

averages = [(x + y) / 2.0 for (x, y) in zip(my_list[:-1], my_list[1:])]

问题2：

的使用sum应该可以正常工作。以下作品：

a = range(10)
# [0,1,2,3,4,5,6,7,8,9]
b = sum(a)
print b
# Prints 45

同样，您不需要在此过程的每一步都将所有内容分配给变量。print sum(a)效果很好。

您将必须更确切地确切地写出您所写的内容以及它是如何工作的。

总数列表：

sum(list_of_nums)

使用列表推导计算n和n-1的一半（如果我的模式正确）：

[(x + (x - 1)) / 2 for x in list_of_nums]

对相邻元素求和，例如（（1 + 2）/ 2）+（（2 + 3）/ 2）+ …使用reduce和lambda

reduce(lambda x, y: (x + y) / 2, list_of_nums)

问题2： 总结一个整数列表：

a = [2, 3, 5, 8]
sum(a)
# 18
# or you can do:
sum(i for i in a)
# 18

如果列表包含整数作为字符串：

a = ['5', '6']
# import Decimal: from decimal import Decimal
sum(Decimal(i) for i in a)

您可以这样尝试：

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
sm = sum(a[0:len(a)]) # Sum of 'a' from 0 index to 9 index. sum(a) == sum(a[0:len(a)]
print(sm) # Python 3
print sm  # Python 2

>>> a = range(10)
>>> sum(a)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not callable
>>> del sum
>>> sum(a)
45

似乎sum已经在代码中的某个地方定义了该代码，并覆盖了默认功能。所以我删除了它，问题解决了。

使用简单list-comprehension和sum：

>> sum(i for i in range(x))/2. #if x = 10 the result will be 22.5

所有答案均显示出程序化和通用的方法。我建议针对您的情况的数学方法。特别是对于长列表，它可能会更快。之所以有效，是因为您的列表是一个自然数列表，最多可包含n：

假设我们有自然数1, 2, 3, ..., 10：

>>> nat_seq = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

您可以sum在列表中使用该功能：

>>> print sum(nat_seq)
55

您还可以使用公式n*(n+1)/2where n是列表中最后一个元素的值（此处nat_seq[-1]：），因此可以避免迭代元素：

>>> print (nat_seq[-1]*(nat_seq[-1]+1))/2
55

要生成序列(1+2)/2, (2+3)/2, ..., (9+10)/2，可以使用生成器和公式(2*k-1)/2.（注意点使值成为浮点）。生成新列表时，您必须跳过第一个元素：

>>> new_seq = [(2*k-1)/2. for k in nat_seq[1:]]
>>> print new_seq
[1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5]

您也可以sum在此列表中使用该函数：

>>> print sum(new_seq)
49.5

但是您也可以使用公式(((n*2+1)/2)**2-1)/2，因此可以避免迭代元素：

>>> print (((new_seq[-1]*2+1)/2)**2-1)/2
49.5

解决此问题的最简单方法：

l =[1,2,3,4,5]
sum=0
for element in l:
    sum+=element
print sum

这个问题已经在这里回答

a = [1,2,3,4] sum（a）返回10

import numpy as np    
x = [1,2,3,4,5]
[(np.mean((x[i],x[i+1]))) for i in range(len(x)-1)]
# [1.5, 2.5, 3.5, 4.5]

生成器是编写此代码的简单方法：

from __future__ import division
# ^- so that 3/2 is 1.5 not 1

def averages( lst ):
    it = iter(lst) # Get a iterator over the list
    first = next(it)
    for item in it:
        yield (first+item)/2
        first = item

print list(averages(range(1,11)))
# [1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5]

让我们为初学者轻松：-

1. 的global关键字将允许主函数内分配全局变量消息，而不产生新的本地变量

    message = "This is a global!"


def main():
    global message
    message = "This is a local"
    print(message)


main()
# outputs "This is a local" - From the Function call
print(message)
# outputs "This is a local" - From the Outer scope

这个概念叫做阴影

2. 对Python中的数字列表求和

nums = [1, 2, 3, 4, 5]

var = 0


def sums():
    for num in nums:
        global var
        var = var + num
    print(var)


if __name__ == '__main__':
    sums()

输出= 15

使用pairwise itertools配方：

import itertools
def pairwise(iterable):
    "s -> (s0,s1), (s1,s2), (s2, s3), ..."
    a, b = itertools.tee(iterable)
    next(b, None)
    return itertools.izip(a, b)

def pair_averages(seq):
    return ( (a+b)/2 for a, b in pairwise(seq) )

简短：

def ave(x,y):
  return (x + y) / 2.0

map(ave, a[:-1], a[1:])

外观如下：

>>> a = range(10)
>>> map(ave, a[:-1], a[1:])
[0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5]

由于Python如何处理map两个以上的列表有些愚蠢，因此您必须截断该列表a[:-1]。如果您使用它，它的工作效果将超出您的预期itertools.imap：

>>> import itertools
>>> itertools.imap(ave, a, a[1:])
<itertools.imap object at 0x1005c3990>
>>> list(_)
[0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5]

如此众多的解决方案，但我最喜欢的仍然缺失：

>>> import numpy as np
>>> arr = np.array([1,2,3,4,5])

numpy数组与列表没有太大区别（在这种情况下），除了可以将数组视为数字：

>>> ( arr[:-1] + arr[1:] ) / 2.0
[ 1.5  2.5  3.5  4.5]

做完了！

说明

花式索引的含义是：[1:]包括从1到末尾的所有元素（因此省略元素0），并且[:-1]是除最后一个元素之外的所有元素：

>>> arr[:-1]
array([1, 2, 3, 4])
>>> arr[1:]
array([2, 3, 4, 5])

因此，将这两个元素相加即可得到一个由元素（1 + 2），（2 + 3）等组成的数组。并不是说我要除以2.0，不是2因为否则Python会认为您仅使用整数并产生四舍五入的整数结果。

使用numpy的优势

NumPy的可远快于各地的号码清单循环。根据列表的大小，速度快几个数量级。而且，它的代码少得多，至少对我来说，它更易于阅读。我正在尝试养成对所有数字组都使用numpy的习惯，这对我原本必须制作的所有循环和内部循环都是一个巨大的改进。

我只是将lambda与map（）一起使用

a = [1,2,3,4,5,6,7,8,9,10]
b = map(lambda x, y: (x+y)/2.0, fib[:-1], fib[1:])
print b

我使用while循环来获取结果：

i = 0
while i < len(a)-1:
   result = (a[i]+a[i+1])/2
   print result
   i +=1

遍历列表中的元素并像这样更新总数：

def sum(a):
    total = 0
    index = 0
    while index < len(a):
        total = total + a[index]
        index = index + 1
    return total

多亏了Karl Knechtel，我才能够理解您的问题。我的解释：

1. 您想要一个包含元素i和i + 1平均值的新列表。
2. 您要对列表中的每个元素求和。

使用匿名函数（又名Lambda函数）的第一个问题：

s = lambda l: [(l[0]+l[1])/2.] + s(l[1:]) if len(l)>1 else []  #assuming you want result as float
s = lambda l: [(l[0]+l[1])//2] + s(l[1:]) if len(l)>1 else []  #assuming you want floor result

第二个问题也使用匿名函数（又名Lambda函数）：

p = lambda l: l[0] + p(l[1:]) if l!=[] else 0

这两个问题合并在一行代码中：

s = lambda l: (l[0]+l[1])/2. + s(l[1:]) if len(l)>1 else 0  #assuming you want result as float
s = lambda l: (l[0]+l[1])/2. + s(l[1:]) if len(l)>1 else 0  #assuming you want floor result

使用最适合您需求的那个

您也可以使用递归进行相同的操作：

Python片段：

def sumOfArray(arr, startIndex):
    size = len(arr)
    if size == startIndex:  # To Check empty list
        return 0
    elif startIndex == (size - 1): # To Check Last Value
        return arr[startIndex]
    else:
        return arr[startIndex] + sumOfArray(arr, startIndex + 1)


print(sumOfArray([1,2,3,4,5], 0))

尝试使用列表理解。就像是：

new_list = [(old_list[i] + old_list[i+1])/2 for i in range(len(old_list-1))]

本着itertools的精神。成对配方的灵感。

from itertools import tee, izip

def average(iterable):
    "s -> (s0,s1)/2.0, (s1,s2)/2.0, ..."
    a, b = tee(iterable)
    next(b, None)
    return ((x+y)/2.0 for x, y in izip(a, b))

例子：

>>>list(average([1,2,3,4,5]))
[1.5, 2.5, 3.5, 4.5]
>>>list(average([1,20,31,45,56,0,0]))
[10.5, 25.5, 38.0, 50.5, 28.0, 0.0]
>>>list(average(average([1,2,3,4,5])))
[2.0, 3.0, 4.0]

n = int(input("Enter the length of array: "))
list1 = []
for i in range(n):
    list1.append(int(input("Enter numbers: ")))
print("User inputs are", list1)

list2 = []
for j in range(0, n-1):
    list2.append((list1[j]+list1[j+1])/2)
print("result = ", list2)

一种简单的方法是使用iter_tools排列

# If you are given a list

numList = [1,2,3,4,5,6,7]

# and you are asked to find the number of three sums that add to a particular number

target = 10
# How you could come up with the answer?

from itertools import permutations

good_permutations = []

for p in permutations(numList, 3):
    if sum(p) == target:
        good_permutations.append(p)

print(good_permutations)

结果是：

[(1, 2, 7), (1, 3, 6), (1, 4, 5), (1, 5, 4), (1, 6, 3), (1, 7, 2), (2, 1, 7), (2, 3, 
5), (2, 5, 3), (2, 7, 1), (3, 1, 6), (3, 2, 5), (3, 5, 2), (3, 6, 1), (4, 1, 5), (4, 
5, 1), (5, 1, 4), (5, 2, 3), (5, 3, 2), (5, 4, 1), (6, 1, 3), (6, 3, 1), (7, 1, 2), 
(7, 2, 1)]

请注意，顺序很重要-意思是1、2、7也显示为2、1、7和7、1、2。您可以通过使用集合来减少此数目。

在Python 3.8中，可以使用新的赋值运算符

>>> my_list = [1, 2, 3, 4, 5]
>>> itr = iter(my_list)
>>> a = next(itr)
>>> [(a + (a:=x))/2 for x in itr]
[1.5, 2.5, 3.5, 4.5]

a是对列表中前一个值的运行引用，因此将其初始化为列表的第一个元素，并且迭代在列表的其余部分进行，a并在每次迭代中使用后进行更新。

显式迭代器用于避免使用创建列表的副本my_list[1:]。

试试以下-

mylist = [1, 2, 3, 4]   

def add(mylist):
    total = 0
    for i in mylist:
        total += i
    return total

result = add(mylist)
print("sum = ", result)