Dodaj jeden wiersz do pand DataFrame

868

Rozumiem, że pandy są zaprojektowane do ładowania w pełni wypełnionych, DataFrameale muszę utworzyć pustą ramkę danych, a następnie dodać wiersze, jeden po drugim . Jak najlepiej to zrobić?

Pomyślnie utworzyłem pustą ramkę danych z:

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

Następnie mogę dodać nowy wiersz i wypełnić pole:

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

Działa, ale wydaje się bardzo dziwny: - / (nie udaje się dodać wartości ciągu)

Jak mogę dodać nowy wiersz do DataFrame (z innym typem kolumn)?

PhE
źródło
70
Zauważ, że jest to bardzo nieefektywny sposób na zbudowanie dużej DataFrame; po dodaniu wiersza należy utworzyć nowe tablice (kopiowanie istniejących danych).
Wes McKinney
5
@WesMcKinney: Dzięki, to naprawdę dobrze wiedzieć. Czy dodawanie kolumn do dużych tabel jest bardzo szybkie ?
maks.
4
Jeśli jest to zbyt mało wydajne, możesz wstępnie przydzielić dodatkowy wiersz, a następnie go zaktualizować.
user1154664 19.04.13

Odpowiedzi:

568
>>> 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
źródło
25
Rozważ dodanie indeksu do wstępnej alokacji pamięci (patrz moja odpowiedź)
FooBar,
34
@MaximG: Zdecydowanie polecam aktualizację. Obecna wersja Pandy to 0.15.0.
fred
44
.locodwołuje się do kolumny indeksu, więc jeśli pracujesz z istniejącą wcześniej ramką danych z indeksem, który nie jest ciągłą sekwencją liczb całkowitych rozpoczynających się od 0 (jak w twoim przykładzie), .loczastąpi istniejące wiersze lub wstawi wiersze lub tworzyć luki w indeksie. Bardziej niezawodnym (ale nie niezawodnym) podejściem do dodawania istniejącej ramki danych o niezerowej długości byłoby: df.loc[df.index.max() + 1] = [randint(...lub wstępne wypełnianie indeksu, jak sugerował @FooBar.
płyty grzewcze
4
@ hobs df.index.max()występuje, nangdy DataFrame jest pusta.
flow2k 24.0419
4
@ hobs Jednym z rozwiązań, o którym myślałem, jest użycie operatora trójskładnikowego:df.loc[0 if pd.isnull(df.index.max()) else df.index.max() + 1]
flow2k 25.0419
473

W przypadku, gdy można uzyskać wszystkie dane dla ramki danych z góry, istnieje znacznie szybsze podejście niż dołączanie do ramki danych:

  1. Utwórz listę słowników, w których każdy słownik odpowiada wierszowi danych wejściowych.
  2. Utwórz ramkę danych z tej listy.

Miałem podobne zadanie, dla którego dołączanie do ramki danych wiersz po rzędzie trwało 30 minut, a tworzenie ramki danych z listy słowników ukończonych w ciągu kilku sekund.

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
źródło
48
Przeszedłem do robienia tego również w każdej sytuacji, w której nie mogę uzyskać wszystkich danych z góry. Różnica prędkości jest zadziwiająca.
fantastyczny
47
Kopiowanie z dokumentów pandas: 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
To działa świetnie! Z wyjątkiem sytuacji, gdy utworzyłem ramkę danych, nazwy kolumn były w niewłaściwej kolejności ...
user5359531,
5
@ user5359531 W takim przypadku możesz użyć nakazanego dykta
ShikharDua,
20
@ user5359531 Możesz ręcznie określić kolumny, a kolejność zostanie zachowana. pd.DataFrame (lista_wierszy, kolumny = ['C1', 'C2', 'C3']) załatwi sprawę
Marcello Grechi Lins
287

Możesz użyć pandas.concat()lub DataFrame.append(). Aby uzyskać szczegółowe informacje i przykłady, zobacz Scalanie, łączenie i konkatenacja .

NPE
źródło
6
Cześć, więc jaka jest odpowiedź dla metod wykorzystujących append () lub concat (). Mam ten sam problem, ale wciąż próbuję go rozgryźć.
notilas
109
To jest właściwa odpowiedź, ale nie jest to bardzo dobra odpowiedź (prawie tylko link).
jwg
5
Myślę, że odpowiedź @ fred jest bardziej poprawna. IIUC problem z tą odpowiedzią polega na tym, że niepotrzebnie kopiuje całą ramkę DataFrame za każdym razem, gdy dodawany jest wiersz. Używanie .locmechanizmu, którego można uniknąć, zwłaszcza jeśli jesteś ostrożny.
Ken Williams
7
Ale jeśli chcesz użyć DataFrame.append(), musisz przede wszystkim upewnić się, że dane wiersza są również DataFrame, a nie listą.
StayFoolish,
201

Minęło dużo czasu, ale ja też miałem ten sam problem. I znalazłem tutaj wiele ciekawych odpowiedzi. Byłem więc zdezorientowany, jakiej metody użyć.

W przypadku dodawania wielu wierszy do ramki danych interesuje mnie wydajność prędkości . Wypróbowałem więc 4 najpopularniejsze metody i sprawdziłem ich szybkość.

ZAKTUALIZOWANO W 2019 R. przy użyciu nowych wersji pakietów. Zaktualizowano również po komentarzu @FooBar

WYDAJNOŚĆ PRĘDKOŚCI

  1. Korzystanie z .append ( odpowiedź NPE )
  2. Korzystanie z .loc ( odpowiedź Freda )
  3. Używanie .loc z wstępnym przydzielaniem ( odpowiedź FooBar )
  4. Używanie dict i tworzenie DataFrame na końcu ( odpowiedź ShikharDua )

Wyniki (w sekundach):

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

Również dzięki @krassowski za przydatny komentarz - zaktualizowałem kod.

Więc używam dodawania przez słownik dla siebie.


Kod:

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 Uważam, że moja realizacja nie jest idealna i może jest jakaś optymalizacja.

Michaił_Sam
źródło
4
Zastosowanie df2.index.max()dla .locniepotrzebnie zwiększa złożoność obliczeniową. Proste df2.loc[i] = ...by zrobiło. Dla mnie skrócił czas z 10 do 8,64 s
19:30
Proszę usunąć moje nazwisko z listy, ponieważ nie przestrzegacie mojego podejścia w teście: nie dokonujesz wstępnej alokacji pamięci, podając indeks o odpowiednim rozmiarze.
FooBar
@FooBar Cześć! Cieszę się, że autor zobaczył moją odpowiedź :) masz rację, tęskniłem za tym ważnym punktem. Wolę dodać jeszcze jeden wiersz do mojej tabeli wyników, ponieważ twoje podejście pokazuje inny wynik!
Mikhail_Sam
@Mikhail_Sam Jak użyłbyś tabeli przestawnej, aby zapisać ją w pliku programu Excel przy użyciu najszybszej metody, dykt?
FabioSpaghetti,
1
Chciałem tylko dodać kolejny komentarz, dlaczego Dict to Pandas DataFrame jest lepszym sposobem. W moich eksperymentach z zestawem danych, który ma wiele różnych typów danych w tabeli, użycie metod dołączania Pandas niszczy pisanie, podczas gdy użycie Dict i tylko tworzenie DataFrame z niego RAZ wydaje się zachowywać oryginalne typy danych nienaruszone.
trumpetlicks,
109

Jeśli znasz liczbę wpisów ex ante, powinieneś wstępnie przydzielić miejsce, podając również indeks (biorąc przykład danych z innej odpowiedzi):

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

Porównanie prędkości

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

I - zgodnie z komentarzami - przy wielkości 6000 różnica prędkości staje się jeszcze większa:

Zwiększenie rozmiaru tablicy (12) i liczby wierszy (500) sprawia, że ​​różnica prędkości jest bardziej uderzająca: 313 ms w porównaniu z 2,29 s

FooBar
źródło
3
Świetna odpowiedź. Powinno to być normą, aby przestrzeń wierszy nie musiała być przydzielana przyrostowo.
ely
8
Zwiększenie rozmiaru tablicy (12) i liczby wierszy (500) sprawia, że ​​różnica prędkości jest bardziej uderzająca: 313 ms w porównaniu z 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
Lidia
źródło
2
To! Szukałem już od dłuższego czasu i jest to pierwszy post, który naprawdę pokazuje, jak przypisać określone wartości do wiersza! Pytanie dodatkowe: Jaka jest składnia dla par kolumna nazwa / wartość? Wydaje mi się, że to musi być coś przy użyciu dykta, ale wydaje mi się, że nie mam racji.
jhin
3
nie jest to wydajne, ponieważ kopiuje całą ramkę DataFrame po jej rozszerzeniu.
wodoodporny
72

Aby uzyskać skuteczne dołączanie, zobacz Jak dodać dodatkowy wiersz do ramki danych pand i Ustawienia z powiększeniem .

Dodaj wiersze poprzez loc/ixna nieistniejących kluczowych danych indeksowych. np .:

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

Lub:

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
źródło
Użytkownicy poprosili o implementację (dodaj nowy wiersz). Tutaj widzimy, jak dodać wiersz do zdefiniowanego indeksu lub dodać kolumnę.
Guilherme Felipe Reis
1
wszelkie testy porównawcze tego, jak to działa w porównaniu do metody dict
PirateApp
nie jest to wydajne, ponieważ faktycznie kopiuje całą ramkę danych.
wodoodporny
66

Możesz dołączyć pojedynczy wiersz jako słownik, korzystając z ignore_indexopcji.

>>> 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
źródło
37
Możesz również wspomnieć, że f.append(<stuff>)tworzy nowy obiekt, a nie tylko dołącza się do bieżącego obiektu w miejscu, więc jeśli próbujesz dołączyć do ramki danych w skrypcie, musisz powiedziećf = f.append(<stuff>)
Blairg23
2
czy jest na to sposób?
lol
@haha nie. patrz github.com/pandas-dev/pandas/issues/2801 - podstawowych tablic nie można rozszerzyć, więc należy je skopiować.
wodoodporny
46

Ze względu na język Pythona dodaj moją odpowiedź:

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
źródło
26

Możesz także zbudować listę list i przekonwertować ją na ramkę danych -

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)

