Thêm một hàng vào DataFrame của gấu trúc

Tôi hiểu rằng gấu trúc được thiết kế để tải đầy đủ dân cư DataFramenhưng tôi cần tạo một DataFrame trống sau đó thêm từng hàng một . Cách tốt nhất để làm việc này là gì ?

Tôi đã tạo thành công một DataFrame trống với:

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

Sau đó, tôi có thể thêm một hàng mới và điền vào một trường với:

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

Nó hoạt động nhưng có vẻ rất kỳ lạ: - / (không thể thêm giá trị chuỗi)

Làm cách nào tôi có thể thêm một hàng mới vào DataFrame của mình (với các loại cột khác nhau)?

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

Trong trường hợp bạn có thể nhận được tất cả dữ liệu cho khung dữ liệu trả trước, có một cách tiếp cận nhanh hơn nhiều so với việc thêm vào khung dữ liệu:

1. Tạo một danh sách các từ điển trong đó mỗi từ điển tương ứng với một hàng dữ liệu đầu vào.
2. Tạo một khung dữ liệu từ danh sách này.

Tôi đã có một nhiệm vụ tương tự để nối vào hàng khung dữ liệu theo hàng mất 30 phút và tạo khung dữ liệu từ danh sách từ điển hoàn thành trong vài giây.

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)               

Bạn có thể sử dụng pandas.concat()hoặc DataFrame.append(). Để biết chi tiết và ví dụ, xem Hợp nhất, tham gia và nối .

Đó là một thời gian dài, nhưng tôi cũng gặp phải vấn đề tương tự. Và tìm thấy ở đây rất nhiều câu trả lời thú vị. Vì vậy, tôi đã nhầm lẫn sử dụng phương pháp nào.

Trong trường hợp thêm nhiều hàng vào dataframe, tôi quan tâm đến hiệu suất tốc độ . Vì vậy, tôi đã thử 4 phương pháp phổ biến nhất và kiểm tra tốc độ của chúng.

CẬP NHẬT NĂM 2019 bằng cách sử dụng các phiên bản mới của gói. Cũng được cập nhật sau khi bình luận @FooBar

HIỆU SUẤT TỐC ĐỘ

1. Sử dụng .append ( câu trả lời của NPE )
2. Sử dụng .loc ( câu trả lời của fred )
3. Sử dụng .loc với preallocating ( câu trả lời của FooBar )
4. Sử dụng dict và tạo DataFrame cuối cùng ( câu trả lời của ShikharDua )

Kết quả (tính bằng giây):

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

Cũng cảm ơn @krassowski vì bình luận hữu ích - Tôi đã cập nhật mã.

Vì vậy, tôi sử dụng bổ sung thông qua từ điển cho bản thân mình.

Mã số:

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)

Tái bút: Tôi tin rằng, nhận thức của tôi không hoàn hảo và có thể có một số tối ưu hóa.

Nếu bạn biết số lượng mục nhập cũ, bạn nên phân bổ không gian bằng cách cung cấp chỉ mục (lấy ví dụ dữ liệu từ một câu trả lời khác):

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

So sánh tốc độ

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

Và - như từ các bình luận - với kích thước 6000, sự khác biệt về tốc độ càng trở nên lớn hơn:

Việc tăng kích thước của mảng (12) và số lượng hàng (500) làm cho sự khác biệt về tốc độ trở nên nổi bật hơn: 313ms so với 2.29s

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

Để nối thêm hiệu quả, hãy xem Cách thêm một hàng bổ sung vào khung dữ liệu gấu trúc và Cài đặt với Phóng to .

Thêm hàng thông qua loc/ixtrên hiện không dữ liệu chỉ số chủ chốt. ví dụ :

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

Hoặc là:

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

Bạn có thể nối thêm một hàng dưới dạng từ điển bằng ignore_indextùy chọn.

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

Vì lợi ích của cách Pythonic, ở đây thêm câu trả lời của tôi:

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

Bạn cũng có thể xây dựng một danh sách các danh sách và chuyển đổi nó thành một khung dữ liệu -

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)

cho

    tôi gấp đôi hình vuông
0 0 0 0
1 1 2 1
2 2 4 4
3 3 6 9
4 4 8 16
5 5 10 25

Đây không phải là một câu trả lời cho câu hỏi OP mà là một ví dụ đồ chơi để minh họa câu trả lời của @ShikharDua ở trên mà tôi thấy rất hữu ích.

