Fügen Sie Pandas DataFrame eine Zeile hinzu

Ich verstehe, dass Pandas so konzipiert sind, dass sie vollständig ausgefüllt geladen werden, DataFrameaber ich muss einen leeren DataFrame erstellen und dann nacheinander Zeilen hinzufügen . Was ist der beste Weg, dies zu tun?

Ich habe erfolgreich einen leeren DataFrame erstellt mit:

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

Dann kann ich eine neue Zeile hinzufügen und ein Feld füllen mit:

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

Es funktioniert, scheint aber sehr seltsam: - / (es schlägt fehl, einen Zeichenfolgenwert hinzuzufügen)

Wie kann ich meinem DataFrame eine neue Zeile hinzufügen (mit unterschiedlichem Spaltentyp)?

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

Wenn Sie alle Daten für den Datenrahmen im Voraus abrufen können, gibt es einen viel schnelleren Ansatz als das Anhängen an einen Datenrahmen:

1. Erstellen Sie eine Liste von Wörterbüchern, in denen jedes Wörterbuch einer Eingabedatenzeile entspricht.
2. Erstellen Sie aus dieser Liste einen Datenrahmen.

Ich hatte eine ähnliche Aufgabe, bei der das zeilenweise Anhängen an einen Datenrahmen 30 Minuten dauerte und das Erstellen eines Datenrahmens aus einer Liste von Wörterbüchern innerhalb von Sekunden abgeschlossen wurde.

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)               

Sie könnten pandas.concat()oder verwenden DataFrame.append(). Einzelheiten und Beispiele finden Sie unter Zusammenführen, Verbinden und Verketten .

Es ist lange her, aber ich hatte auch das gleiche Problem. Und hier viele interessante Antworten gefunden. Also war ich verwirrt, welche Methode ich verwenden sollte.

Wenn ich dem Datenrahmen viele Zeilen hinzufüge, bin ich an der Geschwindigkeitsleistung interessiert . Also habe ich 4 der beliebtesten Methoden ausprobiert und ihre Geschwindigkeit überprüft.

AKTUALISIERT 2019 mit neuen Versionen von Paketen. Auch nach @FooBar Kommentar aktualisiert

GESCHWINDIGKEITSLEISTUNG

1. Verwenden von .append ( NPE-Antwort )
2. Mit .loc (Fred 's Antwort )
3. Verwenden von .loc mit Vorbelegung ( Antwort von FooBar )
4. Verwenden Sie am Ende dict und erstellen Sie DataFrame ( ShikharDuas 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     |
|------------|-------------|-------------|-------------|

Auch danke an Vielen @krassowski für den nützlichen Kommentar - ich habe den Code aktualisiert.

Also benutze ich Addition 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)

PS Ich glaube, meine Realisierung ist nicht perfekt, und vielleicht gibt es eine Optimierung.

Wenn Sie die Anzahl der Einträge im Voraus kennen, sollten Sie den Speicherplatz vorab zuweisen, indem Sie auch den Index angeben (wobei das Datenbeispiel einer anderen Antwort entnommen wird):

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

Geschwindigkeitsvergleich

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

Und - wie aus den Kommentaren hervorgeht - mit einer Größe von 6000 wird der Geschwindigkeitsunterschied noch größer:

Durch Erhöhen der Größe des Arrays (12) und der Anzahl der Zeilen (500) wird der Geschwindigkeitsunterschied deutlicher: 313 ms gegenüber 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

Informationen zum effizienten Anhängen finden Sie unter Hinzufügen einer zusätzlichen Zeile zu einem Pandas-Datenrahmen und Einstellen mit Erweiterung .

Fügen Sie Zeilen loc/ixzu nicht vorhandenen Schlüsselindexdaten hinzu. 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

Mit der ignore_indexOption können Sie eine einzelne Zeile als Wörterbuch anhängen .

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

Um der pythonischen Art willen, füge hier meine Antwort hinzu:

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

Sie können auch eine Liste von Listen erstellen und in einen Datenrahmen konvertieren.

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)

geben

    Ich verdopple das Quadrat
0 0 0 0
1 1 2 1
2 2 4 4
3 3 6 9
4 4 8 16
5 5 10 25

Dies ist keine Antwort auf die OP-Frage, sondern ein Spielzeugbeispiel, um die Antwort von @ShikharDua zu veranschaulichen, über der ich sehr nützlich fand.

