Zsumuj listę liczb w Pythonie

Mam listę liczb, takich jak [1,2,3,4,5...], i chcę obliczyć, (1+2)/2a dla drugiego, (2+3)/2trzeciego (3+4)/2, i tak dalej. Jak mogę to zrobić?

Chciałbym zsumować pierwszą liczbę z drugą i podzielić ją przez 2, następnie zsumować drugą liczbę z trzecią i podzielić przez 2, i tak dalej.

Jak mogę zsumować listę liczb?

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

Czy to jest:

b = sum(a)
print b

dostać jeden numer?

To mi nie działa.

Pytanie 1: Więc chcesz (element 0 + element 1) / 2, (element 1 + element 2) / 2, ... itd.

Tworzymy dwie listy: jedną z każdego elementu z wyjątkiem pierwszego i jedną z każdego elementu z wyjątkiem ostatniego. Następnie średnie, które chcemy, są średnimi dla każdej pary wziętej z dwóch list. Używamy zippar z dwóch list.

Zakładam, że chcesz zobaczyć dziesiętne wyniki, mimo że wartości wejściowe są liczbami całkowitymi. Domyślnie Python dokonuje podziału na liczby całkowite: odrzuca resztę. Aby podzielić wszystko na wylot, musimy użyć liczb zmiennoprzecinkowych. Na szczęście podzielenie 2.0liczby całkowitej przez liczbę zmiennoprzecinkową spowoduje utworzenie liczby zmiennoprzecinkowej, więc zamiast tego używamy po prostu naszego dzielnika 2.

A zatem:

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

Pytanie 2:

Takie użycie sumpowinno działać dobrze. Następujące prace:

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

Nie musisz też przypisywać wszystkiego do zmiennej na każdym kroku. print sum(a)działa dobrze.

Będziesz musiał sprecyzować dokładnie, co napisałeś i jak to nie działa.

Sumaryczna lista liczb:

sum(list_of_nums)

Obliczanie połowy n i n - 1 (jeśli mam prawidłowy wzorzec), przy użyciu rozumienia listy :

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

Suma sąsiednich elementów, np. ((1 + 2) / 2) + ((2 + 3) / 2) + ... używając redukcji i lambda

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

Pytanie 2: Aby podsumować listę liczb całkowitych:

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

Jeśli lista zawiera liczby całkowite jako ciągi znaków:

a = ['5', '6']
# import Decimal: from decimal import Decimal
sum(Decimal(i) for i in a)

Możesz spróbować w ten sposób:

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

Wygląda na to, że sumgdzieś został zdefiniowany w kodzie i zastępuje domyślną funkcję. Więc go usunąłem i problem został rozwiązany.

Korzystanie z prostego list-comprehensioni sum:

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

Wszystkie odpowiedzi wykazały podejście programowe i ogólne. Proponuję matematyczne podejście właściwe dla twojego przypadku. Może być szybszy, szczególnie w przypadku długich list. Działa, ponieważ twoja lista jest listą liczb naturalnych do n:

Załóżmy, że mamy liczby naturalne 1, 2, 3, ..., 10:

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

Możesz użyć sumfunkcji z listy:

>>> print sum(nat_seq)
55

Możesz także użyć formuły n*(n+1)/2gdzie njest wartością ostatniego elementu na liście (tutaj nat_seq[-1]:), aby uniknąć iteracji elementów:

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

Aby wygenerować sekwencję (1+2)/2, (2+3)/2, ..., (9+10)/2, możesz użyć generatora i formuły (2*k-1)/2.(zanotuj kropkę, aby wartości zmiennoprzecinkowe). Podczas generowania nowej listy musisz pominąć pierwszy element:

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

Tutaj także możesz użyć sumfunkcji z tej listy:

>>> print sum(new_seq)
49.5

Możesz jednak również użyć formuły (((n*2+1)/2)**2-1)/2, aby uniknąć iteracji elementów:

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

