Panda DataFrame'e bir satır ekleme

Pandalar tamamen doldurulmuş yüklemek için tasarlanmış olduğunu anlıyorum DataFrameama boş bir DataFrame oluşturmak sonra tek tek satır eklemek gerekir . Bunu yapmanın en iyi yolu nedir?

Başarıyla boş bir DataFrame oluşturdum:

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

Sonra yeni bir satır ekleyebilir ve bir alanı doldurabilirim:

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

Çalışıyor ama çok garip görünüyor: - / (dize değeri eklenemedi)

DataFrame'ime (farklı sütun türleriyle) nasıl yeni bir satır ekleyebilirim?

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

Veri çerçevesi için tüm verileri önceden alabilmeniz durumunda, veri çerçevesine eklemekten çok daha hızlı bir yaklaşım vardır:

1. Her sözlüğün bir giriş veri satırına karşılık geldiği sözlüklerin bir listesini oluşturun.
2. Bu listeden bir veri çerçevesi oluşturun.

Bir satır veri satırına ekleme 30 dakika sürdü ve saniyeler içinde tamamlanan sözlükler listesinden bir veri çerçevesi oluşturma benzer bir görev vardı.

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)               

Sen kullanabilirsiniz pandas.concat()veya DataFrame.append(). Ayrıntılar ve örnekler için bkz. Birleştirme, katılma ve birleştirme .

Uzun zaman oldu, ama ben de aynı problemle karşılaştım. Ve burada birçok ilginç cevap buldum. Bu yüzden hangi yöntemi kullanacağım karıştı.

Veri çerçevesine çok sayıda satır eklenmesi durumunda, hız performansıyla ilgileniyorum . Bu yüzden en popüler 4 yöntemi denedim ve hızlarını kontrol ettim.

2019'da yeni paket sürümleri kullanılarak GÜNCELLENDİ . @FooBar yorumundan sonra da güncellendi

HIZ PERFORMANSI

1. .Append kullanma (NPE'nin cevabı )
2. .Loc kullanma ( fred cevabı )
3. Ploclocating ile .loc kullanma ( FooBar'ın cevabı )
4. Dict kullanarak ve sonunda DataFrame oluşturmak ( ShikharDua'nın cevabı )

Sonuçlar (saniye cinsinden):

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

Ayrıca yararlı yorum için @krassowski sayesinde - Kodu güncelledim.

Bu yüzden sözlüğü ekleyerek kendim için kullanıyorum.

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 İnanıyorum, aydınlanmam mükemmel değil ve belki de bazı optimizasyonlar var.

Eski girişlerin sayısını biliyorsanız, dizini de sağlayarak alanı önceden yeniden konumlandırmalısınız (veri örneğini farklı bir yanıttan alarak):

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

Hız karşılaştırması

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

Ve - yorumlardan olduğu gibi - 6000 büyüklüğünde, hız farkı daha da büyüyor:

Dizinin boyutunu (12) ve satır sayısını (500) artırmak hız farkını daha çarpıcı hale getirir: 313ms vs 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

Etkili bir ekleme için bkz. Panda veri çerçevesine fazladan bir satır ekleme ve Genişlemeyle Ayarlama .

Aracılığıyla satırları ekleyin loc/ixüzerinde olmayan mevcut anahtar endeks verileri. Örneğin :

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

Veya:

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_indexSeçeneği kullanarak tek bir satırı sözlük olarak ekleyebilirsiniz .

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

Pitonik yol uğruna cevabımı buraya ekleyin:

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

Ayrıca bir liste listesi oluşturabilir ve bunu bir veri çerçevesine dönüştürebilirsiniz -

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)

vererek

    çift ​​kare
0 0 0 0
1 1 2 1
2 2 4 4
3 3 6 9
4 4 8 16
5 5 10 25

Bu OP sorusuna bir cevap değil, çok yararlı bulduğum @ShikharDua'nın cevabını göstermek için oyuncak bir örnek.

Bu parça önemsiz olsa da, gerçek verilerde 1.000 satır ve birçok sütunum vardı ve farklı sütunlara göre gruplandırmak ve ardından birden fazla hedef sütunu için aşağıdaki istatistikleri gerçekleştirmek istedim. Bu nedenle, veri çerçevesini bir seferde bir satır oluşturmak için güvenilir bir yönteme sahip olmak büyük kolaylıktı. Teşekkürler @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)

Basit ve güzel bir yol bulduk:

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

Listede bellekte daha verimli olacak Dataframe oluşturmak için jeneratör nesnesini kullanabilirsiniz.

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

Mevcut DataFrame'e raw eklemek için append yöntemini kullanabilirsiniz.

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

Yeni bir kayıt (veri çerçevesi) oluşturun ve old_data_frame'e ekleyin . new_record oluşturmak için değerlerin
listesini ve karşılık gelen sütun adlarını iletin (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])

