Fügen Sie eine Zeile pandas DataFrame

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

Könnten Sie pandas.concat() oder DataFrame.append(). Für details und Beispiele finden Sie unter Zusammenführen, verknüpfen und verketten.

Es ist schon eine lange Zeit, aber ich Stand vor dem gleichen problem zu. Und fand hier viele interessante Antworten. So war ich verwirrt, welche Methode zu verwenden.

In dem Fall der Zugabe eine Menge von Zeilen zu dataframe ich interessiert Geschwindigkeit Leistung. Also habe ich versucht die 4 beliebtesten Methoden und überprüft Ihre Geschwindigkeit.

AKTUALISIERT 2019 mit neuen Versionen von Paketen.
Auch aktualisiert wird, nachdem @FooBar Kommentar

GESCHWINDIGKEIT

1. Mit .append (NPE ' s Antwort)
2. Mit .loc (fred ' s Antwort)
3. Mit .loc mit preallocating (FooBar ' s Antwort)
4. Mit dict und erstellen DataFrame am Ende (ShikharDua Antwort)

Ergebnisse (in Sekunden):

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

Dank auch an @krassowski für nützliche Kommentar - ich aktualisierte den code.

Also ich benutze neben der durch das Wörterbuch für mich.

Code:

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. ich glaube, meine Erkenntnis ist nicht perfekt, und vielleicht gibt es einige Optimierungen.

Zur effizienten Anhängen sehen Wie fügen Sie eine zusätzliche Zeile in ein pandas dataframe und die - Einstellung Mit der Erweiterung.

Hinzufügen von Zeilen über loc/ix auf nicht vorhandenen - Schlüssel-index-Daten. z.B. :

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

Oder:

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

Zuliebe Pythonic way, hier meine Antwort:

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

Dies ist nicht eine Antwort auf die OP-Frage, aber ein Spielzeug Beispiel zur Veranschaulichung der Antwort von @ShikharDua oben, das fand ich sehr nützlich.

Während dieses fragment ist trivial, in der die eigentlichen Daten, die ich hatte 1000 s von Zeilen und vielen Spalten, und ich wollte in der Lage sein, um die Gruppe durch verschiedene Spalten, und führen Sie dann die stats unten für mehr als ein taget Spalte. Daher ist eine zuverlässige Methode für die Erstellung der Daten-frame eine Zeile zu einem Zeitpunkt war eine große Bequemlichkeit. Danke @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)

Hier ist die Möglichkeit zum hinzufügen/anfügen einer Zeile in 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]) 

Es kann verwendet werden, zum einfügen, Anhängen einer Zeile in leer oder gefüllt pandas DataFrame

Anderen Weg, es zu tun (wahrscheinlich nicht sehr performant):

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

Können Sie verbessern auch die DataFrame Klasse wie folgt aus:

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

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)

Dieser wird sich darum kümmern das hinzufügen eines Elements zu einer leeren DataFrame. Das Problem ist, dass df.index.max() == nan für den ersten index:

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