Vergleich der vorherigen Reihe von Werten in Pandas DataFrame

import pandas as pd
data={'col1':[1,3,3,1,2,3,2,2]}
df=pd.DataFrame(data,columns=['col1'])
print df


         col1  
    0     1          
    1     3          
    2     3          
    3     1          
    4     2          
    5     3          
    6     2          
    7     2

Habe ich Folgendes Pandas DataFrame, und ich möchte eine weitere Spalte, vergleicht die Vorherige Zeile des col1, um zu sehen, wenn Sie gleich sind. Was wäre der beste Weg, dies zu tun? Es wäre wie die folgenden DataFrame. Dank

    col1  match  
0     1   False     
1     3   False     
2     3   True     
3     1   False     
4     2   False     
5     3   False     
6     2   False     
7     2   True

InformationsquelleAutor jth359 | 2016-12-30

Müssen Sie eq mit shift:

df['match'] = df.col1.eq(df.col1.shift())
print (df)
   col1  match
0     1  False
1     3  False
2     3   True
3     1  False
4     2  False
5     3  False
6     2  False
7     2   True

Oder statt eq verwenden ==, aber es ist ein bisschen slowier in großen DataFrame:

df['match'] = df.col1 == df.col1.shift()
print (df)
   col1  match
0     1  False
1     3  False
2     3   True
3     1  False
4     2  False
5     3  False
6     2  False
7     2   True

Timings:

import pandas as pd
data={'col1':[1,3,3,1,2,3,2,2]}
df=pd.DataFrame(data,columns=['col1'])
print (df)
#[80000 rows x 1 columns]
df = pd.concat([df]*10000).reset_index(drop=True)

df['match'] = df.col1 == df.col1.shift()
df['match1'] = df.col1.eq(df.col1.shift())
print (df)

In [208]: %timeit df.col1.eq(df.col1.shift())
The slowest run took 4.83 times longer than the fastest. This could mean that an intermediate result is being cached.
1000 loops, best of 3: 933 µs per loop

In [209]: %timeit df.col1 == df.col1.shift()
1000 loops, best of 3: 1 ms per loop

Sie konnte tun df = pd.concat([df]*10000, ignore_index=True).
== sollte nicht langsamer als mit eq im Allgemeinen (ich bekomme das Gegenteil zu Ihnen, wenn ich diese testen zum Beispiel).
Danke für den Kommentar. Ich Teste es unter windows mehr Zeit, und wenn vergleichen mit skalaren, timings sind die gleichen, aber wenn Sie vergleichen 2 Serie eq, ne, lt... war schneller als ==, !=, > in größeren df. Was war deine timings in größeren df?
Was für ein unglaubliches Konzept! Also die shift Standard ist die Verlagerung nach unten sehe ich. Und warum die pandas Dokumentation auf .eq enthält kein Beispiel, das tatsächlich verwendet .eq? Komisch. Aber ich denke, es funktioniert genauso wie ==, außer für die Rechenzeit.

InformationsquelleAutor jezrael

1) pandas Ansatz: Verwenden diff:

df['match'] = df['col1'].diff().eq(0)

2) numpy Ansatz: Verwenden np.ediff1d.

df['match'] = np.ediff1d(df['col1'].values, to_begin=np.NaN) == 0

Beide produzieren:

Vergleich der vorherigen Reihe von Werten in Pandas DataFrame

Timings: (für den gleichen DF verwendet von @jezrael)

%timeit df.col1.eq(df.col1.shift())
1000 loops, best of 3: 731 µs per loop

%timeit df['col1'].diff().eq(0)
1000 loops, best of 3: 405 µs per loop

InformationsquelleAutor Nickil Maveli

Hier ist ein NumPy-arrays basierenden Ansatz verwenden schneiden , ermöglicht uns die Nutzung der Ansichten in die Eingabe-array für die Effizienz Zwecke -

def comp_prev(a):
    return np.concatenate(([False],a[1:] == a[:-1]))

df['match'] = comp_prev(df.col1.values)

Probe Gefahren -

In [48]: df['match'] = comp_prev(df.col1.values)

In [49]: df
Out[49]: 
   col1  match
0     1  False
1     3  False
2     3   True
3     1  False
4     2  False
5     3  False
6     2  False
7     2   True

Runtime test -

In [56]: data={'col1':[1,3,3,1,2,3,2,2]}
    ...: df0=pd.DataFrame(data,columns=['col1'])
    ...: 

#@jezrael's soln1
In [57]: df = pd.concat([df0]*10000).reset_index(drop=True)

In [58]: %timeit df['match'] = df.col1 == df.col1.shift() 
1000 loops, best of 3: 1.53 ms per loop

#@jezrael's soln2
In [59]: df = pd.concat([df0]*10000).reset_index(drop=True)

In [60]: %timeit df['match'] = df.col1.eq(df.col1.shift())
1000 loops, best of 3: 1.49 ms per loop

#@Nickil Maveli's soln1   
In [61]: df = pd.concat([df0]*10000).reset_index(drop=True)

In [64]: %timeit df['match'] = df['col1'].diff().eq(0) 
1000 loops, best of 3: 1.02 ms per loop

#@Nickil Maveli's soln2
In [65]: df = pd.concat([df0]*10000).reset_index(drop=True)

In [66]: %timeit df['match'] = np.ediff1d(df['col1'].values, to_begin=np.NaN) == 0
1000 loops, best of 3: 1.52 ms per loop

# Posted approach in this post
In [67]: df = pd.concat([df0]*10000).reset_index(drop=True)

In [68]: %timeit df['match'] = comp_prev(df.col1.values)
1000 loops, best of 3: 376 µs per loop

InformationsquelleAutor Divakar

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.