Utilice el df.rename() función y refiera las columnas a ser renombradas. No todas las columnas tienen que ser renombradas:

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)

El rename el método puede tomar una función, por ejemplo:

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)

Como se documenta en http://pandas.pydata.org/pandas-docs/stable/text.html:

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

Dado que solo desea eliminar el sign sign en todos los nombres de columna, solo puede hacer:

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

O

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

Pandas 0.21 + Respuesta

Ha habido algunas actualizaciones significativas en el cambio de nombre de columna en la versión 0.21.

• El rename method ha añadido el parámetro axis, que puede ajustarse a columns o 1. Esta actualización hace que este método coincida con el resto de la API de pandas. Todavía tiene los parámetros index y columns, pero ya no está obligado a usarlos.
• El set_axis method with the inplace set to False le permite cambiar el nombre de todo el índice o etiquetas de columna con una lista.

Ejemplos para Pandas 0.21 +

Construir un DataFrame de muestra:

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

Usando rename con axis='columns' o axis=1

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

O

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

Ambos resultan en lo siguiente:

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

Todavía es posible usar la firma del método antiguo:

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

La función rename también acepta funciones que se aplicarán a cada nombre de columna.

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

O

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

Usando set_axis con a list and inplace=False

Puede proporcionar una lista al método set_axis que sea igual en longitud al número de columnas (o índice). En la actualidad, inplace por defecto True pero inplace será de pago a False en futuras versiones.

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

O

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

¿por Qué no usar df.columns = ['a', 'b', 'c', 'd', 'e']?

No hay nada de malo en asignar columnas directamente como esta. Es una solución perfectamente buena.

La ventaja de usar set_axis es que se puede usar como parte de un método de cadena y que devuelve una nueva copia del DataFrame. Sin ella, tendría que almacenar sus pasos intermedios de la cadena en otra variable antes de reasignar las columnas.

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

Reemplazará los nombres existentes con los nombres que proporcione, en el orden que proporcione.

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)

De esta manera puede editar manualmente el new_names como desee. Funciona muy bien cuando necesita cambiar el nombre de solo unas pocas columnas para corregir errores de escritura, acentos, eliminar caracteres especiales, etc.

Creo que este método es útil:

df.rename(columns={"old_column_name1":"new_column_name1", "old_column_name2":"new_column_name2"})

Este método le permite cambiar los nombres de las columnas individualmente.

Nombres de columnas vs Nombres de Series

Me gustaría explicar un poco lo que sucede detrás de las escenas.

Los Dataframes son un conjunto de Series.

Las series a su vez son una extensión de a numpy.array

numpy.arrays tienen una propiedad .name

Este es el nombre de la serie. Rara vez los pandas respetan este atributo, pero permanece en algunos lugares y se puede usar para hackear algunos comportamientos de pandas.

Nombrando la lista de columnas

Muchas respuestas aquí se habla de que el atributo df.columns es un list cuando en realidad es un Series. Esto significa que tiene un atributo .name.

Esto es lo que sucede si decides rellenar el nombre de las columnas 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

Tenga en cuenta que el nombre del índice siempre viene una columna más abajo.

Artefactos que permanecen

El atributo .name permanece a veces. Si se establece df.columns = ['one', 'two'] entonces el df.one.name será 'one'.

Si establece df.one.name = 'three' entonces df.columns todavía le dará ['one', 'two'], y df.one.name te dará 'three'

PERO

pd.DataFrame(df.one) will return

    three
0       1
1       2
2       3

Porque los pandas reutilizan el .name de los Series ya definidos.

Nombres de columnas de varios niveles

Pandas tiene formas de hacer nombres de columna de múltiples capas. No hay tanta magia involucrada, pero quería cubrir esto en mi respuesta también, ya que no veo a nadie recogiendo esto aquí.

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

Esto es fácilmente alcanzable estableciendo columnas a listas, como esto:

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

Soluciones de una línea o tubería

