Pandalar ve orijinal sütun etiketleri değiştirmek için düzenlemek gerekir sütun etiketleri kullanarak bir DataFrame var.

AOrijinal sütun adlarının olduğu bir DataFrame sütun adlarını değiştirmek istiyorum :

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

için

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

Düzenlenmiş sütun adlarını bir listede sakladım, ancak sütun adlarının nasıl değiştirileceğini bilmiyorum.

Sadece niteliğe atayın .columns:

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

ÖZEL KOLONLARI YENİLE

df.rename()İşlevi kullanın ve yeniden adlandırılacak sütunlara bakın. Tüm sütunların yeniden adlandırılması gerekmez:

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)

Minimum Kod Örneği

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

Aşağıdaki yöntemlerin hepsi aynı çıktıyı üretir ve üretir:

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

Değişikliği yerinde olmadığı için sonucu geri atamayı unutmayın. Alternatif olarak, inplace=Trueşunları belirtin :

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'ten, errors='raise'geçersiz bir yeniden adlandırılacak sütun belirtilirse hataları yükseltmeyi de belirtebilirsiniz . Bkz. V0.25 rename()belgeleri .

REASSIGN KOLON BAŞLIKLARI

Ve (bir kopyasını döndürmek için) df.set_axis()ile kullanın .axis=1inplace=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

Bu bir kopya döndürür, ancak DataFrame'i yerinde ayarlayarak değiştirebilirsiniz inplace=True(bu, <= 0.24 sürümleri için varsayılan davranıştır, ancak gelecekte değişmesi muhtemeldir).

Üstbilgileri doğrudan atayabilirsiniz:

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

renameYöntem sunar fonksiyonu örneğin:

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)

Metin verileriyle çalışma bölümünde belgelendiği gibi :

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

Pandalar 0.21+ Yanıt

0.21 sürümünde sütun yeniden adlandırmada bazı önemli güncelleştirmeler yapılmıştır.

• renameYöntem, ilave olan axisayarlanmış olabilir parametre columnsya da 1. Bu güncelleştirme, bu yöntemi diğer panda API'leriyle eşleşir. Hala indexve columnsparametrelerine sahiptir, ancak artık bunları kullanmak zorunda değilsiniz.
• set_axisYöntem ile inplacesetine Falsebir liste ile tüm dizin veya sütun etiketlerini yeniden adlandırmak sağlar.

Pandalar 0.21+ için örnekler

Örnek DataFrame'i oluşturun:

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

Veya renameile kullanmaaxis='columns'axis=1

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

veya

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

Her ikisi de aşağıdakilerle sonuçlanır:

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

Eski yöntem imzasını kullanmak hala mümkündür:

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

renameFonksiyon aynı zamanda her sütun adının uygulanacak işlevleri kabul eder.

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

veya

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

set_axisBir listeyle kullanma veinplace=False

set_axisYönteme sütun sayısına (veya dizine) eşit uzunlukta bir liste sağlayabilirsiniz . Şu anda, inplacevarsayılan True, ancak inplacevarsayılan olarak kapatılır Falsegelecek sürümlerde.

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

veya

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

Neden kullanmıyorsunuz df.columns = ['a', 'b', 'c', 'd', 'e']?

Sütunları doğrudan bu şekilde atamanın yanlış bir yanı yoktur. Mükemmel bir çözüm.

Kullanmanın avantajı, set_axisbir yöntem zincirinin parçası olarak kullanılabilmesi ve DataFrame'in yeni bir kopyasını döndürmesidir. Bu olmadan, sütunları yeniden atamadan önce zincirin ara adımlarını başka bir değişkene depolamanız gerekir.

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

Yalnızca tüm sütun adlarındaki $ işaretini kaldırmak istediğiniz için şunları yapabilirsiniz:

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

VEYA

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

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

Varolan adları, verdiğiniz sırayla verdiğiniz adlarla değiştirir.

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)

Böylece manuel new_namesolarak dilediğiniz gibi düzenleyebilirsiniz . Yanlış yazımları, aksanları düzeltmek, özel karakterleri kaldırmak vb. İçin yalnızca birkaç sütunu yeniden adlandırmanız gerektiğinde harika çalışır.

Tek hat veya Boru Hattı çözümleri

İki şeye odaklanacağım:

1. OP açıkça belirtiyor

   Düzenlenmiş sütun adlarını bir listede sakladım, ancak sütun adlarının nasıl değiştirileceğini bilmiyorum.

   '$'Her sütun üstbilgisinin ilk karakterini değiştirme veya soyma sorununu çözmek istemiyorum . OP zaten bu adımı attı. Bunun yerine columns, yedek sütun adlarının bir listesi verilen mevcut nesneyi yenisiyle değiştirmeye odaklanmak istiyorum .

2. df.columns = newnewyeni sütun adlarının listesi nerede olduğu kadar basittir. Bu yaklaşımın dezavantajı, mevcut veri çerçevesinin columnsniteliğini düzenlemeyi gerektirmesi ve satır içinde yapılmamasıdır. Mevcut veri çerçevesini düzenlemeden bunu boru hattıyla gerçekleştirmenin birkaç yolunu göstereceğim.