dający

    podwoiłem kwadrat
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
źródło
15

To nie jest odpowiedź na pytanie OP, ale zabawkowy przykład ilustrujący odpowiedź @ShikharDua, powyżej której uważam ją za bardzo przydatną.

Chociaż ten fragment jest trywialny, w rzeczywistych danych miałem 1000 wierszy i wiele kolumn, i chciałem móc grupować według różnych kolumn, a następnie wykonać poniższe statystyki dla więcej niż jednej kolumny taget. Posiadanie niezawodnej metody budowania ramki danych po jednym wierszu na raz było wielką wygodą. Dziękuję @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)
użytkownik3250815
źródło
14

Wymyślił prosty i przyjemny sposób:

>>> 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
źródło
1
Pamiętaj, że spowoduje to skopiowanie całej DataFrame pod maską. Podstawowych tablic nie można rozszerzyć, więc należy je skopiować.
wodoodporny
10

Za pomocą obiektu generatora można utworzyć ramkę danych, która będzie bardziej wydajna pod względem pamięci na liście.

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

Aby dodać raw do istniejącej DataFrame, możesz użyć metody append.

df = df.append([{ 'lib': "name_20", 'qty1': 20, 'qty2': 400  }])
Gwiazda rocka
źródło
9

Utwórz nowy rekord (ramkę danych) i dodaj do old_data_frame .
przekaż listę wartości i odpowiednich nazw kolumn, aby utworzyć nowy rekord (ramka danych)

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
źródło
8

