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

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

重命名特定列

使用#0函数并引用要重命名的列。并非所有列都必须重命名：

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  e0  x  x  x  x  x1  x  x  x  x  x2  x  x  x  x  x

以下方法都可以工作并产生相同的输出：

df2 = df.rename({'a': 'X', 'b': 'Y'}, axis=1)  # new methoddf2 = df.rename({'a': 'X', 'b': 'Y'}, axis='columns')df2 = df.rename(columns={'a': 'X', 'b': 'Y'})  # old method
df2
X  Y  c  d  e0  x  x  x  x  x1  x  x  x  x  x2  x  x  x  x  x

记住将结果赋值回来，因为修改不是就地的。或者，指定inplace=True：

df.rename({'a': 'X', 'b': 'Y'}, axis=1, inplace=True)df
X  Y  c  d  e0  x  x  x  x  x1  x  x  x  x  x2  x  x  x  x  x 

从v0.25开始，如果指定了无效的列重命名，您还可以指定errors='raise'来引发错误。请参阅v0.25#1文档。

重新分配列标题

使用#0与axis=1和inplace=False（返回副本）。

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

这将返回一个副本，但您可以通过设置inplace=True来就地修改DataFrame（这是版本<=0.24的默认行为，但将来可能会更改）。

您也可以直接分配标头：

df.columns = ['V', 'W', 'X', 'Y', 'Z']df
V  W  X  Y  Z0  x  x  x  x  x1  x  x  x  x  x2  x  x  x  x  x

#0方法可以取函数，例如：

