Эффективный способ использования lambda python, map

Question

Мне нужно сохранить большой список целых чисел в Bigtable (db). Для эффективности я храню их как разницу между двумя последовательными элементами.

для например:

 original_list = [1005, 1004, 1003, 1004, 1006]

Хранение выше список (который на самом деле содержит более 1000K элементы), как

 
start = 1005 
diff = [-1, -1, 1, 2]

Ближайший я мог бы управлять это,

 
ltp = [start] 
map(lambda x: ltp.append(ltp[-1] + x), tick)

I Я ищу эффективный способ его преобразования в исходный список.

Answer 1

Следующие работает для меня:

orig = [start] 
for x in diff: 
    orig.append(orig[-1] + x) 

Использование map создаст новый массив того же размера, заполненный None. Я также нахожу простой цикл for более читаемым, и в этом случае так быстро, как вы можете получить.

Answer 2

Хотя я не понимаю, почему это должно быть более эффективным, я уверен, что для цикла даст лучшую производительность:

l = [start] 
for i in diff: 
    l.append(l[-1] + i) 

Answer 3

Некоторые из других респондентов имеют разумные реализации алгоритма, который вы просили, но я не знаю, в чем именно проблема, которую вы действительно пытаетесь решить.

Если числа, которые хранятся, очень велики (то есть, переполняют целое число и требуют bignums), ваш список различий не принесет вам никакой эффективности - целое число является целым числом из POV-времени выполнения Python, поэтому ваш пример «diff» список [-1, -1, 1, 2] будет потреблять столько же памяти, сколько и исходный список [1005, 1004, 1003, 1004, 1006].

Answer 4

Для таких больших структур данных numpy будет работать хорошо. Для этого примера, это над 200x быстрее (смотри ниже), и немного проще кода, в основном только

add.accumulate(diff) 

Сравнение между NumPy и прямого списка манипуляции:

import numpy as nx 
import timeit 

N = 10000 

diff_nx = nx.zeros(N, dtype=nx.int) 
diff_py = list(diff_nx) 

start = 1005 

def f0(): 
    orig = [start] 
    for x in diff_py: 
     orig.append(orig[-1] + x) 

def f1(): 
    diff_nx[0] = start 
    nx.add.accumulate(diff_nx) 

t = timeit.Timer("f0()", "from __main__ import f0, f1, diff_nx, diff_py, nx, start") 
print t.timeit(number=1000) 
t = timeit.Timer("f1()", "from __main__ import f0, f1, diff_nx, diff_py, nx, start") 
print t.timeit(number=1000) 

дает

13.4044158459  # for list looping 
0.0474112033844 # for numpy accumulate 

Действительно, кажется, что лучше повторить установленный алгоритм сжатия, например, можно легко сделать с помощью PyTables, r а не катиться, как будто кажется, что ты здесь.

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

Answer 5

Идеально подходит для генераторов:

def diff2abs(diffs, start): 
    yield start 
    for diff in diffs: 
     start += diff 
     yield start 

start = 1005 
diffs = [-1, -1, 1, 2] 
original_list = list(diff2abs(diffs, start)) 

Answer 6

class runningtotal: 
    def __init__(self, start = 0): 
     self.total = start 
    def __call__(self, value): 
     self.total += value 
     return self.total 

Теперь попробуйте:

>>> map(runningtotal(start), [0,]+diff) 
[1005, 1004, 1003, 1004, 1006] 

Answer 7

Как mshsayem предложил, использовать списковых - они, как правило, быстрее, чем для петель или карты/лямбды (по ДЕЛАТЬ Книга Марка Лутца «Обучение Python»).

Если вы действительно хотите использовать более FP-ish-решение, правильная функция будет «проверять», что [я считаю] не реализовано на Python, поэтому вам придется реализовать его самостоятельно (что не является трудная задача).

«Сканирование» - это в основном сокращение, но вместо уменьшения списка до одного значения он сохраняет результат каждой «итерации» в новом списке.

Если вы реализовали его, вы могли бы сделать что-то вроде:

scan(lambda x,y: x+y, [start]++diff) 

Answer 8

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

start = 1005 
def mod_start(x): 
    global start 
    start += x 
    return start 
int_generator = (mod_start(i) for i in diffs) 

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

Вы можете очистить пример, чтобы переменная начала не была глобальной. Он просто не может быть локальным для функции mod_start.

Редактировать: Вам не обязательно использовать генератор для получения генератора. Вы также можете использовать функцию генератора с выражением yield, например THC4k. Это позволяет избежать проблемы с исходной переменной и, вероятно, немного чище. Вы также можете получить список из генератора в любой момент, передав его в встроенную функцию list().

Answer 9

Нет комментариев к исполнению этого, но здесь вы можете использовать сокращение.

start = 1005 
diffs = [-1,-1,1,2] 
reduce(lambda undiffed_list, diff: undiffed_list + [undiffed_list[-1] + diff],diffs,[start]) 

получает то, что вы хотите.