Si tiene que lidiar con un montón de columnas nombradas por el sistema proveedor 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 cree un diccionario a partir de los nombres de las columnas del marco de datos usando expresiones regulares para eliminar ciertos apéndices de los nombres de las columnas y luego agregue reemplazos específicos al diccionario para nombrar las columnas principales como se espera más adelante en la base de datos receptora.

Esto luego se aplica al marco de datos 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)

Nombres de columna vs Nombres de serie

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

Los marcos de datos son un conjunto de Series.

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

numpy.array s tiene una propiedad .name .

Este es el nombre de la serie. Es raro que Pandas respete este atributo, pero persiste en algunos lugares y puede usarse para piratear algunos comportamientos de Pandas.

Nombrar la lista de columnas

Muchas respuestas aquí hablan de que el atributo df.columns es una list cuando, de hecho, es una Series . Esto significa que tiene un atributo .name .

Esto es lo que sucede si decide completar 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 perduran

El atributo .name persiste a veces. Si configura df.columns = ['one', 'two'] entonces df.one.name será 'one' .

Si establece df.one.name = 'three' , df.columns aún le dará ['one', 'two'] y df.one.name le dará 'three' .

PERO

pd.DataFrame(df.one) volverá

 three 0 1 1 2 2 3

Porque Pandas reutiliza el .name de la Series ya definida.

Nombres de columnas de varios niveles

Pandas tiene formas de hacer nombres de columnas de varias capas. No hay tanta magia involucrada, pero también quería cubrir esto en mi respuesta, ya que no veo que nadie se dé cuenta de esto aquí.

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

Esto se puede lograr fácilmente configurando columnas en listas, como esta:

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

Mi método es genérico en el que puede agregar delimitadores adicionales separando con comas delimiters= variable y prepararlo para el 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 ]

Producción:

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

Tenga en cuenta que los enfoques en las respuestas anteriores no funcionan para un MultiIndex . Para un MultiIndex , debe hacer algo como lo siguiente:

 >>> df = pd.DataFrame({('$a','$x'):[1,2], ('$b','$y'): [3,4], ('e','f'):[5,6]}) >>> df $a $be $x $yf 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 abe xyf 0 1 3 5 1 2 4 6

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 abcde 0 1 1 1 1 1

Si tenía un diccionario tecleado en los nombres de las columnas antiguas a los nombres de las columnas nuevas, 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 abcde 0 1 1 1 1 1

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

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

Podrías usar str.slice para eso:

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

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

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

Si tiene el marco de datos, df.columns vuelca todo en una lista que puede manipular y luego reasignar en su marco de datos 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

¿Mejor manera? No sé. Una manera - sí.

Una mejor manera de evaluar todas las técnicas principales presentadas en las respuestas a la pregunta es usar 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 estamos comparando el redondeo de 0,000 y 0,001 segundos para todas las respuestas. Moraleja: mi respuesta anterior probablemente no sea 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)')

Otra forma de reemplazar las etiquetas de las columnas originales es eliminando los caracteres no deseados (aquí '$') de las etiquetas de las columnas originales.

Esto podría haberse hecho ejecutando un ciclo for sobre df.columns y agregando las columnas eliminadas a df.columns.

En cambio, podemos hacer esto claramente en una sola declaración usando la comprensión de lista como se muestra a continuación:

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

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

Es muy sencillo. Solo usa:

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

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

Dado que solo desea eliminar el signo $ en todos los nombres de columna, podría hacer lo siguiente:

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

O

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

Utilizar:

 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 los new_names como desee. Funciona muy bien cuando necesita cambiar el nombre de solo unas pocas columnas para corregir faltas de ortografía, acentos, eliminar caracteres especiales, etc.

Como se documenta en Trabajar con datos de texto :

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

Solo asígnalo al atributo .columns :

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

RENOMBRAR COLUMNAS ESPECÍFICAS

Utilice la función df.rename() y haga referencia a las columnas que se van a renombrar. 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)

Ejemplo de código mínimo

 df = pd.DataFrame('x', index=range(3), columns=list('abcde')) df abcde 0 xxxxx 1 xxxxx 2 xxxxx

Los siguientes métodos funcionan y producen el mismo resultado:

 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 XY cde 0 xxxxx 1 xxxxx 2 xxxxx

Recuerde volver a asignar el resultado, ya que la modificación no está en su lugar. Como alternativa, especifique inplace=True :

 df.rename({'a': 'X', 'b': 'Y'}, axis=1, inplace=True) df XY cde 0 xxxxx 1 xxxxx 2 xxxxx

