Suma una lista de números en Python

Tengo una lista de números como [1,2,3,4,5...] , y quiero calcular (1+2)/2 y para el segundo, (2+3)/2 y el tercero , (3+4)/2 , y así sucesivamente. ¿Cómo puedo hacer eso?

Me gustaría sumr el primer número con el segundo y dividirlo por 2, luego sumr el segundo número con el tercero y dividir por 2, y así sucesivamente.

Además, ¿cómo puedo sumr una lista de números?

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

Lo es:

 b = sum(a) print b 

para obtener un numero?

Esto no funciona para mí.

Pregunta 1: Así que quieres (elemento 0 + elemento 1) / 2, (elemento 1 + elemento 2) / 2, … etc.

Hacemos dos listas: una de cada elemento excepto la primera, y una de cada elemento excepto la última. Entonces los promedios que queremos son los promedios de cada par tomados de las dos listas. Usamos zip para tomar pares de dos listas.

Supongo que desea ver decimales en el resultado, aunque sus valores de entrada sean enteros. Por defecto, Python hace una división entera: descarta el rest. Para dividir las cosas a lo largo del camino, necesitamos usar números de punto flotante. Afortunadamente, dividir un int por un flotador producirá un flotador, por lo que solo usamos 2.0 para nuestro divisor en lugar de 2 .

Así:

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

Pregunta 2:

Ese uso de la sum debería funcionar bien. Los siguientes trabajos:

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

Además, no es necesario asignar todo a una variable en cada paso del camino. print sum(a) funciona bien.

Tendrá que ser más específico acerca de exactamente lo que escribió y cómo no funciona.

Suma lista de números:

 sum(list_of_nums) 

Cálculo de la mitad de n y n – 1 (si tengo el patrón correcto), usando una lista de comprensión :

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

Suma los elementos adyacentes, por ejemplo ((1 + 2) / 2) + ((2 + 3) / 2) + … usando reducir y lambdas

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

Pregunta 2: Para sumr una lista de enteros:

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

Si la lista contiene enteros como cadenas:

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

Puedes intentarlo de esta manera:

 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 "", line 1, in  TypeError: 'int' object is not callable >>> del sum >>> sum(a) 45 

Parece que la sum se ha definido en el código en algún lugar y sobrescribe la función predeterminada. Así que lo borré y el problema quedó resuelto.

Usando una list-comprehension simple y la sum :

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

Todas las respuestas mostraron un enfoque programático y general. Sugiero un enfoque matemático específico para su caso. Puede ser más rápido en particular para listas largas. Funciona porque su lista es una lista de números naturales hasta n :

Supongamos que tenemos los números naturales 1, 2, 3, ..., 10 :

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

Puedes usar la función de sum en una lista:

 >>> print sum(nat_seq) 55 

También puede usar la fórmula n*(n+1)/2 donde n es el valor del último elemento de la lista (aquí: nat_seq[-1] ), por lo que evita la iteración sobre los elementos:

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

Para generar la secuencia (1+2)/2, (2+3)/2, ..., (9+10)/2 puede usar un generador y la fórmula (2*k-1)/2. (tenga en cuenta el punto para hacer los valores puntos flotantes). Debe omitir el primer elemento al generar la nueva lista:

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

Aquí también, puedes usar la función de sum en esa lista:

 >>> print sum(new_seq) 49.5 

Pero también puede usar la fórmula (((n*2+1)/2)**2-1)/2 , para evitar iterar sobre los elementos:

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

La forma más sencilla de resolver este problema:

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

Corto y sencillo:

 def ave(x,y): return (x + y) / 2.0 map(ave, a[:-1], a[1:]) 

Y así es como se ve:

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

Debido a cierta estupidez en cómo Python maneja un map en dos listas, tiene que truncar la lista, a[:-1] . Funciona más como usted esperaría si lo usara itertools.imap :

 >>> import itertools >>> itertools.imap(ave, a, a[1:])  >>> list(_) [0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.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] 

Los generadores son una forma fácil de escribir esto:

 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] 

Usando la receta de pairwise 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) ) 

Acabo de usar un lambda con el mapa ()

 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 

Utilizo un bucle while para obtener el resultado:

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

Recorra los elementos de la lista y actualice el total de esta manera:

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

Gracias a Karl Knechtel pude entender tu pregunta. Mi interpretación:

  1. Desea una nueva lista con el promedio del elemento i e i + 1.
  2. Quieres sumr cada elemento de la lista.

Primera pregunta usando la función anónima (también conocida como función 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 

Segunda pregunta que también usa una función anónima (también conocida como función Lambda):

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

Ambas preguntas combinadas en una sola línea de código:

 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 

Usa el que mejor se adapte a tus necesidades.

Trate de usar una lista de comprensión. Algo como:

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

En el espíritu de itertools. Inspiración de la receta de pareja.

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

Ejemplos:

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

Una forma sencilla es usar la permutación 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) 

El resultado es:

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

Tenga en cuenta que el orden es importante, lo que significa que 1, 2, 7 también se muestra como 2, 1, 7 y 7, 1, 2. Puede reducir esto utilizando un conjunto.

Hagámoslo fácil para principiantes: –

  1. La palabra clave global permitirá que el mensaje de variable global se asigne dentro de la función principal sin producir una nueva variable local
  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 

Este concepto se llama Shadowing.

  1. Suma una lista de números en 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() 

Salidas = 15

Intente lo siguiente:

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