Finden Unterschiede zwischen den Elementen einer Liste

Gegeben eine Liste von zahlen, wie findet man Unterschiede zwischen den einzelnen (i)-TEN Elemente und Ihre (i+1)-th?

Ist es besser, auf ein lambda Ausdruck oder vielleicht eine list comprehension?

Beispiel:

Gegeben eine Liste t=[1,3,6,...], das Ziel ist es, eine Liste v=[2,3,...] weil 3-1=2, 6-3=3 usw.

InformationsquelleAutor psihodelia | 2010-03-08
  1. 130
    >>> t
[1, 3, 6]
>>> [j-i for i, j in zip(t[:-1], t[1:])]  # or use itertools.izip in py2k
[2, 3]
    • In Fall müssen Sie die absoluten Unterschiede [abs(j-i) for i,j in zip(t, t[1:])]
    • In Fall, dass Sie wollen, um es effizienter: list(itertools.starmap(operator.sub, zip(t[1:], t))) (nach dem Import itertools und operator).
    • Eigentlich einfach list(map(operator.sub, t[1:], t[:-1])) tun.
    InformationsquelleAutor SilentGhost
  2. 96

    Die anderen Antworten sind korrekt, aber wenn du tust numerische arbeiten, möchten Sie vielleicht zu prüfen, numpy. Mit numpy, die Antwort ist:

    v = numpy.diff(t)
    InformationsquelleAutor Christian Alis
  3. 32

    Wenn Sie nicht möchten, zu verwenden numpy noch zip, können Sie die folgende Lösung:

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

    Können Sie itertools.tee und zip effizient zu bauen, das Ergebnis:

    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

    Oder mit itertools.islice statt:

    from itertools import islice

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

    Können Sie auch vermeiden, mit den itertools Modul:

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

    Alle diese Lösung funktioniert in ständiger Platz, wenn Sie nicht brauchen, um zu speichern alle Ergebnisse und Unterstützung unendlich iterables.

    Hier sind einige micro-benchmarks für die Lösungen:

    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

    Und die andere vorgeschlagene Lösungen:

    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

    Beachten Sie, dass:

    • zip(L[1:], L) entspricht zip(L[1:], L[:-1]) seit zip bereits beendet, auf dem kürzesten input, aber es vermeidet eine vollständige Kopie L.
    • Zugriff auf die einzelnen Elemente per index ist sehr langsam, da jeder index-Zugriff ist ein Aufruf der Methode in python

    • numpy.diff ist langsam, da Sie zuerst konvertieren Sie die list zu einem ndarray. Natürlich, wenn Sie start mit einer ndarray es wird viel schneller:

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

In [23]: %timeit np.diff(arr)
100 loops, best of 3: 3.02 ms per loop
    • in der zweiten Lösung, islice(seq, 1, None) statt islice(seq, 1, len(seq)) macht es das arbeiten mit unendlichen iterables
    • Du hast Recht. Fixiert es. Dank
    InformationsquelleAutor Bakuriu
  5. 3

    Ok. Ich glaube, ich fand die richtige Lösung:

    v = [x[1]-x[0] for x in zip(t[1:],t[:-1])]
    • ya seine gute, aber ich denke, es sollte v = [x[0]-x[1] for x in zip(t[1:], t[:-1])] für die sortierte Liste!
    InformationsquelleAutor psihodelia
  6. 3

    Einen funktionalen Ansatz:

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

    Generator:

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

    Unter Verwendung von Indizes:

    >>> [a[i+1]-a[i] for i in xrange(len(a)-1)]
[2, 2, 2, 4, 2, 4, 4]
    • Die operator-Methode ist schön und elegant
    InformationsquelleAutor Ola Fosheim Grøstad
  7. 2

    Ich würde vorschlagen, mit

    v = np.diff(t)

    dies ist einfach und leicht zu Lesen.

    Aber wenn Sie wollen v zu haben, die sich in derselben Zeile wie t dann

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

    oder

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

    FYI: dies funktioniert nur bei Listen.

    für numpy-arrays

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

    Mein Weg

    >>>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
Schreibe einen Kommentar