Me centraré en dos cosas:

1. La OP establece claramente

   Tengo los nombres de columna editados almacenados en una lista, pero no se como reemplazar los nombres de columna.

   No quiero resolver el problema de cómo reemplazar '$' o tira el primer carácter de cada encabezado de columna. OP ya ha hecho este paso. En su lugar, quiero centrarme en reemplazar el objeto columns existente por uno nuevo dada una lista de nombres de columna de reemplazo.

2. df.columns = new donde new es la lista de nuevos nombres de columnas es tan simple como se pone. El inconveniente de este enfoque es que requiere editar el atributo columns del dataframe existente y no se hace en línea. Voy a mostrar algunas maneras de realizar esto a través de canalización sin editar el dataframe existente.

Configuración 1
Para centrarse en la necesidad de cambiar el nombre de reemplazar los nombres de columna con un list, crearé un nuevo dataframe de muestra df con nombres de columna iniciales y nombres de columna nuevos no relacionados.

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

Solución 1
pd.DataFrame.rename

Ya se ha dicho que si tuviera un diccionario que mapeara los nombres de columna antiguos con nombres de columna nuevos, podría usar 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

Sin embargo, puede crear fácilmente ese diccionario e incluirlo en la llamada a rename. Lo siguiente se aprovecha del hecho de que al iterar sobre df, iteramos sobre cada nombre de columna.

# 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

Esto funciona muy bien si los nombres de las columnas originales son únicos. Pero si no lo son, entonces esto se rompe.

Configuración 2
columnas no únicas

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

Solución 2
pd.concat el uso de la keys argumento

Primero, observe lo que sucede cuando intentamos usar la solución 1:{[56]]}

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

   y765  y765  z432
0     1     3     5
1     2     4     6

No mapeamos la lista new como los nombres de las columnas. Terminamos repitiendo y765. En su lugar, podemos usar el argumento keys de la función pd.concat mientras iteramos a través de las columnas de df.

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

   x098  y765  z432
0     1     3     5
1     2     4     6

Solución 3
Reconstruir. Esto solo debe usarse si tiene un único dtype para todas las columnas. De lo contrario, terminarás con dtype object para todas las columnas y convertirlas requiere más trabajo de diccionario.

Soltero dtype

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

   x098  y765  z432
0     1     3     5
1     2     4     6

Mixto 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

Solución 4
Este es un truco con transpose y set_index. pd.DataFrame.set_index nos permite establecer un índice en línea, pero no hay ninguna correspondientes set_columns. Así que podemos transponer, entonces set_index, y transponer de nuevo. Sin embargo, la misma única dtype versus mixta dtype advertencia de la solución 3 se aplica aquí.

Soltero dtype

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

   x098  y765  z432
0     1     3     5
1     2     4     6

Mixto 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

Solución 5
Use un lambda en pd.DataFrame.rename que recorre cada elemento de new
En esta solución, pasamos una lambda que toma x pero luego la ignora. También toma un y pero no lo espera. En su lugar, se da un iterador como valor predeterminado y luego puedo usarlo para recorrer uno a la vez sin tener en cuenta cuál es el valor de x.

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

   x098  y765  z432
0     1     3     5
1     2     4     6

Y como me señaló la gente en sopython chat, si yo agregar un * entre x y y, puedo proteger mi variable y. Sin embargo, en este contexto no creo que necesite protección. Todavía vale la pena mencionarlo.

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

   x098  y765  z432
0     1     3     5
1     2     4     6

DataFrame d df.rename() funcionará.

df.rename(columns = {'Old Name':'New Name'})

Df es el DataFrame que tienes, y el Nombre antiguo es el nombre de columna que desea cambiar, entonces el Nuevo Nombre es el nuevo nombre al que cambia. Este método integrado de DataFrame hace las cosas muy fáciles.

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

Si su nueva lista de columnas está en el mismo orden que las columnas existentes, la asignación es simple:

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