Oto sposób dodania / dołączenia wiersza 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]) 

Można go użyć do wstawienia / dołączenia wiersza w pustej lub zapełnionej pandach DataFrame

Shivam Agrawal
źródło
1
to dodaje się z indeksem w kolejności malejącej
Parthiban Rajendran
5

Zamiast listy słowników, jak w odpowiedzi ShikharDua, możemy również przedstawić naszą tabelę jako słownik list , w którym każda lista przechowuje jedną kolumnę w kolejności wierszy, pod warunkiem , że znamy nasze kolumny wcześniej. Na koniec tworzymy naszą ramkę danych raz.

Dla c kolumn i n wierszy używa to 1 słownika i list c , w porównaniu do 1 listy i n słowników. Metoda listy słowników zawiera wszystkie słowniki do przechowywania wszystkich kluczy i wymaga utworzenia nowego słownika dla każdego wiersza. Tutaj dołączamy tylko do list, co jest stałym czasem i teoretycznie bardzo szybkim.

# 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
źródło
5

jeśli chcesz dodać wiersz na końcu, dodaj go jako listę

valuestoappend = [va1,val2,val3]
res = res.append(pd.Series(valuestoappend,index = ['lib', 'qty1', 'qty2']),ignore_index = True)
Shahir Ansari
źródło
4

