Tambahkan satu baris ke panda DataFrame


871

Saya mengerti bahwa panda dirancang untuk memuat yang terisi penuh DataFrametetapi saya harus membuat DataFrame kosong lalu menambahkan baris, satu per satu . Apa cara terbaik untuk melakukan ini?

Saya berhasil membuat DataFrame kosong dengan:

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

Lalu saya bisa menambahkan baris baru dan mengisi bidang dengan:

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

Ini berfungsi tetapi tampaknya sangat aneh: - / (gagal untuk menambahkan nilai string)

Bagaimana saya bisa menambahkan baris baru ke DataFrame saya (dengan tipe kolom berbeda)?


70
Catatan ini adalah cara yang sangat tidak efisien untuk membangun DataFrame besar; array baru harus dibuat (menyalin data yang ada) ketika Anda menambahkan baris.
Wes McKinney

5
@WesMcKinney: Thx, itu benar-benar baik untuk diketahui. Apakah sangat cepat untuk menambahkan kolom ke tabel besar?
maks

4
Jika terlalu tidak efisien untuk Anda, Anda dapat melakukan praalokasi baris tambahan dan kemudian memperbaruinya.
user1154664

Jawaban:


571

Anda dapat menggunakan df.loc[i], di mana baris dengan indeks iakan menjadi apa yang Anda tentukan berada dalam kerangka data.

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

25
Pertimbangkan untuk menambahkan indeks untuk mengalokasikan memori (lihat jawaban saya)
FooBar

34
@ MaxgG: Saya sangat merekomendasikan upgrade. Versi Pandas saat ini adalah 0.15.0.
fred

44
.locmereferensikan kolom indeks, jadi jika Anda bekerja dengan DataFrame yang sudah ada sebelumnya dengan indeks yang bukan urutan bilangan bulat dimulai dengan 0 (seperti dalam contoh Anda), .locakan menimpa baris yang ada, atau menyisipkan baris, atau buat celah di indeks Anda. Pendekatan yang lebih kuat (tapi bukan bukti-bukti) untuk menambahkan kerangka data non-nol yang ada adalah: df.loc[df.index.max() + 1] = [randint(...atau mengisi ulang indeks seperti yang disarankan @FooBar.
hobs

4
@hobs df.index.max()adalah nanketika DataFrame kosong.
flow2k

4
@hobs Salah satu solusi yang saya pikirkan adalah menggunakan operator ternary:df.loc[0 if pd.isnull(df.index.max()) else df.index.max() + 1]
flow2k

475

Jika Anda bisa mendapatkan semua data untuk frame data di muka, ada pendekatan yang jauh lebih cepat daripada menambahkan ke frame data:

  1. Buat daftar kamus di mana setiap kamus sesuai dengan baris data input.
  2. Buat bingkai data dari daftar ini.

Saya memiliki tugas yang sama dengan yang menambahkan baris bingkai data demi baris memakan waktu 30 menit, dan membuat bingkai data dari daftar kamus diselesaikan dalam hitungan detik.

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)               

48
Saya telah pindah untuk melakukan ini juga untuk setiap situasi di mana saya tidak bisa mendapatkan semua data di muka. Perbedaan kecepatannya mencengangkan.
fantabolous

47
Menyalin dari panda docs: 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
Ini sangat bagus! Kecuali ketika saya membuat frame data, nama kolom semuanya dalam urutan yang salah ...
user5359531

5
@ user5359531 Anda dapat menggunakan perintah dict dalam kasus itu
ShikharDua

21
@ user5359531 Anda dapat menentukan kolom secara manual dan pesanan akan dipertahankan. pd.DataFrame (rows_list, kolom = ['C1', 'C2', 'C3']) akan melakukan trik
Marcello Grechi Lins

288

Anda bisa menggunakan pandas.concat()atau DataFrame.append(). Untuk detail dan contoh, lihat Menggabungkan, bergabung, dan menggabungkan .


6
Hai, jadi apa jawaban untuk metode menggunakan append () atau concat (). Saya memiliki masalah yang sama, tetapi masih berusaha mencari tahu.
notilas

109
Ini adalah jawaban yang tepat, tetapi itu bukan jawaban yang sangat bagus (hampir hanya tautan).
jwg

5
Saya pikir jawaban @ fred lebih benar. IIUC masalah dengan jawaban ini adalah tidak perlu menyalin seluruh DataFrame setiap kali baris ditambahkan. Menggunakan .locmekanisme yang bisa dihindari, terutama jika Anda berhati-hati.
Ken Williams

7
Tetapi jika Anda ingin menggunakan DataFrame.append(), Anda harus memastikan data baris Anda juga merupakan DataFrame di tempat pertama, bukan daftar.
StayFoolish

202

Sudah lama, tapi saya menghadapi masalah yang sama juga. Dan menemukan banyak jawaban menarik di sini. Jadi saya bingung metode apa yang digunakan.

Dalam hal menambahkan banyak baris ke kerangka data saya tertarik pada kinerja kecepatan . Jadi saya mencoba 4 metode paling populer dan memeriksa kecepatannya.

DIPERBARUI PADA 2019 menggunakan versi paket baru. Juga diperbarui setelah komentar @FooBar

KINERJA KECEPATAN

  1. Menggunakan .append ( jawaban NPE )
  2. Menggunakan .loc ( jawaban fred )
  3. Menggunakan .loc dengan preallocating ( jawaban FooBar )
  4. Menggunakan dict dan membuat DataFrame pada akhirnya ( jawaban ShikharDua )

Hasil (dalam detik):

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

Juga terima kasih kepada @krassowski untuk komentar yang bermanfaat - Saya memperbarui kodenya.

Jadi saya menggunakan tambahan melalui kamus untuk diri saya sendiri.


Kode:

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 Saya percaya, realisasiku tidak sempurna, dan mungkin ada beberapa optimasi.


4
Penggunaan df2.index.max()untuk secara .loctidak perlu meningkatkan kompleksitas komputasi. Sederhana df2.loc[i] = ...akan berhasil. Bagi saya itu mengurangi waktu dari 10s menjadi 8,64s
krassowski

Hapus nama saya dari daftar, karena Anda tidak mengikuti pendekatan saya dalam pengujian: Anda tidak mengalokasikan kembali memori dengan memberikan indeks dengan ukuran yang sesuai.
FooBar

@FooBar Hai! Saya senang Anda karena penulis melihat jawaban saya :) Anda benar, saya melewatkan poin penting ini. Saya lebih suka menambahkan satu baris lagi untuk tabel hasil saya karena pendekatan Anda menunjukkan hasil yang berbeda!
Mikhail_Sam

