Trouver les différences entre les éléments d'une liste

Donné une liste de nombres, comment trouver des différences entre chaque (i)-th éléments et de ses (i+1)-th?

Est-il préférable d'utiliser un lambda expression ou peut-être une compréhension de liste?

Par exemple:

Donné une liste t=[1,3,6,...], l'objectif est de trouver une liste v=[2,3,...] parce que 3-1=2, 6-3=3, etc.

InformationsquelleAutor psihodelia | 2010-03-08
  1. 136
    >>> t
[1, 3, 6]
>>> [j-i for i, j in zip(t[:-1], t[1:])]  # or use itertools.izip in py2k
[2, 3]
    • Dans le cas où vous avez besoin différences absolues, [abs(j-i) for i,j in zip(t, t[1:])]
    • Dans le cas où vous souhaitez le rendre plus efficace: list(itertools.starmap(operator.sub, zip(t[1:], t))) (après l'importation itertools et operator).
    • En fait tout simplement list(map(operator.sub, t[1:], t[:-1])) fera.
    • Génial! J'adore cette réponse!
    InformationsquelleAutor SilentGhost
  2. 99

    Les autres réponses sont correctes, mais si vous faites numérique de travail, vous pourriez envisager de numpy. Utilisation de numpy, la réponse est:

    v = numpy.diff(t)
    • Très utile! Merci! np.diff([2,4,9]) serait [2,5]
    InformationsquelleAutor Christian Alis
  3. 32

    Si vous ne souhaitez pas utiliser numpy ni zip, vous pouvez utiliser la solution suivante:

    >>> t = [1, 3, 6]
>>> v = [t[i+1]-t[i] for i in range(len(t)-1)]
>>> v
[2, 3]
    InformationsquelleAutor Omer Dagan
  4. 11

    Vous pouvez utiliser itertools.té et zip efficacement construire le résultat:

    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

    Ou à l'aide de itertools.islice à la place:

    from itertools import islice

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

    Vous pouvez également éviter d'utiliser le itertools module:

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

    Toutes ces solution de travail en constante espace si vous n'avez pas besoin de stocker tous les résultats et le soutien infini iterables.

    Voici quelques micro-benchmarks des solutions:

    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

    Et les autres solutions proposées:

    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

    Noter que:

    • zip(L[1:], L) est équivalent à zip(L[1:], L[:-1]) depuis zip déjà se termine sur la plus courte de l'entrée, mais il évite une copie entière de L.
    • Accès unique des éléments par index est très lent car chaque indice d'accès est un appel de méthode en python

    • numpy.diff est lent, car il doit d'abord convertir le list à un ndarray. Évidemment, si vous commencer avec un ndarray il sera beaucoup plus rapide:

      In [22]: arr = np.array(L)

In [23]: %timeit np.diff(arr)
100 loops, best of 3: 3.02 ms per loop
    • dans la deuxième solution, islice(seq, 1, None) au lieu de islice(seq, 1, len(seq)) permet de travailler avec une infinie iterables
    • Vous êtes de droite. Il fixe. Merci
    InformationsquelleAutor Bakuriu
  5. 3

    Ok. Je crois que j'ai trouvé la bonne solution:

    v = [x[1]-x[0] for x in zip(t[1:],t[:-1])]
    • ya ses bonnes, mais je pense qu'il doit avoir été v = [x[0]-x[1] x dans zip(t[1:], t[:-1])] pour la liste triée!
    InformationsquelleAutor psihodelia
  6. 3

    Une approche fonctionnelle:

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

    À l'aide du générateur:

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

    À l'aide d'indices:

    >>> [a[i+1]-a[i] for i in xrange(len(a)-1)]
[2, 2, 2, 4, 2, 4, 4]
    • L'opérateur méthode est agréable et élégant
    InformationsquelleAutor Ola Fosheim Grøstad
  7. 3

    Je conseille

    v = np.diff(t)

    c'est simple et facile à lire.

    Mais si vous voulez v d'avoir la même ligne que t puis

    v = np.diff([t[0]] + t) # for python 3.x

    ou

    v = np.diff(t + [t[-1]])

    Pour info: cela ne fonctionne que pour les listes.

    pour les tableaux numpy

    v = np.diff(np.append(t[0], t))
    InformationsquelleAutor Chaitanya Kesanapalli
  8. -1

    Ma façon

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