Ответ 1

Решение

Вы можете использовать некоторые причудливые нарезки вашего списка, чтобы манипулировать подмножествами элементов. Просто возьмите каждый из трех подрежимов элементов, сортируйте, чтобы найти два верхних элемента, а затем найдите простой средний (ака средний) и добавьте его в список результатов.

Код

def get_means(input_list):
    means = []
    for i in xrange(len(input_list)-2):
        three_elements = input_list[i:i+3]
        sum_top_two = sum(three_elements) - min(three_elements)
        means.append(sum_top_two/2.0)
    return means

пример

Вы можете увидеть свой пример ввода (и желаемого результата) следующим образом:

print(get_means([3, 5, 2, 7, 5, 3, 6, 8, 4]))
# [4.0, 6.0, 6.0, 6.0, 5.5, 7.0, 7.0]

И больше...

Есть еще несколько замечательных ответов, которые позволяют получить более эффективные ответы, в том числе с использованием генератора, чтобы избежать больших списков памяти: fooobar.com/questions/15230409/...

Ответ 2

Я верю в разделение кода на 2 части. Здесь это будет получение скользящего окна, получение двух верхних элементов и вычисление среднего значения. Самый чистый способ сделать это - использовать генераторы

Раздвижное окно

Небольшое изменение ответа evamicur с использованием tee, islice и zip для создания окна:

def windowed_iterator(iterable, n=2):
    iterators = itertools.tee(iterable, n)
    iterators = (itertools.islice(it, i, None) for i, it in enumerate(iterators))
    yield from zip(*iterators)

windows = windowed_iterator(iterable=a, n=3)

[(3, 5, 2), (5, 2, 7), (2, 7, 5), (7, 5, 3), (5, 3, 6), (3, 6, 8), (6, 8, 4)]

верхние 2 элемента

для вычисления среднего значения 2-го уровня вы можете использовать любой из методов, используемых в других ответах, я думаю, что heapq on является самым ясным

from heapq import nlargest
top_n = map(lambda x: nlargest(2, x), windows)

или эквивалентно

top_n = (nlargest(2, i) for i in windows)

[[5, 3], [7, 5], [7, 5], [7, 5], [6, 5], [8, 6], [8, 6]]

имею в виду

from statistics import mean
means = map(mean, top_n)

[4, 6, 6, 6, 5.5, 7, 7]

Ответ 3

Следующий код делает то, что вам нужно:

[sum(sorted(a[i:i + 3])[-2:]) / 2 for i in range(len(a) - 2)]

Учитывая ваши a=[3, 5, 2, 7, 5, 3, 6, 8, 4], возвращается:

[4.0, 6.0, 6.0, 6.0, 5.5, 7.0, 7.0]

Ответ 4

itertools имеет аккуратный рецепт для извлечения пар элементов из любого итерабельного, не только индексируемого. Вы можете немного приспособить его, чтобы извлечь триплеты:

def tripletwise(iterable):
    a, b, c = itertools.tee(iterable, 3)
    next(b, None)
    next(itertools.islice(c, 2, 2), None)
    return zip(a, b, c)

Используя это, вы можете упростить итерацию по всем триплетам:

def windowed_means(iterable):
    return [
        (sum(window) - min(window)) / 2.0
        for window in tripletwise(iterable)
    ]

Ответ 5

Итераторное решение

Решение foslok, безусловно, прекрасно, но я хотел поиграть и сделать версию этого с генераторами. Он хранит только деку длины (window_size), когда он выполняет итерацию через исходный список, затем находит n_largest значения и вычисляет среднее значение.

import itertools as it
from collections import deque
from heapq import nlargest
from statistics import mean

def windowed(iterable, n):
    _iter = iter(iterable)
    d = deque((it.islice(_iter, n)), maxlen=n)
    yield tuple(d)
    for i in _iter:
        d.append(i)
        yield tuple(d)

a = [3, 5, 2, 7, 5, 3, 6, 8, 4]
means = [mean(nlargest(2, w)) for w in windowed(a, 3)]
print(means)   

результат:

