Sto iniziando dai documenti Panda DataFrame qui: http://pandas.pydata.org/pandas-docs/stable/dsintro.html

Vorrei riempire iterativamente il DataFrame con i valori in un tipo di calcolo di serie temporali. Quindi, fondamentalmente, vorrei inizializzare DataFrame con le colonne A, B e le righe timestamp, tutte 0 o tutte NaN.

Quindi aggiungerei i valori iniziali e ripasserei questi dati calcolando la nuova riga dalla riga precedente, diciamo row[A][t] = row[A][t-1]+1o giù di lì.

Attualmente sto usando il codice come di seguito, ma penso che sia un po 'brutto e ci deve essere un modo per farlo direttamente con un DataFrame, o semplicemente un modo migliore in generale. Nota: sto usando 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

Ecco un paio di suggerimenti:

Utilizzare date_rangeper l'indice:

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']

Nota: potremmo creare un DataFrame vuoto (con NaN) semplicemente scrivendo:

df_ = pd.DataFrame(index=index, columns=columns)
df_ = df_.fillna(0) # with 0s rather than NaNs

Per eseguire questo tipo di calcoli per i dati, utilizzare una matrice numpy:

data = np.array([np.arange(10)]*3).T

Quindi possiamo creare il 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

Se vuoi semplicemente creare un frame di dati vuoto e riempirlo con alcuni frame di dati in arrivo in un secondo momento, prova questo:

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 

In questo esempio sto usando questo panda doc per creare un nuovo frame di dati e quindi usando append per scrivere nel newDF con i dati di oldDF.

Se devo continuare ad aggiungere nuovi dati a questo nuovo DF da più di un vecchio DF, uso semplicemente un ciclo for per scorrere su pandas.DataFrame.append ()

The Right Way ™ per creare un DataFrame

TLDR; (basta leggere il testo in grassetto)

La maggior parte delle risposte qui ti dirà come creare un DataFrame vuoto e compilarlo, ma nessuno ti dirà che è una brutta cosa da fare.

Ecco il mio consiglio: attendi fino a quando non sei sicuro di avere tutti i dati di cui hai bisogno per lavorare. Utilizzare un elenco per raccogliere i dati, quindi inizializzare un DataFrame quando si è pronti.

data = []
for a, b, c in some_function_that_yields_data():
    data.append([a, b, c])

df = pd.DataFrame(data, columns=['A', 'B', 'C'])

È sempre più economico aggiungere a un elenco e creare un DataFrame in una volta, piuttosto che creare un DataFrame vuoto (o uno dei NaN) e aggiungerlo più e più volte. Gli elenchi occupano anche meno memoria e sono una struttura di dati molto più leggera con cui lavorare , aggiungere e rimuovere (se necessario).

L'altro vantaggio di questo metodo è dtypesautomaticamente dedotto (piuttosto che assegnarlo objecta tutti).

L'ultimo vantaggio è che a RangeIndexviene creato automaticamente per i tuoi dati , quindi è una cosa in meno di cui preoccuparsi (dai un'occhiata ai metodi poveri appende di locseguito, vedrai elementi in entrambi che richiedono una gestione appropriata dell'indice).

Cose che NON dovresti fare

appendo concatall'interno di un ciclo

Ecco l'errore più grande che ho visto dai principianti:

df = pd.DataFrame(columns=['A', 'B', 'C'])
for a, b, c in some_function_that_yields_data():
    df = df.append({'A': i, 'B': b, 'C': c}, ignore_index=True) # yuck
    # or similarly,
    # df = pd.concat([df, pd.Series({'A': i, 'B': b, 'C': c})], ignore_index=True)

La memoria viene ri-assegnato per ogni appendo concatoperazioni che avete. Abbina questo ad un loop e avrai un'operazione di complessità quadratica . Dalla df.appendpagina del documento :

L'aggiunta facoltativa di righe a un DataFrame può essere più intensiva dal punto di vista computazionale rispetto a un singolo concatenato. Una soluzione migliore è aggiungere quelle righe a un elenco e quindi concatenare l'elenco con il DataFrame originale tutto in una volta.

