我从这里的 pandas DataFrame 文档开始: Introduction to data structures

我想用时间序列计算中的值迭代地填充 DataFrame。所以基本上，我想用列 A、B 和时间戳行来初始化 DataFrame，全部为 0 或全部为 NaN。

然后我会添加初始值并检查这些数据，从之前的行计算新行，例如 row[A][t] = row[A][t-1]+1 左右。

我目前正在使用下面的代码，但我觉得它有点难看，必须有一种方法可以直接使用 DataFrame 来做到这一点，或者一般来说只是一种更好的方法。

注意:我使用的是 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

最佳答案

永远不要按行增长 DataFrame!

TLDR; (just read the bold text)

这里的大多数答案会告诉你如何创建一个空的 DataFrame 并填写它，但没有人会告诉你这是一件坏事。

这是我的建议:将数据累积到列表中，而不是 DataFrame。

使用列表收集数据，然后在准备好时初始化 DataFrame。 list-of-lists 或 list-of-dicts 格式都可以使用，pd.DataFrame 两者都接受。

data = []
for row in some_function_that_yields_data():
    data.append(row)

df = pd.DataFrame(data)

pd.DataFrame 将行列表(其中每一行是一个标量值)转换为 DataFrame。如果您的函数生成 DataFrame，请调用 pd.concat .

这种方法的优点:

1. 与创建一个空的 DataFrame(或 NaN 之一)并一遍又一遍地附加到它相比，追加到一个列表并一次性创建一个 DataFrame 总是更便宜再次。

2. 列表也占用更少的内存，并且是一种更轻便的数据结构，可以处理、追加和删除(如果需要)。

3. dtypes 是自动推断的(而不是将 object 分配给所有这些)。

4. 会自动为您的数据创建一个 RangeIndex，您不必小心为每次迭代时附加的行分配正确的索引.

如果您还不相信，documentation 中也提到了这一点。 :

Iteratively appending rows to a DataFrame can be more computationally intensive than a single concatenate. A better solution is to append those rows to a list and then concatenate the list with the original DataFrame all at once.

*** pandas >= 1.4 更新:append 现已弃用! ***

从 pandas 1.4 开始，append 现已被弃用!使用pd.concat反而。见 release notes

这些选项太可怕了

append 或 concat 在循环内

这是我从初学者那里看到的最大错误:

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)

内存会为您的每个 append 或 concat 操作重新分配。将此与循环结合起来，您就有了二次复杂度运算。

与 df.append 相关的另一个错误是用户往往会忘记 append 不是就地函数，因此必须将结果分配回。您还必须担心 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

处理对象列从来都不是一件好事，因为 pandas 无法对这些列进行矢量化操作。你需要这样做来修复它:

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

loc 在循环内

我还看到 loc 用于附加到创建为空的 DataFrame:

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

和以前一样，您没有预先分配每次所需的内存量，因此每次创建新行时内存都会重新增长。它和append一样糟糕，甚至更丑。

NaN 的空 DataFrame

然后，创建一个包含 NaN 的 DataFrame，以及与之相关的所有注意事项。

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

它创建一个对象列的 DataFrame，就像其他列一样。

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

追加仍然存在上述方法的所有问题。

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

证据就在布丁里

对这些方法进行计时是了解它们在内存和实用性方面的差异的最快方法。

Benchmarking code for reference.

关于python - 创建一个空的 Pandas DataFrame，然后填充它，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/13784192/