Jeg tager udgangspunkt i pandas DataFrame-dokumentationen her: http://pandas.pydata.org/pandas-docs/stable/dsintro.html
Jeg vil gerne iterativt fylde DataFrame med værdier i en tidsserie-agtig beregning. Så dybest set, I'd gerne initialisere DataFrame med kolonner A, B og tidsstempel rækker, alle 0 eller alle NaN.
I'd derefter tilføje indledende værdier og gå over disse data beregne den nye række fra rækken før, siger row[A][t][t] = row[A][t-1]+1
eller så.
I'm i øjeblikket bruger koden som nedenfor, men jeg føler det's lidt grimt, og der må være en måde at gøre dette med en DataFrame direkte, eller bare en bedre måde generelt. Bemærk: I'm bruger Python 2.7.
import datetime as dt
import pandas as pd
import scipy as s
if __name__ == '__main__':
base = dt.datetime.today().date()
dates = [ base - dt.timedelta(days=x) for x in range(0,10) ]
dates.sort()
valdict = {}
symbols = ['A','B', 'C']
for symb in symbols:
valdict[symb] = pd.Series( s.zeros( len(dates)), dates )
for thedate in dates:
if thedate > dates[0]:
for symb in valdict:
valdict[symb][thedate] = 1+valdict[symb][thedate - dt.timedelta(days=1)]
print valdict
Her er et par forslag:
Brug date_range
til indekset:
import datetime
import pandas as pd
import numpy as np
todays_date = datetime.datetime.now().date()
index = pd.date_range(todays_date-datetime.timedelta(10), periods=10, freq='D')
columns = ['A','B', 'C']
Bemærk: vi kan oprette et tomt DataFrame (med NaN
s) ved at skrive:
df_ = pd.DataFrame(index=index, columns=columns)
df_ = df_.fillna(0) # with 0s rather than NaNs
For at lave denne type beregninger for dataene skal du bruge et numpy-array:
data = np.array([np.arange(10)]*3).T
Derfor kan vi oprette DataFrame:
In [10]: df = pd.DataFrame(data, index=index, columns=columns)
In [11]: df
Out[11]:
A B C
2012-11-29 0 0 0
2012-11-30 1 1 1
2012-12-01 2 2 2
2012-12-02 3 3 3
2012-12-03 4 4 4
2012-12-04 5 5 5
2012-12-05 6 6 6
2012-12-06 7 7 7
2012-12-07 8 8 8
2012-12-08 9 9 9
I Hvis du blot ønsker at oprette en tom dataramme og senere udfylde den med nogle indgående datarammer, kan du prøve følgende:
I dette eksempel bruger jeg this pandas doc til at oprette en ny dataramme og derefter append til at skrive til den nyeDF med data fra oldDF.
Se på dette
newDF = pd.DataFrame() #creates a new dataframe that's empty
newDF = newDF.append(oldDF, ignore_index = True) # ignoring index is optional
# try printing some data from newDF
print newDF.head() #again optional
I Hvis du ønsker at have kolonnenavnene på plads fra starten, skal du bruge denne fremgangsmåde:
import pandas as pd
col_names = ['A', 'B', 'C']
my_df = pd.DataFrame(columns = col_names)
my_df
I Hvis du ønsker at tilføje en post til datarammen, er det bedre at bruge:
my_df.loc[len(my_df)] = [2, 4, 5]
Du vil måske også gerne overdrage en ordbog:
my_dic = {'A':2, 'B':4, 'C':5}
my_df.loc[len(my_df)] = my_dic
Hvis du ønsker at tilføje et andet dataframe til my_df, skal du gøre som følger:
col_names = ['A', 'B', 'C']
my_df2 = pd.DataFrame(columns = col_names)
my_df = my_df.append(my_df2)
I Hvis du tilføjer rækker inden for en løkke, skal du tage hensyn til ydelsesproblemer:
For omkring de første 1000 poster "my_df.loc" er ydelsen bedre, men den bliver gradvist langsommere ved at øge antallet af poster i sløjfen.
I Hvis du har planer om at udføre thins i en stor løkke (f.eks. 10 mio. poster eller deromkring):
Det er bedre at bruge en blanding af disse to;
fyld et dataramme med iloc, indtil størrelsen kommer op på ca. 1000, og tilføj det derefter til det oprindelige dataramme, og tøm det midlertidige dataramme.
Dette ville øge din ydeevne med omkring 10 gange.