Fügen Sie Pandas DataFrame eine Zeile hinzu

870

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

PhE
quelle
70
Beachten Sie, dass dies eine sehr ineffiziente Methode zum Erstellen eines großen DataFrame ist. Beim Anhängen einer Zeile müssen neue Arrays erstellt werden (Kopieren über die vorhandenen Daten).
Wes McKinney
5
@WesMcKinney: Danke, das ist wirklich gut zu wissen. Ist es sehr schnell, Spalten zu großen Tabellen hinzuzufügen ?
Max
4
Wenn es für Sie zu ineffizient ist, können Sie eine zusätzliche Zeile vorab zuweisen und diese dann aktualisieren.
user1154664

Antworten:

569
>>> 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
Fred
quelle
25
Erwägen Sie, den Index hinzuzufügen, um Speicher vorab zuzuweisen (siehe meine Antwort)
FooBar
34
@ MaximG: Ich empfehle dringend ein Upgrade. Die aktuelle Pandas-Version ist 0.15.0.
Fred
44
.locverweist auf die Indexspalte. Wenn Sie also mit einem bereits vorhandenen DataFrame mit einem Index arbeiten, der keine fortlaufende Folge von Ganzzahlen ist, die mit 0 beginnen (wie in Ihrem Beispiel), .locwerden vorhandene Zeilen überschrieben oder Zeilen eingefügt oder Erstellen Sie Lücken in Ihrem Index. Ein robusterer (aber nicht narrensicherer) Ansatz zum Anhängen eines vorhandenen Datenrahmens ungleich Null wäre Folgendes: df.loc[df.index.max() + 1] = [randint(...oder das Vorabfüllen des Index, wie von @FooBar vorgeschlagen.
Kochfelder
4
@hobs df.index.max()ist, nanwenn der DataFrame leer ist.
flow2k
4
@hobs Eine Lösung, an die ich gedacht habe, ist die Verwendung des ternären Operators:df.loc[0 if pd.isnull(df.index.max()) else df.index.max() + 1]
flow2k
475

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)               
ShikharDua
quelle
48
Ich bin auch dazu übergegangen, wenn ich nicht alle Daten im Voraus erhalten kann. Der Geschwindigkeitsunterschied ist erstaunlich.
fantastisch
47
Kopieren aus Pandas-Dokumenten: It is worth noting however, that concat (and therefore append) makes a full copy of the data, and that constantly reusing this function can create a significant performance hit. If you need to use the operation over several datasets, use a list comprehension.( pandas.pydata.org/pandas-docs/stable/… )
Thikonom
5
Das funktioniert super! Außer als ich den
Datenrahmen
5
@ user5359531 Sie können in diesem Fall geordnetes Diktat verwenden
ShikharDua
20
@ user5359531 Sie können die Spalten manuell angeben und die Reihenfolge bleibt erhalten. pd.DataFrame (rows_list, columns = ['C1', 'C2', 'C3']) wird den Trick machen
Marcello Grechi Lins
288

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

NPE
quelle
6
Hallo, was ist die Antwort für die Methoden mit append () oder concat ()? Ich habe das gleiche Problem, versuche aber immer noch, es herauszufinden.
Notilas
109
Dies ist die richtige Antwort, aber keine sehr gute Antwort (fast nur Link).
JWG
5
Ich denke, @ freds Antwort ist korrekter. IIUC Das Problem bei dieser Antwort ist, dass bei jedem Anhängen einer Zeile unnötigerweise der gesamte DataFrame kopiert wird. Verwenden Sie den .locMechanismus, der vermieden werden kann, insbesondere wenn Sie vorsichtig sind.
Ken Williams
7
Wenn Sie jedoch verwenden möchten DataFrame.append(), müssen Sie sicherstellen, dass Ihre Zeilendaten in erster Linie auch ein DataFrame und keine Liste sind.
StayFoolish
202

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.

Mikhail_Sam
quelle
4
Die Verwendung von df2.index.max()for .locerhöht unnötig die Rechenkomplexität. Einfach df2.loc[i] = ...würde reichen. Für mich reduzierte es die Zeit von 10 auf 8,64 Sekunden
Krassowski
Bitte entfernen Sie meinen Namen aus der Liste, da Sie bei Ihrem Test nicht meinem Ansatz folgen: Sie ordnen den Speicher nicht vor, indem Sie einen Index geeigneter Größe angeben.
FooBar
@FooBar Hi! Ich bin froh, dass Sie als Autor meine Antwort gesehen haben :) Sie haben Recht, ich habe diesen wichtigen Punkt verpasst. Ich ziehe es vor, eine weitere Zeile für meine Ergebnistabelle hinzuzufügen, da Ihr Ansatz das unterschiedliche Ergebnis zeigt!
Mikhail_Sam
@Mikhail_Sam Wie würden Sie Pivot-Table verwenden, um es mit der schnellsten Methode in eine Excel-Datei zu schreiben?
FabioSpaghetti
1
Ich wollte nur einen weiteren Kommentar dazu abgeben, warum das Dict to Pandas DataFrame ein besserer Weg ist. In meinen Experimenten mit einem Dataset, das mehrere verschiedene Datentypen in der Tabelle enthält, wird durch die Verwendung der Pandas-Append-Methoden die Typisierung zerstört, während die Verwendung eines Dict und die erstmalige Erstellung des DataFrame daraus die ursprünglichen Datentypen intakt zu halten scheint.
Trompetenlicks
109

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