@Mikhail_Sam Bagaimana Anda menggunakan pivot-table untuk menuliskannya pada file excel menggunakan metode tercepat, dict?
FabioSpaghetti

1
Hanya ingin membuang komentar lain mengapa Dict to Pandas DataFrame adalah cara yang lebih baik. Dalam eksperimen saya dengan set data yang memiliki beberapa tipe data berbeda dalam tabel, menggunakan metode append Pandas menghancurkan pengetikan, sedangkan menggunakan Dict, dan hanya membuat DataFrame dari itu SEKALI, tampaknya menjaga tipe data asli tetap utuh.
trumpetlicks

109

Jika Anda tahu jumlah entri ex ante, Anda harus melakukan prealokasi spasi dengan memberikan indeks (mengambil contoh data dari jawaban yang berbeda):

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

Perbandingan kecepatan

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

Dan - seperti dari komentar - dengan ukuran 6000, perbedaan kecepatan menjadi lebih besar:

Meningkatkan ukuran array (12) dan jumlah baris (500) membuat perbedaan kecepatan lebih mencolok: 313ms vs 2.29s


3
Jawaban yang bagus Ini harus menjadi norma sehingga ruang baris tidak harus dialokasikan secara bertahap.
ely

8
Meningkatkan ukuran array (12) dan jumlah baris (500) membuat perbedaan kecepatan lebih mencolok: 313ms vs 2.29s
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

2
Ini! Saya sudah mencari cukup lama, dan ini adalah posting pertama yang benar-benar menunjukkan cara menetapkan nilai tertentu ke baris! Pertanyaan bonus: Manakah sintaks untuk pasangan nama-kolom / nilai? Saya kira itu pasti sesuatu menggunakan dict, tapi sepertinya saya tidak bisa memperbaikinya.
jhin

3
ini tidak efisien karena sebenarnya menyalin seluruh DataFrame ketika Anda memperpanjangnya.
tahan air

72

Untuk penambahan yang efisien, lihat Cara menambahkan baris tambahan ke bingkai data panda dan Pengaturan Dengan Pembesaran .

Tambahkan baris melalui loc/ixpada data indeks kunci yang tidak ada . misalnya:

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

Atau:

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

Para pengguna meminta implementasi (tambahkan baris baru). Di sini kita melihat bagaimana cara menambahkan baris dalam indeks yang ditentukan atau menambahkan kolom.
Guilherme Felipe Reis

1
setiap tolok ukur tentang cara kerjanya dibandingkan dengan metode dict
PirateApp

ini tidak efisien karena sebenarnya menyalin seluruh DataFrame.
anti air

66

Anda dapat menambahkan satu baris sebagai kamus menggunakan ignore_indexopsi.

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

37
Anda mungkin juga menyebutkan bahwa f.append(<stuff>)membuat objek baru, bukan hanya menambahkan objek saat ini di tempat, jadi jika Anda mencoba menambahkan bingkai data dalam skrip, Anda perlu mengatakanf = f.append(<stuff>)
Blairg23

2
apakah ada cara untuk melakukan ini?
lol

@ lol no. lihat github.com/pandas-dev/pandas/issues/2801 - array yang mendasarinya tidak dapat diperpanjang sehingga harus disalin.
tahan air

46

Demi cara Pythonic, di sini tambahkan jawaban saya:

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

27

Anda juga dapat membuat daftar daftar dan mengonversinya menjadi kerangka data -

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)

memberi

    saya menggandakan persegi
0 0 0 0
1 1 2 1
2 2 4 4
3 3 6 9
4 4 8 16
5 5 10 25

15