Kurulum 1
Sütun adlarını önceden var olan bir listeyle değiştirmenin yeniden adlandırılması ihtiyacına odaklanmak için, dfilk sütun adlarını ve ilgisiz yeni sütun adlarını içeren yeni bir örnek veri çerçevesi oluşturacağım .

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

Çözüm 1
pd.DataFrame.rename

Eski sütun adlarını yeni sütun adlarıyla eşleştiren bir sözlüğünüz varsa, kullanabileceğiniz zaten söylenmiştir 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

Ancak sözlüğü kolayca oluşturabilir ve çağrısına ekleyebilirsiniz rename. Aşağıdakiler, yineleme yaparken dfher sütun adı üzerinde yineleme yaptığımız gerçeğinden yararlanır .

# 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

Orijinal sütun adlarınız benzersizse bu harika çalışır. Ama eğer değillerse, o zaman bu yıkılır.

Benzersiz olmayan 2 sütun ayarlama

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. argümanı
pd.concatkullanarak çözümkeys

İlk olarak, çözüm 1'i kullanmaya çalıştığımızda ne olduğuna dikkat edin:

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

   y765  y765  z432
0     1     3     5
1     2     4     6

newListeyi sütun adları olarak eşleştirmedik . Biz tekrarlanan sona erdi y765. Bunun yerine ,. Sütunlarını yinelerken işlevin keysbağımsız değişkenini kullanabiliriz .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

Çözüm 3
Rekonstrüksiyon. Bu, yalnızca dtypetüm sütunlar için bir tekli varsa kullanılmalıdır . Aksi takdirde, dtype objecttüm sütunlar için sonuçlanır ve bunları geri dönüştürmek daha fazla sözlük çalışması gerektirir.

Tek dtype

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

   x098  y765  z432
0     1     3     5
1     2     4     6

Karışık 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

Çözüm 4
Bu transposeve ile dikkat çeken bir numaradır set_index. pd.DataFrame.set_indexsatır içi bir dizin belirlememize izin verir, ancak karşılık gelen yoktur set_columns. Böylece, sonradan set_indexve sonradan geri dönüş yapabiliriz. Bununla birlikte, çözelti 3'teki aynı tekli dtypeveya karışık dtypeuyarı burada geçerlidir.

Tek dtype

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

   x098  y765  z432
0     1     3     5
1     2     4     6

Karışık 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

Çözüm 5 Her bir elementin içinden geçen
bir lambdain kullanın . Bu çözümde, onu alan ancak görmezden gelen bir lambda geçiririz. Ayrıca alır ama beklemiyor. Bunun yerine, bir yineleyici varsayılan bir değer olarak verilir ve daha sonra değeri ne olursa olsun bir seferde bir geçiş yapmak için kullanabilirsiniz .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

Ve bana sopython sohbetinde millet tarafından işaret edildiği gibi *, arasına bir ek eklersemx ve değişkenimi ykoruyabilirim y. Yine de, bu bağlamda korunmaya ihtiyacı olduğuna inanmıyorum. Hala bahsetmeye değer.

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

   x098  y765  z432
0     1     3     5
1     2     4     6

Sütun adları ve Seri Adları

Perde arkasında neler olduğunu biraz açıklamak istiyorum.

Veri çerçeveleri bir dizi seridir.

Seri sırayla bir numpy.array

numpy.arraybir özelliği var .name

Bu serinin adı. Pandaların bu niteliğe saygı duyması nadiren görülür, ancak yerlerde kalır ve bazı pandaların davranışlarını kesmek için kullanılabilir.

Sütunlar listesini adlandırma

Burada birçok cevap, df.columnsözniteliğin listaslında bir olduğu zamandan bahsediyor Series. Bu, bir .nameniteliği olduğu anlamına gelir .

Sütunların adını girmeye karar verirseniz ne olur 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

Dizinin adının her zaman bir sütun daha düşük olduğunu unutmayın.

Oyalanacak eserler

.nameNitelik bazen çekişiyor. Eğer ayarladıysanız, df.columns = ['one', 'two']o zaman df.one.nameolacak 'one'.

Ayarlarsanız df.one.name = 'three'daha sonra df.columnsyine verecek ['one', 'two']ve df.one.namesize verecektir'three'

FAKAT

pd.DataFrame(df.one) geri dönücek

    three
0       1
1       2
2       3

Çünkü pandalar .nameönceden tanımlanmış olanları yeniden kullanır Series.

Çok düzeyli sütun adları

Pandaların çok katmanlı sütun adları yapma yolları vardır. Çok fazla sihir yok ama cevabımda bunu da ele almak istedim, çünkü burada kimsenin almasını görmüyorum.

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

Bu, sütunları listelere aşağıdaki gibi ayarlayarak kolayca elde edilebilir:

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

Veri çerçevesine sahipseniz, df.columns her şeyi değiştirebileceğiniz bir listeye atar ve ardından veri çerçevenize sütun adları olarak yeniden atayabilirsiniz ...

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

En iyi yol? BİLMİYORUM. Bir yol - evet.