FooBar
quelle
3
Gute Antwort. Dies sollte die Norm sein, damit der Zeilenraum nicht inkrementell zugewiesen werden muss.
Ely
8
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
Tickon
80
mycolumns = ['A', 'B']
df = pd.DataFrame(columns=mycolumns)
rows = [[1,2],[3,4],[5,6]]
for row in rows:
    df.loc[len(df)] = row
Lydia
quelle
2
Diese! Ich habe eine ganze Weile gesucht und dies ist der erste Beitrag, der wirklich zeigt, wie man einer Zeile bestimmte Werte zuweist! Bonusfrage: Wie lautet die Syntax für Spalten-Name / Wert-Paare? Ich denke, es muss etwas sein, das ein Diktat verwendet, aber ich kann es nicht richtig machen.
Jhin
3
Dies ist nicht effizient, da beim Erweitern tatsächlich der gesamte DataFrame kopiert wird.
wasserdicht
72

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
Nasser Al-Wohaibi
quelle
Die Benutzer fragten nach der Implementierung (fügen Sie eine neue Zeile hinzu). Hier sehen wir, wie Sie eine Zeile in einen definierten Index einfügen oder eine Spalte hinzufügen.
Guilherme Felipe Reis
1
Alle
Dies ist nicht effizient, da tatsächlich der gesamte DataFrame kopiert wird.
wasserdicht
66

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
WP McNeill
quelle
37
Sie können auch erwähnen, dass f.append(<stuff>)ein neues Objekt erstellt wird, anstatt nur an das aktuelle Objekt anzuhängen. Wenn Sie also versuchen, einen Datenrahmen in einem Skript anzuhängen, müssen Sie sagenf = f.append(<stuff>)
Blairg23
2
Gibt es eine Möglichkeit, dies zu tun?
lol
@lol Nein. Siehe github.com/pandas-dev/pandas/issues/2801 - Die zugrunde liegenden Arrays können nicht erweitert werden, sodass sie kopiert werden müssen.
wasserdicht
46

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
hkyi
quelle
27

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
Brian Burns
quelle
15

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)
user3250815
quelle
14

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
Qinsi
quelle
1
Beachten Sie, dass dadurch der gesamte DataFrame unter die Haube kopiert wird. Die zugrunde liegenden Arrays können nicht erweitert werden, sodass sie kopiert werden müssen.
wasserdicht
10

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  }])
Rockstar
quelle
9

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])
Jack Daniel
quelle
8

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

Shivam Agrawal
quelle
1
Dies wird mit Index in absteigender Reihenfolge hinzugefügt
Parthiban Rajendran
5

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
qwr
quelle
5

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)
Shahir Ansari
quelle
4

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
qed
quelle
1

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)
Vineet Jain
quelle
1

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] 
Giorgos Myrianthous
quelle
0

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.

Armali
quelle
Ein Codebeispiel hierfür wäre nützlich
baxx
1
@baxx - Ein Codebeispiel befindet sich am Benchmark- Link ( # .loc with prealloc), ein weiteres Beispiel ist die Frage, ob ich Daten aus jeder Zeile eines Pandas DataFrame mit Daten aus den übrigen Zeilen vergleichen muss. Gibt es eine Möglichkeit, die Berechnung zu beschleunigen? ? und seine akzeptierte Antwort.
Armali
0

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)
Kamran Kausar
quelle
0

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
Srikanth Gattu
quelle
0

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])
hansrajSwapnil
quelle
-1

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