python valeur Renommer des colonnes dans les pandas




supprimer colonne dataframe python (20)

Si vous devez gérer des tas de colonnes nommées par le système fournissant hors de votre contrôle, je suis venu avec l'approche suivante qui est une combinaison d'une approche générale et des remplacements spécifiques en une seule fois.

Je crée d'abord un dictionnaire à partir des noms de colonnes de données à l'aide d'expressions regex afin de supprimer certaines annexes de noms de colonnes, puis j'ajoute des remplacements spécifiques au dictionnaire pour nommer les colonnes principales comme attendu plus tard dans la base de données réceptrice.

Ceci est ensuite appliqué à l'ensemble de données en une fois.

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)

J'ai un DataFrame en utilisant des pandas et des étiquettes de colonnes que j'ai besoin de modifier pour remplacer les étiquettes de colonnes d'origine.

Je voudrais changer les noms de colonnes dans un DataFrame A où les noms de colonnes d'origine sont:

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

à

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

J'ai les noms de colonne édités l'ont stocké dans une liste, mais je ne sais pas comment remplacer les noms de colonne.


Puisque vous ne voulez supprimer que le signe $ dans tous les noms de colonnes, vous pouvez simplement faire:

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

OU

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

Voici une petite fonction utile que j'aime utiliser pour réduire la frappe:

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   

Voici un exemple de comment cela fonctionne:

In [2]: df = pd.DataFrame(np.random.randint(0,10,size=(10, 4)), columns=['col1','col2','omg','idk'])

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

Je sais que cette question et réponse a été mâchée à mort. Mais je me suis référé à lui pour l'inspiration pour l'un des problèmes que j'avais. J'ai été capable de le résoudre en utilisant des morceaux de réponses différentes, fournissant ainsi ma réponse au cas où quelqu'un en aurait besoin.

Ma méthode est générique dans laquelle vous pouvez ajouter des délimiteurs supplémentaires en séparant les delimiters= par des virgules delimiters= variables et futures.

Code de travail:

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 ]

Sortie:

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

Utilisez la fonction df.rename() et reportez les colonnes à renommer. Toutes les colonnes ne doivent pas être renommées:

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)

Je pense que cette méthode est utile:

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

Cette méthode vous permet de modifier les noms de colonne individuellement.


Pandas 0.21+ réponse

Des modifications importantes ont été apportées au changement de nom de la colonne dans la version 0.21.

  • La méthode rename a ajouté le paramètre d' axis qui peut être défini sur des columns ou 1 . Cette mise à jour rend cette méthode correspondre au reste de l'API pandas. Il a toujours les paramètres d' index et de columns , mais vous n'êtes plus obligé de les utiliser.
  • La méthode set_axis avec le inplace défini sur False vous permet de renommer toutes les étiquettes d'index ou de colonne avec une liste.

Exemples pour les pandas 0.21+

Construire un exemple de 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

Utiliser rename avec axis='columns' ou axis=1

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

ou

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

Les deux ont les conséquences suivantes:

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

Il est toujours possible d'utiliser l'ancienne signature de méthode:

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

La fonction rename accepte également les fonctions qui seront appliquées à chaque nom de colonne.

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

ou

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

Utiliser set_axis avec une liste et inplace=False

Vous pouvez fournir une liste à la méthode set_axis dont la longueur est égale au nombre de colonnes (ou d'index). Actuellement, inplace défaut est True , mais inplace sera inplace par défaut sur False dans les versions ultérieures.

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

ou

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

Pourquoi ne pas utiliser df.columns = ['a', 'b', 'c', 'd', 'e'] ?

Il n'y a rien de mal à assigner des colonnes directement comme ça. C'est une solution parfaitement bonne.

L'avantage d'utiliser set_axis est qu'il peut être utilisé dans le cadre d'une chaîne de méthodes et qu'il renvoie une nouvelle copie du DataFrame. Sans cela, vous devrez stocker vos étapes intermédiaires de la chaîne dans une autre variable avant de réaffecter les colonnes.

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

Essaye ça. Ça marche pour moi

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

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

est un moyen fonctionnel de résoudre ce problème


Noms de colonnes vs noms de séries

Je voudrais expliquer un peu ce qui se passe dans les coulisses.

Les données sont un ensemble de séries.

Les séries à leur tour sont une extension d'un numpy.array

numpy.array s possède une propriété .name

C'est le nom de la série. Il est rare que les pandas respectent cet attribut, mais il persiste dans certains endroits et peut être utilisé pour pirater certains comportements de pandas.

Nommer la liste des colonnes

Beaucoup de réponses ici parle de l'attribut df.columns étant une list alors qu'en fait c'est une Series . Cela signifie qu'il a un attribut .name .

C'est ce qui se passe si vous décidez de renseigner le nom des colonnes.

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

Notez que le nom de l'index est toujours inférieur d'une colonne.

Des artefacts qui persistent

L'attribut .name persiste parfois. Si vous définissez df.columns = ['one', 'two'] alors le nom de df.one.name sera 'one' .

Si vous définissez df.one.name = 'three' alors df.columns vous donnera toujours ['one', 'two'] , et df.one.name vous donnera 'three'

MAIS

pd.DataFrame(df.one) retournera

    three
0       1
1       2
2       3

Parce que les pandas réutilise le nom de la série déjà définie.

Noms de colonnes multi-niveaux

Pandas a des façons de faire des noms de colonnes multi-couches. Il n'y a pas tellement de magie en jeu, mais je voulais aussi couvrir cela dans ma réponse, car je ne vois personne en parler ici.

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

Ceci est facilement réalisable en définissant des colonnes à des listes, comme ceci:

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

.columns le .columns attribut .columns :

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

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

Cela aurait pu être fait en exécutant une boucle for over df.columns et en ajoutant les colonnes dénudées à df.columns.

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

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

(La méthode strip en Python enlève le caractère donné du début et de la fin de la chaîne.)



Notez que ces approches ne fonctionnent pas pour un MultiIndex. Pour un MultiIndex, vous devez faire quelque chose comme:

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

La méthode de df.rename() peut prendre une fonction, par exemple:

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)

DataFrame - df.rename () fonctionnera.

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

df est le DataFrame que vous avez, et l' ancien nom est le nom de la colonne que vous voulez changer, puis le nouveau nom est le nouveau nom que vous changez. Cette méthode intégrée DataFrame rend les choses très faciles.


Vous pouvez utiliser str.slice pour cela:

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

Au cas où vous ne voulez pas les noms de ligne df.columns = ['a', 'b',index=False]


Vraiment simple, utilisez simplement

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

et il va attribuer les noms de colonnes par l'ordre que vous les mettez


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

Il remplacera les noms existants par les noms que vous fournissez, dans l'ordre que vous avez fourni.

Vous pouvez également les affecter par index comme ceci:

df.columns.values[2] = 'c'    #renames the 2nd column to 'c' (in position #3)






rename