A partir de la versión 0.25, también puede especificar errors='raise' para generar errores si se especifica una columna para cambiar el nombre no válida. Ver v0.25 rename() docs .

REASIGNAR TÍTULOS DE COLUMNA

Use df.set_axis() con axis=1 e inplace=False (para devolver una copia).

 df2 = df.set_axis(['V', 'W', 'X', 'Y', 'Z'], axis=1, inplace=False) df2 VWXYZ 0 xxxxx 1 xxxxx 2 xxxxx

Esto devuelve una copia, pero puede modificar el DataFrame en el lugar configurando inplace=True (este es el comportamiento predeterminado para las versiones <=0.24 pero es probable que cambie en el futuro).

También puede asignar encabezados directamente:

 df.columns = ['V', 'W', 'X', 'Y', 'Z'] df VWXYZ 0 xxxxx 1 xxxxx 2 xxxxx

El método de cambio de rename 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)

Suponiendo que puede usar una expresión regular, esta solución elimina la necesidad de codificación manual usando una expresión regular:

 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

Digamos que este es su marco de datos.

Puede cambiar el nombre de las columnas utilizando dos métodos.

1. Usando dataframe.columns=[#list]

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

   

   La limitación de este método es que si se debe cambiar una columna, se debe pasar la lista completa de columnas. Además, este método no se aplica a las etiquetas de índice. Por ejemplo, si pasaste esto:

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

   Esto arrojará un error. Discrepancia de longitud: el eje esperado tiene 5 elementos, los nuevos valores tienen 4 elementos.

2. Otro método es el método de cambio de rename() que se utiliza para cambiar el nombre de cualquier índice, columna o fila

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

   

Del mismo modo, puede cambiar cualquier fila o columna.

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

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 abc 0 1 3 5 1 2 4 6

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

pandas.DataFrame.renombrar

Pandas 0.21+ Respuesta

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

• El método de cambio de rename ha agregado el parámetro de axis que se puede establecer en 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 método set_axis inplace el valor in situ establecido en False le permite cambiar el nombre de todas las etiquetas de índice o columna con una lista.

Ejemplos para Pandas 0.21+

Construya un marco de datos 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:

 abcde 0 1 3 5 7 9 1 2 4 6 8 10

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

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

La función de cambio de 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 una lista e inplace=False

Puede proporcionar una lista al método set_axis que tenga la misma longitud que el número de columnas (o índice). Actualmente, inplace el valor predeterminado True , pero inplace tendrá el valor predeterminado False en versiones futuras.

 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 de esta manera. Es una solución perfectamente buena.

La ventaja de usar set_axis es que se puede usar como parte de una cadena de métodos y que devuelve una nueva copia del DataFrame. Sin él, 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()

Cambiar el nombre de las columnas en Pandas es una tarea fácil.

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

Necesitaba cambiar el nombre de las funciones para XGBoost, y no me gustó ninguna de estas:

 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)

Entendamos el cambio de nombre con un pequeño ejemplo...

1. Cambiar el nombre de las columnas usando el mapeo:

    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. Cambiar el nombre de index/Row_Name usando el mapeo:

    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

Además de la solución ya proporcionada, puede reemplazar todas las columnas mientras lee el archivo. Podemos usar names y header=0 para hacer eso.

Primero, creamos una lista de los nombres que nos gusta usar como nuestros nombres de columna:

 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)

En este caso, todos los nombres de las columnas se reemplazarán con los nombres que tiene en su lista.

Si ya tiene una lista para los nuevos nombres de columna, puede probar esto:

 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)

Muchas de las funciones de pandas tienen un parámetro en el lugar. Al establecerlo en True, la transformación se aplica directamente al marco de datos al que lo está llamando. Por ejemplo:

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

Alternativamente, hay casos en los que desea conservar el marco de datos original. A menudo he visto a personas caer en este caso si crear el marco de datos es una tarea costosa. Por ejemplo, si la creación del marco de datos requería consultar una base de datos de copos de nieve. En este caso, solo asegúrese de que el parámetro en el lugar esté establecido en 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')

Si este tipo de transformaciones es algo que hace con frecuencia, también puede buscar en una serie de herramientas GUI de pandas diferentes. Soy el creador de uno llamado Mito . Es una hoja de cálculo que convierte automáticamente sus ediciones en código python.

Supongamos que el nombre de su conjunto de datos es df y df tiene.

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

Entonces, para cambiar el nombre de estos, simplemente lo haríamos.

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

Si solo desea eliminar el signo '$', use el siguiente código

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

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