somme une liste de numéros en Python

Question

Si j'ai une liste de numéros tels que [1,2,3,4,5...] et je veux calculer (1+2)/2 et pour la deuxième, et la troisième (2+3)/2, (3+4)/2, et ainsi de suite.

Comment puis-je faire cela? Je voudrais additionner le premier nombre avec le second et le diviser par 2, puis additionner le second avec le troisième et diviser par 2, et ainsi de suite.

En outre, comment puis-je additionner une liste de nombres?

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

Est-il:

b = sum(a) 
print b 

pour obtenir un numéro? Cela ne fonctionne pas pour moi. Aidez-moi s'il vous plaît.

Answer 1

liste Somme des numéros:

sum(list_of_nums) 

Calcul de la moitié de n et n - 1 (si je le motif correct), en utilisant un list comprehension:

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

Somme des éléments adjacents, par exemple, ((1 + 2)/2) + ((2 + 3)/2) + ... en utilisant reduce et lambdas

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

Answer 2

Question 1: Vous voulez donc (élément 0 + élément 1)/2, (élément 1 + élément 2)/2, ... etc.

Ce que nous faisons est de faire deux listes: un de chaque élément sauf le premier, et un de chaque élément sauf le dernier. Ensuite, les moyennes que nous voulons sont les moyennes de chaque paire tirée des deux listes. Nous utilisons zip pour prendre des paires de deux listes. Editer: Je suppose que vous voulez voir des décimales dans le résultat, même si vos valeurs d'entrée sont des entiers. Par défaut, Python fait la division entière: il rejette le reste. Pour diviser les choses à travers tout le chemin, nous devons utiliser des nombres à virgule flottante. Heureusement, diviser un int par un float produira un float, donc nous utilisons simplement 2.0 pour notre diviseur au lieu de 2.

Ainsi:

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

Question 2:

Cette utilisation de sum devrait fonctionner correctement. Les travaux suivants:

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

De même, vous n'avez pas besoin d'affecter tout à une variable à chaque étape du processus. print sum(a) fonctionne très bien.

Vous devrez être plus précis sur ce que vous avez écrit et comment cela ne fonctionne pas.

Answer 3

Essayez d'utiliser une liste de compréhension.Quelque chose comme:

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

Answer 4

Les générateurs sont un moyen facile d'écrire ceci:

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] 

Answer 5

Dans l'esprit de itertools. Inspiration de la recette par paire.

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

Exemples:

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

Answer 6

Utilisation du pairwiseitertools recipe:

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

Answer 7

court et simple:

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

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

Et voici à quoi il ressemble:

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

En raison une certaine stupidité dans la façon dont Python gère un map plus de deux listes, vous n'avez tronquer la liste, a[:-1]. Il travaille plus que vous attendez si vous utilisez 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] 

Answer 8

Je venais d'utiliser un lambda sur la carte()

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 

Answer 9

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

Il semble que la somme a été définie dans la code quelque part et écrase la fonction par défaut. Je l'ai donc supprimé et le problème a été résolu.

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

Answer 11

Toutes les réponses ont fait preuve d'une approche programmatique et générale. Je suggère une approche mathématique spécifique à votre cas. Cela peut être plus rapide en particulier pour les longues listes. Cela fonctionne parce que votre liste est une liste de nombres naturels jusqu'à n:

Supposons que nous avons les nombres naturels 1,2,3,....,10:

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

Vous pouvez utiliser la fonction sum sur une liste:

>>> print sum(nat_seq) 
55 

Vous pouvez également utiliser la formule n*(n+1)/2 où n est la valeur du dernier élément de la liste (ici: nat_seq[-1]), de sorte que vous évitez d'itérer sur l'élément s:

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

Pour générer la séquence (1+2)/2, (2+3)/2, ..., (9+10)/2 vous pouvez utiliser un générateur et la formule (2*k-1)/2. (notez le point pour rendre les valeurs des points flottants).Vous devez sauter le premier élément lors de la génération de la nouvelle liste:

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

Ici aussi, vous pouvez utiliser la fonction sum sur cette liste:

>>> print sum(new_seq) 
49.5 

Mais vous pouvez aussi utiliser la formule (((n*2+1)/2)**2-1)/2, donc vous pouvez éviter itérer sur les éléments:

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

Answer 12

en utilisant un simple list-comprehension et sum:

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

Answer 13

La façon la plus simple de résoudre ce problème:

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

Answer 14

mylist=[1,2,3,4] 
total=0 
def add(mylist): 
    for i in mylist: 
     total+=i 
    return total 

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

Answer 15

Question 2: En résumé une liste d'entiers:

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

Si la liste contient des nombres entiers comme chaînes:

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

Answer 16

J'utilise en boucle pour obtenir le résultat

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

Answer 17

en boucle à travers des éléments dans la liste et la mise à jour du total comme celui-ci

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

Answer 18

Vous pouvez essayer cette façon.

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 

Answer 19

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]