在Python求和list数字


Sum a list of numbers in Python

我有一个数字列表，比如[1,2,3,4,5...]，我想计算(1+2)/2，第二个是(2+3)/2，第三个是，(3+4)/2等。我该怎么做？

我想把第一个数和第二个数相加，再除以2，然后把第二个数和第三个数相加，再除以2，依此类推。

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

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

它是：

1
2
b = sum(a)
print b

想要一个号码？

这对我不起作用。

相关讨论

问题1：所以你想要(元素0+元素1)/2，(元素1+元素2)/2，…等。

我们制作了两个列表：除第一个元素外的每个元素中的一个，除最后一个元素外的每个元素中的一个。那么我们想要的平均数就是从两个列表中得到的每一对的平均数。我们使用zip从两个列表中取对。

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

因此：

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

问题2：

使用sum应该是可行的。以下工作：

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

此外，您不需要在过程中的每一步都将所有内容赋给变量。print sum(a)工作得很好。

你必须更具体地说明你写了什么以及它是如何不起作用的。

相关讨论

数字汇总表：

1
sum(list_of_nums)

使用列表理解计算n和n-1的一半(如果我的模式正确的话)：

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

求和相邻元素，例如((1+2)/2)+((2+3)/2)+…使用reduce和lambdas

1
reduce(lambda x, y: (x + y) / 2, list_of_nums)
相关讨论

问题2：对整数列表求和：

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

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

1
2
3
a = ['5', '6']
# import Decimal: from decimal import Decimal
sum(Decimal(i) for i in a)
相关讨论

您可以这样尝试：

1
2
3
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
相关讨论

1
2
3
4
5
6
7
8
>>> 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：

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

所有的答案都显示了一种程序性和一般性的方法。我建议针对你的情况采用一种数学方法。它可以更快，特别是对于长列表。它之所以有效，是因为您的列表是一个自然数列表，最多为n：

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

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

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

1
2
>>> print sum(nat_seq)
55

也可以使用公式n*(n+1)/2，其中n是列表中最后一个元素的值(此处：nat_seq[-1])，因此避免重复元素：

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

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

1
2
3
>>> 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函数：

1
2
>>> print sum(new_seq)
49.5

但也可以使用公式(((n*2+1)/2)**2-1)/2，这样可以避免重复元素：

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

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

1
2
3
4
5
l =[1,2,3,4,5]
sum=0
for element in l:
    sum+=element
print sum
1
2
3
4
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]

简明扼要：

1
2
3
4
def ave(x,y):
  return (x + y) / 2.0

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

它的外观如下：

1
2
3
>>> 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，它会比您预期的更有效：

1
2
3
4
5
>>> 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]
相关讨论

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

1
2
3
4
5
6
7
8
9
10
11
12
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]
相关讨论

我用一个while循环得到结果：

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

循环遍历列表中的元素并按如下方式更新汇总：

1
2
3
4
5
6
7
def sum(a):
    total = 0
    index = 0
    while index < len(a):
        total = total + a[index]
        index = index + 1
    return total

我只需要在map()中使用lambda

1
2
3
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

使用pairwiseitertools配方：

1
2
3
4
5
6
7
8
9
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) )

多亏了KarlKnechtel，我才明白你的问题。我的解释：

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

    • 使用匿名函数的第一个问题(aka.lambda函数)：

    1
    2
    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函数)：

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

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

    1
    2
    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

    使用最适合你需要的那个

    让我们让初学者更容易：

  • global关键字将允许在主函数中分配全局变量消息，而不生成新的局部变量。
    • 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
        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对数字列表求和
    • 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    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

    一个简单的方法是使用ITER工具排列

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    # 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
    3
    4
    [(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。你可以用一套来减少这个。

    以Itertools的精神。灵感来自配对食谱。

    1
    2
    3
    4
    5
    6
    7
    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))

    实例：

    1
    2
    3
    4
    5
    6
    >>>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]

    尝试使用列表理解。类似：

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    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)

    尝试以下操作-

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

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

    result = add(mylist)
    print("sum =", result)
    相关讨论