Wie zwei Pandas Datenframe parallel verschmelzen (Multithreading oder Multiprocessing)

Question

Ohne parallele Programmierung kann ich linken und rechten Datenrahmen auf key Spalte unter Verwendung von Code unter, aber es wird zu langsam, da beide sehr groß sind. Gibt es einen Weg, wie ich es effizient parallelisieren kann?

Ich habe 64 Kerne, und so praktisch kann ich 63 von ihnen verwenden, um diese beiden Daten zu verschmelzen.

left = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'], 
         'A': ['A0', 'A1', 'A2', 'A3'], 
        'B': ['B0', 'B1', 'B2', 'B3']}) 


right = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'], 
         'C': ['C0', 'C1', 'C2', 'C3'], 
         'D': ['D0', 'D1', 'D2', 'D3']}) 


result = pd.merge(left, right, on='key') 

Ausgang wird sein:

left: 
    A B key 
0 A0 B0 K0 
1 A1 B1 K1 
2 A2 B2 K2 
3 A3 B3 K3 

right: 
    C D key 
0 C0 D0 K0 
1 C1 D1 K1 
2 C2 D2 K2 
3 C3 D3 K3 

result: 
    A B key C D 
0 A0 B0 K0 C0 D0 
1 A1 B1 K1 C1 D1 
2 A2 B2 K2 C2 D2 
3 A3 B3 K3 C3 D3 

ich dies parallel tun will, damit ich es bei der Geschwindigkeit tun.

Answer 1

Sie können die Geschwindigkeit (um den Faktor 3 im angegebenen Beispiel) Ihrer Zusammenführung verbessern, indem Sie die key Spalte zum Index Ihrer Datenrahmen machen und stattdessen join verwenden.

left2 = left.set_index('key') 
right2 = right.set_index('key') 

In [46]: %timeit result2 = left2.join(right2) 
1000 loops, best of 3: 361 µs per loop 

In [47]: %timeit result = pd.merge(left, right, on='key') 
1000 loops, best of 3: 1.01 ms per loop 

Answer 2

Ich glaube, Sie können dask verwenden. und Funktion merge.

Docs sagen:

Was funktioniert auf jeden Fall?

Cleverly parallelizable Operationen (auch schnell):

Join auf Index: dd.merge (DF1, DF2, left_index = True, right_index = True)

Oder:

Operationen einen Shuffle erfordern (slow-ish, es sei denn, auf Index)

Set Index: df.set_index (df.x)

Mitglied werden nicht auf dem Index: auch pd.merge (DF1, DF2, auf 'name' =)

Sie können überprüfen Sie, wie .

Beispiel

import pandas as pd 

left = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'], 
         'A': ['A0', 'A1', 'A2', 'A3'], 
        'B': ['B0', 'B1', 'B2', 'B3']}) 


right = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'], 
         'C': ['C0', 'C1', 'C2', 'C3'], 
         'D': ['D0', 'D1', 'D2', 'D3']}) 


result = pd.merge(left, right, on='key') 
print result 
    A B key C D 
0 A0 B0 K0 C0 D0 
1 A1 B1 K1 C1 D1 
2 A2 B2 K2 C2 D2 
3 A3 B3 K3 C3 D3 

import dask.dataframe as dd 

#Construct a dask objects from a pandas objects 
left1 = dd.from_pandas(left, npartitions=3) 
right1 = dd.from_pandas(right, npartitions=3) 

#merge on key 
print dd.merge(left1, right1, on='key').compute() 
    A B key C D 
0 A3 B3 K3 C3 D3 
1 A1 B1 K1 C1 D1 
0 A2 B2 K2 C2 D2 
1 A0 B0 K0 C0 D0 

#first set indexes and then merge by them 
print dd.merge(left1.set_index('key').compute(), 
       right1.set_index('key').compute(), 
       left_index=True, 
       right_index=True) 
     A B C D 
key     
K0 A0 B0 C0 D0 
K1 A1 B1 C1 D1 
K2 A2 B2 C2 D2 
K3 A3 B3 C3 D3