Mặc dù đoạn này là không đáng kể, nhưng trong dữ liệu thực tế tôi có 1.000 hàng và nhiều cột và tôi muốn có thể nhóm theo các cột khác nhau và sau đó thực hiện các số liệu thống kê bên dưới cho nhiều hơn một cột thẻ. Vì vậy, có một phương pháp đáng tin cậy để xây dựng khung dữ liệu một hàng tại một thời điểm là một thuận tiện lớn. Cảm ơn bạn @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)

Tìm ra một cách đơn giản và tốt đẹp:

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

Bạn có thể sử dụng đối tượng trình tạo để tạo Dataframe, sẽ giúp bộ nhớ hiệu quả hơn trong danh sách.

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

Để thêm thô vào DataFrame hiện tại, bạn có thể sử dụng phương thức chắp thêm.

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

Tạo một bản ghi mới (khung dữ liệu) và thêm vào old_data_frame .
vượt qua danh sách các giá trị và tên cột tương ứng để tạo 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])

Đây là cách để thêm / nối một hàng trong 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]) 

Nó có thể được sử dụng để chèn / nối một hàng trong gấu trúc trống hoặc dân cư DataFrame

Thay vì một danh sách các từ điển như trong câu trả lời của ShikharDua, chúng ta cũng có thể biểu diễn bảng của mình dưới dạng từ điển danh sách , trong đó mỗi danh sách lưu trữ một cột theo thứ tự hàng, cho chúng ta biết trước các cột của mình. Cuối cùng, chúng tôi xây dựng DataFrame của chúng tôi một lần.

Đối với cột c và n hàng, điều này sử dụng 1 từ điển và danh sách c , so với 1 danh sách và n từ điển. Danh sách phương pháp từ điển có mỗi từ điển lưu trữ tất cả các khóa và yêu cầu tạo một từ điển mới cho mỗi hàng. Ở đây chúng tôi chỉ nối vào danh sách, đó là thời gian không đổi và về mặt lý thuyết rất nhanh.

# 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

nếu bạn muốn thêm hàng ở cuối, hãy thêm nó vào danh sách

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

Một cách khác để làm điều đó (có thể không thực hiện nhiều):

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

Bạn cũng có thể nâng cao lớp DataFrame như thế này:

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

Làm nó đơn giản. Bằng cách lấy danh sách làm đầu vào sẽ được thêm vào dưới dạng hàng trong khung dữ liệu: -

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)

Tất cả bạn cần là loc[df.shape[0]]hoặcloc[len(df)]

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

hoặc là

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

Chúng ta thường thấy cấu trúc df.loc[subscript] = …để gán cho một hàng DataFrame. Mikhail_Sam đã đăng các điểm chuẩn có chứa, trong số những người khác, cấu trúc này cũng như phương thức sử dụng dict và tạo DataFrame cuối cùng . Ông tìm thấy cái sau là nhanh nhất cho đến nay. Nhưng nếu chúng ta thay thế df3.loc[i] = …(với DataFrame được preallocated) trong mã của anh ta df3.values[i] = …, thì kết quả sẽ thay đổi đáng kể, theo đó phương thức đó thực hiện tương tự như sử dụng dict. Vì vậy, chúng ta nên thường xuyên sử dụng df.values[subscript] = …xem xét. Tuy nhiên, lưu ý rằng .valuescó một chỉ mục dựa trên zero, có thể khác với DataFrame.index.

gấu trúc.DataFrame.append

DataFrame.append (tự, khác, ign_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)

Với ign_index được đặt thành True:

df.append(df2, ignore_index=True)

trước khi thêm một hàng, chúng ta phải chuyển đổi khung dữ liệu thành từ điển ở đó bạn có thể thấy các khóa là các cột trong khung dữ liệu và các giá trị của các cột được lưu lại trong từ điển nhưng có khóa cho mỗi cột là số chỉ mục trong khung dữ liệu. Ý tưởng đó khiến tôi viết mã dưới đây.

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

Bạn có thể ghép hai DataFrames cho việc này. Về cơ bản, tôi đã gặp vấn đề này để thêm một hàng mới vào DataFrame hiện có với một chỉ mục ký tự (không phải là số). Vì vậy, tôi nhập dữ liệu cho một hàng mới trong ống dẫn () và chỉ mục trong danh sách.

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

Điều này sẽ đảm nhiệm việc thêm một mục vào DataFrame trống. Vấn đề là df.index.max() == nanchỉ số đầu tiên:

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