在Python中对数字列表求和

对一串数字求和:

sum(list_of_nums)

使用列表理解生成一个包含xs中相邻元素平均的新列表:

[(x + y) / 2 for x, y in zip(xs, xs[1:])]

将所有相邻元素求和为一个值:

sum((x + y) / 2 for x, y in zip(xs, xs[1:]))

问题1:

要对一个数字列表求和，使用sum:

xs = [1, 2, 3, 4, 5]
print(sum(xs))

这个输出:

15

问题2:

所以你需要(元素0 +元素1)/ 2，(元素1 +元素2)/ 2，…等。

我们做两个列表:一个是除第一个元素之外的所有元素，一个是除最后一个元素之外的所有元素。我们想要的平均值是从这两个表中取的每对的平均值。我们使用zip从两个列表中获取对。

我假设您希望在结果中看到小数，即使您的输入值是整数。默认情况下，Python执行整数除法:它会丢弃余数。要一直除以，我们需要使用浮点数。幸运的是，整型数除以浮点数将产生一个浮点数，所以我们只使用2.0而不是2作为除数。

因此:

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

尝试使用列表理解。喜欢的东西:

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

生成器是一种简单的编写方法:

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]

本着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]

使用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]

我只使用带有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

>>> 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已经在代码的某个地方定义并覆盖了默认函数。所以我删除了它，问题解决了。

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)

所有的回答都显示了一种纲领性和一般性的方法。我建议用一种数学方法来解决你的问题。它可以更快，特别是对于长列表。它可以工作，因为你的列表是一个到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)/2，其中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

使用简单的list-comprehension和sum:

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

解决这个问题最简单的方法是:

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

试试以下方法:

mylist = [1, 2, 3, 4]


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


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

< >强问题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)

我使用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

你可以试试这种方法:

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

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]

一种简单的方法是使用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。您可以通过使用集合来减少这种情况。

感谢卡尔Knechtel，我能够理解你的问题。我的解释:

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

第一个问题使用匿名函数(aka。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

第二个问题也使用匿名函数(aka。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

使用最适合你需要的那个

让我们让初学者容易:-

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()

Outputs = 15

这个问题已经被回答了

a = [1,2,3,4]
sum(a)

Sum (a)返回10

这么多解决方案，但我最喜欢的还是没有:

>>> 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])

使用numpy的优点

Numpy可以多快于围绕数字列表的循环。这取决于你的列表有多大，快几个数量级。此外，它的代码更少，至少对我来说，它更容易阅读。 我试图养成对所有数字组使用numpy的习惯，这对于所有循环和循环中的循环都是一个巨大的改进，否则我必须编写

在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:]创建列表的副本。

你也可以使用递归来做同样的事情:

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))

保持简单:

def cool_sum(list: numbers):
b = 0;
for i in numbers:
b += i
return b;




a = [1, 2, 4]
print(cool_sum(a))