Summiere eine Liste von Zahlen in Python

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

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

Wie kann ich auch eine Liste von Zahlen summieren?

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

Ist es:

b = sum(a)
print b

eine Nummer bekommen?

Das funktioniert bei mir nicht.

Frage 1: Sie möchten 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. Dann sind die Durchschnittswerte, die wir wollen, die Durchschnittswerte jedes Paares aus den beiden Listen. Wir verwenden zipPaare aus zwei Listen.

Ich gehe davon aus, dass Sie im Ergebnis Dezimalstellen sehen möchten, obwohl Ihre Eingabewerte Ganzzahlen sind. Standardmäßig führt Python eine Ganzzahldivision durch: Der Rest wird verworfen. Um die Dinge vollständig zu teilen, müssen wir Gleitkommazahlen verwenden. Glücklicherweise wird durch Teilen eines Int durch einen Float ein Float erzeugt, sodass wir 2.0stattdessen nur für unseren Divisor verwenden 2.

Somit:

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

Frage 2:

Diese Verwendung von sumsollte gut funktionieren. Folgendes funktioniert:

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 dem Weg alles einer Variablen zuweisen. print sum(a)funktioniert gut.

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

Summenliste der Zahlen:

sum(list_of_nums)

Berechnung der Hälfte von n und n - 1 (wenn ich das richtige Muster habe) unter Verwendung eines Listenverständnisses :

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

Summiere benachbarte Elemente, z. B. ((1 + 2) / 2) + ((2 + 3) / 2) + ... mit Reduce und Lambdas

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

Frage 2: Um eine Liste von ganzen 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)

Sie können dies folgendermaßen 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

>>> 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 dies sumirgendwo im Code definiert wurde und die Standardfunktion überschreibt. Also habe ich es gelöscht und das Problem wurde gelöst.

Mit einem einfachen list-comprehensionund dem sum:

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

Alle Antworten zeigten einen programmatischen und allgemeinen Ansatz. Ich schlage einen für Ihren Fall spezifischen mathematischen Ansatz vor. Dies kann insbesondere bei langen Listen schneller sein. Es funktioniert, weil Ihre Liste eine Liste von natürlichen Zahlen bis zu istn :

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 sumFunktion in einer Liste verwenden:

>>> print sum(nat_seq)
55

Sie können auch die Formel verwenden, n*(n+1)/2bei der nder Wert des letzten Elements in der Liste (hier nat_seq[-1]:) angegeben ist, damit Sie nicht über Elemente iterieren:

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

Um die Sequenz zu generieren (1+2)/2, (2+3)/2, ..., (9+10)/2, können Sie einen Generator und die Formel verwenden (2*k-1)/2.(beachten Sie den Punkt, um die Werte als Gleitkommawerte zu setzen). Sie müssen das erste Element überspringen, wenn Sie die neue Liste erstellen:

>>> 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 sumFunktion in dieser Liste verwenden:

>>> print sum(new_seq)
49.5

Sie können aber auch die Formel verwenden (((n*2+1)/2)**2-1)/2, um zu vermeiden, dass Elemente wiederholt werden:

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

Der einfachste Weg, um dieses Problem zu lösen:

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

Diese Frage wurde beantwortet hier

a = [1,2,3,4] Summe (a) ergibt 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]

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]

Machen wir es Anfängern einfach: -

1. Mit dem globalSchlüsselwort kann die globale Variablennachricht innerhalb 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 nennt man Shadowing

2. 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 __name__ == '__main__':
    sums()

Ausgänge = 15

Verwenden des pairwise itertools-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) )

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 mit mapmehr als zwei Listen umgeht, müssen Sie die Liste abschneiden a[:-1]. Es funktioniert besser als erwartet, wenn Sie Folgendes verwenden 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]

So viele Lösungen, aber mein Favorit fehlt noch:

>>> import numpy as np
>>> arr = np.array([1,2,3,4,5])

Ein Numpy-Array unterscheidet sich nicht allzu sehr von einer Liste (in diesem Anwendungsfall), außer dass Sie Arrays wie Zahlen behandeln können:

>>> ( arr[:-1] + arr[1:] ) / 2.0
[ 1.5  2.5  3.5  4.5]

Erledigt!

Erläuterung

Die ausgefallenen Indizes bedeuten Folgendes: [1:]Enthält alle Elemente von 1 bis zum Ende (wodurch Element 0 weggelassen wird) und [:-1]sind alle Elemente außer dem letzten:

>>> arr[:-1]
array([1, 2, 3, 4])
>>> arr[1:]
array([2, 3, 4, 5])

Wenn Sie also diese beiden addieren, erhalten Sie ein Array, das aus Elementen (1 + 2), (2 + 3) usw. besteht. Nicht, dass ich durch teile 2.0, nicht 2weil Python sonst glaubt, dass Sie nur Ganzzahlen verwenden, und gerundete Ganzzahlergebnisse erzeugt.

Vorteil der Verwendung von Numpy

Numpy kann viel schneller sein als Schleifen um Zahlenlisten . Je nachdem, wie groß Ihre Liste ist, sind mehrere Größenordnungen schneller. Außerdem ist es viel weniger Code, und zumindest für mich ist es einfacher zu lesen. Ich versuche, es mir zur Gewohnheit zu machen, Numpy für alle Zahlengruppen zu verwenden, und es ist eine enorme Verbesserung für alle Schleifen und Schleifen innerhalb von Schleifen, die ich sonst hätte machen müssen.

Ich würde nur 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

Ich benutze eine whileSchleife, um das Ergebnis zu erhalten:

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

Durchlaufen Sie die Elemente in der Liste und aktualisieren Sie die Gesamtsumme wie folgt:

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

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

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

Erste Frage mit anonymer Funktion (auch bekannt als 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

Zweite Frage auch mit anonymer Funktion (auch bekannt als Lambda-Funktion):

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

Beide Fragen in einer einzigen 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 Anforderungen am besten entspricht

Sie können dasselbe auch mithilfe der Rekursion tun:

Python-Snippet:

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

Versuchen Sie es mit einem Listenverständnis. Etwas wie:

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

Im Geiste von 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]

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)

Eine einfache Möglichkeit besteht darin, die Permutation iter_tools zu verwenden

# 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 wichtig ist - dh 1, 2, 7 wird auch als 2, 1, 7 und 7, 1, 2 angezeigt. Sie können dies mithilfe eines Satzes reduzieren.

In Python 3.8 kann der neue Zuweisungsoperator verwendet werden

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

aist eine laufende Referenz auf den vorherigen Wert in der Liste, daher wird sie mit dem ersten Element der Liste initialisiert und die Iteration erfolgt über den Rest der Liste und wird aktualisierta nachdem sie in jeder Iteration verwendet wurde.

Ein expliziter Iterator wird verwendet, um zu vermeiden, dass eine Kopie der Liste mit erstellt werden muss my_list[1:].

Versuche Folgendes -

mylist = [1, 2, 3, 4]   

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

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