web-dev-qa-db-de.com

Summe einer Liste von Zahlen in Python

Ich habe eine Liste mit Zahlen wie [1,2,3,4,5...], und ich möchte (1+2)/2 und für die zweite (2+3)/2 und die dritte ._(3+4)/2 usw. berechnen. Wie kann ich das machen?

Ich möchte die erste Zahl mit der zweiten summieren und durch 2 dividieren, dann die zweite mit der dritten addieren und durch 2 dividieren, und so weiter.

Wie kann ich auch eine Liste mit Zahlen zusammenfassen?

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

Ist es:

b = sum(a)
print b

eine Nummer bekommen?

Das funktioniert bei mir nicht.

295
layo

Frage 1: Sie wollen also (Element 0 + Element 1)/2, (Element 1 + Element 2)/2, ... usw.

Wir erstellen zwei Listen: eine von jedem Element außer dem ersten und eine von jedem Element außer dem letzten. Die Durchschnittswerte, die wir wollen, sind die Durchschnittswerte für jedes Paar, die den beiden Listen entnommen werden. Wir verwenden Zip, um Paare aus zwei Listen zu entnehmen.

Ich nehme an, Sie möchten Dezimalzahlen im Ergebnis sehen, obwohl Ihre Eingabewerte Ganzzahlen sind. Standardmäßig führt Python eine Ganzzahleinteilung durch: Der Rest wird verworfen. Um die Dinge vollständig zu trennen, müssen wir Fließkommazahlen verwenden. Glücklicherweise führt die Division eines int durch einen Float zu einem Float. Daher verwenden wir 2.0 für unseren Divisor anstelle von 2.

Somit:

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

Frage 2:

Diese Verwendung von sum sollte gut funktionieren. Die folgenden Arbeiten:

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

Außerdem müssen Sie nicht bei jedem Schritt auf der Route alles einer Variablen zuweisen. print sum(a) funktioniert einwandfrei.

Sie müssen genauer sagen, was genau Sie geschrieben haben und wie es nicht funktioniert.

225
Karl Knechtel

Sum Liste der Zahlen:

sum(list_of_nums)

Berechnen der Hälfte von n und n - 1 (wenn ich das Muster richtig eingestellt habe), unter Verwendung eines Listenverständnisses :

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

Summe benachbarter Elemente, z. ((1 + 2)/2) + ((2 + 3)/2) + ... mit reduzieren und lambdas

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

Frage 2: Um eine Liste ganzer Zahlen zusammenzufassen

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

Wenn die Liste Ganzzahlen als Zeichenfolgen enthält:

a = ['5', '6']
# import Decimal: from decimal import Decimal
sum(Decimal(i) for i in a)
63
Evans Murithi
>>> 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

Es scheint, dass sum irgendwo im Code definiert wurde und die Standardfunktion überschreibt. Also habe ich es gelöscht und das Problem wurde gelöst.

23
user4183543

Sie können diesen Weg versuchen:

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
22

Verwenden Sie einen einfachen list-comprehension und die sum:

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

Alle Antworten zeigten einen programmatischen und allgemeinen Ansatz. Ich empfehle einen für Ihren Fall spezifischen mathematischen Ansatz. Es kann insbesondere für lange Listen schneller sein. Es funktioniert, weil Ihre Liste eine Liste natürlicher Zahlen bis zu n ist:

Nehmen wir an, wir haben die natürlichen Zahlen 1, 2, 3, ..., 10:

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

Sie können die Funktion sum für eine Liste verwenden:

>>> print sum(nat_seq)
55

Sie können auch die Formel n*(n+1)/2 verwenden, wobei n der Wert des letzten Elements in der Liste ist (hier: nat_seq[-1]). So vermeiden Sie das Durchlaufen von Elementen:

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

Um die Sequenz (1+2)/2, (2+3)/2, ..., (9+10)/2 zu erzeugen, können Sie einen Generator und die Formel (2*k-1)/2. verwenden (beachten Sie den Punkt, um die Werte zu Fließpunkten zu machen). Das erste Element muss beim Generieren der neuen Liste übersprungen werden:

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

Auch hier können Sie die sum-Funktion in dieser Liste verwenden:

>>> print sum(new_seq)
49.5

Sie können jedoch auch die Formel (((n*2+1)/2)**2-1)/2 verwenden, um das Durchlaufen von Elementen zu vermeiden:

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

Der einfachste Weg, dieses Problem zu lösen:

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

Generatoren sind eine einfache Möglichkeit, dies zu schreiben:

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]
2
Jochen Ritzel
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]
2
tagoma

Kurz und einfach:

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

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

Und so sieht es aus:

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

Aufgrund der Dummheit, wie Python eine map über zwei Listen behandelt, müssen Sie die Liste a[:-1] abschneiden. Es funktioniert mehr als erwartet, wenn Sie itertools.imap verwenden:

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

Dank Karl Knechtel konnte ich Ihre Frage verstehen. Meine Interpretation:

  1. Sie möchten eine neue Liste mit dem Durchschnitt des Elements i und i + 1.
  2. Sie möchten jedes Element in der Liste summieren.

Erste Frage mit anonymer Funktion (aka Lambda-Funktion):

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

Zweitens Frage auch mit anonymer Funktion (aka Lambda-Funktion):

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

Beide Fragen in einer Codezeile zusammengefasst:

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

Verwenden Sie diejenige, die Ihren Bedürfnissen am besten entspricht

1
Stickysli

Durchlaufen Sie die Elemente in der Liste und aktualisieren Sie die Summe folgendermaßen:

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

Ich würde einfach ein Lambda mit map () verwenden

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

Ich verwende eine while-Schleife, um das Ergebnis zu erhalten:

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

Verwenden des pairwiseitertools-Rezepts :

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

Machen wir es Anfängern leicht:

  1. Mit dem Schlüsselwort global kann die globale Variablennachricht in der Hauptfunktion zugewiesen werden, ohne dass eine neue lokale Variable erstellt wird
    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

Dieses Konzept heißt Shadowing

  1. Summiere eine Liste von Zahlen in Python
nums = [1, 2, 3, 4, 5]

var = 0


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


if __== '__main__':
    sums()

Ausgänge = 15

1
Aamir M Meman

Im Geiste der itertools. Inspiration aus dem paarweisen Rezept.

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

Beispiele:

>>>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]
0
kevpie
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)
0
vasanth kumar

Versuchen Sie es mit einem Listenverständnis. So etwas wie:

new_list = [(old_list[i] + old_list[i+1])/2 for i in range(len(old_list-1))]
0
TartanLlama
mylist=[1,2,3,4]   
total=0
def add(mylist):
    for i in mylist:
        total+=i
    return total

result=add(mylist)
print("sum = ",result)
0
Sai G

Ein einfacher Weg ist die Verwendung der iter_tools-Permutation

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

Das Ergebnis ist:

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

Beachten Sie, dass die Reihenfolge von Bedeutung ist - die Bedeutung 1, 2, 7 wird auch als 2, 1, 7 und 7, 1, 2 angezeigt.

0
Jesse