Как быстро пройтись по всем строкам в Python Pandas?

Question

[AlexShilov]

Доброго времени суток, друзья. У меня есть более 3 млн. строк в ДатаФрэйме. Мне необходимо взять первого клиента, посмотреть все его операции за каждый месяц, занести все эти операции в другой ДатаФрэйм, добавив некоторые данные на основе операций. И затем так пройтись по всем клиентам. 3 млн. строк - это все операции, всех клиентов.

Как реализовал это я

Я формирую ДатаФрэйм по одному клиента и через itertuples пробегаю по всем его операциям. Затем удаляю все, что связано с этим клиентом из ДатаФрэйма, беру другого и все по накатанной. Но этот алгоритм очень медленный. Может подскажите что можно сделать, чтобы обработать таким образом данные значительно быстрее.

Заранее благодарю!

Comments

[zexer]

Будет отлично, если вы продемонстрируете, какие манипуляции вы производите, чтобы понимать, как это можно оптимизировать.
Приведите в миниатюре то, что вы делаете, пожалуйста.

[AlexShilov]

zexer, спасибо за отклик.

1. Смотрю остаток баллов по бонусной карте. Вычитаю из предыдущего значения потраченное кол-во.
   
2. Через функцию смотрю, как часто клиент посещает магазин. Смотрю сколько раз посетил и присваиваю ему определенную категорию. Допустим, если < 5 раз / мес., то категория 1 и т.д.
   
3. Записываю данные в Фрэйм следующим образом: Клиент | Пред. категория | Новая категория | Количество баллов осталось | Количество баллов было
   
   
4. Записываю второй Фрэйм следующим образом: Клиент | Пред. категория | Новая категория | Количество баллов потратилось| Количество баллов было
   
   

[zexer]

AlexShilov, я имел ввиду привести код, чтобы было понятно.

[AlexShilov]

zexer, точнее 3, 4 пункт записываю строки с помощью concat все в один Фрэйм, но они отличаются по предпоследнему значению.

[Влад Григорьев]

AlexShilov, это по прежнему не похоже на код

[AlexShilov]

zexer, Влад Григорьев,

def tenor(ltt):
    if ltt <= 24*30: return 24
    elif ltt <= 36*30: return 36
    else: return 60

def buckclass(odues):
    # Определение класса
    if odues == 0: return 0
    elif 0 < odues <= 30: return 1
    elif 30 < odues <= 60: return 2
    elif 60 < odues <= 90: return 3
    elif 90 < odues <= 120: return 4
    else: return 5

datareport = pd.DataFrame({'ODATE': {0:0},
                           'TENOR': {0:0},
                           'VDATE': {0:0},
                           'R': {0:0},
                           'RC': {0:0},
                           'DE': {0:0},
                           'I': {0:0},
                           'DEB': {0:0},
                           'D': {0:0}})
for nc in data.nc.unique():
    # Просматриваем каждый ID

    fordata = data[data.nc == nc].sort_values(by='vdate')

    onrow = fordata.iloc[0,:]
    for row in fordata.itertuples(index=False):
        if (onrow.odate == row.odate) & (onrow.vdate == row.vdate) & (onrow.ball == row.ball):
            ball_old = onrow.ball
            bucket_class_old = 0

        difference = ball_old - row.ball

        datareport = pd.concat([datareport, pd.DataFrame({'ODATE': {0:row.odate},
                                                          'TENOR': {0:tenor(row.ltt)},
                                                          'VDATE': {0:row.vdate},
                                                          'R': {0:bucket_class_old},
                                                          'RC': {0:buckclass(row.odues)},
                                                          'DE': {0:row.ball},
                                                          'I': {0:0},
                                                          'DEB': {0:ball_old},
                                                          'D': {0:0}})])

        datareport = pd.concat([datareport, pd.DataFrame({'ODATE': {0:row.odate},
                                                          'TENOR': {0:tenor(row.ltt)},
                                                          'VDATE': {0:row.vdate},
                                                          'R': {0:bucket_class_old},
                                                          'RC': {0:100},
                                                          'DE': {0:difference},
                                                          'I': {0:0},
                                                          'DEB': {0:ball_old},
                                                          'D': {0:0}})])

        ball_old = row.ball
        bucket_class_old = buckclass(row.odues)

[AlexShilov]

Влад Григорьев, спасибо за отклик. Выше привел фрагмент кода.

[AlexShilov]

zexer, выше привел пример кода.

[AlexShilov]

Влад Григорьев, это по прежнему не похоже на ответ.

[AlexShilov]

zexer, теперь понятно?

[zexer]

AlexShilov, единственное, что понятно, так это то, что вместо например data.nc нужно писать data['nc'], это правило хорошего тона, так как когда вы пишете data.nc не понятно, nc это столбец или nc это какой-то метод у датафрейма.

