पांडा के लिए एक पंक्ति जोड़ें DataFrame

Question

मैं समझता हूं कि पांडा पूरी तरह से आबादी को लोड करने के लिए डिज़ाइन किए गए हैं, DataFrameलेकिन मुझे एक खाली डेटाफ़्रेम बनाने की आवश्यकता है , फिर पंक्तियों को एक-एक करके जोड़ें । इसे करने का बेहतरीन तरीका क्या है ?

मैंने सफलतापूर्वक एक खाली DataFrame बनाया है:

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

फिर मैं एक नई पंक्ति जोड़ सकता हूं और एक फ़ील्ड भर सकता हूं:

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

यह काम करता है लेकिन बहुत ही अजीब लगता है: - / (यह स्ट्रिंग मान जोड़ने में विफल रहता है)

मैं अपने डेटाफ़्रेम (विभिन्न कॉलम प्रकार के साथ) में एक नई पंक्ति कैसे जोड़ सकता हूं?

Comments

ध्यान दें कि यह एक बड़ा DataFrame बनाने के लिए एक बहुत ही अक्षम तरीका है; जब आप किसी पंक्ति को जोड़ते हैं तो नई सरणियाँ बनानी होती हैं (मौजूदा डेटा पर प्रतिलिपि बनाना)।

— वेस मैकिन्नी

@WesMcKinney: Thx, यह जानना वास्तव में अच्छा है। क्या विशाल तालिकाओं में कॉलम जोड़ना बहुत तेज़ है ?

— अधिकतम

यदि यह आपके लिए बहुत अक्षम है, तो आप एक अतिरिक्त पंक्ति का प्रचार कर सकते हैं और फिर उसे अपडेट कर सकते हैं।

— user1154664

Answer 1

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

Comments

मेमोरी को

— प्रचार

@MaximG: मैं दृढ़ता से अपग्रेड की सिफारिश करता हूं। वर्तमान पंडों का संस्करण 0.15.0 है।

— फ्रेड