In [11]: df.columnsOut[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.columnsOut[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('$', '')

如果你有数据框，df.columns将所有内容转储到一个可以操作的列表中，然后将列的名称重新分配到你的数据框中。

columns = df.columnscolumns = [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 pdimport 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.columnscolumns = [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上运行进行循环并将剥离的列附加到df.columns.

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

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

（Python中的strip方法从字符串的开头和结尾剥离给定字符。）

这很简单。只需使用：

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

它会按照你输入的顺序分配列名。

你可以使用#0：

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>>> dfa  b  c  d  e0  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.>>> dfa  b  c  d  e0  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 pdimport 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  $e0   1   3   5   7   91   2   4   6   8  10
>>> dfa  b  c  d   e0  1  3  5  7   91  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  f0  1  3  51  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()])>>> dfa  b  ex  y  f0  1  3  51  2  4  6

列名与系列名称

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

数据帧是一组序列。

系列反过来是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_twoname of the index0                                    4           11                                    5           22                                    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)将返回

    three0       11       22       3

因为Pandas重用了已经定义的Series的.name。

多级列名

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其中new是新列名的列表非常简单。这种方法的缺点是它需要编辑现有数据框的columns属性，并且不是内联完成的。我将展示几种通过流水线执行此操作而不编辑现有数据框的方法。

设置1
为了专注于需要用预先存在的列表重命名替换列名，我将创建一个新的示例dataframedf，其中包含初始列名和不相关的新列名。

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

解决方案1
#0

已经说过如果你有一个字典将旧列名映射到新列名，你可以使用pd.DataFrame.rename。

d = {'Jack': 'x098', 'Mahesh': 'y765', 'Xin': 'z432'}df.rename(columns=d)
x098  y765  z4320     1     3     51     2     4     6

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

# Given just a list of new column namesdf.rename(columns=dict(zip(df, new)))
x098  y765  z4320     1     3     51     2     4     6

如果您的原始列名是唯一的，这很有效。但如果它们不是，那么它就会崩溃。

设置2
非唯一列

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

解决方案2
#0使用keys参数

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

df.rename(columns=dict(zip(df, new)))
y765  y765  z4320     1     3     51     2     4     6

我们没有将new列表映射为列名。我们最终重复了y765。相反，我们可以在迭代df的列时使用pd.concat函数的keys参数。

pd.concat([c for _, c in df.items()], axis=1, keys=new)
x098  y765  z4320     1     3     51     2     4     6

解决方案3
重构。仅当您对所有列都有一个dtype时才应使用此选项。否则，您将以dtypeobject结束所有列，并且将它们转换回需要更多的字典工作。

单曲dtype

pd.DataFrame(df.values, df.index, new)
x098  y765  z4320     1     3     51     2     4     6

混合dtype

pd.DataFrame(df.values, df.index, new).astype(dict(zip(new, df.dtypes)))
x098  y765  z4320     1     3     51     2     4     6

解决方案4
这是transpose和set_index的噱头。<说明>#2允许我们内联设置索引，但没有相应的set_columns。所以我们可以转置，然后set_index，然后转置回来。然而，解决方案3中相同的单一dtype对混合dtype的警告适用于此。

单曲dtype

df.T.set_index(np.asarray(new)).T
x098  y765  z4320     1     3     51     2     4     6

混合dtype

df.T.set_index(np.asarray(new)).T.astype(dict(zip(new, df.dtypes)))
x098  y765  z4320     1     3     51     2     4     6

解决方案5
在pd.DataFrame.rename中使用lambda循环遍历new的每个元素。
在这个解决方案中，我们传递了一个接受x但随后忽略它的lambda。它也接受y但不期望它。相反，迭代器被作为默认值给出，然后我可以使用它一次循环遍历一个，而不考虑x的值是什么。

df.rename(columns=lambda x, y=iter(new): next(y))
x098  y765  z4320     1     3     51     2     4     6

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

df.rename(columns=lambda x, *, y=iter(new): next(y))
x098  y765  z4320     1     3     51     2     4     6

熊猫0.21+答案

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

• #0方法添加了axis参数，可以设置为columns或1。此更新使此方法与熊猫API的其余部分匹配。它仍然具有index和columns参数，但您不再被迫使用它们。
• 将inplace设置为False的#0方法使您能够使用列表重命名所有索引或列标签。

熊猫的例子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  $e0   1   3   5   7   91   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   e0  1  3  5  7   91  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 waydf1 = df.some_method1().some_method2()df1.columns = columnsdf1.some_method3()

这里有一个我喜欢用来减少打字的漂亮小功能：

def rename(data, oldnames, newname):if type(oldnames) == str: # Input can be a string or list of stringsoldnames = [oldnames] # When renaming multiple columnsnewname = [newname] # Make sure you pass the corresponding list of new namesi = 0for 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 matchprint("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 += 1return 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 variablesIn [3]: df = rename(df, ['col', 'omg'],['first', 'ohmy'])Found multiple columns that matched col:0: col11: col2
Please enter the index of the column you would like to rename: 0
In [4]: df.columnsOut[5]: Index(['first', 'col2', 'ohmy', 'idk'], dtype='object')

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

import pandas as pdimport re
df = pd.DataFrame({'$a':[1,2], '$b':[3,4], '$c':[5,6]})
df = df.rename(columns=lambda x: re.sub('\$','',x))>>> dfa  b  c0  1  3  51  2  4  6

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

pandas.DataFrame.rename

假设你可以使用正则表达式，这个解决方案删除需要使用正则表达式手动编码：

import pandas as pdimport re
srch = re.compile(r"\w+")
data = pd.read_csv("CSV_FILE.csv")cols = data.columnsnew_cols = list(map(lambda v:v.group(), (list(map(srch.search, cols)))))data.columns = new_cols

假设这是你的dataframe。

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

1. 使用dataframe.columns=[#list]

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

   

   此方法的限制是，如果必须更改一列，则必须传递完整的列列表。此外，此方法不适用于索引标签。例如，如果您传递了：

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

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

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

   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 Bdf.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_b0  1       41  2       52  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_bx  1       4y  2       5z  3       6

除了已经提供的解决方案之外，您还可以在读取文件时替换所有列。我们可以使用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)

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

在Pandas中重命名列是一项简单的任务。

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

我需要重命名XGBoost的功能，但它不喜欢这些功能：

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

或者，在某些情况下，您想保留原始数据帧。如果创建数据帧是一项昂贵的任务，我经常看到人们陷入这种情况。例如，如果创建数据帧需要查询雪花数据库。在这种情况下，只需确保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')

如果这些类型的转换是您经常做的事情，您还可以查看许多不同的熊猫GUI工具。我是一个名为水户的创建者。这是一个自动将您的编辑转换为python代码的电子表格。

# This way it will workimport pandas as pd
# Define a dictionaryrankings = {'test': ['a'],'odi': ['E'],'t20': ['P']}
# Convert the dictionary into DataFramerankings_pd = pd.DataFrame(rankings)
# Before renaming the columnsprint(rankings_pd)
rankings_pd.rename(columns = {'test':'TEST'}, inplace = True)

您可以将#0或#1方法与索引一起使用：

df.columns = df.columns.str.lstrip('$')

或

cols = ['$a', '$b', '$c', '$d', '$e']pd.Series(cols).str.lstrip('$').tolist()

输出：

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

我的回答是

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_cols72.9 µs ± 17.2 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

一个简单而“有趣”（和pythonic？）的解决方案：

df.rename(columns={x: x.replace('$', '') for x in df.columns})

在哪里：

df = pd.DataFrame(columns=['$a', '$b', '$c', '$d', '$e'])

步骤：

以列表形式获取DataFrame的列：

df.columns

在DataFrames中重命名的方法：

df.rename()

属性指定要重命名列：

columns={}

在字典中，您需要指定要重命名的列（在每个键中）以及它们将获得哪些新名称（每个值）

{'old_col_name': 'new_col_name', ...}

由于您的更改遵循一种模式，因此要删除每列中的$字符，我们可以使用字典理解：

{x: x.replace('$', '') for x in df.columns}