මුල් තීරු ලේබල වෙනුවට ආදේශ කිරීමට මට සංස්කරණය කිරීමට අවශ්‍ය පැන්ඩා සහ තීරු ලේබල භාවිතා කරමින් මට දත්ත රාමුවක් ඇත.

Aමුල් තීරු නම් ඇති දත්ත රාමුවක තීරු නම් වෙනස් කිරීමට මම කැමතියි :

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

වෙත

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

මා විසින් සංස්කරණය කරන ලද තීරු නම් ලැයිස්තුවක් තුළ ගබඩා කර ඇත, නමුත් තීරු නම් ආදේශ කරන්නේ කෙසේදැයි මම නොදනිමි.

එය ගුණාංගයට පවරන්න .columns:

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

විශේෂිත තීරු නැවත නම් කරන්න

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

වෙනස් කිරීම සිදු නොවන බැවින් ප්‍රති result ලය නැවත ලබා දීමට මතක තබා ගන්න. විකල්පයක් ලෙස, සඳහන් කරන්න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() ලේඛන .

COLUMN HEADERS නැවත සකස් කරන්න

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

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

පෙළ දත්ත සමඟ වැඩ කිරීමේදී ලේඛනගත කර ඇති පරිදි :

df.columns = df.columns.str.replace('$','')

පණ්ඩස් 0.21+ පිළිතුර

0.21 අනුවාදයේ තීරු නැවත නම් කිරීම සඳහා සැලකිය යුතු යාවත්කාලීනයන් ඇත.

• මෙම renameක්රමය ද සඳහන් කර ඇත axisසකසා විය හැක පරාමිතිය columnsහෝ 1. මෙම යාවත්කාලීනය මෙම ක්‍රමය අනෙක් පැන්ඩාස් API සමඟ ගැලපේ. එයට තවමත් 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)

දෙකම පහත සඳහන් ප්‍රති in ල වලට හේතු වේ:

   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නම් එය ක්‍රම දාමයක කොටසක් ලෙස භාවිතා කළ හැකි අතර එය දත්ත රාමුවේ නව පිටපතක් ලබා දීමයි. එය නොමැතිව, තීරු නැවත පැවරීමට පෙර දාමයේ අතරමැදි පියවර වෙනත් විචල්‍යයකට ගබඩා කිරීමට ඔබට සිදුවේ.

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

ඔබට අවශ්‍ය වන්නේ සියලු තීරු නම්වල $ ලකුණ ඉවත් කිරීමට පමණි, ඔබට කළ හැක්කේ:

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

හෝ

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

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

එය ඔබ සපයන අනුපිළිවෙලට පවතින නම් වෙනුවට ඔබ සපයන නම් ආදේශ කරනු ඇත.

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. OP පැහැදිලිව සඳහන් කරයි

   මා විසින් සංස්කරණය කරන ලද තීරු නම් ලැයිස්තුවක් තුළ ගබඩා කර ඇත, නමුත් තීරු නම් ආදේශ කරන්නේ කෙසේදැයි මම නොදනිමි.

   '$'එක් එක් තීරු ශීර්ෂයේ පළමු අක්‍ෂරය ප්‍රතිස්ථාපනය කරන්නේ හෝ ඉවත් කරන්නේ කෙසේද යන ගැටළුව විසඳීමට මට අවශ්‍ය නැත . OP දැනටමත් මෙම පියවර කර ඇත. ඒ වෙනුවට මට අවශ්‍ය වන්නේ පවතින columnsවස්තුව ප්‍රතිස්ථාපනය කිරීම සඳහා නව තීරු නාම ලැයිස්තුවක් ලබා දීමයි .

2. df.columns = newඑහිදී newනව තීරු නම් ලැයිස්තුව එය ලැබෙන ලෙස සරල ලෙස වේ. මෙම ප්‍රවේශයේ ඇති අඩුපාඩුව නම්, දැනට පවතින දත්ත රාමුවේ 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