.locइंडेक्स कॉलम को संदर्भित कर रहा है, इसलिए यदि आप पहले से मौजूद DataFrame के साथ एक इंडेक्स के साथ काम कर रहे हैं जो 0 से शुरू होने वाले पूर्णांक का एक निरंतर अनुक्रम नहीं है (जैसा कि आपके उदाहरण में), .locमौजूदा पंक्तियों को अधिलेखित कर देगा, या पंक्तियों को सम्मिलित करेगा, या अपने सूचकांक में अंतराल बनाएं। मौजूदा नॉनजरो-लेंथ डेटाफ्रेम को लागू करने के लिए एक अधिक मजबूत (लेकिन मूर्खतापूर्ण नहीं) दृष्टिकोण होगा: df.loc[df.index.max() + 1] = [randint(...या @FooBar के रूप में सूचकांक को पूर्व निर्धारित करने का सुझाव दिया।

— हॉब्स

@ हब्स तब df.index.max()है nanजब DataFrame खाली है।

— 1

@ हब्स एक समाधान जो मैंने सोचा था कि df.loc[0 if pd.isnull(df.index.max()) else df.index.max() + 1]

— टर्नेरी

Answer 2

यदि आप डेटा फ़्रेम अपफ्रंट के लिए सभी डेटा प्राप्त कर सकते हैं, तो डेटा फ्रेम में संलग्न होने की तुलना में बहुत तेज़ दृष्टिकोण है:

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)               

Comments

मैं किसी भी स्थिति के लिए ऐसा करने के लिए स्थानांतरित हो गया हूं जहां मुझे सभी डेटा सामने नहीं मिल सकते हैं। गति का अंतर आश्चर्यजनक है।

— फंतासी

पंडों के डॉक्स से कॉपी करना: 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

यह महान काम करता है! सिवाय जब मैंने डेटा फ्रेम बनाया, कॉलम के नाम सभी गलत क्रम में थे ...

— user5359531

@ user5359531 आप उस मामले में आदेश का उपयोग कर सकते हैं

— ShikharDua

@ user5359531 आप कॉलम को मैन्युअल रूप से निर्दिष्ट कर सकते हैं और ऑर्डर संरक्षित रहेगा। pd.DataFrame (पंक्तियों_सूची, कॉलम = ['C1', 'C2', 'C3']) चाल को पूरा करेगा

— Marcello Grechi Lins

Answer 3

आप pandas.concat()या उपयोग कर सकते हैं DataFrame.append()। विवरण और उदाहरणों के लिए, मर्ज देखें , जुड़ें, और संक्षिप्त करें ।

Comments

हाय, तो एपेंड () या कंकट () का उपयोग करने के तरीकों के लिए क्या जवाब है। मैं एक ही समस्या है, लेकिन अभी भी यह पता लगाने की कोशिश कर रहा।

— 22

यह सही उत्तर है, लेकिन यह बहुत अच्छा उत्तर नहीं है (केवल लगभग लिंक)।

— संयुक्त कार्य समूह

मुझे लगता है कि @ fred का उत्तर अधिक सही है। IIUC इस उत्तर के साथ समस्या यह है कि यह हर बार एक पंक्ति में संलग्न होने पर पूरे DataFrame को अनावश्यक रूप से कॉपी करता है। उस .locतंत्र का उपयोग करना जिसे टाला जा सकता है, खासकर यदि आप सावधान रहें।

— केन विलियम्स

लेकिन अगर आप उपयोग करना चाहते हैं DataFrame.append(), तो आपको यह सुनिश्चित करना होगा कि पहली पंक्ति में आपका डेटा भी एक सूची में एक DataFrame है।

— स्टेफुलिश

Answer 4

यह एक लंबा समय रहा है, लेकिन मुझे भी यही समस्या आई। और यहाँ बहुत सारे दिलचस्प जवाब मिले। तो मैं उलझन में था कि किस विधि का उपयोग करूं।

गति प्रदर्शन में रुचि रखने वाले डेटाफ्रेम में बहुत सी पंक्तियों को जोड़ने के मामले में । इसलिए मैंने 4 सबसे लोकप्रिय तरीकों की कोशिश की और उनकी गति की जाँच की।

पैकेजों के नए संस्करणों का उपयोग करके 2019 में अद्यतन किया गया । @FooBar कमेंट के बाद भी अपडेट किया गया

स्पीड प्रदर्शन

1. .Append ( NPE's उत्तर ) का उपयोग करना
2. .Loc का उपयोग करना ( fred's answer )
3. का उपयोग करना। उपदेश देने के साथ। FooBar का जवाब )
4. तानाशाही का उपयोग करना और अंत में डेटाफ़्रेम बनाना ( शिखरदुआ का जवाब )

परिणाम (सेकंड में):

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

पीएस मुझे विश्वास है, मेरा अहसास सही नहीं है, और शायद कुछ अनुकूलन है।

Comments

अनावश्यक रूप से उपयोग के df2.index.max()लिए .locकम्प्यूटेशनल जटिलता बढ़ जाती है। सिंपल df2.loc[i] = ...होता। मेरे लिए इसने समय 10 से 8.64 तक घटा दिया

— krassowski

कृपया सूची से मेरा नाम हटा दें, क्योंकि आप अपने परीक्षण में मेरे दृष्टिकोण का पालन नहीं कर रहे हैं: आप उपयुक्त आकार का एक सूचकांक प्रदान करके स्मृति का प्रचार नहीं कर रहे हैं।

— फुआबर

@FooBar हाय! मुझे खुशी है कि लेखक ने मेरा जवाब देखा :) आप सही हैं, मैं इस महत्वपूर्ण बिंदु से चूक गया। मैं अपने परिणाम तालिका के लिए एक और पंक्ति जोड़ना पसंद करता हूं क्योंकि आपका दृष्टिकोण अलग परिणाम दिखाता है!

— मिखाइल_सम

@Mikhail_Sam आप सबसे तेज़ विधि का उपयोग करके एक्सेल फ़ाइल पर लिखने के लिए पिवट-टेबल का उपयोग कैसे करेंगे?

— FabioSpaghetti

बस एक और टिप्पणी करना चाहते थे कि डंड टू पंडास डेटाफ्रेम एक बेहतर तरीका क्यों है। एक डेटासेट के साथ मेरे प्रयोग में, जिसमें तालिका में कई अलग-अलग प्रकार के डेटा होते हैं, पंडों को जोड़ने के तरीकों का उपयोग करते हुए टाइपिंग को नष्ट करते हैं, जबकि एक डिक्ट का उपयोग करते हुए, और केवल ONFCE से डेटाफ़्रेम का निर्माण करते हुए, मूल डेटाटैक्ट को निष्क्रिय रखने के लिए लगता है।

— ट्रम्पेटलिक्स

Answer 5

यदि आप एंटे पूर्व की संख्या जानते हैं, तो आपको सूचकांक प्रदान करके स्थान का प्रचार करना चाहिए (एक अलग उत्तर से डेटा उदाहरण लेना):

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) बढ़ने से गति का अंतर अधिक हड़ताली हो जाता है: 313 मीटर 4. 2 लाख

Comments

बहुत बढ़िया जवाब। यह मानदंड होना चाहिए ताकि पंक्ति स्थान को वृद्धिशील रूप से आवंटित न करना पड़े।