[AlexShilov]

zexer, спасибо за ценный совет, в будущем учту.

Answer 1

[zexer]

Судя по всему здесь вы создаете однострочный датафрейм, однако можно создать обычную серию (pd.Series)

datareport = pd.DataFrame({'ODATE': {0:0},
                           'TENOR': {0:0},
                           'VDATE': {0:0},
                           'R': {0:0},
                           'RC': {0:0},
                           'DE': {0:0},
                           'I': {0:0},
                           'DEB': {0:0},
                           'D': {0:0}}

Далее вы этот однострочный датафрейм через pd.concat присоединяете к еще одному однострочному датафрейму:

datareport = pd.concat([datareport, pd.DataFrame({'ODATE': {0:row.odate},
                                                          'TENOR': {0:tenor(row.ltt)},
                                                          'VDATE': {0:row.vdate},
                                                          'R': {0:bucket_class_old},
                                                          'RC': {0:buckclass(row.odues)},
                                                          'DE': {0:row.ball},
                                                          'I': {0:0},
                                                          'DEB': {0:ball_old},
                                                          'D': {0:0}})])

а после этого еще раз к одному однострочному датафрейму

datareport = pd.concat([datareport, pd.DataFrame({'ODATE': {0:row.odate},
                                                          'TENOR': {0:tenor(row.ltt)},
                                                          'VDATE': {0:row.vdate},
                                                          'R': {0:bucket_class_old},
                                                          'RC': {0:100},
                                                          'DE': {0:difference},
                                                          'I': {0:0},
                                                          'DEB': {0:ball_old},
                                                          'D': {0:0}})])

Вместо них тоже можно использовать pd.Series.
Данный код отрабатывает в среднем за 2.5 миллисикунды

ser1 = pd.Series({'ODATE': 0,
           'TENOR': 0,
           'VDATE':0,
           'R': 0,
           'RC': 0,
           'DE': 0,
           'I': 0,
           'DEB': 0,
           'D': 0})
ser2 = pd.Series({'ODATE': 0,
           'TENOR': 1,
           'VDATE':2,
           'R': 3,
           'RC': 4,
           'DE': 5,
           'I': 6,
           'DEB': 7,
           'D': 8})
df = pd.concat([ser1, ser2], axis=1).T

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

datareport1 = pd.DataFrame({'ODATE': {0:0},
                           'TENOR': {0:0},
                           'VDATE': {0:0},
                           'R': {0:0},
                           'RC': {0:0},
                           'DE': {0:0},
                           'I': {0:0},
                           'DEB': {0:0},
                           'D': {0:0}})
datareport2 = pd.DataFrame({'ODATE': {0:1},
                           'TENOR': {0:2},
                           'VDATE': {0:3},
                           'R': {0:4},
                           'RC': {0:5},
                           'DE': {0:6},
                           'I': {0:7},
                           'DEB': {0:8},
                           'D': {0:9}})
df2 = pd.concat([datareport1, datareport2])

Так что можете попробовать выиграть в скорости, перебравшись с однострочных датафреймов на серии.

Comments

[AlexShilov]

Спасибо.

[zexer]

AlexShilov, а еще быстрее будет через массивы numpy, данный код выполняется за 385 микросекунд.

array1 = np.array([[0,0,0,0,0,0,0,0,0]])
array2 = np.array([[0,1,2,3,4,5,6,7,8]])
columns=['ODATE', 'TENOR', 'VDATE', 'R', 'RC', 'DE', 'I', 'DEB', 'D']
df = pd.DataFrame(np.append(array1, array2, axis=0), columns=columns)

[AlexShilov]

zexer, спасибо.

[zexer]

AlexShilov, Получилось выиграть в скорости? Интересно даже наблюдать за ситуацией)

Answer 2

[Viktor T2]

Можно попробовать обычную базу данных,
но данные запихнуть в оперативную память.
Проиндексировать по клиенту.
Гуглить "sqlite in memory"

Comments

[AlexShilov]

Благодарю, обязательно посмотрю

Answer 3

[AlexShilov]

Единственная на текущий момент оптимизация, которая мне пришла на ум, это убрать операцию конкатенации и вместо ее создать массив типа:

array_data = []

'''
    Тут находиться код программы
'''

array_data.append([row['odate'], tenor(row(ltt)), row['vdate'], bucket_class_old, buckclass(row['odues']), row['ball'], 0, ball_old, 0])
array_data.append([row['odate'], tenor(row(ltt)), row['vdate'], bucket_class_old, 100, difference, 0, ball_old, 0])

'''
    Тут остальной код программы
'''

pandas.DataFrame(array_data)