[4, 6, 6, 6, 5.5, 7, 7]

Таким образом, чтобы изменить как количество элементов (размер окна), так и n наибольших элементов, просто измените аргументы на соответствующие функции. Этот подход также позволяет избежать использования разрезания, поэтому его можно более легко применить к итерациям, которые вы не можете или не хотите срезать.

Задержки

def deque_version(iterable, n, k):
    means = (mean(nlargest(n, w)) for w in windowed(iterable, k))
    for m in means:
        pass

def tee_version(iterable, n, k):
    means = (mean(nlargest(n, w)) for w in windowed_iterator(iterable, k))
    for m in means:
        pass

a = list(range(10**5))


n = 3 
k = 2
print("n={} k={}".format(n, k))
print("Deque")
%timeit deque_version(a, n, k)
print("Tee")
%timeit tee_version(a, n, k)

n = 1000 
k = 2
print("n={} k={}".format(n, k))
print("Deque")
%timeit deque_version(a, n, k)
print("Tee")
%timeit tee_version(a, n, k)

n = 50
k = 25
print("n={} k={}".format(n, k))
print("Deque")
%timeit deque_version(a, n, k)
print("Tee")
%timeit tee_version(a, n, k)


result:

n=3 k=2
Deque
1.28 s ± 3.07 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
Tee
1.28 s ± 16.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
n=1000 k=2
Deque
1.28 s ± 8.72 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
Tee
1.27 s ± 2.92 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
n=50 k=25
Deque
2.46 s ± 10.6 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
Tee
2.47 s ± 2.45 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

Так что, по-видимому, itertools tee vs deque не имеет большого значения.

Ответ 6

В качестве векторизованного подхода, использующего Numpy, вы можете сделать следующее:

np.sort(np.column_stack((a[:-2], a[1:-1], a[2:])))[:,-2:].mean(axis=1)

Демо-версия:

In [13]: a=np.array([3, 5, 2, 7, 5, 3, 6, 8, 4])

In [14]: np.sort(np.column_stack((a[:-2], a[1:-1], a[2:])))[:,-2:].mean(axis=1)
Out[14]: array([4. , 6. , 6. , 6. , 5.5, 7. , 7. ])

Ответ 7

Использовать список

from statistics import mean

yourList=[3, 5, 2, 7, 5, 3, 6, 8, 4]

k = 3

listYouWant = [mean(x) for x in [y[1:k] for y in [sorted(yourList[z:z+k]) for z in xrange(len(yourList)) if z < len(yourList) -(k-1)]]]

дает [4.0, 6.0, 6.0, 6.0, 5.5, 7.0, 7.0]

Ответ 8

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

>>> a
[3, 5, 2, 7, 5, 3, 6, 8, 4]
>>> n
3
>>> m
2
>>> [sum(sorted(a[i*n:i*n+n])[1:])/m for i in range(len(a)/n)]
[4, 6, 7]

То есть,

>>> a
[3, 5, 2, 7, 5, 3, 6, 8, 4]
>>> n
3
>>> [i for i in range(len(a)/n)]
[0, 1, 2]
>>> m=2
>>> [a[i*n:i*n+n] for i in range(len(a)/n)]
[[3, 5, 2], [7, 5, 3], [6, 8, 4]]
>>> [sorted(a[i*n:i*n+n]) for i in range(len(a)/n)]
[[2, 3, 5], [3, 5, 7], [4, 6, 8]]
>>> [sorted(a[i*n:i*n+n])[1:] for i in range(len(a)/n)]
[[3, 5], [5, 7], [6, 8]]
>>> [sum(sorted(a[i*n:i*n+n])[1:]) for i in range(len(a)/n)]
[8, 12, 14]
>>> [sum(sorted(a[i*n:i*n+n])[1:])/m for i in range(len(a)/n)]
[4, 6, 7]

Ответ 9

a=[3, 5, 2, 7, 5, 3, 6, 8, 4]
mean_list = [
    mean(x)
        for x in [
            y[1:3]
                for y in [
                    sorted(a[z:z+3])
                        for z in range(len(a))
                            if z < len(a) -2
                ]
        ]
]