Si tuviera un diccionario con claves de nombres de columna antiguos a nombres de columna nuevos, podría hacer lo siguiente:

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

Si no tiene una lista o un mapeo de diccionario, puede eliminar el símbolo $ a través de una comprensión de lista:

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

Si tienes el dataframe, df.columns vuelca todo en una lista que puede manipular y luego reasignar a su dataframe como los nombres de las columnas...

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

¿La mejor manera? IDK. Una manera-sí.

Una mejor manera de evaluar todas las técnicas principales presentadas en las respuestas a la pregunta está a continuación utilizando cProfile para medir la memoria y el tiempo de ejecución. @ kadee, @kaitlyn y @ eumiro tenían las funciones con los tiempos de ejecución más rápidos, aunque estas funciones son tan rápidas que comparando el redondeo de .000 y .001 segundos para todas las respuestas. Morales: mi respuesta anterior probablemente no es la Mejor manera.

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

Es una forma funcional de resolver esto

Otra forma en que podríamos reemplazar las etiquetas de columna originales es eliminando los caracteres no deseados (aquí '$') de las etiquetas de columna originales.

Esto podría haberse hecho ejecutando un bucle for sobre df.columnas y anexando las columnas despojadas a df.columna.

En su lugar, podemos hacer esto cuidadosamente en una sola declaración mediante el uso de la comprensión de la lista como a continuación:

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

(strip método en Python elimina el carácter dado desde el principio y el final de la cadena.)

Sé que esta pregunta y respuesta ha sido mordida hasta la muerte. Pero me referí a él como inspiración para uno de los problemas que estaba teniendo . Pude resolverlo usando bits y piezas de diferentes respuestas, por lo tanto, proporcionando mi respuesta en caso de que alguien lo necesite.

Mi método es genérico en el que puede agregar delimitadores adicionales por coma separando delimiters= variable y a prueba de futuro.

Código De Trabajo:

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 ]

Salida:

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

Real simple solo use

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

Y asignará los nombres de las columnas por el orden en que los ponga

Usted podría utilizar str.slice para ello:

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

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

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

Tenga en cuenta que estos enfoques no funcionan para un multiíndice. Para un multiíndice, necesitas hacer algo como lo siguiente:

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

Cambiar el nombre de las columnas dataframe y reemplazar formato

import pandas as pd

data = {'year':[2015,2011,2007,2003,1999,1996,1992,1987,1983,1979,1975],
        'team':['Australia','India','Australia','Australia','Australia','Sri Lanka','Pakistan','Australia','India','West Indies','West Indies'],
        }
df = pd.DataFrame(data)

#Rename Columns
df.rename(columns={'year':'Years of Win','team':'Winning Team'}, inplace=True)

#Replace format
df = df.columns.str.replace(' ', '_')

Si tiene que lidiar con un montón de columnas nombradas por el sistema de suministro fuera de su control, se me ocurrió el siguiente enfoque que es una combinación de un enfoque general y reemplazos específicos de una sola vez.

Primero creo un diccionario a partir de los nombres de columna de dataframe usando expresiones regex para desechar ciertos apéndices de nombres de columna y luego agrego reemplazos específicos al diccionario para nombrar las columnas principales como se espera más adelante en la recepción base.

Esto se aplica al dataframe de una sola vez.

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)

Otra opción es cambiar el nombre usando una expresión regular:

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

Prueba esto. Funciona para mí

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

En caso de que no desee los nombres de las filas df.columns = ['a', 'b',index=False]

Aquí hay una pequeña función ingeniosa que me gusta usar para reducir la escritura:

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   

Aquí hay un ejemplo de cómo funciona:

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

Renaming columns while reading the Dataframe: 

>>> df = pd.DataFrame({'$a': [1], '$b': [1], '$c': [1]}).rename(columns = 
         {'$a' : 'a','$b':'b','$c':'c'})

Out[1]: 
   a  b  c
0  1  1  1