Agregar una fila a pandas DataFrame

Entiendo que los pandas están diseñados para cargar completamente poblados, DataFramepero necesito crear un DataFrame vacío y luego agregar filas, una por una . Cuál es la mejor manera de hacer esto ?

Creé con éxito un DataFrame vacío con:

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

Luego puedo agregar una nueva fila y llenar un campo con:

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

Funciona pero parece muy extraño: - / (falla al agregar valor de cadena)

¿Cómo puedo agregar una nueva fila a mi DataFrame (con diferentes tipos de columnas)?

Puede usar df.loc[i], donde la fila con índice iserá lo que especifique para que esté en el marco de datos.

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

En caso de que pueda obtener todos los datos para el marco de datos por adelantado, hay un enfoque mucho más rápido que agregar un marco de datos:

1. Cree una lista de diccionarios en los que cada diccionario corresponde a una fila de datos de entrada.
2. Cree un marco de datos de esta lista.

Tuve una tarea similar para la cual agregar un marco de datos fila por fila tomó 30 minutos, y crear un marco de datos a partir de una lista de diccionarios completada en segundos.

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)               

Podrías usar pandas.concat()o DataFrame.append(). Para obtener detalles y ejemplos, consulte Combinar, unir y concatenar .

Ha pasado mucho tiempo, pero también enfrenté el mismo problema. Y encontré aquí muchas respuestas interesantes. Entonces estaba confundido qué método usar.

En el caso de agregar muchas filas al marco de datos, me interesa el rendimiento de la velocidad . Así que probé los 4 métodos más populares y verifiqué su velocidad.

ACTUALIZADO EN 2019 utilizando nuevas versiones de paquetes. También actualizado después del comentario de @FooBar

RENDIMIENTO DE VELOCIDAD

1. Usando .append ( respuesta de NPE )
2. Usando .loc ( respuesta de fred )
3. Usando .loc con preasignación ( respuesta de FooBar )
4. Usar dict y crear DataFrame al final ( respuesta de ShikharDua )

Resultados (en segundos):

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

También gracias a @krassowski por sus útiles comentarios. Actualicé el código.

Entonces uso la suma a través del diccionario para mí.

Código:

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)

PD: Creo que mi realización no es perfecta, y tal vez hay algo de optimización.

Si conoce el número de entradas ex ante, debe preasignar el espacio proporcionando también el índice (tomando el ejemplo de datos de una respuesta diferente):

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

Comparación de velocidad

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

Y, a partir de los comentarios, con un tamaño de 6000, la diferencia de velocidad se vuelve aún mayor:

Aumentar el tamaño de la matriz (12) y el número de filas (500) hace que la diferencia de velocidad sea más sorprendente: 313 ms frente a 2.29 s

mycolumns = ['A', 'B']
df = pd.DataFrame(columns=mycolumns)
rows = [[1,2],[3,4],[5,6]]
for row in rows:
    df.loc[len(df)] = row

Para un agregado eficiente, vea Cómo agregar una fila adicional a un marco de datos de pandas y Configuración con ampliación .

Agregue filas a través loc/ixde datos de índice clave no existentes . p.ej :

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

In [2]: se
Out[2]: 
0    1
1    2
2    3
dtype: int64

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

In [4]: se
Out[4]: 
0    1.0
1    2.0
2    3.0
5    5.0
dtype: float64

O:

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

In [2]: dfi
Out[2]: 
   A  B
0  0  1
1  2  3
2  4  5

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

In [4]: dfi
Out[4]: 
   A  B  C
0  0  1  0
1  2  3  2
2  4  5  4
In [5]: dfi.loc[3] = 5

In [6]: dfi
Out[6]: 
   A  B  C
0  0  1  0
1  2  3  2
2  4  5  4
3  5  5  5

Puede agregar una sola fila como diccionario utilizando la ignore_indexopción

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

Por el bien de Pythonic, aquí agregue mi respuesta:

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

También puede crear una lista de listas y convertirla en un marco de datos:

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)

dando

    Yo doble cuadrado
0 0 0 0
1 1 2 1
2 2 4 4
3 3 6 9
4 4 8 16
5 5 10 25

Esta no es una respuesta a la pregunta de OP sino un ejemplo de juguete para ilustrar la respuesta de @ShikharDua, que he encontrado muy útil.

Si bien este fragmento es trivial, en los datos reales tenía miles de filas y muchas columnas, y deseaba poder agrupar por diferentes columnas y luego realizar las estadísticas a continuación para más de una columna de taget. Por lo tanto, tener un método confiable para construir el marco de datos una fila a la vez fue una gran conveniencia. ¡Gracias @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)

Descubrí una manera simple y agradable:

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

Puede usar el objeto generador para crear un Marco de datos, que será más eficiente en la memoria en la lista.

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