Während dieses Fragment trivial ist, hatte ich in den tatsächlichen Daten 1000 Zeilen und viele Spalten, und ich wollte in der Lage sein, nach verschiedenen Spalten zu gruppieren und dann die folgenden Statistiken für mehr als eine Taget-Spalte auszuführen. Eine zuverlässige Methode zum zeilenweisen Erstellen des Datenrahmens war daher sehr praktisch. Vielen Dank, dass Sie @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)

Einfach und schön herausgefunden:

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

Sie können ein Generatorobjekt verwenden, um einen Datenrahmen zu erstellen, der über die Liste speichereffizienter ist.

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

Um Raw zu vorhandenem DataFrame hinzuzufügen, können Sie die Append-Methode verwenden.

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

Erstellen Sie einen neuen Datensatz ( Datenrahmen ) und fügen Sie ihn zu old_data_frame hinzu . Übergeben Sie eine
Liste mit Werten und entsprechenden Spaltennamen , um einen neuen Datensatz (Datenrahmen) zu erstellen.

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

Hier ist die Möglichkeit, eine Zeile hinzuzufügen / anzuhängen 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, um eine Zeile in einen leeren oder ausgefüllten Pandas DataFrame einzufügen / anzuhängen

Anstelle einer Liste von Wörterbüchern wie in ShikharDuas Antwort können wir unsere Tabelle auch als ein Wörterbuch von Listen darstellen , in dem jede Liste eine Spalte in Zeilenreihenfolge speichert, sofern wir unsere Spalten vorher kennen. Am Ende erstellen wir unseren DataFrame einmal.

Für c Spalten und n Zeilen werden 1 Wörterbuch und c Listen verwendet, gegenüber 1 Liste und n Wörterbüchern. In der Methode "Liste der Wörterbücher" werden in jedem Wörterbuch alle Schlüssel gespeichert, und für jede Zeile muss ein neues Wörterbuch erstellt werden. Hier hängen wir nur an Listen an, was zeitlich konstant und theoretisch sehr schnell ist.

# 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

Wenn Sie am Ende eine Zeile hinzufügen möchten, fügen Sie diese als Liste hinzu

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

Ein anderer Weg, dies 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))

Sie können die DataFrame-Klasse auch folgendermaßen erweitern:

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

Mach es einfach. Indem Sie die Liste als Eingabe verwenden, die als Zeile im Datenrahmen angehängt wird: -

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)

Alles was Sie brauchen ist loc[df.shape[0]]oderloc[len(df)]

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

oder

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

Wir sehen oft das Konstrukt df.loc[subscript] = …, das einer DataFrame-Zeile zugewiesen werden soll. Mikhail_Sam hat am Ende Benchmarks veröffentlicht , die unter anderem dieses Konstrukt sowie die Methode dict und create DataFrame enthalten . Letzteres war bei weitem das schnellste. Wenn wir jedoch den df3.loc[i] = …(durch vorab zugewiesenen DataFrame) in seinem Code durch ersetzen df3.values[i] = …, ändert sich das Ergebnis erheblich, da diese Methode ähnlich wie die mit dict funktioniert. Deshalb sollten wir öfter die Verwendung von df.values[subscript] = …in Betracht ziehen. Beachten Sie jedoch, dass .valuesein auf Null basierender Index erforderlich ist, der sich möglicherweise vom DataFrame.index unterscheidet.

pandas.DataFrame.append

DataFrame.append (self, other, ignore_index = False, verify_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)

Wenn ignore_index auf True gesetzt ist:

df.append(df2, ignore_index=True)

Bevor wir eine Zeile hinzufügen, müssen wir den Datenrahmen in ein Wörterbuch konvertieren. Dort können Sie die Schlüssel als Spalten im Datenrahmen sehen und die Werte der Spalten werden erneut im Wörterbuch gespeichert. Der Schlüssel für jede Spalte ist jedoch die Indexnummer im Datenrahmen. Diese Idee bringt mich dazu, den folgenden Code zu schreiben.

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

Sie können hierfür zwei DataFrames verketten. Grundsätzlich bin ich auf dieses Problem gestoßen, indem ich einem vorhandenen DataFrame eine neue Zeile mit einem Zeichenindex (nicht numerisch) hinzugefügt habe. Also gebe ich die Daten für eine neue Zeile in einen Kanal () und den Index in eine Liste ein.

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

Dadurch wird ein Element zu einem leeren DataFrame hinzugefügt. Das Problem ist das df.index.max() == nanfü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)]