पंडों में नाम बदलना कॉलम


1822

मेरे पास पंडों और स्तंभ लेबल का उपयोग करने वाला एक डेटाफ्रेम है जिसे मुझे मूल कॉलम लेबल को बदलने के लिए संपादित करने की आवश्यकता है।

मैं स्तंभ नाम को एक DataFrame में बदलना चाहता हूँ Aजहाँ मूल स्तंभ नाम हैं:

['$a', '$b', '$c', '$d', '$e'] 

सेवा

['a', 'b', 'c', 'd', 'e'].

मेरे पास संपादित स्तंभ नाम एक सूची में संग्रहीत हैं, लेकिन मुझे नहीं पता कि स्तंभ नामों को कैसे बदला जाए।


1
आप उन आधिकारिक डॉक्स की जांच कर सकते हैं, जो नाम बदलने वाले कॉलम लेबल को कवर करते हैं: pandas.pydata.org/pandas-docs/stable/user_guide/text.html
ccpizza

जवाबों:


1825

बस इसे .columnsविशेषता पर नियत करें:

>>> df = pd.DataFrame({'$a':[1,2], '$b': [10,20]})
>>> df.columns = ['a', 'b']
>>> df
   a   b
0  1  10
1  2  20

302
क्या एकल कॉलम हेडर नाम बदलना संभव है?
ericmjl

112
@ericmjl: मान लीजिए कि आप df के पहले वेरिएबल का नाम बदलना चाहते हैं। तब आप कुछ इस तरह कर सकते हैं:new_columns = df.columns.values; new_columns[0] = 'XX'; df.columns = new_columns
cd98

54
ऐसा लगता है कि आप बस df.columns.values ​​[0] = 'XX' कर सकते हैं
RAY

25
बस मजाक कर रहे हैं, @ - ऐसा मत करो। ऐसा लगता है कि स्तंभ सूची में जो भी अनुक्रमण संग्रहीत करता है, वह स्वतंत्र सूची है। अपने डीएफ के लिए नामकरण को नष्ट करने वाला एक अच्छा काम करता है ...
मिच फ्लैक्स

433
@ericmjl हांdf.rename(columns = {'$b':'B'}, inplace = True)
नाचोकाब

2842

RENAME विशिष्ट रंग

df.rename()फ़ंक्शन का उपयोग करें और स्तंभों का नाम बदला जा सकता है। सभी स्तंभों का नाम बदलना नहीं है:

df = df.rename(columns={'oldName1': 'newName1', 'oldName2': 'newName2'})
# Or rename the existing DataFrame (rather than creating a copy) 
df.rename(columns={'oldName1': 'newName1', 'oldName2': 'newName2'}, inplace=True)

न्यूनतम कोड उदाहरण

df = pd.DataFrame('x', index=range(3), columns=list('abcde'))
df

   a  b  c  d  e
0  x  x  x  x  x
1  x  x  x  x  x
2  x  x  x  x  x

निम्नलिखित तरीके सभी काम करते हैं और एक ही आउटपुट का उत्पादन करते हैं:

df2 = df.rename({'a': 'X', 'b': 'Y'}, axis=1)  # new method
df2 = df.rename({'a': 'X', 'b': 'Y'}, axis='columns')
df2 = df.rename(columns={'a': 'X', 'b': 'Y'})  # old method  

df2

   X  Y  c  d  e
0  x  x  x  x  x
1  x  x  x  x  x
2  x  x  x  x  x

रिजल्ट को वापस असाइन करना याद रखें, क्योंकि संशोधन नहीं-इन-प्लेस है। वैकल्पिक रूप से, निर्दिष्ट करें inplace=True:

df.rename({'a': 'X', 'b': 'Y'}, axis=1, inplace=True)
df

   X  Y  c  d  e
0  x  x  x  x  x
1  x  x  x  x  x
2  x  x  x  x  x

V0.25 से, errors='raise'यदि आप एक अमान्य कॉलम-टू-रीनेम निर्दिष्ट करते हैं, तो आप त्रुटियों को भी निर्दिष्ट कर सकते हैं । V0.25 rename()डॉक्स देखें ।


READIGN COLUMN हेडर

के df.set_axis()साथ प्रयोग करें axis=1और inplace=False(प्रति वापस करने के लिए)।

df2 = df.set_axis(['V', 'W', 'X', 'Y', 'Z'], axis=1, inplace=False)
df2

   V  W  X  Y  Z
0  x  x  x  x  x
1  x  x  x  x  x
2  x  x  x  x  x

यह एक प्रति लौटाता है, लेकिन आप सेटिंग द्वारा डेटा-इन-इन को संशोधित कर सकते हैं inplace=True (यह संस्करणों के लिए डिफ़ॉल्ट व्यवहार <= 0.24 है लेकिन भविष्य में बदलने की संभावना है)।

आप सीधे हेडर भी दे सकते हैं:

df.columns = ['V', 'W', 'X', 'Y', 'Z']
df

   V  W  X  Y  Z
0  x  x  x  x  x
1  x  x  x  x  x
2  x  x  x  x  x

2
जब मैं 6 कॉलम डेटा फ़्रेम (डेटाफ़्रेम <प्रेस codeएन्ट्री >) संक्षिप्त प्रतिनिधित्व के साथ करता हूं : <वर्ग 'pandas.core.frame.ata.DrFrame'> Int64Index: 1000 प्रविष्टियां, 0 से 999 डेटा कॉलम: बॉडीआर्कडाउन 1000 नॉन-नल codeकार्य , लेकिन जब मैं डेटाफ्रेम.हेड () कॉलम के पुराने नाम फिर से प्रकट होता हूं।
darKoram