Para agregar datos en bruto al DataFrame existente, puede usar el método append.

df = df.append([{ 'lib': "name_20", 'qty1': 20, 'qty2': 400  }])

Cree un nuevo registro (marco de datos) y agréguelo a old_data_frame .
pasar la lista de valores y los nombres de columna correspondientes para crear un nuevo registro (marco_de_datos)

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

Aquí está la forma de agregar / agregar una fila en 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]) 

Se puede usar para insertar / anexar una fila en pandas vacíos o poblados DataFrame

En lugar de una lista de diccionarios como en la respuesta de ShikharDua, también podemos representar nuestra tabla como un diccionario de listas , donde cada lista almacena una columna en orden de fila, dado que conocemos nuestras columnas de antemano. Al final construimos nuestro DataFrame una vez.

Para c columnas y n filas, esto usa 1 diccionario y c listas, versus 1 lista y n diccionarios. El método de la lista de diccionarios tiene cada diccionario almacenando todas las claves y requiere crear un nuevo diccionario para cada fila. Aquí solo agregamos listas, que es tiempo constante y teóricamente muy rápido.

# current data
data = {"Animal":["cow", "horse"], "Color":["blue", "red"]}

# adding a new row (be careful to ensure every column gets another value)
data["Animal"].append("mouse")
data["Color"].append("black")

# at the end, construct our DataFrame
df = pd.DataFrame(data)
#   Animal  Color
# 0    cow   blue
# 1  horse    red
# 2  mouse  black

si desea agregar una fila al final, agréguela como una lista

valuestoappend = [va1,val2,val3]
res = res.append(pd.Series(valuestoappend,index = ['lib', 'qty1', 'qty2']),ignore_index = True)

Otra forma de hacerlo (probablemente no muy eficiente):

# 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))

También puede mejorar la clase DataFrame de esta manera:

import pandas as pd
def add_row(self, row):
    self.loc[len(self.index)] = row
pd.DataFrame.add_row = add_row

Todo lo que necesitas es loc[df.shape[0]]oloc[len(df)]

# Assuming your df has 4 columns (str, int, str, bool)
df.loc[df.shape[0]] = ['col1Value', 100, 'col3Value', False] 

o

df.loc[len(df)] = ['col1Value', 100, 'col3Value', False] 

Hazlo simple. Al tomar la lista como entrada que se agregará como fila en el marco de datos: -

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)

A menudo vemos la construcción df.loc[subscript] = …para asignar a una fila de DataFrame. Mikhail_Sam publicó puntos de referencia que contienen, entre otros, esta construcción, así como el método que usa dict y crear DataFrame al final . Encontró que este último era el más rápido con diferencia. Pero si reemplazamos el df3.loc[i] = …(con DataFrame preasignado) en su código con df3.values[i] = …, el resultado cambia significativamente, ya que ese método funciona de manera similar al que usa dict. Por lo tanto, debemos tener más en cuenta el uso de df.values[subscript] = …. Sin embargo, tenga en cuenta que .valuestoma un subíndice basado en cero, que puede ser diferente del DataFrame.index.

pandas.DataFrame.append

DataFrame.append (self, other, ignore_index = False, verificar_integrity = False, sort = False) → 'DataFrame'

df = pd.DataFrame([[1, 2], [3, 4]], columns=list('AB'))
df2 = pd.DataFrame([[5, 6], [7, 8]], columns=list('AB'))
df.append(df2)

Con ignore_index establecido en True:

df.append(df2, ignore_index=True)

antes de agregar una fila, tenemos que convertir el marco de datos al diccionario, allí puede ver las claves como columnas en el marco de datos y los valores de las columnas se almacenan nuevamente en el diccionario, pero la clave para cada columna es el número de índice en el marco de datos. Esa idea me hace escribir el siguiente código.

df2=df.to_dict()
values=["s_101","hyderabad",10,20,16,13,15,12,12,13,25,26,25,27,"good","bad"] #this is total row that we are going to add
i=0
for x in df.columns:   #here df.columns gives us the main dictionary key
    df2[x][101]=values[i]   #here the 101 is our index number it is also key of sub dictionary
    i+=1

Puede concatenar dos DataFrames para esto. Básicamente me encontré con este problema para agregar una nueva fila a un DataFrame existente con un índice de caracteres (no numérico). Entonces, ingreso los datos para una nueva fila en un ducto () y el índice en una lista.

new_dict = {put input for new row here}
new_list = [put your index here]

new_df = pd.DataFrame(data=new_dict, index=new_list)

df = pd.concat([existing_df, new_df])

Esto se encargará de agregar un elemento a un DataFrame vacío. El problema es que df.index.max() == nanpara el primer índice:

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