Renommer des colonnes dans pandas
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 les noms de colonne dans un DataFrame A où les noms de colonne d'origine sont:
['$a', '$b', '$c', '$d', '$e']
à
['a', 'b', 'c', 'd', 'e'].
Les noms de colonne modifiés sont stockés dans une liste, mais je ne sais pas comment remplacer les noms de colonne.
Attribuez-le simplement à l'attribut .columns:
>>> df = pd.DataFrame({'$a':[1,2], '$b': [10,20]})
>>> df.columns = ['a', 'b']
>>> df
a b
0 1 10
1 2 20
RENOMMER DES COLONNES SPÉCIFIQUES
Utilisez la fonction df.rename() et reportez-vous aux 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)
Exemple de code minimal
df = pd.DataFrame('x', index=range(3), columns=list('abcde'))
df
a b c d e
0 x x x x x
1 x x x x x
2 x x x x x
Les méthodes suivantes fonctionnent toutes et produisent le même résultat:
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
X Y c d e
0 x x x x x
1 x x x x x
2 x x x x x
N'oubliez pas de réattribuer le résultat, car la modification n'est pas en place. Sinon, spécifiez inplace=True:
df.rename({'a': 'X', 'b': 'Y'}, axis=1, inplace=True)
df
X Y c d e
0 x x x x x
1 x x x x x
2 x x x x x
À partir de la version 0.25, vous pouvez également spécifier errors='raise' pour générer des erreurs si un nom de colonne à renommer non valide est spécifié. Voir v0.25 rename() docs .
Réaffectation des chefs de colonne
Utilisez df.set_axis() avec axis=1 et inplace=False (pour renvoyer une copie).
df2 = df.set_axis(['V', 'W', 'X', 'Y', 'Z'], axis=1, inplace=False)
df2
V W X Y Z
0 x x x x x
1 x x x x x
2 x x x x x
Cela renvoie une copie, mais vous pouvez modifier le DataFrame sur place en définissant inplace=True (il s'agit du comportement par défaut pour les versions <= 0.24, mais il est susceptible de changer à l'avenir).
Vous pouvez également affecter directement des en-têtes:
df.columns = ['V', 'W', 'X', 'Y', 'Z']
df
V W X Y Z
0 x x x x x
1 x x x x x
2 x x x x x
La méthode 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)
Comme documenté dans http://pandas.pydata.org/pandas-docs/stable/text.html :
df.columns = df.columns.str.replace('$','')
Pandas 0.21+ réponse
Le renommage des colonnes a été mis à jour de manière significative dans la version 0.21.
- La méthode
renamea ajouté le paramètreaxisqui peut être défini surcolumnsou1. Cette mise à jour fait en sorte que cette méthode corresponde au reste de l'API pandas. Il a toujours les paramètresindexetcolumnsmais vous n'êtes plus obligé de les utiliser. - La méthode
set_axis) avecinplacedéfini surFalsevous permet de renommer tous les libellés d'index ou de colonne avec une liste.
Exemples pour Pandas 0.21+
Exemple de construction 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
Utilisation de 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 résultent comme suit:
a b c d e
0 1 3 5 7 9
1 2 4 6 8 10
Il est encore 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 à la méthode set_axis une liste dont la longueur est égale au nombre de colonnes (ou d'index). Actuellement, inplace est défini par défaut sur True, mais inplace sera défini 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 ceci. C'est une très bonne solution.
L'utilisation de set_axis présente l'avantage de pouvoir être utilisé dans une chaîne de méthodes et de renvoyer une nouvelle copie du DataFrame. Sans cette valeur, 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()
Puisque vous voulez seulement supprimer le signe $ dans tous les noms de colonnes, vous pouvez simplement faire:
df = df.rename(columns=lambda x: x.replace('$', ''))
OR
df.rename(columns=lambda x: x.replace('$', ''), inplace=True)
df.columns = ['a', 'b', 'c', 'd', 'e']
Il remplacera les noms existants par les noms que vous avez fournis, dans l'ordre indiqué.
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 cette façon, vous pouvez éditer manuellement le new_names comme vous le souhaitez. Fonctionne très bien lorsque vous ne devez renommer que quelques colonnes pour corriger les fautes d'orthographe, les accents, supprimer les caractères spéciaux, etc.
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.
Solutions en ligne ou en pipeline
Je vais me concentrer sur deux choses:
OP indique clairement
Les noms de colonne modifiés sont stockés dans une liste, mais je ne sais pas comment remplacer les noms de colonne.
Je ne veux pas résoudre le problème de la façon de remplacer
'$'ou d'effacer le premier caractère de chaque en-tête de colonne. OP a déjà effectué cette étape. Au lieu de cela, je souhaite me concentrer sur le remplacement de l'objetcolumnsexistant par un nouvel objet, à partir de la liste des noms de colonnes de remplacement.df.columns = newoùnewest la liste des nouveaux noms de colonnes est aussi simple que possible. L'inconvénient de cette approche est qu'elle nécessite la modification de l'attributcolumnsde la base de données existante et qu'elle n'est pas effectuée en ligne. Je vais montrer quelques manières d'effectuer ceci via le traitement en pipeline sans éditer le cadre de données existant.
Configuration 1
Pour mettre l'accent sur la nécessité de renommer les noms de colonne par une liste préexistante, je vais créer un nouvel exemple de structure de données df avec des noms de colonne initiaux et de nouveaux noms de colonne non liés.
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
Solution 1 pd.DataFrame.rename
Il a déjà été dit que si vous aviez un dictionnaire mappant les anciens noms de colonnes sur les nouveaux noms de colonnes, vous pourriez utiliser 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
Cependant, vous pouvez facilement créer ce dictionnaire et l’inclure dans l’appel à rename. Ce qui suit tire profit du fait que lorsque nous itérons sur df, nous itérons sur chaque nom de colonne.
# 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
Cela fonctionne très bien si vos noms de colonne d'origine sont uniques. Mais si ce n'est pas le cas, cela s'effondre.
Configuration 2
colonnes non uniques
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
Solution 2 pd.concat en utilisant l'argument keys
Tout d’abord, remarquez ce qui se passe lorsque nous essayons d’utiliser la solution 1:
df.rename(columns=dict(Zip(df, new)))
y765 y765 z432
0 1 3 5
1 2 4 6
Nous n'avons pas mappé la liste new en tant que noms de colonnes. Nous avons fini par répéter y765. Au lieu de cela, nous pouvons utiliser l'argument keys de la fonction pd.concat en effectuant une itération dans les colonnes 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
Solution 3
Reconstruire. Cela ne devrait être utilisé que si vous avez un seul dtype pour toutes les colonnes. Sinon, vous obtiendrez dtypeobject pour toutes les colonnes et leur conversion nécessitera davantage de travail avec le dictionnaire.
Unique dtype
pd.DataFrame(df.values, df.index, new)
x098 y765 z432
0 1 3 5
1 2 4 6
mixte 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
Solution 4
C’est un tour de magie avec transpose et set_index. pd.DataFrame.set_index nous permet de définir un index en ligne mais il n'y a pas de set_columns correspondant. Nous pouvons donc transposer, puis set_index, et transposer en arrière. Cependant, la même mise en garde dtype versus mixte dtype de la solution 3 s'applique ici.
Unique dtype
df.T.set_index(np.asarray(new)).T
x098 y765 z432
0 1 3 5
1 2 4 6
mixte 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
Solution 5
Utilisez un lambda dans pd.DataFrame.rename qui parcourt chaque élément de new
Dans cette solution, nous passons un lambda qui prend x mais l’ignore ensuite. Cela prend aussi un y mais ne l'attend pas. Au lieu de cela, un itérateur est donné comme valeur par défaut et je peux ensuite l'utiliser pour en parcourir un à la fois sans tenir compte de la valeur de x.
df.rename(columns=lambda x, y=iter(new): next(y))
x098 y765 z432
0 1 3 5
1 2 4 6
Et comme me l’ont souligné les gens de sopython chat, si je rajoute un * entre x et y, je peux protéger mon y variable. Bien que, dans ce contexte, je ne pense pas qu'il soit nécessaire de protéger. Cela vaut encore la peine d'être mentionné.
df.rename(columns=lambda x, *, y=iter(new): next(y))
x098 y765 z432
0 1 3 5
1 2 4 6
Noms de colonnes et noms de séries
Je voudrais expliquer un peu ce qui se passe dans les coulisses.
Les images de données sont un ensemble de séries.
Les séries sont à leur tour une extension d'un numpy.array
numpy.arrays a une propriété .name
C'est le nom de la série. Il est rare que pandas respecte cet attribut, mais il persiste par endroits et peut être utilisé pour pirater certains pandas comportements.
Nommer la liste des colonnes
Beaucoup de réponses ici parlent de l'attribut df.columns comme étant un list alors qu'en fait il s'agit d'un 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 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
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 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) reviendra
three
0 1
1 2
2 3
Parce que pandas réutilise le .name du Series déjà défini.
Noms de colonne multi-niveaux
Les pandas ont le moyen de créer des noms de colonnes multicouches. Il n'y a pas tellement de magie en jeu, mais je voulais aussi en parler dans ma réponse, car je ne vois personne y revenir.
|one |
|one |two |
0 | 4 | 1 |
1 | 5 | 2 |
2 | 6 | 3 |
Ceci est facilement réalisable en définissant des colonnes dans des listes, comme ceci:
df.columns = [['one', 'one'], ['one', 'two']]
df = df.rename(columns=lambda n: n.replace('$', '')) est une manière fonctionnelle de résoudre ce problème.
Si vous avez le dataframe, df.columns vide tout dans une liste que vous pouvez manipuler puis réaffecter dans votre dataframe en tant que 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
Meilleur moyen? IDK. Un moyen - oui.
Une meilleure façon d’évaluer toutes les techniques principales mises en avant dans les réponses à la question est d'utiliser ci-dessous 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, nous comparons les arrondis de 0,000 et 0,001 secondes pour toutes les réponses. Morale: ma réponse ci-dessus n'est probablement pas la meilleure façon.
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 = 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 aviez un dictionnaire associé d'anciens noms de colonne à de nouveaux noms de colonne, vous pouvez procéder comme 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 n'avez pas de mappage de liste ou de dictionnaire, vous pouvez effacer le symbole $ initial par l'intermédiaire d'une liste de compréhension:
df.columns = [col[1:] if col[0] == '$' else col for col in df]
df.rename(index=str,columns={'A':'a','B':'b'})
https://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.rename.html
Une autre façon de remplacer les étiquettes de colonne d'origine consiste à supprimer les caractères non souhaités (ici '$') des étiquettes de colonne d'origine.
Cela aurait pu être fait en exécutant une boucle for sur df.columns et en ajoutant les colonnes dépouillées à df.columns.
Au lieu de cela, nous pouvons le faire proprement dans une seule déclaration en utilisant une compréhension de liste comme ci-dessous:
df.columns = [col.strip('$') for col in df.columns]
(La méthode strip dans Python supprime le caractère donné du début et de la fin de la chaîne.)
Real simple suffit d'utiliser
df.columns = ['Name1', 'Name2', 'Name3'...]
et il va assigner les noms de colonnes par l'ordre que vous les mettez
Je sais que cette question et cette réponse ont été mâchées à mort. Mais je me suis référé à cela pour trouver l'inspiration pour l'un des problèmes que je rencontrais. 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 par des virgules la variable delimiters= et en la protégeant du futur.
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
Vous pouvez utiliser str.slice pour cela:
_df.columns = df.columns.str.slice(1)
_renommer les colonnes de la structure de données et remplacer le format
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(' ', '_')
Notez que cette approche ne fonctionne pas pour un MultiIndex. Pour un MultiIndex, vous devez effectuer les opérations suivantes:
>>> 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
Renommer des colonnes lors de la lecture du 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
Une autre option consiste à renommer à l'aide d'une expression régulière:
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
C'est probablement la solution la plus simple au problème. C'est assez explicite comment ça marche.
import pandas as pd
df.columns = [['$a', '$b', '$c', '$d', '$e']]
df.rename(columns = {'$a':'a','$b':'b','$c':'c','$d':'d','$e':'e'})
df.head()
Importez des bibliothèques qui nous aideront à créer un cadre de données:
import pandas as pd
import numpy as np
Créer un cadre de données:
df = pd.DataFrame(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), columns=['a', 'b', 'c'])
Renommer Dataframe:
df.rename(columns={'a':'x', 'b':'y', 'c':'z'}, index=str)
df.columns devrait maintenant avoir des valeurs différentes
Je vois 3 façons faciles
df.columns
sortie: ['$ a', '$ b', '$ c', '$ d', '$ e']
1.
df.columns = ['a', 'b', 'c', 'd', 'e']
2.
df.columns = df.columns.str.replace('$','')
3.
df.rename(columns={'$a': 'a', '$b': 'b', '$c': 'c', '$d': 'd', '$e' : 'e'}, inplace=True)
Si vous devez gérer des charges de colonnes nommées par le système fournisseur hors de votre contrôle, je propose l'approche suivante qui combine une approche générale et des remplacements spécifiques en une fois.
Commencez par créer un dictionnaire à partir des noms de colonne dataframe en utilisant des expressions rationnelles afin d'éliminer certains appendices des noms de colonne, puis ajoutez des remplacements spécifiques au dictionnaire pour nommer les colonnes principales comme prévu ultérieurement dans la base de réception.
Ceci est ensuite appliqué à la structure de données en une seule 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)
Essaye ça. Ça marche pour moi
df.rename(index=str, columns={"$a": "a", "$b": "b", "$c" : "c", "$d" : "d", "$e" : "e"})
Voici une petite fonction astucieuse que j'aime utiliser pour réduire la dactylographie:
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 la façon dont cela fonctionne:
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')
Si vous ne voulez pas que les noms de ligne df.columns = ['a', 'b',index=False]
En supposant que vous puissiez utiliser une expression régulière. Cette solution élimine le besoin de codage manuel avec regex
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
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.columns = df.columns.str.replace(' ', '_')
Disons que ceci est votre base de données.
Vous pouvez renommer les colonnes en utilisant deux méthodes.
Utilisation de dataframe.columns = [# list]
df.columns = ['a', 'b', 'c', 'd', 'e']
La limite de cette méthode est que si une colonne doit être modifiée, la liste complète des colonnes doit être passée. En outre, cette méthode n'est pas applicable sur les étiquettes d'index. Par exemple, si vous avez passé ceci:
df.columns = ['a','b','c','d']
Cela jettera une erreur. Longueur incompatible: L'axe attendu a 5 éléments, les nouvelles valeurs ont 4 éléments.
Une autre méthode est la méthode Pandas rename (), utilisée pour renommer un index, une colonne ou une ligne.
df = df.rename (columns = {'$ a': 'a'})
De même, vous pouvez modifier toutes les lignes ou les colonnes.