විසඳුම 2 තර්කය
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.concatශ්‍රිතයේ තර්කය භාවිතා කළ හැකිය df.

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_index. pd.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 හි එක් එක් මූලද්‍රව්‍යය හරහා එම චක්‍රයන්හි
a භාවිතා කරන්න. මෙම ද්‍රාවණය තුළ, අපි ලැම්බඩා එකක් පසුකර එය නොසලකා හරිමු. එය ද ගත වන නමුත් එය අපේක්ෂා නොකරයි. ඒ වෙනුවට, ඉරේටරයක් ​​පෙරනිමි අගයක් ලෙස ලබා දී ඇති අතර, පසුව එහි වටිනාකම කුමක් දැයි නොසලකා එක වරකට එක හරහා චක්‍රීය කිරීමට මට එය භාවිතා කළ හැකිය .lambdapd.DataFrame.renamenew
xyx

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

   x098  y765  z432
0     1     3     5
1     2     4     6

සොපයිතන් චැට් වල සිටින පුද්ගලයින් විසින් මට පෙන්වා දුන් පරිදි , මම *අතරට එකතු කළහොත් xසහ yමගේ yවිචල්‍යය ආරක්ෂා කළ හැකිය . මෙම සන්දර්භය තුළ එය ආරක්ෂා කිරීම අවශ්‍ය යැයි මම විශ්වාස නොකරමි. එය තවමත් සඳහන් කිරීම වටී.

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

   x098  y765  z432
0     1     3     5
1     2     4     6

තීරු නම් එදිරිව ශ්‍රේණියේ නම්

තිරය ​​පිටුපස සිදුවන දේ ටිකක් පැහැදිලි කිරීමට මම කැමතියි.

දත්ත රාමු යනු ශ්‍රේණි සමූහයකි.

ශ්‍රේණිය අනෙක් අතට a හි දිගුවකි numpy.array

numpy.arrayදේපල ඇත .name

මෙය මාලාවේ නමයි. පැන්ඩාස් මෙම ගුණාංගයට ගරු කරන්නේ කලාතුරකිනි, නමුත් එය ස්ථානවල රැඳී ඇති අතර සමහර පැන්ඩා හැසිරීම් හැක් කිරීමට භාවිතා කළ හැකිය.

තීරු ලැයිස්තුව නම් කිරීම

මෙහි බොහෝ පිළිතුරු කථා කරන්නේ df.columnsගුණාංගය listඇත්ත වශයෙන්ම එය a 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සමහරවිට විශේෂණය මොනවායේ. ඔබ සකසන්නේ 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']]

ඔබට දත්ත රාමුව තිබේ නම්, 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 භාවිතා කර මතකය සහ ක්‍රියාත්මක කිරීමේ වේලාව ගණනය කිරීමයි. adeKadee, akakaitlyn, & uemumro වේගවත්ම ක්‍රියාත්මක කිරීමේ වේලාවන් සමඟ ක්‍රියා කර ඇත - මෙම කාර්යයන් ඉතා වේගවත් වුවද අපි සියලු පිළිතුරු සඳහා තත්පර .000 සහ .001 ක වටය සංසන්දනය කරමු. සදාචාරය: ඉහත මගේ පිළිතුර 'හොඳම' ක්‍රමය නොවේ.

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

මෙය ඔබගේ දත්ත රාමුව යැයි කියමු.

ක්‍රම දෙකක් භාවිතා කර ඔබට තීරු නම් කළ හැකිය.

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

   

ඒ හා සමානව, ඔබට ඕනෑම පේළි හෝ තීරු වෙනස් කළ හැකිය.

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]

df.rename(index=str,columns={'A':'a','B':'b'})

https://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.rename.html

කුඩා උදාහරණයකින් නැවත නම් කිරීම තේරුම් ගනිමු ...

සිතියම් ගත කිරීම මඟින් තීරු නැවත නම් කිරීම:

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

සිතියම් ගත කිරීම මඟින් දර්ශකය / පේළියේ නම නැවත නම් කිරීම:

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

මුල් තීරු ලේබල ප්‍රතිස්ථාපනය කළ හැකි තවත් ක්‍රමයක් නම් මුල් තීරු ලේබල වලින් අනවශ්‍ය අක්ෂර (මෙහි '$') ඉවත් කිරීමයි.

මෙය කළ හැකි වූයේ df.columns හරහා ලූපයක් ධාවනය කිරීමෙන් සහ ඉවත් කළ තීරු df.columns වෙත එකතු කිරීමෙනි.

