Python - Различия между элементами списка

Question

Учитывая список чисел, как найти различия между каждым (i) -th и (i+1) -гом его элементами? Следует ли лучше использовать лямбда или, возможно, списки понимания?

Пример: Учитывая список t=[1,3,6,...] это найти список v=[2,3,...] потому 3-1=2, 6-3=3 и т.д.

Answer 1

>>> t 
[1, 3, 6] 
>>> [j-i for i, j in zip(t[:-1], t[1:])] # or use itertools.izip in py2k 
[2, 3] 

Answer 2

Ok. Я думаю, что я нашел правильное решение:

v = [x[1]-x[0] for x in zip(t[1:],t[:-1])] 

Answer 3

Другие ответы правильны, но если вы делаете численную работу, вы можете рассмотреть NumPy. Использование NumPy, ответ:

v = numpy.diff(t) 

Answer 4

Если вы не хотите использовать numpy ни zip, вы можете использовать простой (простейший, на мой взгляд) решение:

>>> t = [1, 3, 6] 
>>> v = [t[i+1]-t[i] for i in range(len(t)-1)] 
>>> v 
[2, 3] 

Answer 5

Вы можете использовать itertools.tee и zip эффективно построить результат:

from itertools import tee 
# python2 only: 
#from itertools import izip as zip 

def differences(seq): 
    iterable, copied = tee(seq) 
    next(copied) 
    for x, y in zip(iterable, copied): 
     yield y - x 

Или с помощью itertools.islice вместо:

from itertools import islice 

def differences(seq): 
    nexts = islice(seq, 1, len(seq)) 
    for x, y in zip(seq, nexts): 
     yield y - x 

Вы также можете избежать использования itertools модуля:

def differences(seq): 
    iterable = iter(seq) 
    prev = next(iterable) 
    for element in iterable: 
     yield element - prev 
     prev = element 

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

---

Вот некоторые микро-тесты решений:

In [12]: L = range(10**6) 

In [13]: from collections import deque 
In [15]: %timeit deque(differences_tee(L), maxlen=0) 
10 loops, best of 3: 122 ms per loop 

In [16]: %timeit deque(differences_islice(L), maxlen=0) 
10 loops, best of 3: 127 ms per loop 

In [17]: %timeit deque(differences_no_it(L), maxlen=0) 
10 loops, best of 3: 89.9 ms per loop 

А другие предложенные решения:

In [18]: %timeit [x[1] - x[0] for x in zip(L[1:], L)] 
10 loops, best of 3: 163 ms per loop 

In [19]: %timeit [L[i+1]-L[i] for i in range(len(L)-1)] 
1 loops, best of 3: 395 ms per loop 

In [20]: import numpy as np 

In [21]: %timeit np.diff(L) 
1 loops, best of 3: 479 ms per loop 

In [35]: %%timeit 
    ...: res = [] 
    ...: for i in range(len(L) - 1): 
    ...:  res.append(L[i+1] - L[i]) 
    ...: 
1 loops, best of 3: 234 ms per loop 

Обратите внимание, что:

• zip(L[1:], L) эквивалентно zip(L[1:], L[:-1]) с zip уже оканчивается на кратчайший вход, однако он избегает целой копии L.
• Доступа к отдельным элементам с помощью индекса очень медленно, потому что каждый доступ индекса является вызовом метода в питоне

• numpy.diff является медленно, потому что он должен сначала преобразовать list в ndarray.Очевидно, что если вы начать с ndarray будет гораздо быстрее:

  In [22]: arr = np.array(L) 
  
  In [23]: %timeit np.diff(arr) 
  100 loops, best of 3: 3.02 ms per loop 
  

Answer 6

Мой путь

>>>v = [1,2,3,4,5] 
>>>[v[i] - v[i-1] for i, value in enumerate(v[1:], 1)] 
[1, 1, 1, 1] 

Answer 7

Функциональный подход:

>>> import operator 
>>> a = [1,3,5,7,11,13,17,21] 
>>> map(operator.sub, a[1:], a[:-1]) 
[2, 2, 2, 4, 2, 4, 4] 

Использование генератора:

>>> import operator, itertools 
>>> g1,g2 = itertools.tee((x*x for x in xrange(5)),2) 
>>> list(itertools.imap(operator.sub, itertools.islice(g1,1,None), g2)) 
[1, 3, 5, 7] 

Использование индексов:

>>> [a[i+1]-a[i] for i in xrange(len(a)-1)] 
[2, 2, 2, 4, 2, 4, 4]