Ini bukan jawaban untuk pertanyaan OP tetapi contoh mainan untuk menggambarkan jawaban @ShikharDua di atas yang menurut saya sangat berguna.

Meskipun fragmen ini sepele, dalam data aktual saya memiliki 1.000 baris, dan banyak kolom, dan saya berharap dapat mengelompokkan berdasarkan kolom yang berbeda dan kemudian melakukan statistik di bawah ini untuk lebih dari satu kolom taget. Jadi memiliki metode yang dapat diandalkan untuk membangun kerangka data satu per satu adalah kenyamanan yang luar biasa. @ShikharDua terima kasih!

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)

14

Menemukan cara sederhana dan menyenangkan:

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

1
Perhatikan bahwa ini akan menyalin seluruh DataFrame di bawah tenda. Array yang mendasarinya tidak dapat diperpanjang sehingga harus disalin.
anti air

10

Anda dapat menggunakan objek generator untuk membuat Dataframe, yang akan lebih efisien dalam daftar.

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

Untuk menambahkan mentah ke DataFrame yang ada, Anda dapat menggunakan metode append.

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

9

Buat catatan baru (bingkai data) dan tambahkan ke old_data_frame .
lulus daftar nilai dan nama kolom yang sesuai untuk membuat new_record (data_frame)

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

8

Inilah cara untuk menambah / menambahkan baris 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]) 

Ini dapat digunakan untuk menyisipkan / menambahkan baris dalam dataFrame panda yang kosong atau terisi


1
ini ditambahkan dengan indeks dalam urutan menurun
Parthiban Rajendran

5

Alih-alih daftar kamus seperti dalam jawaban ShikharDua, kami juga dapat mewakili tabel kami sebagai kamus daftar , di mana setiap daftar menyimpan satu kolom dalam urutan baris, mengingat kami tahu kolom kami sebelumnya. Pada akhirnya kami membangun DataFrame kami sekali.

Untuk c kolom dan n baris, ini menggunakan 1 kamus dan c daftar, dibandingkan 1 daftar dan n kamus. Daftar metode kamus membuat setiap kamus menyimpan semua kunci dan mengharuskan pembuatan kamus baru untuk setiap baris. Di sini kita hanya menambahkan daftar, yang merupakan waktu konstan dan secara teoritis sangat cepat.

# 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

5

jika Anda ingin menambahkan baris di akhir tambahkan sebagai daftar

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

4

Cara lain untuk melakukannya (mungkin tidak terlalu performan):

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

Anda juga dapat meningkatkan kelas DataFrame seperti ini:

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

2

Yang Anda butuhkan adalah loc[df.shape[0]]atauloc[len(df)]


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

atau

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

1

Sederhanakan. Dengan mengambil daftar sebagai input yang akan ditambahkan sebagai baris dalam bingkai data: -

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)

0

Kita sering melihat konstruk df.loc[subscript] = …untuk menetapkan satu baris DataFrame. Mikhail_Sam memposting tolok ukur yang berisi, antara lain, konstruksi ini serta metode menggunakan dict dan membuat DataFrame pada akhirnya . Dia menemukan yang terakhir menjadi yang tercepat sejauh ini. Tetapi jika kita mengganti df3.loc[i] = …(dengan DataFrame preallocated) dalam kodenya df3.values[i] = …, hasilnya berubah secara signifikan, dalam metode yang melakukan mirip dengan yang menggunakan dict. Jadi kita harus lebih sering mempertimbangkan penggunaan df.values[subscript] = …. Namun, perhatikan bahwa .valuesdibutuhkan subskrip berbasis nol, yang mungkin berbeda dari DataFrame.index.


contoh kode ini akan berguna
baxx

1
@ baxx - Salah satu contoh kode ada di tautan tolok ukur ( # .loc with prealloc), contoh lain adalah dalam pertanyaan saya harus membandingkan data dari setiap baris DataFrame Pandas dengan data dari sisa baris, apakah ada cara untuk mempercepat perhitungan ? dan jawaban yang diterima.
Armali

0

pandas.DataFrame.append

DataFrame.append (diri sendiri, lainnya, ign_index = Salah, verifikasi_integritas = Salah, sortir = Salah) → 'DataFrame'

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

Dengan Abaikan_indeks disetel ke True:

df.append(df2, ignore_index=True)

0

sebelum menambahkan baris, kita harus mengonversi dataframe ke kamus di sana Anda dapat melihat kunci sebagai kolom dalam dataframe dan nilai-nilai kolom lagi disimpan dalam kamus tetapi ada kunci untuk setiap kolom adalah nomor indeks dalam dataframe. Gagasan itu membuat saya menulis kode di bawah ini.

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

0

Anda dapat menggabungkan dua DataFrames untuk ini. Saya pada dasarnya menemukan masalah ini untuk menambahkan baris baru ke DataFrame yang ada dengan indeks karakter (bukan numerik). Jadi, saya memasukkan data untuk baris baru di saluran () dan indeks dalam daftar.

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

-1

Ini akan membantu menambahkan item ke DataFrame kosong. Masalahnya adalah bahwa df.index.max() == nanuntuk indeks pertama:

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)]
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.