I'm mulai dari panda DataFrame dokumen berikut: http://pandas.pydata.org/pandas-docs/stable/dsintro.html
I'd ingin iteratif mengisi DataFrame dengan nilai-nilai dalam time series jenis perhitungan. Jadi pada dasarnya, saya'd seperti untuk menginisialisasi DataFrame dengan kolom A, B dan timestamp baris, semua 0 atau semua NaN.
I'a kemudian menambahkan nilai awal dan pergi dari data ini menghitung baris baru dari baris sebelumnya, mengatakan row[A][t] = row[A][t-1]+1
atau jadi.
I'm saat ini dengan menggunakan kode seperti di bawah ini, tapi saya merasa itu's agak jelek dan harus ada cara untuk melakukan hal ini dengan DataFrame secara langsung, atau hanya cara yang lebih baik secara umum. Catatan: saya'm menggunakan 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
Berikut ini's beberapa saran:
Gunakan date_range
untuk indeks:
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']
Catatan: kita bisa membuat kosong DataFrame (dengan `NaN) cukup dengan menulis:
df_ = pd.DataFrame(index=index, columns=columns)
df_ = df_.fillna(0) # with 0s rather than NaNs
Untuk melakukan ini jenis perhitungan untuk data, menggunakan numpy array:
data = np.array([np.arange(10)]*3).T
Oleh karena itu kita dapat membuat 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
Jika anda hanya ingin membuat sebuah data kosong frame dan mengisinya dengan beberapa data yang masuk frame kemudian, coba ini:
Dalam contoh ini saya menggunakan ini panda doc untuk membuat data baru frame dan kemudian menggunakan menambahkan untuk menulis ke newDF dengan data dari oldDF.
Ini
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
Jika anda ingin memiliki nama kolom di tempat dari awal, menggunakan pendekatan ini:
import pandas as pd
col_names = ['A', 'B', 'C']
my_df = pd.DataFrame(columns = col_names)
my_df
Jika anda ingin menambahkan catatan ke dataframe itu akan lebih baik untuk menggunakan:
my_df.loc[len(my_df)] = [2, 4, 5]
Anda juga mungkin ingin lulus kamus:
my_dic = {'A':2, 'B':4, 'C':5}
my_df.loc[len(my_df)] = my_dic
Namun jika anda ingin menambah dataframe untuk my_df dilakukan sebagai berikut:
col_names = ['A', 'B', 'C']
my_df2 = pd.DataFrame(columns = col_names)
my_df = my_df.append(my_df2)
Jika anda menambahkan baris dalam lingkaran mempertimbangkan masalah kinerja:
Untuk pertama 1000 catatan "my_df.loc" kinerja lebih baik, tetapi secara bertahap menjadi lebih lambat dengan meningkatkan jumlah record dalam lingkaran.
Jika anda berencana untuk melakukan menipis di dalam sebuah lingkaran besar (katakanlah 10M catatan atau lebih):
Anda lebih baik menggunakan campuran dari dua;
mengisi dataframe dengan iloc sampai mendapat ukuran sekitar 1000, kemudian menambahkan asli dataframe, dan kosong temp dataframe.
Hal ini akan meningkatkan kinerja anda oleh sekitar 10 kali.
TLDR; (hanya membaca teks yang dicetak tebal)
Kebanyakan jawaban berikut akan memberitahu anda bagaimana untuk membuat kosong DataFrame dan mengisinya, tapi tidak ada yang akan memberitahu anda bahwa itu adalah hal yang buruk untuk dilakukan.
Berikut adalah saran saya: Tunggu sampai anda yakin anda memiliki semua data yang anda butuhkan untuk bekerja dengan. Gunakan daftar untuk mengumpulkan data, kemudian menginisialisasi sebuah DataFrame ketika anda siap.
data = []
for a, b, c in some_function_that_yields_data():
data.append([a, b, c])
df = pd.DataFrame(data, columns=['A', 'B', 'C'])
Itu adalah selalu lebih murah untuk menambahkan ke daftar dan membuat DataFrame dalam satu pergi dari itu adalah untuk menciptakan kosong DataFrame (atau salah satu dari NaNs) dan menambahkan untuk itu berulang lagi. Daftar juga mengambil sedikit memori dan jauh lebih ringan struktur data untuk bekerja dengan, menambahkan, dan menghapus (jika diperlukan).
Keuntungan lain dari metode ini adalah dtypes
secara otomatis disimpulkan (bukan menetapkan objek
untuk semua dari mereka).
Keuntungan terakhir adalah bahwa a RangeIndex
secara otomatis dibuat untuk anda data, jadi itu adalah salah satu hal yang kurang perlu khawatir (lihatlah miskin menambahkan
dan loc
metode di bawah ini, anda akan melihat elemen-elemen dalam investasi yang memerlukan penanganan indeks dengan tepat).
menambahkan
atau concat
di dalam loopBerikut ini adalah kesalahan terbesar saya've dilihat dari pemula:
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)
Memori ini kembali dialokasikan untuk setiap menambahkan
atau concat
operasi yang anda miliki. Pasangan ini dengan loop dan anda memiliki kuadrat kompleksitas operasi. Dari df.menambahkan
doc halaman:
Iteratif menambahkan baris ke DataFrame dapat lebih komputasi intensif dari satu concatenate. Solusi yang lebih baik adalah untuk menambahkan baris untuk daftar dan kemudian menggabungkan daftar dengan asli DataFrame sekaligus.
<!- ->
Kesalahan lain yang terkait dengan df.menambahkan
adalah bahwa pengguna cenderung lupa append tidak di tempat fungsi, sehingga hasilnya harus ditetapkan kembali. Anda juga perlu khawatir tentang dtypes:
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
Berhadapan dengan obyek kolom ini tidak pernah hal yang baik, karena panda tidak vectorize operasi pada kolom tersebut. Anda akan perlu melakukan hal ini untuk memperbaikinya:
df.infer_objects().dtypes
A int64
B float64
C object
dtype: object
loc
di dalam loopSaya juga telah melihat loc
digunakan untuk menambahkan ke DataFrame yang dibuat kosong:
df = pd.DataFrame(columns=['A', 'B', 'C'])
for a, b, c in some_function_that_yields_data():
df.loc[len(df)] = [a, b, c]
Seperti sebelumnya, anda tidak memiliki pra-dialokasikan jumlah memori yang anda butuhkan setiap waktu, jadi memori ini kembali tumbuh setiap kali anda membuat baris baru. It's hanya sebagai buruk sebagai menambahkan
, dan bahkan lebih jelek.
Dan kemudian, ada's menciptakan DataFrame dari NaNs, dan semua peringatan yang terkait dengan itu.
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
Ini menciptakan DataFrame dari obyek kolom, seperti yang lain.
df.dtypes
A object # you DON'T want this
B object
C object
dtype: object
Menambahkan masih memiliki semua masalah-masalah seperti metode di atas.
for i, (a, b, c) in enumerate(some_function_that_yields_data()):
df.iloc[i] = [a, b, c]
Waktu metode ini adalah cara tercepat untuk melihat seberapa banyak mereka berbeda dalam hal memori mereka dan utilitas.
Menganggap dataframe dengan 19 baris
index=range(0,19)
index
columns=['A']
test = pd.DataFrame(index=index, columns=columns)
Menjaga Kolom A sebagai konstanta
test['A']=10
Menjaga kolom b sebagai variabel yang diberikan oleh loop
for x in range(0,19):
test.loc[[x], 'b'] = pd.Series([x], index = [x])
Anda dapat mengganti pertama x di pd.Seri([x], indeks = [x])
dengan nilai