Добавить одну строку в панды DataFrame

Я понимаю, что pandas предназначен для загрузки полностью заполненного DataFrame, но мне нужно создать пустой DataFrame, а затем добавить строки, один за другим. Каков наилучший способ сделать это?

Я успешно создал пустой DataFrame с:

res = DataFrame(columns=('lib', 'qty1', 'qty2'))

Затем я могу добавить новую строку и заполнить поле:

res = res.set_value(len(res), 'qty1', 10.0)

Это работает, но кажется очень странным: -/(для добавления строкового значения не получается)

Как добавить новую строку в мой DataFrame (с разными типами столбцов)?

+695
источник поделиться
20 ответов
>>> import pandas as pd
>>> from numpy.random import randint

>>> df = pd.DataFrame(columns=['lib', 'qty1', 'qty2'])
>>> for i in range(5):
>>>     df.loc[i] = ['name' + str(i)] + list(randint(10, size=2))

>>> df
     lib qty1 qty2
0  name0    3    3
1  name1    2    4
2  name2    2    8
3  name3    2    1
4  name4    9    6
+448
источник

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

  1. Создайте список словарей, в которых каждый словарь соответствует строке входных данных.
  2. Создайте фрейм данных из этого списка.

У меня была аналогичная задача, для которой добавление к кадру данных по строкам заняло 30 минут и создание фрейма данных из списка словарей, завершенных за считанные секунды.

rows_list = []
for row in input_rows:

        dict1 = {}
        # get input row in dictionary format
        # key = col_name
        dict1.update(blah..) 

        rows_list.append(dict1)

df = pd.DataFrame(rows_list)               
+361
источник
другие ответы

Связанные вопросы


Похожие вопросы

Вы можете использовать pandas.concat() или DataFrame.append(). Подробнее и примеры см. В Объединить, объединить и объединить.

+261
источник

Это было давно, но я столкнулся с той же проблемой. И нашел здесь много интересных ответов. Поэтому я запутался, какой метод использовать.

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

ОБНОВЛЕНО в 2019 году с использованием новых версий пакетов. Также обновляется после комментария @FooBar

СКОРОСТЬ ЭФФЕКТИВНОСТИ

  1. Использование .append(NPE ответ)
  2. Использование .loc(Фред ответ)
  3. Использование .loc с предварительным распределением (ответ FooBar)
  4. Использование dict и создание DataFrame в конце (ShikharDua answer)

Результаты (в секундах):

|------------|-------------|-------------|-------------|
|  Approach  |  1000 rows  |  5000 rows  | 10 000 rows |
|------------|-------------|-------------|-------------|
| .append    |    0.69     |    3.39     |    6.78     |
|------------|-------------|-------------|-------------|
| .loc w/o   |    0.74     |    3.90     |    8.35     |
| prealloc   |             |             |             |
|------------|-------------|-------------|-------------|
| .loc with  |    0.24     |    2.58     |    8.70     |
| prealloc   |             |             |             |
|------------|-------------|-------------|-------------|
|  dict      |    0.012    |   0.046     |   0.084     |
|------------|-------------|-------------|-------------|

Также спасибо @krassowski за полезный комментарий - я обновил код.

Поэтому я использую дополнение через словарь для себя.


Код:

import pandas as pd
import numpy as np
import time

del df1, df2, df3, df4
numOfRows = 1000
# append
startTime = time.perf_counter()
df1 = pd.DataFrame(np.random.randint(100, size=(5,5)), columns=['A', 'B', 'C', 'D', 'E'])
for i in range( 1,numOfRows-4):
    df1 = df1.append( dict( (a,np.random.randint(100)) for a in ['A','B','C','D','E']), ignore_index=True)
print('Elapsed time: {:6.3f} seconds for {:d} rows'.format(time.perf_counter() - startTime, numOfRows))
print(df1.shape)

# .loc w/o prealloc
startTime = time.perf_counter()
df2 = pd.DataFrame(np.random.randint(100, size=(5,5)), columns=['A', 'B', 'C', 'D', 'E'])
for i in range( 1,numOfRows):
    df2.loc[i]  = np.random.randint(100, size=(1,5))[0]
print('Elapsed time: {:6.3f} seconds for {:d} rows'.format(time.perf_counter() - startTime, numOfRows))
print(df2.shape)

# .loc with prealloc
df3 = pd.DataFrame(index=np.arange(0, numOfRows), columns=['A', 'B', 'C', 'D', 'E'] )
startTime = time.perf_counter()
for i in range( 1,numOfRows):
    df3.loc[i]  = np.random.randint(100, size=(1,5))[0]
print('Elapsed time: {:6.3f} seconds for {:d} rows'.format(time.perf_counter() - startTime, numOfRows))
print(df3.shape)

