Каков наиболее эффективный способ перебрать фреймы данных с помощью панд?

Новейшие версии pandas теперь включают встроенную функцию для перебора строк.

for index, row in df.iterrows():

    # do some logic here

Или, если хотите быстрее, используйте itertuples()

Но предложение unutbu использовать функции numpy, чтобы избежать итерации по строкам, даст самый быстрый код.

Pandas основан на массивах NumPy. Ключ к ускорению работы с массивами NumPy - это выполнение операций со всем массивом сразу, а не построчно или построчно.

Например, если close - это одномерный массив, и вы хотите, чтобы процентное изменение дня было изменено,

pct_change = close[1:]/close[:-1]

Это вычисляет весь массив процентных изменений как один оператор, а не

pct_change = []
for row in close:
    pct_change.append(...)

Поэтому постарайтесь полностью избежать цикла Python for i, row in enumerate(...) и подумайте о том, как выполнять свои вычисления с операциями над всем массивом (или фреймом данных) в целом, а не построчно.

Как уже упоминалось ранее, объект pandas наиболее эффективен при одновременной обработке всего массива. Однако для тех, кому действительно нужно перебрать pandas DataFrame для выполнения чего-то, я нашел как минимум три способа сделать это. Я провел небольшой тест, чтобы увидеть, какой из трех занимает меньше всего времени.

t = pd.DataFrame({'a': range(0, 10000), 'b': range(10000, 20000)})
B = []
C = []
A = time.time()
for i,r in t.iterrows():
    C.append((r['a'], r['b']))
B.append(time.time()-A)

C = []
A = time.time()
for ir in t.itertuples():
    C.append((ir[1], ir[2]))    
B.append(time.time()-A)

C = []
A = time.time()
for r in zip(t['a'], t['b']):
    C.append((r[0], r[1]))
B.append(time.time()-A)

print B

Результат:

[0.5639059543609619, 0.017839908599853516, 0.005645036697387695]

Вероятно, это не лучший способ измерить потребление времени, но для меня он быстрый.

Вот некоторые плюсы и минусы ИМХО:

• .iterrows (): возвращать индекс и элементы строки в отдельных переменных, но значительно медленнее
• .itertuples (): быстрее, чем .iterrows (), но возвращает индекс вместе с элементами строки, ir [0] - это индекс
• zip: самый быстрый, но без доступа к индексу строки

РЕДАКТИРОВАТЬ 2020/11/10

Вот обновленный тест с некоторыми другими альтернативами (производительность с MacBookPro 2,4 ГГц Intel Core i9 8 ядер 32 Go 2667 МГц DDR4)

import sys
import tqdm
import time
import pandas as pd

B = []
t = pd.DataFrame({'a': range(0, 10000), 'b': range(10000, 20000)})
for _ in tqdm.tqdm(range(10)):
    C = []
    A = time.time()
    for i,r in t.iterrows():
        C.append((r['a'], r['b']))
    B.append({"method": "iterrows", "time": time.time()-A})

    C = []
    A = time.time()
    for ir in t.itertuples():
        C.append((ir[1], ir[2]))
    B.append({"method": "itertuples", "time": time.time()-A})

    C = []
    A = time.time()
    for r in zip(t['a'], t['b']):
        C.append((r[0], r[1]))
    B.append({"method": "zip", "time": time.time()-A})

    C = []
    A = time.time()
    for r in zip(*t.to_dict("list").values()):
        C.append((r[0], r[1]))
    B.append({"method": "zip + to_dict('list')", "time": time.time()-A})

    C = []
    A = time.time()
    for r in t.to_dict("records"):
        C.append((r["a"], r["b"]))
    B.append({"method": "to_dict('records')", "time": time.time()-A})

    A = time.time()
    t.agg(tuple, axis=1).tolist()
    B.append({"method": "agg", "time": time.time()-A})

    A = time.time()
    t.apply(tuple, axis=1).tolist()
    B.append({"method": "apply", "time": time.time()-A})

print(f'Python {sys.version} on {sys.platform}')
print(f"Pandas version {pd.__version__}")
print(
    pd.DataFrame(B).groupby("method").agg(["mean", "std"]).xs("time", axis=1).sort_values("mean")
)

## Output