Innym sposobem na to (prawdopodobnie mało wydajnym):

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

Możesz także ulepszyć klasę DataFrame w następujący sposób:

import pandas as pd
def add_row(self, row):
    self.loc[len(self.index)] = row
pd.DataFrame.add_row = add_row
co było do okazania
źródło
1

Uprość to. Przyjmując listę jako dane wejściowe, które zostaną dołączone jako wiersz w ramce danych: -

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
źródło
1

Wszystko czego potrzebujesz to loc[df.shape[0]]lubloc[len(df)]


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

lub

df.loc[len(df)] = ['col1Value', 100, 'col3Value', False] 
Giorgos Myrianthous
źródło
0

Często widzimy konstrukcję df.loc[subscript] = …do przypisania do jednego wiersza DataFrame. Mikhail_Sam opublikował testy porównawcze zawierające między innymi ten konstrukt, a także metodę wykorzystującą dict i ostatecznie DataFrame . Zdecydował, że ten drugi jest zdecydowanie najszybszy. Ale jeśli df3.loc[i] = …zastąpimy (z wstępnie przydzielonym DataFrame) w jego kodzie df3.values[i] = …, wynik zmienia się znacząco, ponieważ ta metoda działa podobnie do metody używającej dict. Dlatego powinniśmy częściej brać df.values[subscript] = …pod uwagę wykorzystanie. Należy jednak pamiętać, że .valuespobiera indeks dolny od zera, który może różnić się od DataFrame.index.

Armali
źródło
przydatny byłby przykład kodu
baxx
1
@baxx - Jeden przykład kodu znajduje się w linku testu porównawczego ( # .loc with prealloc), innym przykładem jest pytanie, czy muszę porównywać dane z każdego wiersza Pandas DataFrame z danymi z pozostałych wierszy, czy istnieje sposób na przyspieszenie obliczeń ? i jego zaakceptowana odpowiedź.
Armali
0

pandas.DataFrame.append

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

Przy ignore_index ustawionym na True:

df.append(df2, ignore_index=True)
kamran kausar
źródło
0

przed dodaniem wiersza musimy przekonwertować ramkę danych na słownik, aby zobaczyć klucze jako kolumny w ramce danych, a wartości kolumn są ponownie przechowywane w słowniku, ale kluczem do każdej kolumny jest numer indeksu w ramce danych. Ten pomysł zmusza mnie do napisania poniższego kodu.

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
źródło
0

W tym celu można połączyć dwie ramki danych. Zasadniczo natknąłem się na ten problem, aby dodać nowy wiersz do istniejącej ramki danych z indeksem znaków (nie numerycznym). Wprowadzam więc dane dla nowego wiersza w duct () i indeksuję na liście.

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
źródło
-1

To zajmie się dodaniem elementu do pustej ramki danych. Problem polega na tym, że df.index.max() == nanw przypadku pierwszego indeksu:

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)]
Pomidor
źródło