Somme une liste de nombres en Python
J'ai une liste de nombres tels que [1,2,3,4,5...], et je veux calculer (1+2)/2 et pour le second, (2+3)/2 et le troisième, (3+4)/2, etc. Comment puis je faire ça?
Je voudrais faire la somme du premier nombre avec le second et le diviser par 2, puis le deuxième avec le troisième et diviser par 2, et ainsi de suite.
Aussi, comment puis-je résumer une liste de nombres?
a = [1, 2, 3, 4, 5, ...]
Est-ce:
b = sum(a)
print b
obtenir un numéro?
Cela ne marche pas pour moi.
Question 1: Donc vous voulez (élément 0 + élément 1)/2, (élément 1 + élément 2)/2, ... etc.
Nous faisons deux listes: une de chaque élément sauf le premier et une de chaque élément sauf le dernier. Ensuite, les moyennes que nous voulons sont les moyennes de chaque paire tirées des deux listes. Nous utilisons Zip pour prendre des paires de deux listes.
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 effectue une division entière: il rejette le reste. Pour diviser les choses complètement, nous devons utiliser des nombres à virgule flottante. Heureusement, diviser un int par un float produira un float, nous utilisons donc 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 oeuvres suivantes:
a = range(10)
# [0,1,2,3,4,5,6,7,8,9]
b = sum(a)
print b
# Prints 45
De plus, vous n'avez pas besoin de tout affecter à 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.
Liste de somme des nombres:
sum(list_of_nums)
Calculer la moitié de n et n - 1 (si le motif est correct), en utilisant une compréhension de liste :
[(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 reduction et lambdas
reduce(lambda x, y: (x + y) / 2, list_of_nums)
Question 2: Pour résumer 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 entiers sous forme de chaînes:
a = ['5', '6']
# import Decimal: from decimal import Decimal
sum(Decimal(i) for i in a)
>>> 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 sum ait été défini quelque part dans le code et écrase la fonction par défaut. Alors je l'ai supprimé et le problème a été résolu.
Vous pouvez essayer de 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
En utilisant un simple list-comprehension et la sum:
>> sum(i for i in range(x))/2. #if x = 10 the result will be 22.5
Toutes les réponses ont montré 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 car votre liste est une liste de nombres naturels allant 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]), afin d'éviter d'itérer sur des éléments:
>>> 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 définir les valeurs en points flottants). Vous devez ignorer 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 pour éviter de parcourir les éléments:
>>> print (((new_seq[-1]*2+1)/2)**2-1)/2
49.5
Le moyen le plus simple de résoudre ce problème:
l =[1,2,3,4,5]
sum=0
for element in l:
sum+=element
print sum
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]
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]
Court et simple:
def ave(x,y):
return (x + y) / 2.0
map(ave, a[:-1], a[1:])
Et voici à quoi ça 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 de la stupidité avec laquelle Python gère une map sur deux listes, vous devez tronquer la liste, a[:-1]. Cela fonctionne plus que prévu 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]
Grâce à Karl Knechtel j’ai pu comprendre votre question. Mon interprétation:
- Vous voulez une nouvelle liste avec la moyenne de l'élément i et i + 1.
- Vous voulez additionner chaque élément de la liste.
Première question utilisant une fonction anonyme (alias. Fonction 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
Deuxième question utilisant également la fonction anonyme (aussi appelée fonction Lambda):
p = lambda l: l[0] + p(l[1:]) if l!=[] else 0
Les deux questions combinées dans une seule ligne de code:
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
utilisez celui qui répond le mieux à vos besoins
Parcourez les éléments de la liste et mettez à jour le total comme suit:
def sum(a):
total = 0
index = 0
while index < len(a):
total = total + a[index]
index = index + 1
return total
Je viens d'utiliser un lambda avec 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
J'utilise une boucle while pour obtenir le résultat:
i = 0
while i < len(a)-1:
result = (a[i]+a[i+1])/2
print result
i +=1
Utilisation de la recette pairwiseitertools :
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) )
Rendons la tâche facile pour les débutants: -
- Le mot clé
globalpermettra d'attribuer le message à la variable globale dans la fonction principale sans générer de nouvelle variable locale
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
Ce concept s'appelle Shadowing
- Somme une liste de nombres en 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()
Sorties = 15
Dans l'esprit d'itertools. Inspiration de la recette par paires.
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]
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)
Essayez d'utiliser une compréhension de liste. Quelque chose comme:
new_list = [(old_list[i] + old_list[i+1])/2 for i in range(len(old_list-1))]
mylist=[1,2,3,4]
total=0
def add(mylist):
for i in mylist:
total+=i
return total
result=add(mylist)
print("sum = ",result)
Un moyen simple consiste à utiliser la permutation 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)
Le résultat est:
[(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)]
Notez que l'ordre est important - ce qui signifie que 1, 2, 7 est également indiqué par 2, 1, 7 et 7, 1, 2. Vous pouvez le réduire en utilisant un jeu.