ඒ වෙනුවට, පහත දැක්වෙන පරිදි ලැයිස්තු අවබෝධය භාවිතා කිරීමෙන් අපට මෙය තනි ප්‍රකාශයකින් පිළිවෙලට කළ හැකිය:

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

( stripපයිතන් හි ක්‍රමය මඟින් ලබා දී ඇති අක්‍ෂරය ආරම්භයේ සිට අවසානය දක්වා තීරු කරයි.)

නියම සරල භාවිතා කරන්න

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

එය තීරු නම් ඔබ තැබූ අනුපිළිවෙලට ලබා දෙනු ඇත

ඔබට ඒ සඳහා භාවිතා කළ හැකිය str.slice:

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

මම දන්නවා මේ ප්‍රශ්නය සහ පිළිතුර හපනු ලැබුවා. නමුත් මා එය යොමු කළේ මට තිබූ එක් ගැටලුවකට ආශ්වාදයක් ලබා දීම සඳහා ය. විවිධ පිළිතුරු වලින් බිටු සහ කෑලි භාවිතයෙන් එය විසඳීමට මට හැකි විය. එබැවින් ඕනෑම කෙනෙකුට අවශ්‍ය විටෙක මගේ ප්‍රතිචාරය සපයයි.

මගේ ක්‍රමය සාමාන්‍යය වන අතර, කොමා මඟින් 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

තවත් විකල්පයක් වන්නේ සාමාන්‍ය ප්‍රකාශනයක් භාවිතා කර නැවත නම් කිරීමයි:

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

මෙම ප්‍රවේශය බහු ඉන්ඩෙක්ස් සඳහා ක්‍රියා නොකරන බව සලකන්න. 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

පැන්ඩා වල තීරු නැවත නම් කිරීම පහසු කාර්යයකි.

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

ඔබේ පාලනයෙන් බැහැරව සැපයුම් පද්ධතිය විසින් නම් කරන ලද තීරු රාශියක් සමඟ කටයුතු කිරීමට ඔබට සිදුවුවහොත්, මම පහත දැක්වෙන ප්‍රවේශය ඉදිරිපත් කළේ එය සාමාන්‍ය ප්‍රවේශයක එකතුවක් සහ එකවර එකවර ප්‍රතිස්ථාපනය කිරීමෙනි.

තීරු නම් වල සමහර උපග්‍රන්ථ ඉවතලීම සඳහා පළමුවෙන්ම දත්ත රාමු තීරු නාම වලින් රීජෙක්ස් ප්‍රකාශන භාවිතා කරමින් ශබ්ද කෝෂයක් සාදන්න, පසුව ලැබෙන දත්ත ගබඩාවේ අපේක්ෂා කළ පරිදි මූලික තීරු නම් කිරීම සඳහා ශබ්දකෝෂයට නිශ්චිත ආදේශක එකතු කරන්න.

මෙය එකවර දත්ත රාමුවට අදාළ වේ.

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)

දැනටමත් සපයා ඇති විසඳුමට අමතරව, ඔබ ගොනුව කියවන අතරතුර සියලු තීරු ප්රතිස්ථාපනය කළ හැකිය. අපි භාවිතා කළ හැකි 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)

මෙම අවස්ථාවේදී, සියලු තීරු නම් ඔබගේ ලැයිස්තුවේ ඇති නම් සමඟ ප්‍රතිස්ථාපනය වේ.

මෙන්න මම යතුරු ලියනය අඩු කිරීමට භාවිතා කිරීමට කැමති කුඩා කාර්යයක්:

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

ඔබට නිත්‍ය ප්‍රකාශනය භාවිතා කළ හැකි යැයි උපකල්පනය කිරීම. මෙම විසඳුම රීජෙක්ස් භාවිතයෙන් අතින් කේතීකරණයේ අවශ්‍යතාවය ඉවත් කරයි

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

මට XGBoost සඳහා විශේෂාංග නැවත නම් කිරීමට අවශ්‍ය විය, එය මේ කිසිවක් කැමති නැත:

import re
regex = r"[!\"#$%&'()*+,\-.\/:;<=>?@[\\\]^_`{|}~ ]+"
X_trn.columns = X_trn.columns.str.replace(regex, '_', regex=True)
X_tst.columns = X_tst.columns.str.replace(regex, '_', regex=True)