Renommer les noms de colonnes dans Pandas

Question

J'ai un DataFrame utilisant Pandas et des étiquettes de colonne que je dois modifier pour remplacer les étiquettes de colonne d'origine.

Je voudrais changer le nom des colonnes dans un DataFrame. A où se trouvent les noms des colonnes originales :

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

à

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

Les noms des colonnes modifiées sont stockés dans une liste, mais je ne sais pas comment remplacer les noms des colonnes.

Answer 1

De nombreuses fonctions de pandas ont un paramètre inplace. Lorsqu'il est défini sur True, la transformation s'applique directement au dataframe sur lequel vous l'appelez. Par exemple :

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

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

Par ailleurs, il existe des cas où vous souhaitez préserver le cadre de données d'origine. J'ai souvent vu des gens tomber dans ce cas si la création du dataframe est une tâche coûteuse. Par exemple, si la création du dataframe nécessite l'interrogation d'une base de données snowflake. Dans ce cas, il suffit de s'assurer que le paramètre inplace est défini sur 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 vous effectuez souvent ce type de transformations, vous pouvez également vous pencher sur un certain nombre d'outils GUI de pandas. Je suis le créateur d'un outil appelé Mito . C'est une feuille de calcul qui convertit automatiquement vos modifications en code python.

Answer 2

Si vous avez le cadre de données, df.columns déverse tout dans une liste que vous pouvez manipuler et ensuite réaffecter dans votre cadre de données comme noms de colonnes...

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

Le meilleur moyen ? Je ne sais pas. Un moyen - oui.

Une meilleure façon d'évaluer toutes les techniques principales proposées dans les réponses à la question est ci-dessous en utilisant cProfile pour mesurer la mémoire et le temps d'exécution. @kadee, @kaitlyn, et @eumiro avaient les fonctions avec les temps d'exécution les plus rapides - bien que ces fonctions soient si rapides que nous comparons les arrondis de 0.000 et 0.001 secondes pour toutes les réponses. Moralité : ma réponse ci-dessus n'est probablement pas la "meilleure".

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

Answer 3

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

Si votre nouvelle liste de colonnes est dans le même ordre que les colonnes existantes, l'affectation est 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 vous disposiez d'un dictionnaire dont la clé est constituée des anciens noms de colonnes vers les nouveaux noms de colonnes, vous pourriez faire ce qui suit :

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 vous ne disposez pas d'une liste ou d'un dictionnaire de correspondance, vous pouvez supprimer le caractère de tête de l'élément $ via une compréhension de liste :

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

Answer 4

Une autre façon de remplacer les étiquettes de colonne d'origine consiste à supprimer les caractères indésirables (ici '$') des étiquettes de colonne d'origine.

Cela aurait pu être fait en exécutant un pour boucle sur df.columns et ajoute les colonnes dépouillées à df.columns.

Au lieu de cela, nous pouvons le faire proprement dans une seule déclaration en utilisant la compréhension de liste comme ci-dessous :

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

( strip en Python supprime le caractère donné du début et de la fin de la chaîne).

Answer 5

C'est très simple. Il suffit d'utiliser :

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

Et il attribuera les noms de colonnes dans l'ordre dans lequel vous les avez mis.