# dict
startTime = time.perf_counter()
row_list = []
for i in range (0,5):
    row_list.append(dict( (a,np.random.randint(100)) for a in ['A','B','C','D','E']))
for i in range( 1,numOfRows-4):
    dict1 = dict( (a,np.random.randint(100)) for a in ['A','B','C','D','E'])
    row_list.append(dict1)

df4 = pd.DataFrame(row_list, columns=['A','B','C','D','E'])
print('Elapsed time: {:6.3f} seconds for {:d} rows'.format(time.perf_counter() - startTime, numOfRows))
print(df4.shape)

P.S. Я считаю, что моя реализация не идеальна, и, возможно, есть некоторая оптимизация.

+100
источник

Если вы знаете количество записей ex ante, вы должны предварительно распределить пространство, указав индекс (принимая пример данных из другого ответа):

import pandas as pd
import numpy as np
# we know we're gonna have 5 rows of data
numberOfRows = 5
# create dataframe
df = pd.DataFrame(index=np.arange(0, numberOfRows), columns=('lib', 'qty1', 'qty2') )

# now fill it up row by row
for x in np.arange(0, numberOfRows):
    #loc or iloc both work here since the index is natural numbers
    df.loc[x] = [np.random.randint(-1,1) for n in range(3)]
In[23]: df
Out[23]: 
   lib  qty1  qty2
0   -1    -1    -1
1    0     0     0
2   -1     0    -1
3    0    -1     0
4   -1     0     0

Сравнение скорости

In[30]: %timeit tryThis() # function wrapper for this answer
In[31]: %timeit tryOther() # function wrapper without index (see, for example, @fred)
1000 loops, best of 3: 1.23 ms per loop
100 loops, best of 3: 2.31 ms per loop

И - как из комментариев - с размером 6000, разница в скорости становится еще больше:

Увеличение размера массива (12) и количества строк (500) делает разница в скорости более яркая: 313ms против 2.29s

+92
источник

Для эффективного добавления см. Как добавить дополнительную строку в фреймворк pandas и Настройка с расширением.

Добавьте строки через loc/ix в не существующие данные индекса ключа. например

  В [1]: se = pd.Series([1,2,3])

В [2]: se
Из [2]:
0 1
1 2
2 3
dtype: int64

В [3]: se [5] = 5.

В [4]: ​​se
Выход [4]:
0 1,0
1 2,0
2 3,0
5,0
dtype: float64
Код>

Или:

  В [1]: dfi = pd.DataFrame(np.arange(6).resape(3,2),  .....: columns = ['A', 'B'])  .....:

В [2]: dfi
Из [2]:  A B
0 0 1
1 2 3
2 4 5

В [3]: dfi.loc [:, 'C'] = dfi.loc [:, 'A']

В [4]: ​​dfi
Выход [4]:  A B C
0 0 1 0
1 2 3 2
2 4 5 4
В [5]: dfi.loc [3] = 5

В [6]: dfi
Из [6]:  A B C
0 0 1 0
1 2 3 2
2 4 5 4
3 5 5 5
Код>
+66
источник
mycolumns = ['A', 'B']
df = pd.DataFrame(columns=mycolumns)
rows = [[1,2],[3,4],[5,6]]
for row in rows:
    df.loc[len(df)] = row
+65
источник

Вы можете добавить одну строку в качестве словаря, используя опцию ignore_index.

>>> f = pandas.DataFrame(data = {'Animal':['cow','horse'], 'Color':['blue', 'red']})
>>> f
  Animal Color
0    cow  blue
1  horse   red
>>> f.append({'Animal':'mouse', 'Color':'black'}, ignore_index=True)
  Animal  Color
0    cow   blue
1  horse    red
2  mouse  black
+54
источник

Ради питонического пути добавьте мой ответ:

res = pd.DataFrame(columns=('lib', 'qty1', 'qty2'))
res = res.append([{'qty1':10.0}], ignore_index=True)
print(res.head())

   lib  qty1  qty2
0  NaN  10.0   NaN
+40
источник

Вы также можете создать список списков и преобразовать его в фрейм данных -

import pandas as pd

columns = ['i','double','square']
rows = []

for i in range(6):
    row = [i, i*2, i*i]
    rows.append(row)

df = pd.DataFrame(rows, columns=columns)

давая

    i   double  square
0   0   0   0
1   1   2   1
2   2   4   4
3   3   6   9
4   4   8   16
5   5   10  25
+18
источник

Это не ответ на вопрос OP, а пример с игрушкой, чтобы проиллюстрировать ответ @ShikharDua, выше которого я нашел очень полезным.

Хотя этот фрагмент тривиален, в фактических данных у меня было 1000 строк и много столбцов, и я хотел иметь возможность группировать по разным столбцам, а затем выполнять статистику ниже для более чем одного столбца taget. Таким образом, надежный метод построения кадра данных по одной строке за раз был большим удобством. Спасибо @ShikharDua!

