Ich habe einen DataFrame mit pandas und Spaltenbeschriftungen, die ich bearbeiten muss, um die ursprünglichen Spaltenbeschriftungen zu ersetzen.
Ich möchte die Spaltennamen in einem DataFrame A
ändern, wobei die ursprünglichen Spaltennamen wie folgt lauten:
['$a', '$b', '$c', '$d', '$e']
zu
['a', 'b', 'c', 'd', 'e'].
Ich habe die bearbeiteten Spaltennamen in einer Liste gespeichert, weiß aber nicht, wie ich die Spaltennamen ersetzen soll.
Weisen Sie es einfach dem .columns
Attribut zu:
>>> df = pd.DataFrame({'$a':[1,2], '$b': [10,20]})
>>> df.columns = ['a', 'b']
>>> df
a b
0 1 10
1 2 20
Verwenden Sie die Funktion df.rename()
und verweisen Sie auf die umzubenennenden Spalten. Nicht alle Spalten müssen umbenannt werden:
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)
Minimales Codebeispiel
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
Die folgenden Methoden funktionieren alle und erzeugen die gleiche Ausgabe:
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
Denken Sie daran, das Ergebnis zurück zu geben, da die Änderung nicht vorhanden ist. Alternativ können Sie inplace=True
angeben:
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
Ab Version 0.25 können Sie auch errors='raise'
angeben, um Fehler auszulösen, wenn eine ungültige Spalte zum Umbenennen angegeben wird. Siehe v0.25 rename()
docs .
Verwenden Sie df.set_axis()
mit axis=1
und inplace=False
(um eine Kopie zurückzugeben).
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
Dies gibt eine Kopie zurück, aber Sie können den DataFrame direkt ändern, indem Sie inplace=True
festlegen (dies ist das Standardverhalten für Versionen <= 0.24, wird sich aber wahrscheinlich in Zukunft ändern).
Sie können Header auch direkt zuweisen:
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
Die Methode rename
kann eine Funktion übernehmen, zum Beispiel:
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)
Wie in http://pandas.pydata.org/pandas-docs/stable/text.html dokumentiert:
df.columns = df.columns.str.replace('$','')
In Version 0.21 wurden einige wichtige Aktualisierungen der Spaltenumbenennung vorgenommen.
rename
-Methode hat den axis
-Parameter hinzugefügt, der auf columns
oder _1
_ gesetzt werden kann. Durch dieses Update stimmt diese Methode mit dem Rest der pandas-API überein. Es enthält weiterhin die Parameter index
und columns
, aber Sie müssen sie nicht mehr verwenden.set_axis
_ -Methode mit inplace
auf False
ermöglicht es Ihnen, alle Index- oder Spaltenbeschriftungen mit einer Liste umzubenennen.Erstellen Sie einen Beispiel-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
_
rename
mit _axis='columns'
_ oder _axis=1
__df.rename({'$a':'a', '$b':'b', '$c':'c', '$d':'d', '$e':'e'}, axis='columns')
_
oder
_df.rename({'$a':'a', '$b':'b', '$c':'c', '$d':'d', '$e':'e'}, axis=1)
_
Beides ergibt folgendes:
_ a b c d e
0 1 3 5 7 9
1 2 4 6 8 10
_
Es ist weiterhin möglich, die alte Methodensignatur zu verwenden:
_df.rename(columns={'$a':'a', '$b':'b', '$c':'c', '$d':'d', '$e':'e'})
_
Die Funktion rename
akzeptiert auch Funktionen, die auf jeden Spaltennamen angewendet werden.
_df.rename(lambda x: x[1:], axis='columns')
_
oder
_df.rename(lambda x: x[1:], axis=1)
_
set_axis
_ mit einer Liste und _inplace=False
_Sie können der _set_axis
_ -Methode eine Liste bereitstellen, deren Länge der Anzahl der Spalten (oder des Index) entspricht. Derzeit ist inplace
standardmäßig True
, aber inplace
wird in zukünftigen Versionen standardmäßig False
sein.
_df.set_axis(['a', 'b', 'c', 'd', 'e'], axis='columns', inplace=False)
_
oder
_df.set_axis(['a', 'b', 'c', 'd', 'e'], axis=1, inplace=False)
_
df.columns = ['a', 'b', 'c', 'd', 'e']
_ verwenden?Es ist nichts Falsches daran, Spalten direkt so zuzuweisen. Es ist eine vollkommen gute Lösung.
Der Vorteil von _set_axis
_ besteht darin, dass es als Teil einer Methodenkette verwendet werden kann und eine neue Kopie des DataFrame zurückgibt. Ohne sie müssten Sie Ihre Zwischenschritte der Kette in einer anderen Variablen speichern, bevor Sie die Spalten neu zuweisen.
_# 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()
_
Da Sie nur das $ -Zeichen in allen Spaltennamen entfernen möchten, können Sie Folgendes tun:
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']
Die vorhandenen Namen werden in der von Ihnen angegebenen Reihenfolge durch die von Ihnen angegebenen Namen ersetzt.
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)
Auf diese Weise können Sie den new_names
manuell nach Ihren Wünschen bearbeiten. Funktioniert hervorragend, wenn Sie nur einige Spalten umbenennen müssen, um Rechtschreibfehler, Akzente, Sonderzeichen usw. zu korrigieren.
Ich halte diese Methode für nützlich:
df.rename(columns={"old_column_name1":"new_column_name1", "old_column_name2":"new_column_name2"})
Mit dieser Methode können Sie die Spaltennamen einzeln ändern.
Ich werde mich auf zwei Dinge konzentrieren:
OP gibt klar an
Ich habe die bearbeiteten Spaltennamen in einer Liste gespeichert, weiß aber nicht, wie ich die Spaltennamen ersetzen soll.
Ich möchte nicht das Problem lösen, wie man _'$'
_ ersetzt oder das erste Zeichen aus jeder Spaltenüberschrift entfernt. OP hat diesen Schritt bereits getan. Stattdessen möchte ich mich darauf konzentrieren, das vorhandene columns
-Objekt durch ein neues zu ersetzen, wenn eine Liste mit Ersatzspaltennamen angegeben wird.
_df.columns = new
_ wobei new
die Liste der neuen Spaltennamen ist, ist so einfach wie es nur geht. Der Nachteil dieses Ansatzes besteht darin, dass das vorhandene Attribut columns
des Datenrahmens bearbeitet werden muss und nicht inline ausgeführt wird. Ich zeige Ihnen einige Möglichkeiten, wie Sie dies per Pipelining durchführen können, ohne den vorhandenen Datenrahmen zu bearbeiten.
Setup 1
Um sich auf die Notwendigkeit zu konzentrieren, Spaltennamen durch eine bereits vorhandene Liste zu ersetzen, erstelle ich einen neuen Beispieldatenrahmen df
mit anfänglichen Spaltennamen und nicht verwandten neuen Spaltennamen.
_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
_
Lösung 1 pd.DataFrame.rename
Es wurde bereits gesagt, dass Sie , wenn Sie ein Wörterbuch hätten, das die alten Spaltennamen den neuen Spaltennamen zuordnet, _pd.DataFrame.rename
_ verwenden könnten.
_d = {'Jack': 'x098', 'Mahesh': 'y765', 'Xin': 'z432'}
df.rename(columns=d)
x098 y765 z432
0 1 3 5
1 2 4 6
_
Sie können dieses Wörterbuch jedoch problemlos erstellen und in den Aufruf von rename
aufnehmen. Im Folgenden wird die Tatsache ausgenutzt, dass beim Durchlaufen von df
die einzelnen Spaltennamen durchlaufen werden.
_# 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
_
Dies funktioniert hervorragend, wenn Ihre ursprünglichen Spaltennamen eindeutig sind. Aber wenn sie es nicht sind, bricht dies zusammen.
Setup 2
nicht eindeutige Spalten
_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
_
Lösung 2 pd.concat
mit dem Argument keys
Beachten Sie zunächst, was passiert, wenn Sie versuchen, Lösung 1 zu verwenden:
_df.rename(columns=dict(Zip(df, new)))
y765 y765 z432
0 1 3 5
1 2 4 6
_
Wir haben die Liste new
nicht als Spaltennamen zugeordnet. Wir haben _y765
_ wiederholt. Stattdessen können wir das Argument keys
der Funktion _pd.concat
_ verwenden, während wir die Spalten von df
durchlaufen.
_pd.concat([c for _, c in df.items()], axis=1, keys=new)
x098 y765 z432
0 1 3 5
1 2 4 6
_
Lösung 3
Rekonstruieren. Dies sollte nur verwendet werden, wenn Sie für alle Spalten eine einzige dtype
haben. Andernfalls erhalten Sie dtype
object
für alle Spalten, und das Zurückkonvertieren erfordert mehr Wörterbucharbeit.
Single dtype
_pd.DataFrame(df.values, df.index, new)
x098 y765 z432
0 1 3 5
1 2 4 6
_
Gemischt 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
_
Lösung 4
Dies ist ein kniffliger Trick mit transpose
und _set_index
_. pd.DataFrame.set_index
ermöglicht es uns, einen Index inline zu setzen, aber es gibt keinen entsprechenden _set_columns
_. Wir können also transponieren, dann _set_index
_ und zurück transponieren. Hier gilt jedoch derselbe einzelne dtype
versus gemischter dtype
Vorbehalt aus Lösung 3.
Single dtype
_df.T.set_index(np.asarray(new)).T
x098 y765 z432
0 1 3 5
1 2 4 6
_
Gemischt 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
_
Lösung 5
Verwenden Sie in _pd.DataFrame.rename
_ ein lambda
, das jedes Element von new
durchläuft.
In dieser Lösung übergeben wir ein Lambda, das x
annimmt, es dann jedoch ignoriert. Es braucht auch ein y
, erwartet es aber nicht. Stattdessen wird ein Iterator als Standardwert angegeben, und damit kann ich nacheinander durchlaufen, ohne auf den Wert von x
zu achten.
_df.rename(columns=lambda x, y=iter(new): next(y))
x098 y765 z432
0 1 3 5
1 2 4 6
_
Und wie mir die Leute in sopython chat gesagt haben, kann ich meine Variable x
schützen, wenn ich zwischen y
und y
einen _*
_ hinzufüge. In diesem Zusammenhang glaube ich jedoch nicht, dass es eines Schutzes bedarf. Es ist immer noch erwähnenswert.
_df.rename(columns=lambda x, *, y=iter(new): next(y))
x098 y765 z432
0 1 3 5
1 2 4 6
_
Ich möchte kurz erklären, was hinter den Kulissen passiert.
Datenrahmen sind eine Reihe von Reihen.
Serien wiederum sind eine Erweiterung eines numpy.array
numpy.array
s haben eine Eigenschaft .name
Dies ist der Name der Serie. Es ist selten, dass pandas dieses Attribut respektiert, aber es verweilt an einigen Stellen und kann verwendet werden, um einige pandas Verhaltensweisen zu hacken.
In vielen Antworten wird davon gesprochen, dass das df.columns
-Attribut ein list
ist, obwohl es tatsächlich ein Series
ist. Dies bedeutet, dass es ein .name
-Attribut hat.
Dies passiert, wenn Sie den Namen der Spalten Series
eingeben:
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
Beachten Sie, dass der Name des Index immer eine Spalte tiefer steht.
Das .name
Attribut bleibt manchmal an. Wenn Sie df.columns = ['one', 'two']
einstellen, ist df.one.name
'one'
.
Wenn Sie df.one.name = 'three'
einstellen, dann gibt df.columns
Ihnen noch ['one', 'two']
und df.one.name
gibt Ihnen 'three'
pd.DataFrame(df.one)
kehrt zurück
three
0 1
1 2
2 3
Weil pandas den .name
des bereits definierten Series
wiederverwendet.
Pandas bietet Möglichkeiten, mehrschichtige Spaltennamen zu erstellen. Es ist nicht so viel Magie involviert, aber ich wollte dies auch in meiner Antwort behandeln, da ich hier niemanden sehe, der dies aufgreift.
|one |
|one |two |
0 | 4 | 1 |
1 | 5 | 2 |
2 | 6 | 3 |
Dies ist leicht zu erreichen, indem Spalten wie folgt in Listen gesetzt werden:
df.columns = [['one', 'one'], ['one', 'two']]
df = df.rename(columns=lambda n: n.replace('$', ''))
ist eine funktionale Möglichkeit, dies zu lösen
Wenn Sie den Datenrahmen haben, speichert df.columns alles in einer Liste, die Sie bearbeiten und anschließend Ihrem Datenrahmen als Spaltennamen zuweisen können ...
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
Bester Weg? IDK. Ein Weg - ja.
Eine bessere Methode zur Bewertung aller Haupttechniken, die in den Antworten auf die Frage aufgeführt sind, ist die Verwendung von cProfile, um die Speicher- und Ausführungszeit zu ermitteln. @kadee, @kaitlyn & @eumiro hatten die Funktionen mit den schnellsten Ausführungszeiten - obwohl diese Funktionen so schnell sind, vergleichen wir die Rundung von .000 und .001 Sekunden für alle Antworten. Moral: Meine obige Antwort ist wahrscheinlich nicht der beste Weg.
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]})
Wenn sich Ihre neue Spaltenliste in derselben Reihenfolge wie die vorhandenen Spalten befindet, ist die Zuordnung einfach:
new_cols = ['a', 'b', 'c', 'd', 'e']
df.columns = new_cols
>>> df
a b c d e
0 1 1 1 1 1
Wenn Sie ein Wörterbuch für alte Spaltennamen in neue Spaltennamen eingegeben haben, können Sie Folgendes tun:
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
Wenn Sie keine Listen- oder Wörterbuchzuordnung haben, können Sie das führende $
-Symbol über ein Listenverständnis entfernen:
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
Eine andere Möglichkeit, die ursprünglichen Spaltenbeschriftungen zu ersetzen, besteht darin, die unerwünschten Zeichen (hier '$') von den ursprünglichen Spaltenbeschriftungen zu entfernen.
Dies könnte durch Ausführen einer for-Schleife über df.columns und Anhängen der entfernten Spalten an df.columns geschehen sein.
Stattdessen können wir dies in einer einzelnen Anweisung unter Verwendung des folgenden Listenverständnisses ordentlich ausführen:
df.columns = [col.strip('$') for col in df.columns]
(strip
Methode in Python entfernt das angegebene Zeichen vom Anfang und Ende der Zeichenfolge.)
Ganz einfach einfach benutzen
df.columns = ['Name1', 'Name2', 'Name3'...]
die Spaltennamen werden in der Reihenfolge zugewiesen, in der Sie sie eingegeben haben
Ich weiß, dass diese Frage und Antwort zu Tode gekaut wurde. Aber ich bezog mich darauf, um mich für eines der Probleme zu inspirieren, die ich hatte. Ich war in der Lage, es mit Stücken aus verschiedenen Antworten zu lösen und meine Antwort zu geben, falls jemand es braucht.
Meine Methode ist generisch, wobei Sie zusätzliche Trennzeichen hinzufügen können, indem Sie die Variable delimiters=
durch Kommas trennen und zukunftssicher machen.
Arbeitscode:
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 ]
Ausgabe:
>>> 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
Sie könnten dafür str.slice
verwenden:
_df.columns = df.columns.str.slice(1)
_
Die Datenrahmenspalten umbenennen und das Format ersetzen
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(' ', '_')
Beachten Sie, dass diese Vorgehensweise für einen MultiIndex nicht funktioniert. Für einen MultiIndex müssen Sie wie folgt vorgehen:
>>> 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
Spalten beim Lesen des Datenrahmens umbenennen:
>>> 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
Eine andere Möglichkeit ist das Umbenennen mit einem regulären Ausdruck:
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
Dies ist wahrscheinlich die einfachste Lösung für das Problem. Es ist ziemlich selbsterklärend, wie es funktioniert.
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()
Importieren Sie Bibliotheken, die uns beim Erstellen eines Datenrahmens helfen:
import pandas as pd
import numpy as np
Datenrahmen erstellen:
df = pd.DataFrame(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), columns=['a', 'b', 'c'])
Datenrahmen umbenennen:
df.rename(columns={'a':'x', 'b':'y', 'c':'z'}, index=str)
df.columns sollte jetzt unterschiedliche Werte haben
Ich sehe 3 einfache Möglichkeiten
df.columns
ausgabe: ['$ 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)
Wenn Sie mit einer Vielzahl von Spalten zu tun haben, die vom bereitstellenden System außerhalb Ihrer Kontrolle benannt wurden, habe ich den folgenden Ansatz gefunden, der eine Kombination aus einem allgemeinen Ansatz und spezifischen Ersetzungen in einem Durchgang darstellt.
Erstellen Sie zunächst ein Wörterbuch aus den Namen der Datenrahmenspalten mit regulären Ausdrücken, um bestimmte Anhänge von Spaltennamen zu entfernen, und fügen Sie dem Wörterbuch dann bestimmte Ersetzungen hinzu, um die Kernspalten wie erwartet später in der empfangenden Datenbank zu benennen.
Dies wird dann auf einmal auf den Datenrahmen angewendet.
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)
Versuche dies. Für mich geht das
df.rename(index=str, columns={"$a": "a", "$b": "b", "$c" : "c", "$d" : "d", "$e" : "e"})
Hier ist eine nette kleine Funktion, mit der ich das Tippen einschränken möchte:
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
Hier ist ein Beispiel, wie es funktioniert:
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')
Falls Sie die Zeilennamen nicht möchten df.columns = ['a', 'b',index=False]
Angenommen, Sie können einen regulären Ausdruck verwenden. Diese Lösung macht die manuelle Codierung mit Regex überflüssig
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(' ', '_')
Angenommen, dies ist Ihr Datenrahmen.
Sie können die Spalten mit zwei Methoden umbenennen.
Using dataframe.columns = [# list]
df.columns = ['a', 'b', 'c', 'd', 'e']
Die Einschränkung dieser Methode besteht darin, dass, wenn eine Spalte geändert werden muss, eine vollständige Spaltenliste übergeben werden muss. Diese Methode ist auch auf Indexbeschriftungen nicht anwendbar. Wenn Sie dies zum Beispiel bestanden haben:
df.columns = ['a','b','c','d']
Dies wird einen Fehler auslösen. Längeninkongruenz: Erwartete Achse hat 5 Elemente, neue Werte haben 4 Elemente.
Eine andere Methode ist die Pandas rename () -Methode, mit der jeder Index, jede Spalte oder Zeile umbenannt wird
df = df.rename (columns = {'$ a': 'a'})
Ebenso können Sie beliebige Zeilen oder Spalten ändern.