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

데이터 프레임에 대한 모든 데이터를 미리 가져올 수있는 경우 데이터 프레임에 추가하는 것보다 훨씬 빠른 방법이 있습니다.

1. 각 사전이 입력 데이터 행에 해당하는 사전 목록을 작성하십시오.
2. 이 목록에서 데이터 프레임을 작성하십시오.

행 단위로 데이터 프레임을 추가하는 데 30 분이 걸리는 비슷한 작업이 있었고 몇 초 안에 완료 된 사전 목록에서 데이터 프레임을 작성했습니다.

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(). 세부 사항 및 예제는 병합, 결합 및 연결을 참조하십시오 .

오랜 시간이 지났지 만 같은 문제에 직면했습니다. 그리고 여기에 흥미로운 답변이 많이 있습니다. 그래서 어떤 방법을 사용 해야할지 혼란 스러웠습니다.

데이터 프레임에 많은 행을 추가하는 경우 속도 성능에 관심 이 있습니다. 그래서 가장 인기있는 4 가지 방법을 시도하고 속도를 확인했습니다.

새 버전의 패키지를 사용하여 2019 년에 업데이트되었습니다 . @FooBar 주석 후에도 업데이트 됨

속도 성능

1. .append 사용하기 ( NPE 's answer )
2. .loc 사용하기 ( fred 's answer )
3. 사전 할당과 함께 .loc 사용하기 ( FooBar 's answer )
4. dict을 사용하고 결국 DataFrame을 생성하십시오 ( ShikharDua 's answer )

결과 (초) :

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

추신 : 나는 내 실현이 완벽하지 않으며 아마도 최적화가 있다고 생각합니다.

사전에 입력 한 항목 수를 알고 있으면 인덱스를 제공하여 공간을 미리 할당해야합니다 (다른 답변에서 데이터 예제를 가져옴).

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

그리고 주석에서와 같이 크기가 6000 인 경우 속도 차이가 훨씬 커집니다.

어레이 (12) 및 행 수 (500)의 크기를 늘리면 속도 차이가 더욱 두드러집니다. 313ms 대 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

효율적으로 추가하려면 팬더 데이터 프레임에 추가 행을 추가하는 방법 및 확대 설정 을 참조하십시오 .

를 통해 행을 추가 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

파이썬 방식으로 여기에 내 대답을 추가하십시오.

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
1 1 1
2 2 4 4
3 3 6 9
44 8 16
5 5 10 25

이것은 OP 질문에 대한 대답이 아니라 위의 @ShikharDua의 대답을 설명하는 장난감 예제입니다.

이 조각은 사소한 것이지만 실제 데이터에는 1,000 개의 행과 많은 열이 있었고 여러 열로 그룹화 한 다음 둘 이상의 태그 열에 대해 아래 통계를 수행 할 수 있기를 원했습니다. 따라서 한 번에 한 행씩 데이터 프레임을 작성하는 신뢰할 수있는 방법을 갖는 것이 매우 편리했습니다. @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

생성기 객체를 사용하여 데이터 프레임을 만들 수 있으며, 이는 목록보다 메모리 효율성이 높습니다.

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

기존 DataFrame에 raw를 추가하려면 append 메소드를 사용할 수 있습니다.

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

간단하게. 데이터 프레임에서 행으로 추가 될 입력으로 목록을 가져옴 :-

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 및 create DataFrame을 사용하는 방법을 포함하는 벤치 마크 를 게시했습니다 . 그는 후자가 가장 빠르다는 것을 발견했다. 그러나 그의 코드에서 (사전 할당 된 DataFrame으로)를로 바꾸면 그 방법은 dict를 사용하는 것과 비슷한 방식으로 결과가 크게 변경됩니다. 따라서 우리는 더 자주 사용 을 고려해야합니다. 그러나 0부터 시작하는 아래 첨자를 사용해야합니다.이 첨자는 DataFrame.index와 다를 수 있습니다.df3.loc[i] = …df3.values[i] = …df.values[subscript] = ….values

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)

ignore_index를 True로 설정 한 경우 :

df.append(df2, ignore_index=True)

행을 추가하기 전에 데이터 프레임을 딕셔너리로 ​​변환해야합니다. 여기에서 키를 데이터 프레임의 열로 볼 수 있고 열의 값이 다시 사전에 저장되지만 모든 열의 키는 데이터 프레임의 인덱스 번호입니다. 그 아이디어는 아래 코드를 작성하게합니다.

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

이를 위해 두 개의 DataFrame을 연결할 수 있습니다. 기본적 으로이 문제를 발견하여 문자 색인 (숫자가 아님)으로 기존 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)]