Zaczynam od dokumentów DataFrame pand tutaj: http://pandas.pydata.org/pandas-docs/stable/dsintro.html

Chciałbym iteracyjnie wypełnić DataFrame wartościami w rodzaju obliczeń szeregów czasowych. Zasadniczo chciałbym zainicjować ramkę danych z kolumnami A, B i wierszami znaczników czasu, wszystkie 0 lub wszystkie NaN.

Następnie dodałbym wartości początkowe i przejrzałem te dane, obliczając nowy wiersz z rzędu przed, powiedzmy row[A][t] = row[A][t-1]+1lub tak.

Obecnie używam kodu jak poniżej, ale czuję, że jest to trochę brzydkie i musi istnieć sposób, aby to zrobić bezpośrednio z DataFrame, lub po prostu lepszy sposób w ogóle. Uwaga: używam 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

Oto kilka sugestii:

Użyj date_rangedla indeksu:

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

Uwaga: możemy utworzyć pustą ramkę danych (z NaNs), pisząc:

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

Aby wykonać tego typu obliczenia dla danych, użyj tablicy numpy:

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

Dlatego możemy stworzyć 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

Jeśli chcesz po prostu utworzyć pustą ramkę danych i wypełnić ją później niektórymi ramkami danych przychodzących, spróbuj tego:

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 

W tym przykładzie używam tego dokumentu pandy do utworzenia nowej ramki danych, a następnie używam append do zapisu do newDF z danymi ze staregoDF.

Jeśli muszę dodawać nowe dane do tego nowego pliku z więcej niż jednego starego pliku, po prostu używam pętli for, aby iterować po pandas.DataFrame.append ()

Właściwy sposób ™ do utworzenia DataFrame

TLDR; (po prostu przeczytaj pogrubiony tekst)

Większość odpowiedzi tutaj powie ci, jak utworzyć pustą ramkę danych i wypełnić ją, ale nikt nie powie ci, że to źle.

Oto moja rada: poczekaj, aż będziesz mieć pewność, że masz wszystkie dane, z którymi musisz pracować. Użyj listy, aby zebrać swoje dane, a następnie zainicjuj ramkę DataFrame, gdy będziesz gotowy.

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

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

To jest zawsze tańsze, aby dołączyć do listy i utworzyć DataFrame za jednym razem , niż jest, aby utworzyć pusty DataFrame (lub jedną z Nans) i dołączyć do niej w kółko. Listy zajmują również mniej pamięci i są znacznie lżejszą strukturą danych do pracy , dołączania i usuwania (w razie potrzeby).

Inną zaletą tej metody jest dtypesautomatyczne wnioskowanie (zamiast przypisywania objectich wszystkim).

Ostatnią zaletą jest to, że jest tworzony automatycznie dla swoich danych , więc jest to jeden mniej rzeczy się martwić (spójrz na biednych i metodach poniżej, widać zarówno elementy, które wymagają obsługi indeksu odpowiednio).RangeIndexappendloc

Rzeczy, których NIE powinieneś robić

appendlub concatwewnątrz pętli

Oto największy błąd, jaki widziałem od początkujących:

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)

Pamięć jest przydzielana ponownie dla każdej operacji appendlub concatoperacji. Połącz to z pętlą, a otrzymasz kwadratową operację złożoności . Ze strony df.appenddokumentu :

Iteracyjne dołączanie wierszy do DataFrame może być bardziej wymagające obliczeniowo niż pojedynczy konkatenat. Lepszym rozwiązaniem jest dodanie tych wierszy do listy, a następnie połączenie listy z oryginalną ramką DataFrame jednocześnie.

Innym błędem związanym z df.appendtym jest to, że użytkownicy często zapominają, że append nie jest funkcją lokalną , więc wynik należy przypisać z powrotem. Musisz także martwić się o typy:

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

Radzenie sobie z kolumnami obiektów nigdy nie jest dobrą rzeczą, ponieważ pandy nie mogą wektoryzować operacji na tych kolumnach. Musisz to zrobić, aby to naprawić:

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

loc wewnątrz pętli

Widziałem również locużywane do dołączania do DataFrame, który został utworzony pusty:

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

Tak jak poprzednio, nie przydzielono wstępnie wymaganej ilości pamięci za każdym razem, więc pamięć jest odnawiana za każdym razem, gdy tworzysz nowy wiersz . Jest tak samo zły, jak appendi jeszcze bardziej brzydki.

Pusta ramka danych dla NaNs

Następnie powstaje ramka danych NaNs i wszystkie związane z tym zastrzeżenia.

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

Tworzy ramkę danych kolumn obiektowych, podobnie jak inne.

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

Dołączanie nadal ma wszystkie problemy, jak powyższe metody.

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

Dowód jest w budyniu

Pomiar tych metod jest najszybszym sposobem, aby zobaczyć, jak bardzo różnią się one pod względem pamięci i użyteczności.

Kod porównawczy w celach informacyjnych.

Zainicjuj pustą ramkę za pomocą nazw kolumn

import pandas as pd

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

Dodaj nowy rekord do ramki

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

Możesz także przekazać słownik:

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

Dołącz kolejną ramkę do istniejącej ramki

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

Uwagi dotyczące wydajności

Jeśli dodajesz wiersze wewnątrz pętli, rozważ problemy z wydajnością. W przypadku około 1000 pierwszych rekordów wydajność „my_df.loc” jest lepsza, ale stopniowo staje się wolniejsza przez zwiększenie liczby rekordów w pętli.

Jeśli planujesz robić cienkie elementy w dużej pętli (powiedzmy, że około 10M‌ rekordów), lepiej jest użyć kombinacji tych dwóch; wypełnij ramkę danych iloc, aż rozmiar osiągnie około 1000, następnie dołącz ją do oryginalnej ramki danych i opróżnij tymczasową ramkę danych. Zwiększy to twoją wydajność około 10 razy.

Załóżmy ramkę danych z 19 wierszami

index=range(0,19)
index

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

Utrzymywanie kolumny A jako stałej

test['A']=10

Zachowanie kolumny b jako zmiennej podanej przez pętlę

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

Możesz zamienić pierwsze x na pd.Series([x], index = [x])dowolną wartość