İşte bir satır eklemenin / eklemenin yolu 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]) 

Boş veya doldurulmuş pandalara satır eklemek / eklemek için kullanılabilir DataFrame

Bunun yerine ShikharDua yanıtında olduğu gibi sözlüklerde listesinin, biz de bir şekilde masamıza temsil edebilir listelerin sözlüğe her liste depolar satır-sırayla bir sütun, biz önceden bizim sütunları biliyorum verilen. Sonunda DataFrame'imizi bir kez inşa ediyoruz.

İçin c sütun ve n satır, bu kullanımlar 1 Sözlük ve c listeleri, 1 listesi ve karşı n sözlükleri. Sözlükler listesi yöntemi her sözlüğün tüm anahtarları depolamasını sağlar ve her satır için yeni bir sözlük oluşturmayı gerektirir. Burada sadece sabit zaman ve teorik olarak çok hızlı listelere ekliyoruz.

# 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

sonunda satır eklemek isterseniz, listeye ekleyin

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

Bunu yapmanın başka bir yolu (muhtemelen çok performanslı değil):

# 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 sınıfını şu şekilde de geliştirebilirsiniz:

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

Basitleştir. Veri çerçevesinde satır olarak eklenecek girdi olarak liste alınarak: -

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)

Tek ihtiyacınız olan loc[df.shape[0]]veyaloc[len(df)]

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

veya

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

Genellikle df.loc[subscript] = …bir DataFrame satırına atama yapısını görüyoruz . Mikhail_Sam , diğerleri arasında bu yapıyı içeren testler yayınladı ve sonunda dict kullanan ve sonunda DataFrame'i oluşturan yöntemi yayınladı . İkincisini açık arayla en hızlı buldu. Ancak, df3.loc[i] = …kodundaki (önceden yerleştirilmiş DataFrame ile) ile değiştirirsek, df3.values[i] = …sonuç önemli ölçüde değişir, bu yöntem dict kullanana benzer bir performans gösterir. Bu nedenle, kullanımını daha sık df.values[subscript] = …dikkate almalıyız . Ancak .values, DataFrame.index'ten farklı olabilecek sıfır tabanlı bir alt simge aldığını unutmayın.

pandas.DataFrame.append

DataFrame.append (kendi kendine, diğer, 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)

İgnore_index öğesi True olarak ayarlandığında:

df.append(df2, ignore_index=True)

bir satır eklemeden önce, veri çerçevesini sözlüğe dönüştürmeliyiz, anahtarları veri çerçevesinde sütunlar olarak görebilirsiniz ve sütunların değerleri tekrar sözlükte saklanır, ancak her sütun için anahtar veri çerçevesindeki dizin numarasıdır. Bu fikir bana aşağıdaki kodu yazmamı sağlıyor.

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

Bunun için iki DataFrame'i birleştirebilirsiniz. Temelde bir karakter dizini (sayısal değil) ile mevcut bir DataFrame yeni bir satır eklemek için bu sorunla karşılaştı. Bu nedenle, bir kanaldaki yeni bir satırın verilerini girerim () ve bir listede indeks.

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

Bu, boş bir DataFrame'e öğe eklemeyle ilgilenir. Sorun df.index.max() == nanilk dizin için:

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