Ответ 10

Вы также можете посмотреть на него с точки зрения генераторов:

a=[3, 5, 2, 7, 5, 3, 6, 8, 4]

def gen_list():
    for i in range(0, len(a) - 3):
        yield sorted(a[i:i + 3], reverse=True)

apply_division = map(lambda x: sum(x[:2]) / len(x[:2]), gen_list())


if __name__=="__main__":
    result = list(apply_division)
    print(result)
[4.0, 6.0, 6.0, 6.0, 5.5, 7.0]

Ответ 11

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

from itertools import islice

def calculate_means(items, window_length=3):
     stop_seq = window_length - 1
     sliding_window = [sorted(islice(items[x:],window_length),reverse=True) for x in range(len(items)-stop_seq)]
     return [sum(a[:stop_seq])/stop_seq for a in sliding_window]

>>> calculate_means([3, 5, 2, 7, 5, 3, 6, 8, 4])
>>> [4.0, 6.0, 6.0, 6.0, 5.5, 7.0, 7.0]

Ответ 12

Для записи здесь есть функциональная версия:

>>> f=lambda values:[] if len(values)<=2 else [(sum(values[:3])-min(values[:3]))/2]+f(values[1:])
>>> f([3, 5, 2, 7, 5, 3, 6, 8, 4])
[4.0, 6.0, 6.0, 6.0, 5.5, 7.0, 7.0]
>>> f([3, 5, 2])
[4.0]
>>> f([3, 5])
[]

Ответ 13

Используя алгоритм скользящего окна и сторонний инструмент more_itertools.windowed:

import statistics as stats

import more_itertools as mit


lst = [3, 5, 2, 7, 5, 3, 6, 8, 4]

[stats.mean(sorted(w)[1:]) for w in mit.windowed(lst, 3)]
# [4, 6, 6, 6, 5.5, 7, 7]

Смотрите также @Maarten Fabre, связанный пост.

Ответ 14

Не nlog(n) свои под-списки, эта операция - nlog(n) ! Вместо этого найдите самые большие два числа с алгоритмом O(n). Это повысит эффективность вашего решения. Повышение эффективности будет более заметным, если вы будете работать над большей проблемой "найти сумму вершины m из движущегося окна k элементов" для больших m и k.

def largestTwoMeans(myList):
    means = []
    for i in xrange(len(myList)-2):
        subList = myList[i:i+3]
        first, second = -float("inf"), -float("inf")
        for f in subList:       
            if f >= first:
                first, second = f, first
            elif first > f > second:
                second = f
        means.append((first+second)/2.0)
    return means

print largestTwoMeans(myList)
Out[222]: [4.0, 6.0, 6.0, 6.0, 5.5, 7.0, 7.0]

Вот версия генератора:

def largestTwoMeans(myList):
    for i in xrange(len(myList)-2):
        subList = myList[i:i+3]
        first, second = -float("inf"), -float("inf")
        for f in subList:       
            if f >= first:
                first, second = f, first
            elif first > f > second:
                second = f
        yield (first+second)/2.0

print list(largestTwoMeans(myList))
Out[223]: [4.0, 6.0, 6.0, 6.0, 5.5, 7.0, 7.0]

Ответ 15

Чтобы отсортировать три числа, нам нужно не более трех сравнений. Чтобы найти самое низкое из трех чисел, нам нужно только два путем quickselect. Нам также не нужно делать копии подписок:

a,b,c

a < b
? (a < c ? a : c)
: (b < c ? b : c)

def f(A):
  means = [None] * (len(A) - 2)

  for i in xrange(len(A) - 2):
    if A[i] < A[i+1]:
      means[i] = (A[i+1] + A[i+2]) / 2.0 if A[i] < A[i+2] else (A[i] + A[i+1]) / 2.0
    else:
      means[i] = (A[i] + A[i+2]) / 2.0 if A[i+1] < A[i+2] else (A[i] + A[i+1]) / 2.0

  return means

print f([3, 5, 2, 7, 5, 3, 6, 8, 4])