Python 3.7.9 (default, Oct 13 2020, 10:58:24) 
[Clang 12.0.0 (clang-1200.0.32.2)] on darwin
Pandas version 1.1.4
                           mean       std
method                                   
zip + to_dict('list')  0.002353  0.000168
zip                    0.003381  0.000250
itertuples             0.007659  0.000728
to_dict('records')     0.025838  0.001458
agg                    0.066391  0.007044
apply                  0.067753  0.006997
iterrows               0.647215  0.019600

Вы можете прокручивать строки, транспонируя и затем вызывая iteritems:

for date, row in df.T.iteritems():
   # do some logic here

Я не уверен в эффективности в этом случае. Чтобы добиться максимальной производительности итеративного алгоритма, вы можете попробовать написать его в Cython, чтобы сделать что-то вроде:

def my_algo(ndarray[object] dates, ndarray[float64_t] open,
            ndarray[float64_t] low, ndarray[float64_t] high,
            ndarray[float64_t] close, ndarray[float64_t] volume):
    cdef:
        Py_ssize_t i, n
        float64_t foo
    n = len(dates)

    for i from 0 <= i < n:
        foo = close[i] - open[i] # will be extremely fast

Я бы порекомендовал сначала написать алгоритм на чистом Python, убедитесь, что он работает, и посмотрите, насколько он быстр - если он недостаточно быстр, конвертируйте такие вещи в Cython, как этот, с минимальными усилиями, чтобы получить что-то такое же быстрое, как написанное вручную C / C ++.

У вас есть три варианта:

По index (простейший ):

>>> for index in df.index:
...     print ("df[" + str(index) + "]['B']=" + str(df['B'][index]))

С iterrows (большинство использовал):

>>> for index, row in df.iterrows():
...     print ("df[" + str(index) + "]['B']=" + str(row['B']))

С помощью itertuples (самый быстрый ):

>>> for row in df.itertuples():
...     print ("df[" + str(row.Index) + "]['B']=" + str(row.B))

Три варианта отображают что-то вроде:

df[0]['B']=125
df[1]['B']=415
df[2]['B']=23
df[3]['B']=456
df[4]['B']=189
df[5]['B']=456
df[6]['B']=12

Источник: alphons .io

Я проверил iterrows после того, как заметил ответ Ника Кроуфорда, но обнаружил, что он дает кортежи (index, Series). Не уверен, что лучше всего подойдет вам, но в итоге я использовал метод itertuples для своей проблемы, который дает кортежи (index, row_value1 ...).

Также есть iterkv, который выполняет итерацию по кортежам (столбцам, сериям).

В качестве небольшого дополнения вы также можете применить приложение, если у вас есть сложная функция, которую вы применяете к одному столбцу:

http://pandas.pydata.org/pandas-docs/dev/generated/pandas.DataFrame.apply.html

df[b] = df[a].apply(lambda col: do stuff with col here)

Как отметил @joris, iterrows намного медленнее, чем itertuples, а itertuples примерно в 100 раз длиннее, чем iterrows, и я тестировал скорость обоих методов в DataFrame с 5027505 записями результат для iterrows, это 1200 бит / с, а itertuples - 120000 бит / с.

Если вы используете itertuples, обратите внимание, что каждый элемент в цикле for является именованным кортежем, поэтому, чтобы получить значение в каждом столбце, вы можете обратиться к следующему примеру кода

>>> df = pd.DataFrame({'col1': [1, 2], 'col2': [0.1, 0.2]},
                      index=['a', 'b'])
>>> df
   col1  col2
a     1   0.1
b     2   0.2
>>> for row in df.itertuples():
...     print(row.col1, row.col2)
...
1, 0.1
2, 0.2

Конечно, самый быстрый способ перебрать фрейм данных - это получить доступ к базовому numpy ndarray либо через df.values (как вы), либо через доступ к каждому столбцу отдельно df.column_name.values. Поскольку вы тоже хотите иметь доступ к индексу, вы можете использовать для этого df.index.values.

index = df.index.values
column_of_interest1 = df.column_name1.values
...
column_of_interestk = df.column_namek.values

for i in range(df.shape[0]):
   index_value = index[i]
   ...
   column_value_k = column_of_interest_k[i]

Не питонический? Конечно. Но быстро.

