Am o DataFrame folosind panda și coloana de etichete de care am nevoie pentru a edita pentru a înlocui originalul etichete de coloană.
Am'd dori să schimbe numele coloanelor într-o DataFrame " O " în cazul în care originalul nume de coloane sunt:
['$a', '$b', '$c', '$d', '$e']
pentru a
['a', 'b', 'c', 'd', 'e'].
Am editat numele coloanelor stocate într-o listă, dar nu't știu cum să înlocuiți coloana nume.
Utilizați df.rename()
funcția și se referă la coloane să fie redenumit. Nu toate coloanele trebuie să fie redenumit:
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)
Minim Exemplu De Cod
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
Următoarele metode de lucru și pentru a produce aceeași ieșire:
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
Amintiți-vă pentru a atribui rezultatul înapoi, ca modificarea nu este-efectivă. Alternativ, precizează efectivă=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
De la v0.25, puteți specifica, de asemenea, erori='ridica' sa ridice erori în cazul în care un invalid coloana-a-redenumiți este specificat. A se vedea [v0.25
rename()` docs](https://pandas-docs.github.io/pandas-docs-travis/reference/api/pandas.DataFrame.rename.html#pandas.DataFrame.rename).
Utilizarea df.set_axis()
cu axa=1 " și " efectivă=False` (pentru a returna o 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
Acesta întoarce o copie, dar puteți modifica DataFrame în loc de setarea efectivă=True` (acesta este comportamentul implicit pentru versiunile <=0.24 dar este probabil să se schimbe în viitor).
Puteți aloca, de asemenea, antete direct:
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
A rename
metoda poate avea o funcția de, de exemplu:
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)
Au existat unele actualizări semnificative la coloana redenumirea în versiunea 0.21.
rename
method a adăugat " axă " parametru care poate fi setat la coloane
sau 1
. Această actualizare face ca această metodă se potrivi cu restul de panda API. Încă mai are "index" și coloane
parametrii dar nu mai sunt obligați să le folosească. set_axis
method cu inplace
setat la "False" vă permite să redenumiți toate indexul sau etichete de coloană cu o listă.Construct eșantion 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
redenumi " cu "axa='coloane'" sau " axa=1
df.rename({'$a':'a', '$b':'b', '$c':'c', '$d':'d', '$e':'e'}, axis='columns')
sau
df.rename({'$a':'a', '$b':'b', '$c':'c', '$d':'d', '$e':'e'}, axis=1)
Ambele rezultat următoarele:
a b c d e
0 1 3 5 7 9
1 2 4 6 8 10
Este încă posibil să se utilizeze metoda veche semnătura:
df.rename(columns={'$a':'a', '$b':'b', '$c':'c', '$d':'d', '$e':'e'})
Anii rename
funcția acceptă, de asemenea, funcții care vor fi aplicate pentru fiecare nume de coloană.
df.rename(lambda x: x[1:], axis='columns')
sau
df.rename(lambda x: x[1:], axis=1)
set_axis cu o listă și efectivă=False
Puteți să furnizeze o listă a set_axis
metoda care este egal în lungime cu numărul de coloane (sau index). În prezent, inplace
implicit Adevărat
, dar `efectivă va fi implicit la "False", în edițiile viitoare.
df.set_axis(['a', 'b', 'c', 'd', 'e'], axis='columns', inplace=False)
sau
df.set_axis(['a', 'b', 'c', 'd', 'e'], axis=1, inplace=False)
Nu este nimic în neregulă cu atribuirea coloane direct așa. Este o foarte bună soluție.
Avantajul de a folosi `set_axis este că acesta poate fi folosit ca parte dintr-o metoda de lanț și care se întoarce o nouă copie a DataFrame. Fără ea, nu ar trebui să stocați etape intermediare ale lanțului de o altă variabilă înainte de a-l repartiza pe coloane.
# 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()
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)
În acest fel puteți edita manual new_names
cum doriți.
Lucrari de mare atunci când aveți nevoie pentru a redenumi numai câteva coloane pentru a corecta mispellings, accente, elimina caractere speciale etc.
Am'll se concentreze pe două lucruri:
am editat numele coloanelor stocate într-o listă, dar nu't știu cum să înlocuiți coloana nume.
Nu vreau pentru a rezolva problema de modul de a înlocui'$'
sau benzi primul caracter de pe fiecare antet de coloană. OP a făcut deja acest pas. În schimb, vreau să se concentreze pe o înlocuiască pe cea existentă coloane
obiect cu unul nou dat o listă de înlocuire coloană de nume.
df.coloane = new
unde nou
este lista de coloane noi nume este la fel de simplu ca acesta devine. Dezavantajul acestei abordări este că necesită editare existente dataframe's coloane
atribut și e't face inline. Am'll arată câteva modalități de a efectua acest lucru prin conducte fără editare existente dataframe.Setup 1 Să se concentreze pe nevoia de a redenumi a înlocui nume de coloană cu o pre-existente în listă, am'll crea un nou eșantion dataframe " df " cu inițială coloana nume și neafiliați nou nume de coloană.
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
Soluție 1 pd.DataFrame.redenumiți`
Acesta a fost spus deja că daca ai avut un dicționar de cartografiere vechiul nume de coloană pentru coloana nou nume, ai putea folosi pd.DataFrame.redenumiți`.
d = {'Jack': 'x098', 'Mahesh': 'y765', 'Xin': 'z432'}
df.rename(columns=d)
x098 y765 z432
0 1 3 5
1 2 4 6
Cu toate acestea, puteți crea cu ușurință că dicționarul și include în apelul la rename
. Următoarele profită de faptul că atunci când iterarea peste "df", vom repeta pe fiecare nume de coloană.
# 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
Acest lucru funcționează foarte bine dacă originalul nume de coloană sunt unice. Dar dacă nu sunt, atunci acest lucru se descompune.
Setup 2 non-unic coloane
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
Soluție 2 pd.concat` folosind "cheilor" de argument
În primul rând, observați ce se întâmplă când încercăm să folosim soluția 1:
df.rename(columns=dict(zip(df, new)))
y765 y765 z432
0 1 3 5
1 2 4 6
Ne-am't harta "noua" lista ca nume de coloane. Ne-am trezit repetând y765`. În schimb, putem folosi "cheilor" argument al pd.concat funcția în timp ce iterarea prin coloane 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
Soluție de 3
Reconstrui. Acest lucru ar trebui să fie utilizate numai dacă aveți o singur dtype pentru toate coloanele. În caz contrar,'ll end up cu
dtype` "obiect" pentru toate coloanele și convertindu-le înapoi necesită mai mult dicționar de muncă.
Singur dtype
pd.DataFrame(df.values, df.index, new)
x098 y765 z432
0 1 3 5
1 2 4 6
Amestecat 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
Soluție 4
Acesta este un truc înșelătoare cu transpun
și set_index
. pd.DataFrame.set_index` ne permite să setați un indice de linie, dar nu este corespunzătoare set_columns
. Deci, putem transpune, apoi set_index
, și transpună înapoi. Cu toate acestea, același unic dtype
versus amestecat dtype
avertisment de soluție 3 se aplică și aici.
Singur dtype
df.T.set_index(np.asarray(new)).T
x098 y765 z432
0 1 3 5
1 2 4 6
Amestecat 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
Soluție 5 Utilizați un "lambda" în pd.DataFrame.redenumiți` care trece prin fiecare element de "noi" În această soluție, vom trece un lambda care are "x", dar apoi ignoră-l. Ea are, de asemenea, un "y", dar nu't aștepta. În schimb, un iterator este dat ca o valoare prestabilită și nu poate apoi folosi pentru a parcurge unul la un moment dat, fără a ține cont de ceea ce valoare de " x " este.
df.rename(columns=lambda x, y=iter(new): next(y))
x098 y765 z432
0 1 3 5
1 2 4 6
Și după cum mi-a subliniat de către oameni în sopython chat, dacă am adăuga un " * "între" x " și "y", pot să-mi protejez " y " variabila. Totuși, în acest context, am don't cred că are nevoie de protecție. Este totuși important de menționat.
df.rename(columns=lambda x, *, y=iter(new): next(y))
x098 y765 z432
0 1 3 5
1 2 4 6
Aș vrea să explic un pic ce se întâmplă în spatele scenei.
Dataframes sunt un set de Serie.
Seria la rândul lor, sunt o extensie a o numpy.array
numpy.matrice au o proprietate
.numele`
Acesta este numele seriei. Rareori este că panda respectă acest atribut, dar ea persistă în locuri și poate fi folosit pentru a hack un panda comportamente.
O mulțime de răspunsuri aici vorbește despre df.coloane
atribut fiind o "listă" când de fapt este o "Serie". Acest lucru înseamnă că are un `.numele atributelor.
Aceasta este ceea ce se întâmplă dacă vă decideți să completați numele de coloane "Serie":
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
Rețineți că numele de indicele întotdeauna vine o coloana de mai jos.
A .nume atribut persistă uneori. Dacă setați
df.coloane = ['o', 'doi']atunci
df.unul.numeleva fi
'o'`.
Dacă setați df.unul.name = 'trei'", apoi " df.coloanele vor mai da-te['o', 'doi']", și " df.unul.numele
va da'trei'`
pd.DataFrame(df.o)` va reveni
three
0 1
1 2
2 3
Pentru că panda reutilizează `.numele de definit deja "Serie".
Panda are moduri de a face cu mai multe straturi de nume de coloană. Nu este atât de mult de magie, dar am vrut să acopere acest lucru în răspunsul meu, deoarece eu nu't vedea oricine iau pe asta de aici.
|one |
|one |two |
0 | 4 | 1 |
1 | 5 | 2 |
2 | 6 | 3 |
Acest lucru este ușor realizabil prin stabilirea coloane la liste, astfel:
df.columns = [['one', 'one'], ['one', 'two']]
df = pd.DataFrame({'$a': [1], '$b': [1], '$c': [1], '$d': [1], '$e': [1]})
Dacă noua ta lista de coloane este în aceeași ordine ca și coloanele existente, sarcina este simplu:
new_cols = ['a', 'b', 'c', 'd', 'e']
df.columns = new_cols
>>> df
a b c d e
0 1 1 1 1 1
Dacă ați avut un dicționar tastat pe vechiul nume de coloană pentru coloana nou nume, ai putea face următoarele:
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
Dacă tu nu't au o listă sau dicționar de cartografiere, ai putea benzi de conducere $
simbol printr-o listă de înțelegere:
df.columns = [col[1:] if col[0] == '$' else col for col in df]
Daca'am dataframe, df.coloane aruncă totul într-o listă, puteți manipula și apoi realocați în dataframe ca nume de coloane...
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
Cel mai bun mod? IDK. Un fel - da.
O modalitate mai bună de a evalua toate principalele tehnici prezentate în răspunsurile la întrebarea de mai jos este folosind cProfile să gage memorie & timp de executie. @kadee, @kaitlyn, & @eumiro avut funcții cu cel mai rapid ori de execuție - deși aceste funcții sunt atât de rapid încât am're compararea rotunjirea .000 și .001 secunde pentru toate răspunsurile. Morala: răspunsul meu de mai sus probabil e't 'Mai bun' mod.
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.rename(index=str,columns={'A':'a','B':'b'})
https://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.rename.html
Un alt mod am putea înlocui originalul coloana de etichete este de stripping caracterele nedorite (aici '$') din coloana originală etichete.
Acest lucru ar putea fi realizat prin rularea o buclă peste df.coloane și adăugarea dezbrăcat coloane df.coloane.
În schimb , putem face acest lucru cu grijă într-o singură declarație prin utilizarea lista de înțelegere ca mai jos:
df.columns = [col.strip('$') for col in df.columns]
("bandă" metoda în Python benzi de caractere dat de la începutul și sfârșitul șirului.)
Știu că această întrebare și răspunsul a fost ros până la moarte. Dar m-am referit ca sursă de inspirație pentru una dintre probleme le-am avut . Am fost capabil să-l rezolve, folosind biți și piese de răspunsuri diferite, oferind, prin urmare, răspunsul meu în cazul în care cineva are nevoie de ea.
Metoda mea este generic, în care puteți adăuga suplimentar delimitatori prin virgula de separare delimitatori=
variabil și în viitor de ea.
Cod De Lucru:
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 ]
Ieșire:
>>> 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
Rețineți că aceste abordări nu funcționează pentru un MultiIndex. Pentru o MultiIndex, aveți nevoie pentru a face ceva, cum ar fi următoarele:
>>> 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
Las's spun acest lucru este dataframe.
Puteți redenumi coloanele folosind două metode.
dataframe.coloane=[#list]
df.coloane=['un','b','c','d','e']
Limitarea acestei metode este că, dacă o coloană trebuie să fie schimbat, plin column list a de a fi trecut. De asemenea, această metodă nu este aplicabilă pe index etichete. De exemplu, dacă ai trecut de asta:
df.coloane = ['un','b','c','d']
Acest lucru va arunca o eroare. Lungime nepotrivire: Temperatura axa a 5 elemente, valori noi au 4 elemente.
df = df.redenumiți(coloane={'$o':'un'})
În mod similar, aveți posibilitatea să modificați orice rânduri sau coloane.