只需将其分配给属性即可：.columns

>>> df = pd.DataFrame({'$a':[1,2], '$b': [10,20]})
>>> df
   $a  $b
0   1  10
1   2  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)
df2 = df.rename({'a': 'X', 'b': 'Y'}, axis='columns')
df2 = df.rename(columns={'a': 'X', 'b': 'Y'}) 

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
 

您可以指定在指定无效的要重命名的列时引发错误。errors='raise'

---

重新分配列标题

将 df.set_axis（） 与 一起使用。axis=1

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

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

可以直接分配标头：

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 = df.rename(columns=lambda x: x.replace('$', ''))

或

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

用：

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

如使用文本数据中所述：

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

如果您已经获得了 DataFrame，df.columns 会将所有内容转储到一个列表中，您可以对其进行操作，然后将该列表作为列的名称重新分配给 DataFrame...

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

最好的方法？我不知道。一种方式 - 是的。

评估问题答案中提出的所有主要技术的更好方法是在下面使用 cProfile 来衡量内存和执行时间。@kadee、@kaitlyn 和 @eumiro 具有执行时间最快的函数 - 尽管这些函数非常快，但我们比较了所有答案的 0.000 和 0.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)')

替换原始列标签的另一种方法是从原始列标签中去除不需要的字符（此处为“$”）。

这可以通过在 df.columns 上运行 for 循环并将剥离的列附加到 df.columns 来完成。

相反，我们可以通过使用列表推导式在单个语句中巧妙地做到这一点，如下所示：

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

(stripPython 中的方法从字符串的开头和结尾剥离给定字符。

这真的很简单。只需使用：

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

它将按照您放置列名的顺序分配列名。

你可以使用 str.slice 来实现：

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

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.columns = ['a', 'b', 'c', 'd', 'e']

它将按照您提供的顺序将现有名称替换为您提供的名称。

我的方法是通用的，您可以通过逗号分隔变量来添加额外的分隔符，并使其面向未来。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

请注意，前面答案中的方法不适用于 MultiIndex。对于 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

列名与系列名称

我想解释一下幕后发生的事情。

数据帧是一组 Series。

反过来，级数是 .numpy.array

numpy.arrays 有一个属性。.name

这是该系列的名称。熊猫很少尊重这个属性，但它在某些地方徘徊，可以用来破解熊猫的一些行为。

命名列列表

这里的很多答案都谈到属性是 a，而实际上它是一个 .这意味着它有一个属性。df.columnslistSeries.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

请注意，索引的名称始终低一列。

挥之不去的文物

该属性有时会持续存在。如果设置，则 将为 ..namedf.columns = ['one', 'two']df.one.name'one'

如果你设置了 then 仍然会给你 ，并且会给你 .df.one.name = 'three'df.columns['one', 'two']df.one.name'three'

但

pd.DataFrame(df.one)将返回

    three
0       1
1       2
2       3

因为 Pandas 重用了已经定义的 ..nameSeries

多级列名

Pandas 有方法可以做多层列名。没有那么多的魔法，但我也想在我的回答中涵盖这一点，因为我在这里没有看到任何人注意到这一点。

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

这可以通过将列设置为列表来轻松实现，如下所示：

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

如果您必须处理由提供系统命名的大量列，而您无法控制，我想出了以下方法，即一次性结合通用方法和特定替换。

首先，使用正则表达式从数据帧列名称创建一个字典，以便丢弃列名的某些附录，然后向字典添加特定的替换项，以便稍后在接收数据库中按预期命名核心列。

然后，这将一次性应用于数据帧。

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)

一条生产线或管道解决方案

我将重点介绍两件事：

1. OP明确指出

   我将编辑后的列名存储在列表中，但我不知道如何替换列名。

   我不想解决如何替换或去除每个列标题的第一个字符的问题。OP 已经完成了这一步。相反，我想专注于将现有对象替换为给定替换列名称列表的新对象。'$'columns

2. df.columns = new新列名称列表在哪里非常简单。这种方法的缺点是它需要编辑现有 DataFrame 的属性，并且不是内联完成的。我将展示几种在不编辑现有数据帧的情况下通过流水线执行此操作的方法。newcolumns

---

设置 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.重命名

已经说过，如果您有一个字典将旧列名映射到新列名，则可以使用 .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

但是，您可以轻松地创建该字典并将其包含在对 的调用中。下面利用了这样一个事实，即在迭代时，我们遍历每个列名。renamedf

# 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.concatkeys

首先，请注意当我们尝试使用解决方案 1 时会发生什么情况：

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

   y765  y765  z432
0     1     3     5
1     2     4     6

我们没有将列表映射为列名。我们最终重复了.相反，我们可以在遍历 的列时使用函数的参数。newy765keyspd.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：
重建。仅当所有列都有一个列时，才应使用此列。否则，您最终会得到所有列，并且将它们转换回来需要更多的字典工作。dtypedtypeobject

单一 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：
这是一个带有 和 的噱头。PD的。DataFrame.set_index 允许我们内联设置索引，但没有相应的 .因此，我们可以转置，然后转置，然后转置回去。但是，解决方案 3 中的相同单一警告与混合警告适用于此处。transposeset_indexset_columnsset_indexdtypedtype

