Spalten in pandas umbenennen

SPEZIFISCHE SPALTEN UMBENENNEN

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 .

SPALTENKÖPFE NEU ZUORDNEN

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('$','')

Pandas 0.21+ Antwort

In Version 0.21 wurden einige wichtige Aktualisierungen der Spaltenumbenennung vorgenommen.

• Die 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.
• Die _set_axis_ -Methode mit inplace auf False ermöglicht es Ihnen, alle Index- oder Spaltenbeschriftungen mit einer Liste umzubenennen.

Beispiele für Pandas 0.21+

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
_

Verwenden von 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)
_

Verwenden von _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)
_

Warum nicht _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.

Einleitungs- oder Pipeline-Lösungen

Ich werde mich auf zwei Dinge konzentrieren:

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

2. _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 dtypeobject 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
_

Spaltennamen gegen Namen von Serien

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

Benennung der Spaltenliste

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.

Artefakte, die verweilen

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'

ABER

pd.DataFrame(df.one) kehrt zurück

    three
0       1
1       2
2       3

Weil pandas den .name des bereits definierten Series wiederverwendet.

Spaltennamen mit mehreren Ebenen

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.

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

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