performance increase in panda in a liquidity analysis

I have a big CSV table with atm 90k records. I use python + panda for data analysis. (sadly to restriction from the programm, I can only use panda v.0.2). Every record has a date, an account number and two columns with a float value.
For the liquidity analysis I need the sum of the two columns to a given date for a specific account number. The given dates are each day in a year.
So I need the sum of the two columns for the 1st Jan, 2nd Jan, 3rd Jan,....,31th Dec for each account.
If I take the 5th July and account number 3000 as an example, I need the sum of both columns of all entrys with account Number = 3000 and date <= 5th July.
I did that with the following code:

analyseRange = pd.date_range(settings.analyseStartDatum, settings.analyseEndDatum)
for datum in analyseRange:
    globals()[str(datum) + "-vbTable"] = pd.DataFrame(columns=["Konto","Kontobezeichnung", "Datum", "Saldo","nicht Fällig", "Fällige VB"])
    for i in range(settings.accountNummernStart ,settings.accountNummernEnde):
            startTimer = time.perf_counter()
            buchungen = df.loc[(df[settings.kontoNrCol] == i) & (df[settings.belegDatumCol] <= datum),[settings.kontoNrCol, settings.belegDatumCol, settings.sollCol, settings.habenCol, settings.faelligkeitsCol, "FaelligBisClean"]]
            verbindlichkeiten = buchungen[settings.habenCol].sum() - buchungen[settings.sollCol].sum()
            
            nichtFaelligeBuchungen = df.loc[(df[settings.kontoNrCol] == konto) & (df[settings.belegDatumCol] <= datum) & (df["FaelligBisClean"] > datum),[settings.sollCol, settings.habenCol]]
            nichtFaelligeVerbindlichkeit =  nichtFaelligeBuchungen[settings.habenCol].sum()

            if(verbindlichkeiten != 0):
                globals()[str(datum) + "-vbTable"].append([i,"tbd.",datum,verbindlichkeiten,nichtFaelligeVerbindlichkeiten,(verbindlichkeiten - nichtFaelligeVerbindlichkeiten)])
                print("append: " +  str(i) + "-tbd.-" + " - "+ str(datum)  + " - "+ str(verbindlichkeiten)  + " - "+ str(nichtFaelligeVerbindlichkeiten) + " - "+ str(verbindlichkeiten - nichtFaelligeVerbindlichkeiten)+ ",time: " + str(time.perf_counter() - startTimer), flush=True)
            else:
                print("Konto is even: " + str(i) + ",time: " + str(time.perf_counter() - startTimer), flush=True)
return ""

The analyseStartDatum is the first of the year, analyseEndDatum is the last day of a year.
accountNummernStart is 10000 and accountNummernEnde is 90000.

I store every calculated day in a seperate dataframe (globals()[str(datum) + "-vbTable"]) to save it later on the drive.

So I have to check for 365 days a total of 90k accounts. Thats a total of 32 million calculations. One calculation is pretty fast, only 0,002s. But since its need to be executed 32 million time, it take around 18h to finish Thats waaay to slow.

Anyone have some suggestions for some performance boost? I am looking mostly for panda based performance boost. I already know a few ways to reduce the amount of records I have to check. So I get a boost there, but maybe someone have some smart panda commands that calculates the stuff faster. This is the first time working with pandas for me, so Im pretty new to this.

My first idea was a "counter" for the sum. Instead of calculating the sum of the complete row each time, I just add the new entrys to the sum. But I have to add some more logic later, that decides if I really have to add the entry and that depends on the entrys before. So I would have to check the "old" entrys anyway. So I don`t see a boost there.

If I understand your problem correctly, you can do something like this:

import pandas as pd
import numpy as np

# Simple example dataframe
df = pd.DataFrame({'date': [1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4], 
    'account': [10, 20, 30, 10, 20, 30, 10, 20, 30, 10, 20, 30], 
    'number1': np.linspace(100, 110, 12), 
    'number2': np.linspace(110, 130, 12)})

# Calculate the of two columns and store it
df['total'] = df['number1'] + df['number2']
# Sort beforehand; in particular on 'date', for the 
# cumulative sum
df.sort_values(['account', 'date'])

for account, group in df.sort_values(['account', 'date']).groupby('account'):
    group['cum-total'] = group.total.cumsum()
    print(account, ":")
    print(group)
    print()

There are probably niftier ways to do this in a one liner, but this should get you a long way, and should be fast.

No multiple dataframes are needed; that can all be done intrinsically to dataframes.

One caveat is that this is for Pandas 1.x and later, so it may need some adapation. For example, .sort_values is probably just .sort in version 0.2.