单一 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：
使用 in 循环遍历 的每个元素。
在这个解决方案中，我们传递一个 lambda，它接受但随后忽略它。它也需要一个，但没想到。取而代之的是，迭代器作为默认值给出，然后我可以使用它一次循环一个迭代器，而不考虑 的值是什么。lambdapd.DataFrame.renamenewxyx

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

   x098  y765  z432
0     1     3     5
1     2     4     6

正如 sopython 聊天中的人们向我指出的那样，如果我在 和 之间添加一个 ，我可以保护我的变量。不过，在这种情况下，我认为它不需要保护。还是值得一提的。*xyy

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

   x098  y765  z432
0     1     3     5
1     2     4     6

熊猫 0.21+ 回答

在 0.21 版中对列重命名进行了一些重大更新。

• rename 方法添加了可以设置为 或 的参数。此更新使此方法与 pandas API 的其余部分匹配。它仍然具有 和 参数，但您不再被迫使用它们。axiscolumns1indexcolumns
• 使用 set to 的 set_axis 方法，可以使用列表重命名所有索引或列标签。inplaceFalse

Pandas 0.21+ 示例

构造示例 DataFrame：

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

使用 with 或renameaxis='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_axisinplace=False

可以为方法提供长度等于列数（或索引）的列表。目前，默认为 ，但在将来的版本中将默认为 。set_axisinplaceTrueinplaceFalse

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

像这样直接分配列没有错。这是一个很好的解决方案。

使用的优点是它可以用作方法链的一部分，并且它返回 DataFrame 的新副本。如果没有它，您必须在重新分配列之前将链的中间步骤存储到另一个变量。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()

另一种选择是使用正则表达式重命名：

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

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

熊猫。DataFrame.重命名

假设这是您的数据帧。

您可以使用两种方法重命名列。

1. 用dataframe.columns=[#list]

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

   

   此方法的局限性在于，如果必须更改一列，则必须传递完整的列列表。此外，此方法不适用于索引标签。 例如，如果您通过了以下操作：

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

   这将引发错误。长度不匹配：预期轴有 5 个元素，新值有 4 个元素。

2. 另一种方法是 Pandas 方法，用于重命名任何索引、列或行rename()

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

   

同样，您可以更改任何行或列。

让我们通过一个小例子来理解重命名......

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. 使用映射重命名索引/Row_Name：

    df.rename({0: "x", 1: "y", 2: "z"}, axis='index', inplace =True) # Row name are getting replaced by 'x', 'y', and 'z'.
   
    Output:
   
           new_a  new_b
        x  1       4
        y  2       5
        z  3       6
   

除了已提供的解决方案外，还可以在读取文件时替换所有列。我们可以使用并做到这一点。namesheader=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)

在这种情况下，所有列名都将替换为列表中的名称。

在 Pandas 中重命名列是一件容易的事。

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

如果您只想删除“$”符号，请使用以下代码

df.columns = pd.Series(df.columns.str.replace("$", ""))

假设您的数据集名称是 df，并且 df 具有。

df = ['$a', '$b', '$c', '$d', '$e']`

因此，要重命名这些，我们只需这样做。

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

如果您已经有新列名称的列表，则可以尝试以下操作：

new_cols = ['a', 'b', 'c', 'd', 'e']
new_names_map = {df.columns[i]:new_cols[i] for i in range(len(new_cols))}

df.rename(new_names_map, axis=1, inplace=True)

许多 pandas 函数都有一个 inplace 参数。如果将其设置为 True，则转换将直接应用于要调用它的数据帧。例如：

df = pd.DataFrame({'$a':[1,2], '$b': [3,4]})
df.rename(columns={'$a': 'a'}, inplace=True)
df.columns

>>> Index(['a', '$b'], dtype='object')

或者，在某些情况下，您希望保留原始数据帧。我经常看到人们陷入这种情况，如果创建数据帧是一项昂贵的任务。例如，如果创建 DataFrame 需要查询 snowflake 数据库。在这种情况下，只需确保 inplace 参数设置为 False。

df = pd.DataFrame({'$a':[1,2], '$b': [3,4]})
df2 = df.rename(columns={'$a': 'a'}, inplace=False)
df.columns

>>> Index(['$a', '$b'], dtype='object')

df2.columns

>>> Index(['a', '$b'], dtype='object')

如果您经常进行这些类型的转换，您还可以研究许多不同的 pandas GUI 工具。我是一个叫做Mito的创造者。这是一个电子表格，可自动将您的编辑转换为 python 代码。

# This way it will work
import pandas as pd

# Define a dictionary 
rankings = {'test': ['a'],
        'odi': ['E'],
        't20': ['P']}

# Convert the dictionary into DataFrame
rankings_pd = pd.DataFrame(rankings)

# Before renaming the columns
print(rankings_pd)

rankings_pd.rename(columns = {'test':'TEST'}, inplace = True)

我的一句话是

df.columns = df_new_cols

它是最好的，处理时间只有 1/3。

timeit比较：

DF 有七列。我正在尝试更改一些名称。

%timeit df.rename(columns={old_col:new_col for (old_col,new_col) in zip(df_old_cols,df_new_cols)},inplace=True)
214 µs ± 10.1 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

%timeit df.rename(columns=dict(zip(df_old_cols,df_new_cols)),inplace=True)
212 µs ± 7.7 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

%timeit df.columns = df_new_cols
72.9 µs ± 17.2 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)