12
SettingWithCopyWarning:जब मैं इस उत्तर में दूसरे कोड के स्निपेट का उपयोग करता हूं तो मैं घबरा जाता हूं।
मोनिका हेडडेक

वहाँ regex प्रतिस्थापन के साथ इस का एक संस्करण है?
डेन्फ्रोमोफा

@lexual यदि दो मौजूदा कॉलम का एक ही नाम है तो क्या होगा? मैं पुराने कॉलम नाम का उल्लेख कैसे करूं?
आवाराबत्ती

14
पहला समाधान: df = df.rename(columns={'oldName1': 'newName1', 'oldName2': 'newName2'})प्रदर्शित नाम बदलता है, लेकिन अंतर्निहित डेटा संरचना में तत्व नहीं । इसलिए यदि आप कोशिश करते हैं df['newName1']तो आपको एक त्रुटि मिलेगी। inplace=Trueकि gotchya से बचने के लिए आवश्यक है।
चिड़चिड़ा_फिल्ड_स्कैंड्रोम

402

renameविधि एक ले जा सकते हैं समारोह उदाहरण के लिए,:

In [11]: df.columns
Out[11]: Index([u'$a', u'$b', u'$c', u'$d', u'$e'], dtype=object)

In [12]: df.rename(columns=lambda x: x[1:], inplace=True)

In [13]: df.columns
Out[13]: Index([u'a', u'b', u'c', u'd', u'e'], dtype=object)

56
अच्छा लगा। इसने मेरा दिन बचाया:df.rename(columns=lambda x: x.lstrip(), inplace=True)
रूट -11

2
@ रूट -11 के समान - मेरे मामले में एक बुलेट पॉइंट कैरेक्टर था, जिसे आईपिथॉन कंसोल आउटपुट में प्रिंट नहीं किया गया था, इसलिए मुझे सिर्फ व्हॉट्सएप (स्ट्राइप) से ज्यादा निकालने की जरूरत थी, इसलिए:t.columns = t.columns.str.replace(r'[^\x00-\x7F]+','')
द रेड पीए

9
df.rename(columns=lambda x: x.replace(' ', '_'), inplace=True)एक रत्न है, ताकि हम लिखने के df.Column_1_Nameबजाय लिख सकें df.loc[:, 'Column 1 Name']
लिटिल बॉबी टेबल्स


163

पंडों 0.21+ उत्तर

संस्करण 0.21 में नाम बदलने के लिए कुछ महत्वपूर्ण अपडेट किए गए हैं।

  • renameविधि जोड़ा गया है axisपैरामीटर जो करने के लिए सेट किया जा सकता है columnsया 1। यह अद्यतन इस विधि को बाकी पांडा एपीआई से मेल खाता है। यह अभी भी है indexऔरcolumns मापदंडों लेकिन आप अब उन्हें उपयोग करने के लिए मजबूर नहीं हैं।
  • set_axisविधि के साथ inplaceसेट करने के लिए Falseआप एक सूची के साथ सभी सूचकांक या स्तंभ लेबल का नाम बदलने के लिए सक्षम बनाता है।

पंडों के लिए उदाहरण 0.21+

नमूने का निर्माण करें

df = pd.DataFrame({'$a':[1,2], '$b': [3,4], 
                   '$c':[5,6], '$d':[7,8], 
                   '$e':[9,10]})

   $a  $b  $c  $d  $e
0   1   3   5   7   9
1   2   4   6   8  10

के renameसाथ axis='columns'या का उपयोग करaxis=1

df.rename({'$a':'a', '$b':'b', '$c':'c', '$d':'d', '$e':'e'}, axis='columns')

या

df.rename({'$a':'a', '$b':'b', '$c':'c', '$d':'d', '$e':'e'}, axis=1)

निम्नलिखित में दोनों परिणाम:

   a  b  c  d   e
0  1  3  5  7   9
1  2  4  6  8  10

पुरानी पद्धति के हस्ताक्षर का उपयोग करना अभी भी संभव है:

df.rename(columns={'$a':'a', '$b':'b', '$c':'c', '$d':'d', '$e':'e'})

renameफ़ंक्शन उन कार्यों को भी स्वीकार करता है जो प्रत्येक कॉलम नाम पर लागू होंगे।

df.rename(lambda x: x[1:], axis='columns')

या

df.rename(lambda x: x[1:], axis=1)

का उपयोग करते हुए set_axisएक सूची के साथ औरinplace=False

आप उस सूची को एक set_axisविधि प्रदान कर सकते हैं जो लंबाई में स्तंभों (या अनुक्रमणिका) की संख्या के बराबर है। वर्तमान में, inplaceचूक के लिए True, लेकिन भविष्य के रिलीज में inplaceचूक हो जाएगा False

df.set_axis(['a', 'b', 'c', 'd', 'e'], axis='columns', inplace=False)

या

df.set_axis(['a', 'b', 'c', 'd', 'e'], axis=1, inplace=False)

क्यों नहीं इस्तेमाल करते? df.columns = ['a', 'b', 'c', 'd', 'e'] ?

इस तरह सीधे कॉलम असाइन करने में कुछ भी गलत नहीं है। यह पूरी तरह से एक अच्छा उपाय है।