import pandas as pd 

BaseData = pd.DataFrame({ 'Customer' : ['Acme','Mega','Acme','Acme','Mega','Acme'],
                          'Territory'  : ['West','East','South','West','East','South'],
                          'Product'  : ['Econ','Luxe','Econ','Std','Std','Econ']})
BaseData

columns = ['Customer','Num Unique Products', 'List Unique Products']

rows_list=[]
for name, group in BaseData.groupby('Customer'):
    RecordtoAdd={} #initialise an empty dict 
    RecordtoAdd.update({'Customer' : name}) #
    RecordtoAdd.update({'Num Unique Products' : len(pd.unique(group['Product']))})      
    RecordtoAdd.update({'List Unique Products' : pd.unique(group['Product'])})                   

    rows_list.append(RecordtoAdd)

AnalysedData = pd.DataFrame(rows_list)

print('Base Data : \n',BaseData,'\n\n Analysed Data : \n',AnalysedData)
+13
источник

Выяснил простой и приятный способ:

>>> df
     A  B  C
one  1  2  3
>>> df.loc["two"] = [4,5,6]
>>> df
     A  B  C
one  1  2  3
two  4  5  6
+12
источник

Создайте новую запись (фрейм данных) и добавьте в old_data_frame.
перейдите к значениям и соответствующим столбцам, чтобы создать new_record (data_frame)

new_record = pd.DataFrame([[0,'abcd',0,1,123]],columns=['a','b','c','d','e'])

old_data_frame = pd.concat([old_data_frame,new_record])
+6
источник

Вот как добавить/добавить строку в pandas DataFrame

def add_row(df, row):
    df.loc[-1] = row
    df.index = df.index + 1  
    return df.sort_index()

add_row(df, [1,2,3]) 

Его можно использовать для вставки/добавления строки в пустые или заполненные панды DataFrame

+5
источник

Другой способ сделать это (возможно, не очень сильно):

# add a row
def add_row(df, row):
    colnames = list(df.columns)
    ncol = len(colnames)
    assert ncol == len(row), "Length of row must be the same as width of DataFrame: %s" % row
    return df.append(pd.DataFrame([row], columns=colnames))

Вы также можете улучшить класс DataFrame следующим образом:

import pandas as pd
def add_row(self, row):
    self.loc[len(self.index)] = row
pd.DataFrame.add_row = add_row
+3
источник

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

import pandas as pd  
res = pd.DataFrame(columns=('lib', 'qty1', 'qty2'))  
for i in range(5):  
    res_list = list(map(int, input().split()))  
    res = res.append(pd.Series(res_list,index=['lib','qty1','qty2']), ignore_index=True)
+1
источник
import pandas as pd 
t1=pd.DataFrame()
for i in range(len(the number of rows)):
    #add rows as columns
    t1[i]=list(rows)
t1=t1.transpose()
t1.columns=list(columns)
0
источник

Мы часто видим конструкцию df.loc[subscript] = … для назначения одной строке DataFrame. Mikhail_Sam опубликовал тесты, содержащие, помимо прочего, эту конструкцию, а также метод, использующий dict и создающий DataFrame, в конце концов. Он нашел последний самый быстрый на сегодняшний день. Но если мы заменим df3.loc[i] = … (с предварительно выделенным DataFrame) в его коде на df3.values[i] = …, результат значительно изменится, так как этот метод работает аналогично тому, который использует dict. Поэтому мы должны чаще принимать во внимание использование df.values[subscript] = …. Однако обратите внимание, что .values принимает индекс, начинающийся с нуля, который может отличаться от DataFrame.index.

0
источник

Вы можете использовать генератор объекта для создания Dataframe, который будет более эффективным в использовании памяти по списку.

num = 10

# Generator function to generate generator object
def numgen_func(num):
    for i in range(num):
        yield ('name_{}'.format(i), (i*i), (i*i*i))

# Generator expression to generate generator object (Only once data get populated, can not be re used)
numgen_expression = (('name_{}'.format(i), (i*i), (i*i*i)) for i in range(num) )

df = pd.DataFrame(data=numgen_func(num), columns=('lib', 'qty1', 'qty2'))

Чтобы добавить raw в существующий DataFrame, вы можете использовать метод append.

df = df.append([{ 'lib': "name_20", 'qty1': 20, 'qty2': 400  }])
0
источник

Это позаботится о добавлении элемента в пустой DataFrame. Проблема в том, что df.index.max() == nan для первого индекса:

df = pd.DataFrame(columns=['timeMS', 'accelX', 'accelY', 'accelZ', 'gyroX', 'gyroY', 'gyroZ'])

df.loc[0 if math.isnan(df.index.max()) else df.index.max() + 1] = [x for x in range(7)]
-2
источник

Посмотрите другие вопросы по меткам или Задайте вопрос