— ely

सरणी का आकार (12) और पंक्तियों की संख्या (500) बढ़ने से गति का अंतर अधिक हड़ताली हो जाता है: 313ms बनाम 2.29s

— टिकॉन

Answer 6

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

Comments

इस! मैं काफी समय से खोज रहा हूं, और यह पहली पोस्ट है जो वास्तव में दिखाता है कि किसी विशेष मान को एक पंक्ति में कैसे निर्दिष्ट किया जाए! बोनस प्रश्न: कॉलम-नाम / मान जोड़े के लिए कौन सा वाक्यविन्यास है? मुझे लगता है कि यह एक तानाशाह का उपयोग करके कुछ होना चाहिए, लेकिन मैं इसे सही नहीं कर सकता।

— झिन

जब आप इसे बढ़ाते हैं तो यह वास्तव में संपूर्ण डेटाफ़्रेम की प्रतिलिपि बनाने में सक्षम नहीं होता है।

— वाटरप्रूफ

Answer 7

कुशल अपील के लिए एक पांडा डेटाफ़्रेम और इज़ाफ़ा के साथ सेटिंग में एक अतिरिक्त पंक्ति कैसे जोड़ें देखें ।

गैर मौजूदा प्रमुख इंडेक्स डेटा 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

Comments

उपयोगकर्ताओं ने कार्यान्वयन के लिए कहा (एक नई पंक्ति जोड़ें)। यहां हम देखते हैं कि एक परिभाषित सूचकांक में एक पंक्ति कैसे जोड़ें या एक कॉलम जोड़ें।

— गिलहर्मे फेलिप रीस

किसी भी मानक पर यह कैसे काम करता है, इसकी तुलना में इस विधि की तुलना में है

— PirateApp

यह कुशल नहीं है क्योंकि यह वास्तव में पूरे DataFrame को कॉपी करता है।

— जलरोधक

Answer 8

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

Comments

आप यह भी उल्लेख कर सकते हैं कि f.append(<stuff>)एक नई वस्तु बनाता है, बजाय केवल वर्तमान वस्तु को जगह में जोड़ने के लिए, इसलिए यदि आप किसी स्क्रिप्ट में f = f.append(<stuff>)

— डेटाफ़्रेम

क्या ऐसा करने का कोई तरीका है?

— lol

@लॉल नहीं। देखें github.com/pandas-dev/pandas/issues/2801 - अंतर्निहित सरणियों को बढ़ाया नहीं जा सकता है, इसलिए उन्हें कॉपी करना होगा।

— वाटरप्रूफ

Answer 9

पाइथोनिक तरीके की खातिर, यहाँ मेरा जवाब जोड़ें:

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

Answer 10

आप सूचियों की एक सूची भी बना सकते हैं और इसे डेटाफ्रेम में बदल सकते हैं -

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)

दे रही है

    मैं डबल वर्ग
० ० ० ०
१ १ २ २ १
२ २ ४ ४
३ ३ ६ ९
4 4 8 16
५ ५ १० २५

Answer 11

यह ओपी प्रश्न का उत्तर नहीं है, लेकिन @ शेखरदुआ के उत्तर का वर्णन करने के लिए एक खिलौना उदाहरण है जिसके ऊपर मैंने बहुत उपयोगी पाया।

जबकि यह टुकड़ा तुच्छ है, वास्तविक डेटा में मेरे पास 1000 पंक्तियों, और कई कॉलम थे, और मैं अलग-अलग स्तंभों द्वारा समूह बनाने में सक्षम होना चाहता था और फिर नीचे दिए गए आँकड़े एक से अधिक टैग कॉलम के लिए प्रदर्शन करना चाहता था। इसलिए एक समय में डेटा फ्रेम एक पंक्ति के निर्माण के लिए एक विश्वसनीय तरीका एक महान सुविधा थी। शुक्रिया @ शिखारदुआ!

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)

Answer 12

एक सरल और अच्छा तरीका पता लगाया:

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

Comments

ध्यान दें कि यह पूरे डेटाफ्रेम को हुड के नीचे कॉपी करेगा। अंतर्निहित सरणियों को बढ़ाया नहीं जा सकता, इसलिए उन्हें कॉपी करना होगा।

— वाटरप्रूफ

Answer 13

डेटाफ़्रेम बनाने के लिए आप जेनरेटर ऑब्जेक्ट का उपयोग कर सकते हैं, जो सूची में अधिक मेमोरी कुशल होगा।

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 में कच्चे जोड़ने के लिए आप एपेंड विधि का उपयोग कर सकते हैं।

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

Answer 14