Sorunun cevaplarında ortaya konan tüm ana teknikleri değerlendirmenin daha iyi bir yolu, bellek ve yürütme süresini ölçmek için cProfile kullanmaktır. @kadee, @kaitlyn, & @eumiro en hızlı yürütme sürelerine sahip işlevlere sahipti - bu işlevler o kadar hızlı olsa da, tüm yanıtlar için .000 ve .001 saniyelerinin yuvarlanmasını karşılaştırıyoruz. Ahlaki: Yukarıdaki cevabım muhtemelen 'En İyi' yol değil.

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

Bunun veri çerçeveniz olduğunu varsayalım.

Sütunları iki yöntem kullanarak yeniden adlandırabilirsiniz.

1. kullanma dataframe.columns=[#list]

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

   

   Bu yöntemin sınırlaması, bir sütunun değiştirilmesi gerekiyorsa, tam sütun listesinin geçirilmesi gerektiğidir. Ayrıca, bu yöntem dizin etiketlerinde uygulanamaz. Örneğin, bunu geçtiyseniz:

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

   Bu bir hata verecektir. Uzunluk uyuşmazlığı: Beklenen eksenin 5 öğesi, yeni değerlerin 4 öğesi vardır.

2. Başka bir yöntem, rename()herhangi bir dizin, sütun veya satırı yeniden adlandırmak için kullanılan Pandas yöntemidir

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

   

Benzer şekilde, herhangi bir satırı veya sütunu değiştirebilirsiniz.

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

Yeni sütun listeniz mevcut sütunlarla aynı sıradaysa atama basittir:

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

Eski sütun adlarına yeni sütun adlarına anahtarlanmış bir sözlüğünüz varsa, aşağıdakileri yapabilirsiniz:

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

Bir listeniz veya sözlük eşlemeniz yoksa, önde gelen $sembolü bir liste kavramasıyla çıkarabilirsiniz :

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

Küçük bir örnekle yeniden adlandırmayı anlayalım ...

1. Eşlemeyi kullanarak sütunları yeniden adlandırma:

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

Eşleme kullanarak dizin / Satır_Adı yeniden adlandırma:

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

Orijinal sütun etiketlerini değiştirebilmemizin bir başka yolu, istenmeyen sütunları (burada '$') orijinal sütun etiketlerinden çıkarmaktır.

Bu, df.columns üzerinde bir for döngüsü çalıştırarak ve soyulmuş sütunları df.columns'a ekleyerek yapılabilirdi.

Bunun yerine, aşağıdaki gibi liste kavrayışını kullanarak bunu tek bir ifadede düzgün bir şekilde yapabiliriz:

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

( stripPython'daki yöntem, verilen karakteri dizenin başından ve sonundan ayırır.)

Gerçekten basit kullanım

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

sütun adlarını koyduğunuz sıraya göre atar.

Bunun için kullanabilirsiniz str.slice:

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

Bu soruyu biliyorum ve cevap çiğnendi. Ama yaşadığım problemlerden biri için ilham kaynağı olarak bahsettim. Farklı cevaplardan bitler ve parçalar kullanarak çözebildim, böylece herkesin ihtiyaç duyması durumunda cevabımı sağladım.

Benim yöntem jeneriktir, burada virgül ayırıcısını ayırarak delimiters=ve sınırlayıcı olarak ek sınırlayıcılar ekleyebilirsiniz .

Çalışma Kodu:

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 ]

Çıktı:

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

Bu yaklaşımın bir MultiIndex için çalışmadığını unutmayın. MultiIndex için aşağıdakine benzer bir şey yapmanız gerekir:

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

Başka bir seçenek de normal bir ifade kullanarak yeniden adlandırmaktır:

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

Sağlayıcı sistem tarafından adlandırılan sütunlarla kontrolünüz dışında ilgilenmeniz gerekiyorsa, genel bir yaklaşımın ve tek seferde belirli değişikliklerin bir kombinasyonu olan aşağıdaki yaklaşımı buldum.

İlk olarak, sütun adlarının belirli eklerini atmak için regex ifadeleri kullanarak veri çerçevesi sütun adlarından bir sözlük oluşturun ve daha sonra alıcı veritabanında beklendiği gibi çekirdek sütunları adlandırmak için sözlüğe belirli değişiklikler ekleyin.

Bu daha sonra tek seferde veri çerçevesine uygulanır.

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)

Zaten sağlanan çözüme ek olarak, dosyayı okurken tüm sütunları değiştirebilirsiniz. Biz kullanabilir namesve header=0bunu yapmak için.

İlk olarak, sütun adlarımız olarak kullanmak istediğimiz adların bir listesini oluştururuz:

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)

Bu durumda, tüm sütun adları listenizdeki adlarla değiştirilir.

İşte yazmayı azaltmak için kullanmak gibi şık bir küçük fonksiyon:

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   

İşte nasıl çalıştığına bir örnek:

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

Pandalarda sütunları yeniden adlandırmak kolay bir iştir.

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

Normal ifadeyi kullanabileceğinizi varsayarsak. Bu çözüm regex kullanarak manuel kodlama ihtiyacını ortadan kaldırır

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