Tôi đang bắt đầu từ các tài liệu DataFrame của gấu trúc ở đây: http://pandas.pydata.org/pandas-docs/urdy/dsintro.html

Tôi muốn lặp lại điền vào DataFrame bằng các giá trị trong loại tính toán theo chuỗi thời gian. Về cơ bản, tôi muốn khởi tạo DataFrame với các cột A, B và các dấu thời gian, tất cả 0 hoặc tất cả NaN.

Sau đó, tôi sẽ thêm các giá trị ban đầu và chuyển qua dữ liệu này để tính toán hàng mới từ hàng trước đó, giả sử row[A][t] = row[A][t-1]+1như vậy.

Tôi hiện đang sử dụng mã như dưới đây, nhưng tôi cảm thấy nó thật xấu xí và phải có cách trực tiếp để làm điều này với DataFrame hoặc nói chung là một cách tốt hơn. Lưu ý: Tôi đang sử dụng 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

Dưới đây là một vài gợi ý:

Sử dụng date_rangecho chỉ mục:

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

Lưu ý: chúng tôi có thể tạo một DataFrame trống (có NaNs) chỉ bằng cách viết:

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

Để thực hiện các loại tính toán này cho dữ liệu, hãy sử dụng một mảng gọn gàng:

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

Do đó, chúng ta có thể tạo 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

Nếu bạn chỉ muốn tạo một khung dữ liệu trống và lấp đầy nó với một số khung dữ liệu đến sau, hãy thử điều này:

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 

Trong ví dụ này, tôi đang sử dụng tài liệu gấu trúc này để tạo khung dữ liệu mới và sau đó sử dụng chắp thêm để ghi vào newDF với dữ liệu từ oldDF.

Nếu tôi phải tiếp tục nối thêm dữ liệu mới vào newDF này từ nhiều hơn một oldDF, tôi chỉ sử dụng một vòng lặp for để lặp lại trên pandas.DataFrame.append ()

Đúng cách ™ để tạo một DataFrame

TLDR; (chỉ cần đọc văn bản in đậm)

Hầu hết các câu trả lời ở đây sẽ cho bạn biết cách tạo một DataFrame trống và điền nó, nhưng không ai sẽ nói với bạn rằng đó là một việc xấu phải làm.

Đây là lời khuyên của tôi: Đợi cho đến khi bạn chắc chắn rằng bạn có tất cả dữ liệu bạn cần để làm việc. Sử dụng danh sách để thu thập dữ liệu của bạn, sau đó khởi tạo DataFrame khi bạn sẵn sàng.

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

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

Việc thêm vào danh sách và tạo DataFrame trong một lần luôn rẻ hơn so với việc tạo một DataFrame trống (hoặc một trong các NaN) và nối lại nó nhiều lần. Danh sách cũng chiếm ít bộ nhớ hơn và là một cấu trúc dữ liệu nhẹ hơn nhiều để làm việc với , chắp thêm và xóa (nếu cần).

Ưu điểm khác của phương pháp này dtypeslà tự động được suy ra (thay vì gánobject cho tất cả chúng).

Ưu điểm cuối cùng là a RangeIndexđược tạo tự động cho dữ liệu của bạn , do đó, một điều ít phải lo lắng hơn (hãy xem người nghèo appendvà locphương pháp bên dưới, bạn sẽ thấy các yếu tố trong cả hai yêu cầu xử lý chỉ mục một cách thích hợp).

Những điều bạn KHÔNG nên làm

appendhoặc concatbên trong một vòng lặp

Đây là sai lầm lớn nhất tôi từng thấy từ những người mới bắt đầu:

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)

Bộ nhớ được phân bổ lại cho mọi appendhoặc concathoạt động bạn có. Kết hợp điều này với một vòng lặp và bạn có một hoạt động phức tạp bậc hai . Từ df.appendtrang tài liệu :

Lặp đi lặp lại các hàng vào DataFrame có thể được tính toán chuyên sâu hơn so với một liên kết đơn. Một giải pháp tốt hơn là nối các hàng đó vào một danh sách và sau đó nối danh sách với DataFrame gốc cùng một lúc.

Một lỗi khác liên quan đến df.appendlà người dùng có xu hướng quên append không phải là một chức năng tại chỗ , do đó, kết quả phải được gán lại. Bạn cũng phải lo lắng về các 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

Đối phó với các cột đối tượng không bao giờ là một điều tốt, bởi vì gấu trúc không thể vector hóa các hoạt động trên các cột đó. Bạn sẽ cần phải làm điều này để sửa nó:

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

loc bên trong một vòng lặp

Tôi cũng đã thấy locđược sử dụng để chắp thêm vào DataFrame được tạo trống:

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

Như trước đây, bạn chưa phân bổ trước số lượng bộ nhớ bạn cần mỗi lần, vì vậy bộ nhớ được tăng trưởng lại mỗi khi bạn tạo một hàng mới . Nó cũng tệ nhưappend , và thậm chí còn xấu xí hơn.

Khung dữ liệu trống của NaN

Và sau đó, sẽ tạo ra một DataFrame của NaN và tất cả các cảnh báo liên quan.

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

Nó tạo ra một DataFrame của các cột đối tượng, giống như các cột khác.

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

Áp dụng vẫn có tất cả các vấn đề như các phương pháp trên.

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

Bằng chứng là trong pudding

Định thời gian cho các phương thức này là cách nhanh nhất để xem chúng khác nhau bao nhiêu về bộ nhớ và tiện ích của chúng.

Mã điểm chuẩn để tham khảo.

Khởi tạo khung trống với tên cột

import pandas as pd

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

Thêm bản ghi mới vào khung

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

Bạn cũng có thể muốn vượt qua một từ điển:

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

Nối một khung khác vào khung hiện tại của bạn

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

Cân nhắc hiệu suất

Nếu bạn đang thêm các hàng bên trong một vòng lặp, hãy xem xét các vấn đề về hiệu suất. Đối với khoảng 1000 bản ghi đầu tiên, hiệu suất "my_df.loc" tốt hơn, nhưng nó dần trở nên chậm hơn bằng cách tăng số lượng bản ghi trong vòng lặp.

Nếu bạn có kế hoạch thực hiện các hoạt động bên trong một vòng lặp lớn (giả sử các bản ghi 10M‌ hoặc hơn), tốt hơn hết là bạn nên sử dụng hỗn hợp cả hai; điền vào một khung dữ liệu với iloc cho đến khi kích thước đạt khoảng 1000, sau đó nối nó vào khung dữ liệu ban đầu và làm trống khung dữ liệu tạm thời. Điều này sẽ tăng hiệu suất của bạn khoảng 10 lần.

Giả sử một khung dữ liệu với 19 hàng

index=range(0,19)
index

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

Giữ cột A là hằng số

test['A']=10

Giữ cột b là một biến được cho bởi một vòng lặp

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

Bạn có thể thay thế x đầu tiên pd.Series([x], index = [x])bằng bất kỳ giá trị nào