เพิ่มหนึ่งแถวใน DataFrame แพนด้า

ผมเข้าใจว่าหมีแพนด้าถูกออกแบบมาเพื่อโหลดประชากรอย่างเต็มที่DataFrameแต่ฉันจำเป็นต้องสร้าง DataFrame ว่างแล้วเพิ่มแถวหนึ่งโดยหนึ่ง วิธีที่ดีที่สุดในการทำเช่นนี้คืออะไร?

ฉันสร้าง DataFrame ที่ว่างเปล่าเรียบร้อยแล้วด้วย:

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

จากนั้นฉันสามารถเพิ่มแถวใหม่และกรอกข้อมูลด้วย:

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

มันใช้งานได้ แต่ดูเหมือนแปลกมาก: - / (มันล้มเหลวในการเพิ่มค่าสตริง)

ฉันจะเพิ่มแถวใหม่ใน 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

ในกรณีที่คุณสามารถรับข้อมูลทั้งหมดสำหรับ data frame ล่วงหน้ามีวิธีที่เร็วกว่าการผนวกเข้ากับ data frame:

1. สร้างรายการพจนานุกรมที่แต่ละพจนานุกรมสอดคล้องกับแถวข้อมูลเข้า
2. สร้างกรอบข้อมูลจากรายการนี้

ฉันมีงานที่คล้ายกันซึ่งผนวกเข้ากับ data frame แบบแถวต่อแถวใช้เวลา 30 นาทีและสร้าง data frame จากรายการพจนานุกรมที่เสร็จสมบูรณ์ภายในไม่กี่วินาที

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)               

คุณสามารถใช้หรือpandas.concat() DataFrame.append()สำหรับรายละเอียดและตัวอย่างให้ดูที่ผสานเข้าร่วมและ concatenate

เป็นเวลานานแล้ว แต่ฉันก็ประสบปัญหาเดียวกันเช่นกัน และพบคำตอบที่น่าสนใจมากมายที่นี่ ดังนั้นฉันสับสนว่าวิธีการใช้

ในกรณีของการเพิ่มจำนวนมากของแถวให้ฉัน dataframe สนใจในประสิทธิภาพความเร็ว ดังนั้นฉันจึงลองวิธีที่นิยมที่สุด 4 วิธีและตรวจสอบความเร็ว

ปรับปรุงในปี 2019โดยใช้แพ็คเกจใหม่ อัปเดตยังหลังจากความคิดเห็น @FooBar

ผลการดำเนินงานความเร็ว

1. ใช้. ผนวก ( คำตอบของ NPE )
2. ใช้. loc ( คำตอบของ fred )
3. ใช้. loc กับการจัดสรรล่วงหน้า ( คำตอบของ FooBar )
4. ใช้ dict และสร้าง DataFrame ในท้ายที่สุด ( คำตอบของ ShikharDua )

ผลลัพธ์ (ในวินาที):

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

ขอบคุณ@krassowskiสำหรับความคิดเห็นที่เป็นประโยชน์ - ฉันได้อัปเดตรหัสแล้ว

ดังนั้นฉันใช้การเพิ่มผ่านพจนานุกรมสำหรับตัวเอง

รหัส:

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 ฉันเชื่อว่าการรับรู้ของฉันไม่สมบูรณ์แบบและอาจมีการปรับให้เหมาะสมบ้าง

หากคุณทราบจำนวนรายการที่มากกว่าคุณควรจัดสรรพื้นที่ล่วงหน้าด้วยการจัดทำดัชนี (นำตัวอย่างข้อมูลจากคำตอบที่ต่างออกไป):

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

เปรียบเทียบความเร็ว

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

และจากความคิดเห็น - ด้วยขนาดของ 6,000 ความแตกต่างของความเร็วจะยิ่งใหญ่ขึ้น:

การเพิ่มขนาดของอาร์เรย์ (12) และจำนวนแถว (500) ทำให้ความเร็วแตกต่างโดดเด่นมากขึ้น: 313 มิลลิวินาทีกับ 2.29 วินาที

mycolumns = ['A', 'B']
df = pd.DataFrame(columns=mycolumns)
rows = [[1,2],[3,4],[5,6]]
for row in rows:
    df.loc[len(df)] = row

สำหรับท้ายที่มีประสิทธิภาพดูวิธีการเพิ่มแถวพิเศษเพื่อแพนด้า dataframeและการตั้งค่าด้วยการขยาย

เพิ่มแถวผ่านloc/ixในที่มีอยู่ไม่ข้อมูลดัชนีที่สำคัญ เช่น :

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

หรือ:

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

คุณสามารถต่อท้ายแถวเดียวเป็นพจนานุกรมโดยใช้ignore_indexตัวเลือก

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

เพื่อประโยชน์ของวิธี Pythonic ที่นี่เพิ่มคำตอบของฉัน:

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

นอกจากนี้คุณยังสามารถสร้างรายการของรายการและแปลงเป็นรายการ -

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)

ให้

    ฉันสองตาราง
0 0 0 0
1 1 2 1
2 2 4 4
3 3 6 9
4 4 8 16
5 5 10 25

นี่ไม่ใช่คำตอบสำหรับคำถาม OP แต่เป็นตัวอย่างของเล่นเพื่อแสดงคำตอบของ @ShikharDua ด้านบนซึ่งฉันพบว่ามีประโยชน์มาก

