Я начинаю с документов панд DataFrame здесь: http://pandas.pydata.org/pandas-docs/stable/dsintro.html

Я хотел бы итеративно заполнять DataFrame значениями для расчета временных рядов. В общем, я бы хотел инициализировать DataFrame столбцами A, B и строками отметок времени, все 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

Вот пара предложений:

Используйте date_rangeдля индекса:

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

Примечание: мы могли бы создать пустой DataFrame (с NaNs) просто написав:

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

Чтобы выполнить такой тип вычислений для данных, используйте массив numpy:

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

Следовательно, мы можем создать 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

Если вы просто хотите создать пустой фрейм данных и заполнить его несколькими входящими фреймами позже, попробуйте это:

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 

В этом примере я использую этот панд документ , чтобы создать новый фрейм данных , а затем с помощью Append команду для записи в newDF с данными из oldDF.

Если мне нужно продолжать добавлять новые данные в этот newDF из более чем одного oldDF, я просто использую цикл for для перебора pandas.DataFrame.append ()

Правильный путь ™ для создания DataFrame

TLDR; (просто прочитайте жирный текст)

Большинство ответов здесь расскажут вам, как создать пустой DataFrame и заполнить его, но никто не скажет вам, что это плохо.

Вот мой совет: подождите, пока вы не убедитесь, что у вас есть все данные, с которыми вам нужно работать. Используйте список для сбора ваших данных, затем инициализируйте DataFrame, когда будете готовы.

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

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

Это всегда дешевле , чтобы добавить в список и создать DataFrame на одном дыхании , чем это , чтобы создать пустой DataFrame (или один из из NaNs) и дополнения к нему снова и снова. Списки также занимают меньше памяти и представляют собой гораздо более легкую структуру данных для работы , добавления и удаления (при необходимости).

Другое преимущество этого метода заключается в том, что dtypesони автоматически выводятся (а не присваиваются objectвсем).

Последнее преимущество заключается в том, что для ваших данных автоматически создается aRangeIndex , так что беспокоиться об этом будет меньше (взгляните на плохие методы appendи locметоды ниже, вы увидите элементы в обоих, которые требуют соответствующей обработки индекса).

То, что вы не должны делать

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страницы документа :

Итеративное добавление строк в DataFrame может быть более сложным в вычислительном отношении, чем одна конкатенация. Лучшее решение - добавить эти строки в список, а затем объединить список с исходным кадром данных сразу.

Другая ошибка, связанная с этим, df.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 и даже более уродливо.

Пустой фрейм данных NaNs

И затем, создается DataFrame из NaN и все связанные с этим предостережения.

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]

Доказательство в пудинге

Сроки этих методов - самый быстрый способ узнать, насколько они различаются с точки зрения их памяти и полезности.

Контрольный код для справки.

Инициализировать пустой кадр с именами столбцов

import pandas as pd

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

Добавить новую запись в кадр

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

Вы также можете передать словарь:

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

Добавить еще один кадр в ваш существующий кадр

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

Вопросы производительности

Если вы добавляете строки в цикл, учитывайте проблемы с производительностью. Примерно для первых 1000 записей «my_df.loc» производительность лучше, но постепенно она становится медленнее с увеличением количества записей в цикле.

Если вы планируете делать что-то внутри большого цикла (скажем, 10 миллионов записей или около того), вам лучше использовать смесь этих двух; заполняйте фрейм данных iloc, пока размер не достигнет 1000, затем добавьте его к исходному фрейму данных и очистите временный фрейм данных. Это повысит вашу производительность примерно в 10 раз.

Предположим, датафрейм с 19 строками

index=range(0,19)
index

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

Сохранение столбца А в качестве константы

test['A']=10

Сохранение столбца b как переменной, заданной циклом

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

Вы можете заменить первый х в pd.Series([x], index = [x])с любым значением