एक नया रिकॉर्ड (डेटा फ़्रेम) बनाएं और पुराने_डेटा_फ्रेम में जोड़ें । मानों और संबंधित कॉलम नामों
की सूची एक नया_कार्ड बनाने के लिए (डेटा_फ्रेम)

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

Answer 15

यहाँ एक पंक्ति जोड़ने / जोड़ने का तरीका है 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]) 

इसका उपयोग खाली या आबादी वाले पांडा डेटाफ्रेम में एक पंक्ति सम्मिलित / संलग्न करने के लिए किया जा सकता है

Comments

यह नीचे उतरते क्रम में सूचकांक के साथ जोड़ रहा है

— पार्थिबन राजेंद्रन

Answer 16

ShikharDua के उत्तर के रूप में शब्दकोशों की एक सूची के बजाय, हम अपनी तालिका को सूचियों के शब्दकोश के रूप में भी प्रस्तुत कर सकते हैं , जहां प्रत्येक सूची पंक्ति-क्रम में एक कॉलम संग्रहीत करती है, जिसे देखते हुए हम अपने स्तंभों को पहले से जानते हैं। अंत में हम एक बार अपने डेटाफ़्रेम का निर्माण करते हैं।

के लिए सी स्तंभों और एन पंक्तियाँ, इस का उपयोग करता है 1 शब्दकोश और ग सूचियों, 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

Answer 17

यदि आप अंत में पंक्ति जोड़ना चाहते हैं तो इसे एक सूची के रूप में जोड़ें

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

Answer 18

इसे करने का एक और तरीका (शायद बहुत अच्छा नहीं):

# 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

Answer 19

इसे सरल बनाओ। इनपुट के रूप में सूची लेकर, जिसे डेटा-फ्रेम में पंक्ति के रूप में जोड़ा जाएगा: -

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)

Answer 20

आप सभी की जरूरत है 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] 

Answer 21

हम अक्सर df.loc[subscript] = …एक डेटाफ़्रेम पंक्ति को असाइन करने के लिए निर्माण देखते हैं । मिखाइल_सैम ने बेंचमार्क को दूसरों के बीच पोस्ट किया , यह निर्माण के साथ-साथ तानाशाही का उपयोग करने वाला तरीका है और अंत में डेटाफ्रेम का निर्माण करता है । उन्होंने उत्तरार्द्ध को अब तक का सबसे तेज पाया। लेकिन अगर हम df3.loc[i] = …उसके कोड में (उपदेशित DataFrame के साथ) को प्रतिस्थापित करते हैं df3.values[i] = …, तो परिणाम काफी बदल जाता है, उस पद्धति में एक का उपयोग कर के समान होता है। इसलिए हमें अधिक बार df.values[subscript] = …विचार का उपयोग करना चाहिए । हालाँकि ध्यान दें कि .valuesएक शून्य-आधारित सबस्क्रिप्ट लेता है, जो DataFrame.index से भिन्न हो सकता है।

Comments

इसका एक कोड उदाहरण उपयोगी होगा

— baxx

@baxx - एक कोड उदाहरण में है बेंचमार्क लिंक ( # .loc with prealloc), एक और उदाहरण सवाल में है मैं पंक्तियों के बाकी हिस्सों से डेटा के साथ एक पांडा DataFrame की प्रत्येक पंक्ति के डेटा की तुलना करने के लिए है, वहाँ गणना में तेजी लाने के लिए एक रास्ता है ? और इसका स्वीकृत उत्तर।

— आर्मली

Answer 22

pandas.DataFrame.append

DataFrame.append (स्व, अन्य, ign_index = गलत, Ver_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)

Answer 23

एक पंक्ति को जोड़ने से पहले, हमें डेटाफ़्रेम को डिक्शनरी में बदलना होगा। आप डेटाफ़्रेम में कॉलम को देख सकते हैं और कॉलम के मान फिर से डिक्शनरी में स्टोर हो जाते हैं, लेकिन हर कॉलम की कुंजी डेटाफ़्रेम में इंडेक्स नंबर होती है। वह विचार मुझे नीचे दिए गए कोड को लिखने के लिए बनाता है।

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

Answer 24

आप इसके लिए दो DataFrames को संक्षिप्त कर सकते हैं। मैं मूल रूप से एक चरित्र सूचकांक (संख्यात्मक नहीं) के साथ मौजूदा DataFrame में एक नई पंक्ति जोड़ने के लिए इस समस्या में आया था। तो, मैं एक डक्ट () और एक सूची में सूचकांक में एक नई पंक्ति के लिए डेटा इनपुट करता हूं।

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

Answer 25

यह एक खाली 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)]