Вопрос 1: Итак, вы хотите получить (элемент 0 + элемент 1) / 2, (элемент 1 + элемент 2) / 2, ... и т.д.

Составим два списка: один из всех элементов, кроме первого, и один из всех элементов, кроме последнего. Тогда искомые средние - это средние по каждой паре, взятые из этих двух списков. Для извлечения пар из двух списков мы используем функцию zip.

Я предполагаю, что вы хотите видеть десятичные числа в результате, хотя ваши входные значения являются целыми числами. По умолчанию Python выполняет целочисленное деление: он отбрасывает остаток. Чтобы делить до конца, нужно использовать числа с плавающей точкой. К счастью, при делении int на float получается float, поэтому в качестве делителя вместо 2 мы просто используем 2.0.

Таким образом:

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

Вопрос 2:

Такое использование sum должно работать нормально. Работает следующее:

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

Также не обязательно присваивать все переменной на каждом шаге. print sum(a) работает просто отлично.

Вам необходимо уточнить, что именно вы написали и как это не работает.

Суммарный список чисел:

sum(list_of_nums)

Вычисление половины n и n - 1 (если я правильно понял шаблон), используя list comprehension:

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

Суммирование смежных элементов, например, ((1 + 2) / 2) + ((2 + 3) / 2) + ... с использованием reduce и lambdas.

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

Вопрос 2: Суммировать список целых чисел:

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

Если список содержит целые числа в виде строк:

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

Вы можете попробовать этот способ:

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

Похоже, что сумма была определена где-то код и переписывает функцию по умолчанию. Так что я удалил его и проблема была решена.

Используя простой список-пониманиеисумма`:

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

Все ответы не показывать программных и общий подход. Я предлагаю математический подход конкретно для вашего случая. Это может быть быстрее, в частности для длинных списков. Это работает, потому что ваш список-это список из натуральных чисел до Н:

Позвольте'ы предположим, у нас есть натуральные числа1, 2, 3, ..., 10:

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

Вы можете использовать функцию сумма на список:

>>> print sum(nat_seq)
55

Вы также можете использовать формулу Н*(Н+1)/2, где N является значение последнего элемента в списке (здесь: nat_seq[-1]), Так что вам избежать перебора элементов:

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

Для генерации последовательности(1+2)/2, (2+3)/2, ..., (9+10)/2 Вы можете использовать генератор и Формуле (2*к-1)/2. (обратите внимание на точку, чтобы значения с плавающей запятой). Вы должны пропустить первый элемент при создании нового списка:

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

Здесь, вы можете использовать функцию сумма в этом списке:

>>> print sum(new_seq)
49.5

Но вы также можете использовать формулу (((н*2+1)/2)**2-1)/2, Так вы сможете избежать перебора элементов:

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

Самый простой способ решить эту проблему:

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

Давайте сделаем его легким для начинающих:-

1. "Глобального" сайта позволит глобальную переменную сообщение должно быть назначено в пределах основной функции, не производя новую локальную переменную

сообщение = "Это глобальная!&и"

деф главным образом(): глобальное сообщение сообщение = "Это местная"и печать(сообщение)

основной()

выходы на "местный" ПО - от вызова функции

печать(сообщение)

выходов "Это местная" ПО - от внешней области

Эта концепция называется слежка

2. Сумма списка чисел в Python

нумс = [1, 2, 3, 4, 5]

ВАР = 0

деф суммы(): для num в тупик: глобальный ВАР вар = вар + Нум печать(ВАР)

если имя == 'основной': сумм()

Выходов = 15

Коротко и просто:

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

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

И здесь's, как она выглядит:

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

Из-за некоторой глупости в том, как питон обрабатывает "карта" над двумя списками, вы должны усекать список, а[:-1]. Он работает больше, как вы'd не ожидала, если использовать модуле 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]

Используя попарное` рецепт модуле 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) )

Генераторы простой способ, чтобы написать это:

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]

Я использовать а петли, чтобы получить результат:

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

Цикл по элементам списка и обновление всего такой:

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

Спасибо Карл Knechtel я смог понять ваш вопрос. Моя интерпретация:

1. Вы хотите новый список со средним элемента I и i+1.
2. Вы хотите, чтобы сумма каждого элемента в списке.

Первый вопрос, используя анонимную функцию (ака. Функция Lambda): с = лямбда-л: [(л[0]+Л[1])/2.] + с(Л[1:]) Если LEN(л)>1 еще [] #если вы хотите результат как поплавок с = лямбда-л: [(л[0]+Л[1])//2] + С(Л[1:]) Если LEN(л)>1 еще [] #если вы хотите, чтобы пол в результате

Второй вопрос также использование анонимной функции (ака. Функция Lambda): Р = лямда-л: л[0] + р(л[1:]) Если л!=[] еще 0

Оба вопросы объединены в одну строку кода : с = лямбда-л: (л[0]+Л[1])/2. + с(Л[1:]) Если LEN(л)>1 иначе 0 #если вы хотите результат как поплавок с = лямбда-л: (л[0]+Л[1])/2. + с(Л[1:]) Если LEN(л)>1 иначе 0 #если вы хотите, чтобы результат пол используйте тот, который лучше всего соответствует вашим потребностям

Я'd, просто использовать лямбда с картой()

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

В духе модуле itertools. Вдохновение из попарно рецепт.

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

Примеры:

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

Попробуйте использовать списочное понимание. Например:

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