Pythonで数値のリストを合計する

などの数値のリストがあり、2番目、3 番目、などの [1,2,3,4,5...]計算(1+2)/2を行います。どうやってやるの？(2+3)/2(3+4)/2

最初の数値を2番目の数値と合計して2で割り、次に2番目の数値を3番目の数値と合計して2で割ります。

また、数値のリストを合計するにはどうすればよいですか？

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

それは...ですか：

b = sum(a)
print b

1つの番号を取得するには？

これは私にはうまくいきません。

質問1：つまり、（要素0 +要素1）/ 2、（要素1 +要素2）/ 2、...などが必要です。

2つのリストを作成します。最初を除くすべての要素の1つと、最後を除くすべての要素の1つです。次に、必要な平均は、2つのリストから取得した各ペアの平均です。zip2つのリストからペアを取得するために使用します。

入力値が整数であっても、結果に小数を表示したいと思います。デフォルトでは、Pythonは整数除算を実行します。残りは破棄されます。物事をすべてに分割するには、浮動小数点数を使用する必要があります。さいわい、intをfloatで除算するとfloatが生成されるため、の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 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)/2nnat_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がmap2つ以上のリストを処理する方法にはいくつかの愚かさがあるため、リストを切り捨てる必要があります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])

したがって、これら2つを追加すると、要素（1 + 2）、（2 + 3）などで構成される配列が得られます。私がで除算しているわけでは2.0ありません2。そうでない場合、Pythonは整数のみを使用していると考え、丸めた整数の結果を生成するからではありません。

numpyを使用する利点

Numpy は、数値のリストをループするよりもはるかに高速です。リストの大きさにもよりますが、数桁速くなります。また、コードが大幅に少なくなり、少なくとも私にとっては読みやすくなっています。私は数字のすべてのグループにnumpyを使用しないように習慣をつけようとしています。そうしないと、すべてのループとループ内のループが大幅に改善されます。

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関数）を使用する2番目の質問：

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

両方の質問を1行のコードにまとめました。

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)