L'altro errore associato df.appendè che gli utenti tendono a dimenticare che append non è una funzione sul posto , quindi il risultato deve essere assegnato nuovamente. Devi anche preoccuparti dei tipi:

df = pd.DataFrame(columns=['A', 'B', 'C'])
df = df.append({'A': 1, 'B': 12.3, 'C': 'xyz'}, ignore_index=True)

df.dtypes
A     object   # yuck!
B    float64
C     object
dtype: object

Trattare con le colonne di oggetti non è mai una buona cosa, perché i panda non possono vettorializzare le operazioni su quelle colonne. Dovrai farlo per risolverlo:

df.infer_objects().dtypes
A      int64
B    float64
C     object
dtype: object

loc all'interno di un ciclo

Ho anche visto locusato per aggiungere a un DataFrame che è stato creato vuoto:

df = pd.DataFrame(columns=['A', 'B', 'C'])
for a, b, c in some_function_that_yields_data():
    df.loc[len(df)] = [a, b, c]

Come in precedenza, non è stata pre-allocata la quantità di memoria necessaria ogni volta, quindi la memoria viene ricresciuta ogni volta che si crea una nuova riga . È altrettanto brutto appende persino più brutto.

DataFrame vuoto di NaNs

E poi, sta creando un DataFrame di NaN e tutte le avvertenze ad esso associate.

df = pd.DataFrame(columns=['A', 'B', 'C'], index=range(5))
df
     A    B    C
0  NaN  NaN  NaN
1  NaN  NaN  NaN
2  NaN  NaN  NaN
3  NaN  NaN  NaN
4  NaN  NaN  NaN

Crea un DataFrame di colonne di oggetti, come gli altri.

df.dtypes
A    object  # you DON'T want this
B    object
C    object
dtype: object

L'aggiunta ha ancora tutti i problemi come i metodi sopra.

for i, (a, b, c) in enumerate(some_function_that_yields_data()):
    df.iloc[i] = [a, b, c]

La prova è nel budino

Il tempismo di questi metodi è il modo più veloce per vedere quanto differiscono in termini di memoria e utilità.

Codice di riferimento per riferimento.

Inizializza frame vuoto con nomi di colonna

import pandas as pd

col_names =  ['A', 'B', 'C']
my_df  = pd.DataFrame(columns = col_names)
my_df

Aggiungi un nuovo record a un frame

my_df.loc[len(my_df)] = [2, 4, 5]

Potresti anche voler passare un dizionario:

my_dic = {'A':2, 'B':4, 'C':5}
my_df.loc[len(my_df)] = my_dic 

Aggiungi un altro frame al tuo frame esistente

col_names =  ['A', 'B', 'C']
my_df2  = pd.DataFrame(columns = col_names)
my_df = my_df.append(my_df2)

Considerazioni sulle prestazioni

Se si aggiungono righe all'interno di un ciclo, considerare i problemi di prestazioni. Per circa i primi 1000 record le prestazioni di "my_df.loc" sono migliori, ma gradualmente diventano più lente aumentando il numero di record nel ciclo.

Se hai intenzione di fare le cose all'interno di un grande loop (diciamo circa 10 milioni di record), stai meglio usando una combinazione di questi due; riempire un frame di dati con iloc fino a quando la dimensione non raggiunge circa 1000, quindi aggiungerlo al frame di dati originale e svuotare il frame di dati temporaneo. Ciò aumenterebbe le prestazioni di circa 10 volte.

Assumi un frame di dati con 19 righe

index=range(0,19)
index

columns=['A']
test = pd.DataFrame(index=index, columns=columns)

Mantenere la colonna A come costante

test['A']=10

Mantenere la colonna b come variabile data da un ciclo

for x in range(0,19):
    test.loc[[x], 'b'] = pd.Series([x], index = [x])

È possibile sostituire il primo x in pd.Series([x], index = [x])con qualsiasi valore