Najprostszy sposób rozwiązania tego problemu:

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

Odpowiedź na to pytanie znajduje się tutaj

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

Generatory to prosty sposób na napisanie tego:

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]

Ułatwmy dla początkującego: -

1. Słowo globalkluczowe pozwoli na przypisanie komunikatu zmiennej globalnej w ramach funkcji głównej bez tworzenia nowej zmiennej lokalnej

    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

Ta koncepcja nazywa się Shadowing

2. Zsumuj listę liczb w Pythonie

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

Wyjścia = 15

Korzystanie z pairwise przepisu 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) )

Krótkie i proste:

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

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

A oto jak to wygląda:

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

Ze względu na pewne głupoty w jaki Python obsługuje mapponad dwie listy, to trzeba obciąć listy a[:-1]. Działa więcej, niż można się spodziewać, jeśli używasz 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]

Tyle rozwiązań, ale wciąż brakuje mojego ulubionego:

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

tablica numpy nie różni się zbytnio od listy (w tym przypadku użycia), z tym wyjątkiem, że tablice można traktować jak liczby:

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

Gotowy!

wyjaśnienie

Fantazyjne wskaźniki oznaczają to: [1:]obejmują wszystkie elementy od 1 do końca (pomijając element 0) i [:-1]są wszystkimi elementami oprócz ostatniego:

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

Tak więc dodanie tych dwóch daje tablicę składającą się z elementów (1 + 2), (2 + 3) i tak dalej. Nie dlatego, że się dzielę 2.0, nie 2dlatego , że inaczej Python uważa, że ​​używasz tylko liczb całkowitych i generuje zaokrąglone wyniki liczb całkowitych.

zaletą korzystania z numpy

Numpy może być znacznie szybsze niż pętle wokół list numerów. W zależności od tego, jak duża jest twoja lista, kilka rzędów wielkości szybciej. Poza tym jest o wiele mniej kodu i przynajmniej dla mnie jest łatwiejszy do odczytania. Staram się nawiązywać nawyk korzystania z numpy dla wszystkich grup liczb i jest to ogromna poprawa dla wszystkich pętli i pętli wewnątrz pętli, które w innym przypadku musiałbym zrobić.

Po prostu użyłbym lambda z 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

Używam whilepętli, aby uzyskać wynik:

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

Zapętlaj elementy na liście i aktualizuj sumę w następujący sposób:

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

Dzięki Karlowi Knechtelowi mogłem zrozumieć twoje pytanie. Moja interpretacja:

1. Chcesz nową listę ze średnią elementu i i i + 1.
2. Chcesz zsumować każdy element na liście.

Pierwsze pytanie za pomocą funkcji anonimowej (aka. Funkcja 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

Drugie pytanie również za pomocą funkcji anonimowej (aka. Funkcji Lambda):

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

Oba pytania połączone w jednym wierszu kodu:

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

użyj tego, który najlepiej odpowiada Twoim potrzebom

Możesz również zrobić to samo za pomocą rekurencji:

Fragment kodu w języku 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))

Spróbuj użyć listy. Coś jak:

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

W duchu itertools. Inspiracja parą przepisu.

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

Przykłady:

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

Prostym sposobem jest użycie permutacji 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)

Wynik to:

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

Pamiętaj, że kolejność ma znaczenie - co oznacza, że ​​1, 2, 7 jest również pokazane jako 2, 1, 7 i 7, 1, 2. Możesz to zmniejszyć za pomocą zestawu.

W Pythonie 3.8 można użyć nowego operatora przypisania

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

ajest bieżącym odwołaniem do poprzedniej wartości na liście, stąd jest inicjowana do pierwszego elementu listy, a iteracja następuje na pozostałej części listy, aktualizująca po użyciu w każdej iteracji.

Aby uniknąć konieczności tworzenia kopii listy, należy użyć jawnego iteratora my_list[1:].

Spróbuj wykonać następujące czynności -

mylist = [1, 2, 3, 4]   

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

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