Python - wie das letzte Vorkommen Erfüllung einer bestimmten Bedingung aus einer Liste extrahieren

Question

Zum Beispiel habe ich folgende Daten als Liste:

l = [['A', 'aa', '1', '300'], 
    ['A', 'ab', '2', '30'], 
    ['A', 'ac', '3', '60'], 
    ['B', 'ba', '5', '50'], 
    ['B', 'bb', '4', '10'], 
    ['C', 'ca', '6', '50']] 

Jetzt für 'A', 'B' und 'C', ich wollte bekommen ihre letzten Vorkommen, dh:

[['A', 'ab', '3', '30'], 
['B', 'bb', '4', '10'], 
['C', 'ca', '6', '50']] 

oder weitere, die dritte Spalte in diesen Ereignissen, nämlich:

['3', '4', '6'] 

Derzeit

, die Art, wie ich damit umgehen ist:

import pandas as pd 
df = pd.DataFrame(l, columns=['u', 'w', 'y', 'z']) 
df.set_index('u', inplace=True) 
ll = [] 
for letter in df.index.unique(): 
    ll.append((df.ix[letter, 'y'][-1])) 

Dann %timeit ich, es zeigt:

>> The slowest run took 27.86 times longer than the fastest. 
>> This could mean that an intermediate result is being cached. 
>> 1000000 loops, best of 3: 887 ns per loop 

Nur frage mich, ob es eine Möglichkeit ist, dies mit weniger Zeit, als mein Code zu tun ? Vielen Dank!

Answer 1

l = [['A', 'aa', '1', '300'], 
    ['A', 'ab', '2', '30'], 
    ['A', 'ac', '3', '60'], 
    ['B', 'ba', '5', '50'], 
    ['B', 'bb', '4', '10'], 
    ['C', 'ca', '6', '50']] 

import itertools 
for key, group in itertools.groupby(l, lambda x: x[0]): 
    print key, list(group)[-1] 

Ohne Kommentar zu „Effizienz“, weil Sie nicht Ihre Bedingungen erklärt auf alle. Angenommen, die Liste wird im Voraus nach dem ersten Element der Unterliste sortiert.

Wenn die Liste sortiert ist, sollte man durchlaufen genug sein:

def tidy(l): 
    tmp = [] 
    prev_row = l[0] 

    for row in l: 
     if row[0] != prev_row[0]: 
      tmp.append(prev_row) 
     prev_row = row 
    tmp.append(prev_row) 
    return tmp 

und das ist ~ 5x schneller als itertools.groupby in einem timeit Test. Demonstration: https://repl.it/C5Af/0

[Edit: OP ihre Frage aktualisiert hat sie zu sagen, ist GROUPBY bereits Pandas mit, die schneller bereits möglicherweise Weg ist]

Answer 2

Auch wenn ich nicht sicher bin ich Ihre Frage verstanden, dann ist hier, was Sie tun können:

li = [l[i][0] for i in range(len(l))] 
[l[j][2] for j in [''.join(li).rfind(i) for i in set(li)]] 

Beachten Sie, dass die Ausgabe [3,4,6], als das letzte Auftreten von A die dritte zu sein scheint, nicht die zweites Array.

bearbeiten, wie Sie über die Leistung sehr besorgt scheinen (obwohl Sie nicht sagen, was Sie versucht haben und was als „gut“):

%timeit li = [l[i][0] for i in range(len(l))] 
%timeit [l[j][2] for j in [''.join(li).rfind(i) for i in set(li)]] 
>> 1000000 loops, best of 3: 1.19 µs per loop 
>> 100000 loops, best of 3: 2.57 µs per loop 

%timeit [list(group)[-1][2] for key, group in itertools.groupby(l, lambda x: x[0])] 
>> 100000 loops, best of 3: 5.11 µs per loop 

So scheint es, die Liste Verständnis geringfügig schneller ist als itertools (obwohl ich kein Experte für Benchmarks bin und es könnte einen besseren Weg geben, den itertools zu starten).

Answer 3

Ein nicht sehr-pythonic Ansatz: (beachten Sie, dass Nils' Lösung ist die pythonic - mit Liste Verständnis)

def get_last_row(xs,q): 
    for i in range(len(xs)-1,-1,-1): 
     if xs[i][0] == q: 
      return xs[i][2] 

def get_third_cols(xs): 
    third_cols = [] 
    for q in ["A","B","C"]: 
     third_cols.append(get_last_row(xs,q)) 
    return third_cols 

print get_third_cols(xs) 

Dies druckt ['3', '4', '6'] wenn das, was Sie mit dem letzten Auftreten gemeint.

Answer 4

{l[0]: l[2] for l in vals} finden Sie eine Abbildung von ‚A‘ erhalten, ‚B‘ und ‚C‘, um ihre letzten Werte

Answer 5

Dies zu jedem Schlüssel/Wert-Standort verallgemeinern wird.Beachten Sie, dass die Ausgabe in in der Reihenfolge erfolgt, in der der erste Schlüssel beobachtet wurde. Es wäre nicht schwer sein, so einzustellen, dass die Reihenfolge der Ausgabe der Auftrag ist, dass der Ausgangswert

import operator 

l = [['A', 'aa', '1', '300'], 
    ['A', 'ab', '2', '30'], 
    ['A', 'ac', '3', '60'], 
    ['B', 'ba', '5', '50'], 
    ['B', 'bb', '4', '10'], 
    ['C', 'ca', '6', '50']] 

def getLast(data, key, value): 
    f = operator.itemgetter(key,value) 
    store = dict() 
    keys = [] 
    for row in data: 
     key, value = f(row) 
     if key not in store: 
      keys.append(key) 
     store[key] = value 
    return [store[k] for k in keys] 

Jetzt ist es Timing,

%timeit getLast(l,0,2) 

Gibt beobachtet wurde:

The slowest run took 9.44 times longer than the fastest. This could mean that an intermediate result is being cached 
100000 loops, best of 3: 2.85 µs per loop 

Ausgänge

Und die Funktion:

['3', '4', '6']