उपयोग करने set_axisका लाभ यह है कि इसे एक विधि श्रृंखला के भाग के रूप में उपयोग किया जा सकता है और यह DataFrame की एक नई प्रति लौटाता है। इसके बिना, आपको स्तंभों को पुन: असाइन करने से पहले श्रृंखला के अपने मध्यवर्ती चरणों को दूसरे चर पर संग्रहीत करना होगा।

# new for pandas 0.21+
df.some_method1()
  .some_method2()
  .set_axis()
  .some_method3()

# old way
df1 = df.some_method1()
        .some_method2()
df1.columns = columns
df1.some_method3()

1
धन्यवाद के लिए Pandas 0.21+ answer- किसी तरह मैं "नया क्या है" भाग में उस हिस्से को याद किया ...
मैक्सू

1
पंडास 3.6: df.rename ({'$ a': 'a', '$ b': 'b', '$ c': 'c', '$ d': 'd' ',' $ e ':' e '}, अक्ष =' कॉलम ')। एक अप्रत्याशित कीवर्ड तर्क "अक्ष" प्राप्त करता है
आर्थर डी। हावर्ड

3
df.columns = ['a ’,, b’,, c ’,' d’, 'e ’] अब काम नहीं कर रहा है, संस्करण ०.२२ के साथ काम करते हुए मुझे चेतावनी है कि पंडों ने कॉलम बनाने की अनुमति नहीं दी है एक नया विशेषता नाम । नाम बदलने के लिए कैसे अगर मेरे सभी कॉलम समान हैं: /
नबला

क्या एक, एकाधिक या सभी स्तंभों का नाम बदलने का एक तरीका है, यदि आप पहले से ही अपने सूचकांक के स्तंभ (नों) का नाम नहीं जानते हैं? धन्यवाद!
tommy.carstensen

यह एक बहुत ही उपयोगी टिप्पणी थी। उदाहरण के लिए, लंबोदर फ़ंक्शन ने मेरे सवाल का उत्तर दिया कि निम्नलिखित कैसे करें:(df .groupby(['page',pd.Grouper(key='date',freq='MS')])['clicks'].sum() .unstack(1) .rename(lambda x: x.strftime("%Y-%m"), axis='columns') )
दर्जे का

131

चूँकि आप केवल सभी कॉलम नामों में $ चिन्ह को हटाना चाहते हैं, आप बस कर सकते हैं:

df = df.rename(columns=lambda x: x.replace('$', ''))

या

df.rename(columns=lambda x: x.replace('$', ''), inplace=True)

1
यह न केवल ओपी के मामले में बल्कि सामान्य आवश्यकताओं में भी मदद करता है। जैसे: किसी विभाजक द्वारा स्तंभ नाम विभाजित करना और उसके एक हिस्से का उपयोग करना।
दीपक

77
df.columns = ['a', 'b', 'c', 'd', 'e']

यह आपके द्वारा प्रदान किए गए क्रम में मौजूदा नामों को आपके द्वारा प्रदान किए गए नामों से बदल देगा।


5
संशोधित न करें df.columns.values, यह गलत है। stackoverflow.com/questions/43291781/…
llllllllll

61
old_names = ['$a', '$b', '$c', '$d', '$e'] 
new_names = ['a', 'b', 'c', 'd', 'e']
df.rename(columns=dict(zip(old_names, new_names)), inplace=True)

इस तरह से आप अपनी new_namesइच्छानुसार मैन्युअली एडिट कर सकते हैं । महान कार्य करता है जब आपको गलत वर्तनी, उच्चारण, विशेष वर्ण आदि को हटाने के लिए केवल कुछ कॉलम का नाम बदलने की आवश्यकता होती है।


1
मुझे यह दृष्टिकोण पसंद है, लेकिन मुझे लगता df.columns = ['a', 'b', 'c', 'd', 'e']है कि यह सरल है।
क्रिस्टोफर पियर्सन

1
मुझे पुराने और नए नामों को जिप करने का यह तरीका पसंद है। हम df.columns.valuesपुराने नामों को प्राप्त करने के लिए उपयोग कर सकते हैं ।
bkowshik

1
मैं सारणीबद्ध दृश्य प्रदर्शित करता हूं और कॉलम को पुराने_नाम पर कॉपी करता हूं। मैं आवश्यकता सरणी को new_names पर कॉपी करता हूं। फिर ताना (ज़िप (पुराने_नाम, नए_नाम) का उपयोग करें) बहुत सुरुचिपूर्ण समाधान।
पौराणिक

मैं अक्सर कुछ myList = list(df) myList[10:20]आदि से सूचियों के सबसेट का उपयोग करता हूं: आदि - तो यह एकदम सही है।
टिम गॉटग्रेउ

पुराने नामों को लेने के लिए सबसे अच्छा जैसा कि @bkowshik ने सुझाव दिया था, फिर उन्हें संपादित करें और उन्हें फिर से डालें, अर्थात namez = df.columns.valuesउसके बाद कुछ संपादन, फिर करें df.columns = namez
पॉलजोन 32

34

एक पंक्ति या पाइपलाइन समाधान

मैं दो चीजों पर ध्यान केंद्रित करूंगा:

  1. ओपी स्पष्ट रूप से बताता है

    मेरे पास संपादित स्तंभ नाम एक सूची में संग्रहीत हैं, लेकिन मुझे नहीं पता कि स्तंभ नामों को कैसे बदला जाए।

    मैं इस समस्या को हल नहीं करना चाहता कि '$'प्रत्येक कॉलम हेडर के पहले वर्ण को कैसे बदलें या स्ट्रिप करें। ओपी पहले ही यह कदम उठा चुका है। इसके बजाय मैं मौजूदा columnsकॉलम को बदलने वाले कॉलम नामों की एक सूची के साथ मौजूदा ऑब्जेक्ट को बदलने पर ध्यान केंद्रित करना चाहता हूं ।

  2. df.columns = newnewनए कॉलम के नामों की सूची जहां है, वह उतना ही सरल है जितना कि यह मिलता है। इस दृष्टिकोण का दोष यह है कि इसे मौजूदा डेटाफ्रेम की columnsविशेषता को संपादित करने की आवश्यकता है और यह इनलाइन नहीं किया गया है। मैं मौजूदा डेटाफ़्रेम को संपादित किए बिना पाइपलाइनिंग के माध्यम से इसे प्रदर्शित करने के कुछ तरीके दिखाऊंगा।


सेटअप 1
पहले से मौजूद सूची के साथ कॉलम नामों को बदलने का नाम बदलने की आवश्यकता पर ध्यान केंद्रित करने के लिए, मैं dfप्रारंभिक कॉलम नामों और असंबंधित नए कॉलम नामों के साथ एक नया नमूना डेटाफ़्रेम बनाऊंगा ।

df = pd.DataFrame({'Jack': [1, 2], 'Mahesh': [3, 4], 'Xin': [5, 6]})
new = ['x098', 'y765', 'z432']

df

   Jack  Mahesh  Xin
0     1       3    5
1     2       4    6

समाधान 1
pd.DataFrame.rename

यह पहले ही कहा जा चुका है यदि आपके पास पुराने कॉलम के नामों को नए कॉलम नामों में मैप करने की सुविधा है, तो आप इसका उपयोग कर सकते हैं pd.DataFrame.rename

d = {'Jack': 'x098', 'Mahesh': 'y765', 'Xin': 'z432'}
df.rename(columns=d)

   x098  y765  z432
0     1     3     5
1     2     4     6

हालाँकि, आप आसानी से उस शब्दकोश को बना सकते हैं और उसे कॉल में शामिल कर सकते हैं rename । निम्नलिखित इस तथ्य का लाभ उठाता है कि जब पुनरावृत्ति होती है df, तो हम प्रत्येक स्तंभ नाम पर पुनरावृति करते हैं।

# given just a list of new column names
df.rename(columns=dict(zip(df, new)))

   x098  y765  z432
0     1     3     5
1     2     4     6

यदि आपके मूल स्तंभ नाम अद्वितीय हैं, तो यह बहुत अच्छा है। लेकिन अगर वे नहीं हैं, तो यह टूट जाता है।


सेटअप 2
गैर-अद्वितीय स्तंभ

df = pd.DataFrame(
    [[1, 3, 5], [2, 4, 6]],
    columns=['Mahesh', 'Mahesh', 'Xin']
)
new = ['x098', 'y765', 'z432']

df

   Mahesh  Mahesh  Xin
0       1       3    5
1       2       4    6

समाधान २
pd.concat का उपयोग करkeys तर्क हुए

पहले, ध्यान दें कि जब हम समाधान 1 का उपयोग करने का प्रयास करते हैं तो क्या होता है:

df.rename(columns=dict(zip(df, new)))

   y765  y765  z432
0     1     3     5
1     2     4     6

हमने newसूची को स्तंभ नामों के रूप में मैप नहीं किया । हमने दोहराना समाप्त कर दिया y765। इसके बजाय, हम कॉलम के माध्यम से पुनरावृत्ति करते हुए फ़ंक्शन के keysतर्क का उपयोग कर सकते हैं ।pd.concatdf

pd.concat([c for _, c in df.items()], axis=1, keys=new) 

   x098  y765  z432
0     1     3     5
1     2     4     6

समाधान 3
पुनर्निर्माण। इसका उपयोग केवल तभी किया जाना चाहिए जब आपके पास dtypeसभी स्तंभों के लिए एक एकल हो । अन्यथा, आप समाप्त करेंगेdtype object सभी स्तंभों के और उन्हें वापस परिवर्तित करने के लिए अधिक शब्दकोश कार्य की आवश्यकता होगी।

एक dtype

pd.DataFrame(df.values, df.index, new)

   x098  y765  z432
0     1     3     5
1     2     4     6

मिश्रित dtype

pd.DataFrame(df.values, df.index, new).astype(dict(zip(new, df.dtypes)))

   x098  y765  z432
0     1     3     5
1     2     4     6

समाधान 4
इस के साथ एक तिकड़मी चाल है transposeऔर set_indexpd.DataFrame.set_indexहमें एक सूचकांक इनलाइन सेट करने की अनुमति देता है, लेकिन कोई संगत नहीं है set_columns। तो हम संक्रमण कर सकते हैं, फिरset_index , और वापस हैं। हालांकि, एक ही एकल dtypeबनाम मिश्रितdtype समाधान 3 से कैविट यहां लागू होता है।

एक dtype

df.T.set_index(np.asarray(new)).T

   x098  y765  z432
0     1     3     5
1     2     4     6

मिश्रित dtype

df.T.set_index(np.asarray(new)).T.astype(dict(zip(new, df.dtypes)))

   x098  y765  z432
0     1     3     5
1     2     4     6

समाधान 5 प्रत्येक तत्व के माध्यम से उस चक्र में
एक lambdaका उपयोग करें । इस समाधान में, हम एक लैम्ब्डा पास करते हैं जो लेता है लेकिन फिर इसे अनदेखा करता है। यह भी लगता है, लेकिन यह उम्मीद नहीं है। इसके बजाय, एक पुनरावृत्त को एक डिफ़ॉल्ट मान के रूप में दिया जाता है और फिर मैं इसका उपयोग उस मूल्य के संबंध में बिना किसी समय के एक चक्र के माध्यम से कर सकता हूं ।pd.DataFrame.renamenew
xyx

df.rename(columns=lambda x, y=iter(new): next(y))

   x098  y765  z432
0     1     3     5
1     2     4     6

और जैसा कि मैंने sopython चैट में लोगों द्वारा बताया है , अगर मैं *बीच में एक जोड़ देता हूं xऔर y, मैं अपने yचर की रक्षा कर सकता हूं । हालाँकि, इस संदर्भ में मुझे विश्वास नहीं है कि इसे सुरक्षा की आवश्यकता है। यह अभी भी ध्यान देने योग्य है।

df.rename(columns=lambda x, *, y=iter(new): next(y))

   x098  y765  z432
0     1     3     5
1     2     4     6

हो सकता है कि हम जोड़ सकते हैंdf.rename(lambda x : x.lstrip('$'),axis=1)
YOBEN_S

Hi @piRSquared, क्या आप इस बारे में विस्तार से बता पाएंगे कि पांडा समाधान 5 में लैंबडा फ़ंक्शन का उपयोग कैसे करते हैं? जब आप कहते हैं कि आपको xनजरअंदाज किया जाता है, तो मैं आपका अनुसरण नहीं करता।
जोसमूर 98

33

श्रृंखला के नाम बनाम स्तंभ नाम

मैं थोड़ा समझाना चाहूंगा कि पर्दे के पीछे क्या होता है।

डेटाफ्रेम श्रृंखला का एक सेट है।

बदले में श्रृंखला एक का विस्तार कर रहे हैं numpy.array

numpy.arrayकी संपत्ति है .name

यह श्रृंखला का नाम है। यह शायद ही कभी होता है कि पांडा इस विशेषता का सम्मान करते हैं, लेकिन यह स्थानों में सुस्त है और इसका उपयोग कुछ पांडा व्यवहारों को हैक करने के लिए किया जा सकता है।

स्तंभों की सूची का नामकरण

यहाँ बहुत सारे उत्तर df.columnsविशेषता के बारे में बात करते हैं listजब वास्तव में यह एक है Series। इसका मतलब यह एक .nameविशेषता है।

यदि आप कॉलम के नाम को भरने का निर्णय लेते हैं तो यह होता है Series:

df.columns = ['column_one', 'column_two']
df.columns.names = ['name of the list of columns']
df.index.names = ['name of the index']

name of the list of columns     column_one  column_two
name of the index       
0                                    4           1
1                                    5           2
2                                    6           3

ध्यान दें कि इंडेक्स का नाम हमेशा एक कॉलम कम आता है।

कलाकृतियाँ जो लिंजर करती हैं

.nameविशेषता कभी कभी पर lingers। अगर आप सेट करेंगे df.columns = ['one', 'two']तो df.one.nameवसीयत 'one'

अगर आप सेट करेंगे df.one.name = 'three'तो df.columnsअभी भी आपको देंगे ['one', 'two'], और df.one.nameआपको देंगे'three'

परंतु

pd.DataFrame(df.one) वापस होगा

    three
0       1
1       2
2       3

क्योंकि पांडा .nameपहले से परिभाषित की पुन: उपयोग करता है Series

मल्टी लेवल कॉलम नाम

पंडों के पास बहुस्तरीय कॉलम नाम करने के तरीके हैं। इसमें बहुत अधिक जादू शामिल नहीं है, लेकिन मैं अपने उत्तर में भी इसे कवर करना चाहता था क्योंकि मैं किसी को भी यहां उठाता नहीं देखता।

    |one            |
    |one      |two  |
0   |  4      |  1  |
1   |  5      |  2  |
2   |  6      |  3  |

यह इस तरह से सूचियों में कॉलम सेट करके आसानी से प्राप्त करने योग्य है:

df.columns = [['one', 'one'], ['one', 'two']]

18

यदि आपको डेटाफ़्रेम मिला है, तो df.columns सब कुछ एक सूची में डंप करता है जिसे आप हेरफेर कर सकते हैं और फिर कॉलम के नामों के रूप में अपने डेटाफ़्रेम में पुन: असाइन कर सकते हैं ...

columns = df.columns
columns = [row.replace("$","") for row in columns]
df.rename(columns=dict(zip(columns, things)), inplace=True)
df.head() #to validate the output

सर्वोत्तम मार्ग? IDK। एक तरीका - हाँ।

प्रश्न के उत्तर में सामने रखी गई सभी मुख्य तकनीकों के मूल्यांकन का एक बेहतर तरीका है, cProfile का उपयोग करके gage मेमोरी और निष्पादन समय तक करना। @kadee, @kaitlyn, & @eumiro के पास सबसे तेज़ निष्पादन समय के साथ कार्य थे - हालांकि ये कार्य इतनी तेज़ हैं कि हम सभी उत्तरों के लिए .000 और .001 सेकंड के दौर की तुलना कर रहे हैं। Moral: ऊपर दिए गए मेरे उत्तर की संभावना 'सर्वश्रेष्ठ' तरीका नहीं है।

import pandas as pd
import cProfile, pstats, re

old_names = ['$a', '$b', '$c', '$d', '$e']
new_names = ['a', 'b', 'c', 'd', 'e']
col_dict = {'$a': 'a', '$b': 'b','$c':'c','$d':'d','$e':'e'}

df = pd.DataFrame({'$a':[1,2], '$b': [10,20],'$c':['bleep','blorp'],'$d':[1,2],'$e':['texa$','']})

df.head()

def eumiro(df,nn):
    df.columns = nn
    #This direct renaming approach is duplicated in methodology in several other answers: 
    return df

def lexual1(df):
    return df.rename(columns=col_dict)

def lexual2(df,col_dict):
    return df.rename(columns=col_dict, inplace=True)

def Panda_Master_Hayden(df):
    return df.rename(columns=lambda x: x[1:], inplace=True)

def paulo1(df):
    return df.rename(columns=lambda x: x.replace('$', ''))

def paulo2(df):
    return df.rename(columns=lambda x: x.replace('$', ''), inplace=True)

def migloo(df,on,nn):
    return df.rename(columns=dict(zip(on, nn)), inplace=True)

def kadee(df):
    return df.columns.str.replace('$','')

def awo(df):
    columns = df.columns
    columns = [row.replace("$","") for row in columns]
    return df.rename(columns=dict(zip(columns, '')), inplace=True)

def kaitlyn(df):
    df.columns = [col.strip('$') for col in df.columns]
    return df

print 'eumiro'
cProfile.run('eumiro(df,new_names)')
print 'lexual1'
cProfile.run('lexual1(df)')
print 'lexual2'
cProfile.run('lexual2(df,col_dict)')
print 'andy hayden'
cProfile.run('Panda_Master_Hayden(df)')
print 'paulo1'
cProfile.run('paulo1(df)')
print 'paulo2'
cProfile.run('paulo2(df)')
print 'migloo'
cProfile.run('migloo(df,old_names,new_names)')
print 'kadee'
cProfile.run('kadee(df)')
print 'awo'
cProfile.run('awo(df)')
print 'kaitlyn'
cProfile.run('kaitlyn(df)')

आपको नाम बदलने की विधि की आवश्यकता क्यों है? कुछ इस तरह से मेरे लिए काम किया # df.columns = [row.replace ('$', '') पंक्ति में df.columns के लिए]
shantanuo

मैं 'चीजों' को नहीं समझता। मुझे क्या विकल्प देना है? पुराने कॉलम?
एंड्रिया इयानी

18

मान लीजिए कि यह आपकी डेटाफ्रेम है।

यहां छवि विवरण दर्ज करें

आप दो तरीकों का उपयोग करके कॉलम का नाम बदल सकते हैं।

  1. का उपयोग करते हुए dataframe.columns=[#list]

    df.columns=['a','b','c','d','e']

    यहां छवि विवरण दर्ज करें

    इस विधि की सीमा यह है कि यदि एक कॉलम को बदलना है, तो पूर्ण कॉलम सूची को पास करना होगा। साथ ही, यह विधि इंडेक्स लेबल पर लागू नहीं है। उदाहरण के लिए, यदि आपने इसे पारित किया है:

    df.columns = ['a','b','c','d']

    यह एक त्रुटि फेंक देगा। लंबाई बेमेल: अपेक्षित अक्ष में 5 तत्व हैं, नए मानों में 4 तत्व हैं।

  2. एक अन्य विधि पंडों की rename()विधि है जिसका उपयोग किसी भी सूचकांक, स्तंभ या पंक्ति का नाम बदलने के लिए किया जाता है

    df = df.rename(columns={'$a':'a'})

    यहां छवि विवरण दर्ज करें

इसी तरह, आप किसी भी पंक्तियों या स्तंभों को बदल सकते हैं।


17
df = pd.DataFrame({'$a': [1], '$b': [1], '$c': [1], '$d': [1], '$e': [1]})

यदि कॉलम की आपकी नई सूची मौजूदा कॉलम के समान क्रम में है, तो असाइनमेंट सरल है:

new_cols = ['a', 'b', 'c', 'd', 'e']
df.columns = new_cols
>>> df
   a  b  c  d  e
0  1  1  1  1  1

यदि आपके पास पुराने कॉलम नामों पर नए कॉलम नामों के लिए एक शब्दकोष है, तो आप निम्नलिखित कार्य कर सकते हैं:

d = {'$a': 'a', '$b': 'b', '$c': 'c', '$d': 'd', '$e': 'e'}
df.columns = df.columns.map(lambda col: d[col])  # Or `.map(d.get)` as pointed out by @PiRSquared.
>>> df
   a  b  c  d  e
0  1  1  1  1  1

यदि आपके पास सूची या शब्दकोश मानचित्रण नहीं है, तो आप $सूची चिह्न के माध्यम से अग्रणी प्रतीक को हटा सकते हैं:

df.columns = [col[1:] if col[0] == '$' else col for col in df]

2
इसके बजाय lambda col: d[col]आप पास हो सकते हैं d.get... तो ऐसा लगेगाdf.columns.map(d.get)
piRSquared


15

आइए एक छोटे से उदाहरण से नाम बदलने की समझ रखते हैं ...

1. मैपिंग का उपयोग कर कॉलम का नामकरण:

df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}) #creating a df with column name A and B
df.rename({"A": "new_a", "B": "new_b"},axis='columns',inplace =True) #renaming column A with 'new_a' and B with 'new_b'

output:
   new_a  new_b
0  1       4
1  2       5
2  3       6

मैपिंग का उपयोग करके 2.Renaming सूचकांक / Row_Name:

df.rename({0: "x", 1: "y", 2: "z"},axis='index',inplace =True) #Row name are getting replaced by 'x','y','z'.

output:
       new_a  new_b
    x  1       4
    y  2       5
    z  3       6

सबसे उच्च उत्कीर्ण जवाब पहले से ही इस तरह के उदाहरण हैं ...
इटमार मुश्किन

14

मूल स्तंभ लेबल को प्रतिस्थापित करने का एक अन्य तरीका मूल स्तंभ लेबल से अवांछित वर्ण (यहां '$') को अलग करना है।

यह df.columns पर लूप के लिए चलाकर और छपे हुए कॉलम को df.columns में जोड़कर किया जा सकता था।

इसके बजाय, हम नीचे की तरह सूची समझ का उपयोग करके एक ही बयान में बड़े करीने से कर सकते हैं:

df.columns = [col.strip('$') for col in df.columns]

( stripपाइथन में विधि स्ट्रिंग के आरंभ और अंत से दिए गए वर्ण को स्ट्रिप्स करती है।)


2
क्या आप बता सकते हैं कि यह कैसे / क्यों काम करता है? यह भविष्य के पाठकों के लिए उत्तर को अधिक मूल्यवान बना देगा।
डैन लोवे

12

असली सरल बस उपयोग करें

df.columns = ['Name1', 'Name2', 'Name3'...]

और यह कॉलम नामों को आपके द्वारा रखे गए क्रम से असाइन करेगा


10

आप इसके लिए उपयोग कर सकते हैं str.slice:

df.columns = df.columns.str.slice(1)

1
पुनश्च: यह एक और अधिक क्रिया है df.columns.str[1:]... शायद इसका उपयोग करने के लिए बेहतर है, यह छोटा और अधिक स्पष्ट है।
cs95

9

मुझे पता है कि यह सवाल और जवाब मौत को चबा गया है। लेकिन मैंने इसे एक समस्या के लिए प्रेरणा के लिए संदर्भित किया था जो मुझे हो रही थी। मैं विभिन्न उत्तरों से बिट्स और टुकड़ों का उपयोग करके इसे हल करने में सक्षम था इसलिए किसी को भी इसकी आवश्यकता होने पर मेरी प्रतिक्रिया प्रदान करना।

मेरा तरीका सामान्य है जिसमें आप कॉमा को अलग करके अतिरिक्त सीमांकक जोड़ सकते हैं delimiters= - चर और भविष्य के प्रमाण को अलग करके।

काम कोड:

import pandas as pd
import re


df = pd.DataFrame({'$a':[1,2], '$b': [3,4],'$c':[5,6], '$d': [7,8], '$e': [9,10]})

delimiters = '$'
matchPattern = '|'.join(map(re.escape, delimiters))
df.columns = [re.split(matchPattern, i)[1] for i in df.columns ]

आउटपुट:

>>> df
   $a  $b  $c  $d  $e
0   1   3   5   7   9
1   2   4   6   8  10

>>> df
   a  b  c  d   e
0  1  3  5  7   9
1  2  4  6  8  10

8

ध्यान दें कि ये दृष्टिकोण मल्टीएंडेक्स के लिए काम नहीं करते हैं। एक MultiIndex के लिए, आपको निम्नलिखित की तरह कुछ करने की आवश्यकता है:

>>> df = pd.DataFrame({('$a','$x'):[1,2], ('$b','$y'): [3,4], ('e','f'):[5,6]})
>>> df
   $a $b  e
   $x $y  f
0  1  3  5
1  2  4  6
>>> rename = {('$a','$x'):('a','x'), ('$b','$y'):('b','y')}
>>> df.columns = pandas.MultiIndex.from_tuples([
        rename.get(item, item) for item in df.columns.tolist()])
>>> df
   a  b  e
   x  y  f
0  1  3  5
1  2  4  6

8

एक अन्य विकल्प एक नियमित अभिव्यक्ति का उपयोग करके नाम बदलना है:

import pandas as pd
import re

df = pd.DataFrame({'$a':[1,2], '$b':[3,4], '$c':[5,6]})

df = df.rename(columns=lambda x: re.sub('\$','',x))
>>> df
   a  b  c
0  1  3  5
1  2  4  6

6

यदि आपको अपने नियंत्रण से बाहर प्रदान प्रणाली द्वारा नामित स्तंभों के भार से निपटना है, तो मैं निम्नलिखित दृष्टिकोण के साथ आया हूं जो एक सामान्य दृष्टिकोण और एक बार में विशिष्ट प्रतिकृति का संयोजन है।

पहले कॉलम नामों के कुछ परिशिष्टों को फेंकने के लिए रीगेक्स एक्सप्रेशंस का उपयोग करते हुए डेटाफ्रेम कॉलम नामों से एक शब्दकोश बनाएं और फिर प्राप्त डेटाबेस में बाद में अपेक्षित रूप से कोर कॉलम नाम करने के लिए शब्दकोश में विशिष्ट प्रतिस्थापन जोड़ें।

यह तब डेटाफ़्रेम में एक बार में लागू होता है।

dict=dict(zip(df.columns,df.columns.str.replace('(:S$|:C1$|:L$|:D$|\.Serial:L$)','')))
dict['brand_timeseries:C1']='BTS'
dict['respid:L']='RespID'
dict['country:C1']='CountryID'
dict['pim1:D']='pim_actual'
df.rename(columns=dict, inplace=True)

5

पहले से दिए गए समाधान के अलावा, आप फ़ाइल को पढ़ते समय सभी कॉलमों को बदल सकते हैं। हम उपयोग कर सकते हैं namesऔरheader=0

सबसे पहले, हम उन नामों की एक सूची बनाते हैं जिन्हें हम अपने कॉलम नामों के रूप में उपयोग करना चाहते हैं:

import pandas as pd

ufo_cols = ['city', 'color reported', 'shape reported', 'state', 'time']
ufo.columns = ufo_cols

ufo = pd.read_csv('link to the file you are using', names = ufo_cols, header = 0)

इस स्थिति में, आपके नाम की सूची में सभी कॉलम नाम बदल दिए जाएंगे।


4

यहाँ एक छोटा सा फ़ंक्शन है जिसे मैं टाइपिंग में कटौती करना पसंद करता हूं:

def rename(data, oldnames, newname): 
    if type(oldnames) == str: #input can be a string or list of strings 
        oldnames = [oldnames] #when renaming multiple columns 
        newname = [newname] #make sure you pass the corresponding list of new names
    i = 0 
    for name in oldnames:
        oldvar = [c for c in data.columns if name in c]
        if len(oldvar) == 0: 
            raise ValueError("Sorry, couldn't find that column in the dataset")
        if len(oldvar) > 1: #doesn't have to be an exact match 
            print("Found multiple columns that matched " + str(name) + " :")
            for c in oldvar:
                print(str(oldvar.index(c)) + ": " + str(c))
            ind = input('please enter the index of the column you would like to rename: ')
            oldvar = oldvar[int(ind)]
        if len(oldvar) == 1:
            oldvar = oldvar[0]
        data = data.rename(columns = {oldvar : newname[i]})
        i += 1 
    return data   

यह कैसे काम करता है इसका एक उदाहरण है:

In [2]: df = pd.DataFrame(np.random.randint(0,10,size=(10, 4)), columns=['col1','col2','omg','idk'])
#first list = existing variables
#second list = new names for those variables
In [3]: df = rename(df, ['col','omg'],['first','ohmy']) 
Found multiple columns that matched col :
0: col1
1: col2

please enter the index of the column you would like to rename: 0

In [4]: df.columns
Out[5]: Index(['first', 'col2', 'ohmy', 'idk'], dtype='object')

1
इस तरह के एक समारोह के लिए उपयोग मामला अत्यंत दुर्लभ है। ज्यादातर मामलों में, मुझे पता है कि मैं क्या देख रहा हूं और मैं इसका नाम बदलना चाहता हूं, मैं इसे स्वयं असाइन / संशोधित करूंगा।
CS95

1
@ सीएस 95 मैं बड़े राष्ट्रीय या अंतरराष्ट्रीय सर्वेक्षणों के साथ काम करता हूं, जहां चर में कोड नाम वाले चर नाम होंगे, जो उत्तर विकल्पों के आधार पर उपसर्गों से शुरू होते हैं, तराजू और शाखाएं (जैसे कि EDU_2913.443, EDU_2913.421, ...)। यह फ़ंक्शन उन प्रकार के सेटों के साथ काम करने में मेरे लिए बहुत उपयोगी रहा है, मुझे समझ में आता है कि क्या यह आपके लिए नहीं है :)
seeiespi


2

मान लें कि आप नियमित अभिव्यक्ति का उपयोग कर सकते हैं। यह समाधान regex का उपयोग करके मैन्युअल एन्कोडिंग की आवश्यकता को हटाता है

import pandas as pd
import re

srch=re.compile(r"\w+")

data=pd.read_csv("CSV_FILE.csv")
cols=data.columns
new_cols=list(map(lambda v:v.group(),(list(map(srch.search,cols)))))
data.columns=new_cols

1
यह स्टैक ओवरफ्लो पर एक अच्छा अभ्यास है ताकि यह समझा जाए कि आपके समाधान को काम करना चाहिए या मौजूदा समाधानों से बेहतर है। अधिक जानकारी के लिए उत्तर कैसे पढ़ें ।
शमूएल एलवाई

ध्यान दें कि किस प्रकार सर्वोत्तम श्रेणी के उत्तर के लिए किसी प्रकार की हार्ड कोडिंग की आवश्यकता होती है और सबसे खराब मूल्यांकन वाले उत्तर के लिए केवल वर्णनात्मक और प्रक्रियात्मक दृष्टिकोण की आवश्यकता होती है?
कौस्तुभ J

बेहतर (अधिक पठनीय) समाधान हैं जो रेगेक्स का भी उपयोग करते हैं। यह एक सरल रीनेमिंग ऑपरेशन के लिए इससे अधिक रास्ता तय कर रहा है। पैटर्न के खतरे में भी कुछ भी मेल नहीं खाता है जिस स्थिति में आपने त्रुटियों को संभालने के लिए कुछ भी नहीं किया है।
cs95
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.