ในขณะที่ส่วนนี้เป็นเรื่องเล็กน้อยในข้อมูลจริงฉันมี 1,000 แถวและหลายคอลัมน์และฉันต้องการจัดกลุ่มตามคอลัมน์ต่าง ๆ แล้วดำเนินการสถิติด้านล่างสำหรับคอลัมน์แท็กมากกว่าหนึ่งคอลัมน์ ดังนั้นการมีวิธีการที่เชื่อถือได้ในการสร้าง data frame ทีละแถวจึงสะดวกมาก ขอบคุณ @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)

คิดออกเป็นวิธีที่ง่ายและดี:

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

คุณสามารถใช้ตัวสร้างวัตถุเพื่อสร้าง Dataframe ซึ่งจะมีหน่วยความจำมีประสิทธิภาพมากกว่าในรายการ

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

ในการเพิ่ม raw ไปยัง DataFrame ที่มีอยู่คุณสามารถใช้วิธีการต่อท้าย

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

สร้างสถิติใหม่ (กรอบข้อมูล)และเพิ่มold_data_frame
รายการส่งผ่านค่าและชื่อคอลัมน์ที่เกี่ยวข้องเพื่อสร้าง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])

นี่คือวิธีการเพิ่ม / ต่อท้ายแถว 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]) 

มันสามารถใช้ในการแทรก / ผนวกแถวใน DataFrame แพนด้าที่ว่างเปล่าหรือที่มีประชากร

แทนที่จะเป็นรายการพจนานุกรมตามคำตอบของ ShikharDua เราสามารถแสดงตารางของเราเป็นพจนานุกรมของรายการโดยที่แต่ละรายการจะเก็บหนึ่งคอลัมน์ตามลำดับแถวเนื่องจากเราทราบว่าคอลัมน์ของเราล่วงหน้า ในตอนท้ายเราสร้าง DataFrame ของเราหนึ่งครั้ง

สำหรับคอลัมน์cและnแถวสิ่งนี้ใช้ 1 พจนานุกรมและรายการcเทียบกับ 1 รายการและnพจนานุกรม รายการวิธีการพจนานุกรมมีพจนานุกรมแต่ละเล่มจัดเก็บคีย์ทั้งหมดและต้องสร้างพจนานุกรมใหม่สำหรับทุกแถว ที่นี่เราเพิ่มเฉพาะรายการซึ่งเป็นเวลาคงที่และตามหลักวิชาเร็วมาก

# 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

หากคุณต้องการเพิ่มแถวท้ายท้ายรายการให้เป็นรายการ

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

อีกวิธีในการทำ (อาจไม่ค่อยมีประสิทธิภาพ):

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

คุณสามารถปรับปรุงคลาส DataFrame ดังนี้:

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

ทำให้มันง่าย โดยจดรายการเป็นข้อมูลเข้าซึ่งจะถูกผนวกเข้าเป็นแถวใน data-frame: -

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)

สิ่งที่คุณต้องการคือloc[df.shape[0]]หรือloc[len(df)]

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

หรือ

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

เรามักจะเห็นโครงสร้างdf.loc[subscript] = …เพื่อกำหนดให้กับหนึ่ง DataFrame แถว Mikhail_Sam โพสต์มาตรฐานที่มีหมู่คนสร้างนี้เช่นเดียวกับวิธีการใช้Dict และสร้าง DataFrame ในท้ายที่สุด เขาพบว่าสิ่งหลังนั้นเร็วที่สุด แต่ถ้าเราแทนที่df3.loc[i] = …(ด้วยการจัดสรรล่วงหน้า DataFrame) ในรหัสของเขาด้วยdf3.values[i] = …ผลลัพธ์จะเปลี่ยนไปอย่างมีนัยสำคัญในวิธีการนั้นจะทำงานคล้ายกับที่ใช้ dict ดังนั้นเราจึงมักจะมากขึ้นควรจะใช้df.values[subscript] = …ในการพิจารณา อย่างไรก็ตามโปรดทราบว่า.valuesใช้ตัวห้อยเป็นศูนย์ซึ่งอาจแตกต่างจาก DataFrame.index

pandas.DataFrame.append

DataFrame.append (ตัวเองอื่น ๆ ละเว้น _index = เท็จ, Verify_integrity = เท็จ, การจัดเรียง = เท็จ) → 'DataFrame'

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

เมื่อตั้งค่า ign_index เป็น True:

df.append(df2, ignore_index=True)

ก่อนที่จะเพิ่มแถวเราต้องแปลง dataframe เป็นพจนานุกรมที่นั่นคุณสามารถเห็นปุ่มเป็นคอลัมน์ใน dataframe และค่าของคอลัมน์จะถูกเก็บไว้ในพจนานุกรมอีกครั้ง แต่ที่สำคัญสำหรับทุกคอลัมน์คือหมายเลขดัชนีใน dataframe ความคิดนั้นทำให้ฉันเขียนโค้ดด้านล่าง

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

คุณสามารถต่อ DataFrames สองตัวเข้าด้วยกัน โดยทั่วไปแล้วฉันเจอปัญหานี้เพื่อเพิ่มแถวใหม่ไปยัง DataFrame ที่มีอยู่ด้วยดัชนีอักขระ (ไม่ใช่ตัวเลข) ดังนั้นฉันป้อนข้อมูลสำหรับแถวใหม่ใน duct () และดัชนีในรายการ

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

สิ่งนี้จะเป็นการเพิ่มรายการลงใน DataFrame ที่ว่างเปล่า ปัญหาคือว่าdf.index.max() == nanสำหรับดัชนีแรก:

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