Tut pandas iterrows haben performance Probleme?

Vektor-Operationen in Numpy und pandas sind viel schneller als Skalare Operationen in Vanille-Python gibt es mehrere Gründe:

• Fortgeführten Typ lookup: Python ist eine dynamisch typisierte Sprache, so gibt es Laufzeit-overhead für jedes element in einem array. Jedoch, Numpy (und damit pandas) durchführen von Berechnungen in C (oft über Cython). Der Typ des array ist bestimmt nur am Anfang der iteration ist; diese Einsparungen allein ist einer der größten Siege.

• Besser Zwischenspeichern: Iteration über ein C-array ist cache-freundlich und deshalb sehr schnell. Ein pandas DataFrame ist eine "spaltenorientierte Tabelle", was bedeutet, dass jede Spalte ist eigentlich nur ein array. Also die native Aktionen, die Sie durchführen können auf einen DataFrame (wie addieren aller Elemente in einer Spalte) haben nur wenige cache-misses.

• Mehr Möglichkeiten für Parallelität: Ein einfaches C-array betrieben werden kann mittels SIMD-Anweisungen. Einige Teile von Numpy ermöglichen, SIMD, je nach CPU und installation. Die Vorteile für die Parallelität nicht so dramatisch, wie die statische Typisierung und besser Zwischenspeichern, aber Sie sind immer noch eine solide gewinnen.

Moral von der Geschichte: das Vektor-Operationen in Numpy und pandas. Sie sind schneller als Skalare Operationen in Python-aus dem einfachen Grund, dass diese Vorgänge sind genau das, was ein C-Programmierer geschrieben hätte ohnehin von hand. (Außer, dass der array-Begriff ist viel einfacher zu Lesen als eine explizite Schleifen mit embedded-SIMD-Anweisungen.)

Andere Möglichkeit ist die Verwendung to_records(), die schneller ist als beide itertuples und iterrows.

Aber für deinen Fall gibt es viel Raum für andere Arten von Verbesserungen.

Hier mein final optimierte version

def iterthrough():
    ret = []
    grouped = table2.groupby('letter', sort=False)
    t2info = table2.to_records()
    for index, letter, n1 in table1.to_records():
        t2 = t2info[grouped.groups[letter].values]
        # np.multiply is in general faster than "x * y"
        maxrow = np.multiply(t2.number2, n1).argmax()
        # `[1:]`  removes the index column
        ret.append(t2[maxrow].tolist()[1:])
    global table3
    table3 = pd.DataFrame(ret, columns=('letter', 'number2'))

Benchmark-test:

-- iterrows() --
100 loops, best of 3: 12.7 ms per loop
  letter  number2
0      a      0.5
1      b      0.1
2      c      5.0
3      d      4.0

-- itertuple() --
100 loops, best of 3: 12.3 ms per loop

-- to_records() --
100 loops, best of 3: 7.29 ms per loop

-- Use group by --
100 loops, best of 3: 4.07 ms per loop
  letter  number2
1      a      0.5
2      b      0.1
4      c      5.0
5      d      4.0

-- Avoid multiplication --
1000 loops, best of 3: 1.39 ms per loop
  letter  number2
0      a      0.5
1      b      0.1
2      c      5.0
3      d      4.0

Vollständige code:

import pandas as pd
import numpy as np

#%% Create the original tables
t1 = {'letter':['a','b','c','d'],
      'number1':[50,-10,.5,3]}

t2 = {'letter':['a','a','b','b','c','d','c'],
      'number2':[0.2,0.5,0.1,0.4,5,4,1]}

table1 = pd.DataFrame(t1)
table2 = pd.DataFrame(t2)

#%% Create the body of the new table
table3 = pd.DataFrame(np.nan, columns=['letter','number2'], index=table1.index)


print('\n-- iterrows() --')

def optimize(t2info, t1info):
    calculation = []
    for index, r in t2info.iterrows():
        calculation.append(r['number2'] * t1info)
    maxrow_in_t2 = calculation.index(max(calculation))
    return t2info.loc[maxrow_in_t2]

#%% Iterate through filtering relevant data, optimizing, returning info
def iterthrough():
    for row_index, row in table1.iterrows():   
        t2info = table2[table2.letter == row['letter']].reset_index()
        table3.iloc[row_index,:] = optimize(t2info, row['number1'])

%timeit iterthrough()
print(table3)

print('\n-- itertuple() --')
def optimize(t2info, n1):
    calculation = []
    for index, letter, n2 in t2info.itertuples():
        calculation.append(n2 * n1)
    maxrow = calculation.index(max(calculation))
    return t2info.iloc[maxrow]

def iterthrough():
    for row_index, letter, n1 in table1.itertuples():   
        t2info = table2[table2.letter == letter]
        table3.iloc[row_index,:] = optimize(t2info, n1)

%timeit iterthrough()


print('\n-- to_records() --')
def optimize(t2info, n1):
    calculation = []
    for index, letter, n2 in t2info.to_records():
        calculation.append(n2 * n1)
    maxrow = calculation.index(max(calculation))
    return t2info.iloc[maxrow]

def iterthrough():
    for row_index, letter, n1 in table1.to_records():   
        t2info = table2[table2.letter == letter]
        table3.iloc[row_index,:] = optimize(t2info, n1)

%timeit iterthrough()

print('\n-- Use group by --')

def iterthrough():
    ret = []
    grouped = table2.groupby('letter', sort=False)
    for index, letter, n1 in table1.to_records():
        t2 = table2.iloc[grouped.groups[letter]]
        calculation = t2.number2 * n1
        maxrow = calculation.argsort().iloc[-1]
        ret.append(t2.iloc[maxrow])
    global table3
    table3 = pd.DataFrame(ret)

%timeit iterthrough()
print(table3)

print('\n-- Even Faster --')
def iterthrough():
    ret = []
    grouped = table2.groupby('letter', sort=False)
    t2info = table2.to_records()
    for index, letter, n1 in table1.to_records():
        t2 = t2info[grouped.groups[letter].values]
        maxrow = np.multiply(t2.number2, n1).argmax()
        # `[1:]`  removes the index column
        ret.append(t2[maxrow].tolist()[1:])
    global table3
    table3 = pd.DataFrame(ret, columns=('letter', 'number2'))

%timeit iterthrough()
print(table3)

Die final version ist fast 10x schneller als der ursprüngliche code. Die Strategie ist:

1. Verwenden groupby zu vermeiden, wiederholt den Vergleich von Werten.
2. Verwenden to_records Zugriff auf raw-numpy.Datensätze Objekte.
3. Nicht operieren, DataFrame, bis Sie zusammengestellt haben alle Daten.