在 Python 中对数字列表求和[重复]-IT科技

摘要：问题描述：给定一个数字列表，例如：[1, 2, 3, 4, 5, ...] 我如何计算它们的总和：1 + 2 + 3 + 4 + 5 + ... 如何计算它们的成对平均值：[(1+2)/2, (2+3)/2, (3+4)/2, (4+5)/2, ...] 解决方案 1：问题 1:要对数字列表求和，请使用sum...

问题描述：

给定一个数字列表，例如：

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

我如何计算它们的总和：

1 + 2 + 3 + 4 + 5 + ...

如何计算它们的成对平均值：

[(1+2)/2, (2+3)/2, (3+4)/2, (4+5)/2, ...]

解决方案 1：

问题 1:

要对数字列表求和，请使用sum：

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

输出：

问题 2：

所以您想要 (元素 0 + 元素 1) / 2、(元素 1 + 元素 2) / 2，... 等等。

我们制作两个列表：一个包含除第一个之外的所有元素，另一个包含除最后一个之外的所有元素。然后我们想要的平均值是从两个列表中取出的每一对的平均值。我们习惯zip从两个列表中取出一对。

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

因此：

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

解决方案 2：

对一串数字求和：

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

解决方案 3：

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

解决方案 4：

你可以尝试这个方法：

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

解决方案 5：

>>> 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已在代码中的某处定义了它并覆盖了默认函数。因此我将其删除，问题就解决了。

解决方案 6：

这个问题已经在这里得到解答

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

sum(a) 返回 10

解决方案 7：

使用简单的list-comprehension和sum：

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

解决方案 8：

所有答案都表明了一种程序化和通用的方法。我建议针对您的情况采用一种数学方法。对于长列表，这种方法可能会更快。它之所以有效，是因为您的列表是最多为的自然数列表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

解决方案 9：

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

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

解决方案 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])

因此，将这两个相加会得到一个由元素 (1+2)、(2+3) 等组成的数组。请注意，我除以了2.0，而不是，2因为否则 Python 会认为您只使用了整数并产生四舍五入的整数结果。

使用 numpy 的优势

Numpy 比循环数字列表要快得多。根据列表的大小，速度会快几个数量级。此外，它的代码要少得多，至少对我来说，它更容易阅读。我正试图养成对所有数字组使用 numpy 的习惯，这对我本来必须编写的所有循环和循环内循环来说是一个很大的改进。

解决方案 11：

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

解决方案 12：

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]

解决方案 13：

生成器是实现此目的的简单方法：

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]

解决方案 14：

让我们让初学者更容易上手：-

关键字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

这个概念叫做“影子”

在 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

解决方案 15：

在 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:]。

解决方案 16：

简短而简单：

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]

解决方案 17：

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

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

解决方案 18：

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

解决方案 19：

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

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

解决方案 20：

循环遍历列表中的元素并更新总数，如下所示：

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

解决方案 21：

感谢Karl Knechtel，我能够理解您的问题。我的解释是：

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

使用匿名函数（又名 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

使用最适合您需求的那个

解决方案 22：

尝试使用列表推导。例如：

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

解决方案 23：

我只需要使用带有 map() 的 lambda

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

解决方案 24：

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)

解决方案 25：

一个简单的方法是使用 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。您可以使用集合来减少它。

解决方案 26：

请尝试以下操作 -

mylist = [1, 2, 3, 4]   

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

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