Если вы хотите выжать больше из цикла, вам следует изучить cython. Cython позволит вам получить огромное ускорение (подумайте, в 10-100 раз). Для максимальной производительности проверьте просмотры памяти для cython.

Другое предложение - объединить groupby с векторизованными вычислениями, если подмножества строк имеют общие характеристики, которые позволяют вам это делать.

посмотри на последний

t = pd.DataFrame({'a': range(0, 10000), 'b': range(10000, 20000)})
B = []
C = []
A = time.time()
for i,r in t.iterrows():
    C.append((r['a'], r['b']))
B.append(round(time.time()-A,5))

C = []
A = time.time()
for ir in t.itertuples():
    C.append((ir[1], ir[2]))    
B.append(round(time.time()-A,5))

C = []
A = time.time()
for r in zip(t['a'], t['b']):
    C.append((r[0], r[1]))
B.append(round(time.time()-A,5))

C = []
A = time.time()
for r in range(len(t)):
    C.append((t.loc[r, 'a'], t.loc[r, 'b']))
B.append(round(time.time()-A,5))

C = []
A = time.time()
[C.append((x,y)) for x,y in zip(t['a'], t['b'])]
B.append(round(time.time()-A,5))
B

0.46424
0.00505
0.00245
0.09879
0.00209

Я считаю, что самый простой и эффективный способ перебрать DataFrames - использовать numpy и numba. В этом случае во многих случаях цикл может быть примерно таким же быстрым, как и векторизованные операции. Если numba не подходит, то, вероятно, будет следующим лучшим вариантом. Как уже много раз отмечалось, по умолчанию должна быть векторизация, но этот ответ просто рассматривает эффективный цикл, учитывая решение о цикле по какой-либо причине.

В качестве тестового примера давайте воспользуемся примером из ответа @ DSM о вычислении процентного изменения. Это очень простая ситуация, и с практической точки зрения вы не стали бы писать цикл для его вычисления, но как таковой он обеспечивает разумную основу для синхронизации векторизованных подходов по сравнению с циклами.

Давайте настроим 4 подхода с небольшим DataFrame, и мы приурочим их к большему набору данных ниже.

import pandas as pd
import numpy as np
import numba as nb

df = pd.DataFrame( { 'close':[100,105,95,105] } )

pandas_vectorized = df.close.pct_change()[1:]

x = df.close.to_numpy()
numpy_vectorized = ( x[1:] - x[:-1] ) / x[:-1]
        
def test_numpy(x):
    pct_chng = np.zeros(len(x))
    for i in range(1,len(x)):
        pct_chng[i] = ( x[i] - x[i-1] ) / x[i-1]
    return pct_chng

numpy_loop = test_numpy(df.close.to_numpy())[1:]

@nb.jit(nopython=True)
def test_numba(x):
    pct_chng = np.zeros(len(x))
    for i in range(1,len(x)):
        pct_chng[i] = ( x[i] - x[i-1] ) / x[i-1]
    return pct_chng
    
numba_loop = test_numba(df.close.to_numpy())[1:]

И вот тайминги в DataFrame со 100000 строками (тайминги, выполненные с помощью функции Jupyter %timeit, свернуты в сводную таблицу для удобства чтения):

pandas/vectorized   1,130 micro-seconds
numpy/vectorized      382 micro-seconds
numpy/looped       72,800 micro-seconds
numba/looped          455 micro-seconds

Резюме: для простых случаев, подобных этому, вы бы использовали (векторизованные) панды для простоты и удобочитаемости и (векторизованные) numpy для скорости. Если вам действительно нужно использовать цикл, сделайте это в numpy. Если доступно numba, объедините его с numpy для дополнительной скорости. В этом случае numpy + numba почти так же быстро, как векторизованный код numpy.

Другие детали:

• Не показаны различные параметры, такие как iterrows, iteruples и т. Д., Которые работают на несколько порядков медленнее и действительно никогда не должны использоваться.
• Тайминги здесь довольно типичны: numpy быстрее, чем pandas, а векторизация быстрее, чем циклы, но добавление numba к numpy часто значительно ускоряет numpy.
• Все, кроме опции pandas, требует преобразования столбца DataFrame в массив numpy. Это преобразование включено в тайминги.
• Время для определения / компиляции функций numpy / numba не было включено в тайминги, но, как правило, было бы незначительным компонентом времени для любого большого фрейма данных.