Ik heb een DataFrame met Panda’s en kolomlabels die ik moet bewerken om de originele kolomlabels te vervangen.

Ik wil de kolomnamen in een DataFrame A wijzigen waar de originele kolomnamen zijn:

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

naar

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

Ik heb de bewerkte kolomnamen opgeslagen in een lijst, maar ik weet niet hoe ik de kolomnamen moet vervangen.

Antwoord 1, autoriteit 100%

Wijs het gewoon toe aan het kenmerk .columns:

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

Antwoord 2, autoriteit 90%

BENOEM SPECIFIEKE KOLOMMEN WIJZIGEN

Gebruik de df.rename() functie en verwijs naar de kolommen die moeten worden hernoemd. Niet alle kolommen hoeven te worden hernoemd:

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)

Voorbeeld van minimale code

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

De volgende methoden werken allemaal en produceren dezelfde uitvoer:

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

Vergeet niet om het resultaat terug toe te wijzen, aangezien de wijziging niet op zijn plaats is. U kunt ook inplace=True opgeven:

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

Vanaf v0.25 kun je ook errors='raise' specificeren om fouten op te heffen als een ongeldige te hernoemen kolom is opgegeven. Zie v0. 25 rename() documenten.

KOLOMKOPPELINGEN OPNIEUW TOEVOEGEN

Gebruik df.set_axis() met axis=1 en inplace=False (om een kopie terug te sturen).

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

Hiermee wordt een kopie geretourneerd, maar u kunt het DataFrame ter plaatse wijzigen door inplace=True in te stellen (dit is het standaardgedrag voor versies <=0.24, maar zal in de toekomst waarschijnlijk veranderen) .

U kunt kopteksten ook rechtstreeks toewijzen:

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

Antwoord 3, autoriteit 20%

De rename methode kan een functie hebben, bijvoorbeeld:

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)

Antwoord 4, autoriteit 10%

Zoals gedocumenteerd in Werken met tekstgegevens:

df.columns = df.columns.str.replace('$', '')

Antwoord 5, autoriteit 8%

Panda’s 0.21+ Antwoord

Er zijn enkele belangrijke updates geweest voor het hernoemen van kolommen in versie 0.21.

Het rename heeft de parameter axis toegevoegd die kan worden ingesteld op columns of 1. Deze update zorgt ervoor dat deze methode overeenkomt met de rest van de Panda’s API. Het heeft nog steeds de parameters index en columns, maar je bent niet langer gedwongen om ze te gebruiken.
De set_axis methode met de inplace ingesteld op False stelt u in staat om alle index- of kolomlabels te hernoemen met een lijst.

Voorbeelden voor Panda’s 0.21+

Construeer voorbeeld 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` gebruiken met `axis='columns'` of `axis=1`

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

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

Beide resulteren in het volgende:

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

Het is nog steeds mogelijk om de handtekening van de oude methode te gebruiken:

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

De functie rename accepteert ook functies die op elke kolomnaam worden toegepast.

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

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

`set_axis` gebruiken met een lijst en `inplace=False`

U kunt een lijst aanleveren voor de set_axis methode die even lang is als het aantal kolommen (of index). Momenteel is inplace standaard True, maar inplace zal in toekomstige releases standaard worden ingesteld op False.

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

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

Waarom niet `df.columns = ['a', 'b', 'c', 'd', 'e']` gebruiken?

Er is niets mis met het direct toewijzen van kolommen op deze manier. Het is een prima oplossing.

Het voordeel van het gebruik van set_axis is dat het kan worden gebruikt als onderdeel van een methodeketen en dat het een nieuwe kopie van het DataFrame retourneert. Zonder dit zou u uw tussenliggende stappen van de keten naar een andere variabele moeten opslaan voordat u de kolommen opnieuw toewijst.

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

Antwoord 6, autoriteit 6%

Omdat u alleen het $-teken in alle kolomnamen wilt verwijderen, kunt u het volgende doen:

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

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

Antwoord 7, autoriteit 4%

Het hernoemen van kolommen in Panda’s is een gemakkelijke taak.

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

Antwoord 8, autoriteit 4%

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

Het vervangt de bestaande namen door de namen die u opgeeft, in de volgorde die u opgeeft.

Antwoord 9, autoriteit 3%

Gebruik:

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)

Op deze manier kun je de new_names handmatig naar wens aanpassen. Het werkt geweldig als je maar een paar kolommen hoeft te hernoemen om spelfouten, accenten te corrigeren, speciale tekens te verwijderen, enz.

Antwoord 10, autoriteit 2%

One line of Pipeline-oplossingen

Ik zal me op twee dingen concentreren:

OP vermeldt duidelijk

Ik heb de bewerkte kolomnamen opgeslagen in een lijst, maar ik weet niet hoe ik de kolomnamen moet vervangen.

Ik wil het probleem van het vervangen van '$' niet oplossen of het eerste teken van elke kolomkop verwijderen. OP heeft deze stap al gedaan. In plaats daarvan wil ik me concentreren op het vervangen van het bestaande columns-object door een nieuw object met een lijst met vervangende kolomnamen.
df.columns = new waarbij new de lijst met nieuwe kolomnamen is, is zo eenvoudig als maar kan. Het nadeel van deze aanpak is dat het bewerken van het kenmerk columns van het bestaande dataframe vereist is en dat het niet inline wordt gedaan. Ik zal een paar manieren laten zien om dit via pipelining uit te voeren zonder het bestaande dataframe te bewerken.

Setup 1
Om me te concentreren op de noodzaak om kolomnamen te hernoemen of te vervangen door een reeds bestaande lijst, maak ik een nieuw voorbeelddataframe df met initiële kolomnamen en niet-gerelateerde nieuwe kolomnamen.

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

Oplossing 1
pd.DataFrame.rename

Er is al gezegd dat als u een woordenboek had dat de oude kolomnamen toewijst aan nieuwe kolomnamen, u pd.DataFrame.rename zou kunnen gebruiken.

d = {'Jack': 'x098', 'Mahesh': 'y765', 'Xin': 'z432'}
df.rename(columns=d)
   x098  y765  z432
0     1     3     5
1     2     4     6

U kunt dat woordenboek echter eenvoudig maken en opnemen in de aanroep om rename. Het volgende maakt gebruik van het feit dat wanneer we df herhalen, we elke kolomnaam herhalen.

# 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

Dit werkt prima als uw originele kolomnamen uniek zijn. Maar als dat niet het geval is, gaat dit stuk.

Setup 2
Niet-unieke kolommen

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

Oplossing 2
pd.concat met het argument keys

Bekijk eerst wat er gebeurt als we oplossing 1 proberen te gebruiken:

df.rename(columns=dict(zip(df, new)))
   y765  y765  z432
0     1     3     5
1     2     4     6

We hebben de new lijst niet toegewezen als de kolomnamen. Uiteindelijk herhaalden we y765. In plaats daarvan kunnen we het argument keys van de functie pd.concat gebruiken tijdens het doorlopen van de kolommen van df.

pd.concat([c for _, c in df.items()], axis=1, keys=new) 
   x098  y765  z432
0     1     3     5
1     2     4     6

Oplossing 3
Reconstrueren. Dit mag alleen worden gebruikt als u één dtype heeft voor alle kolommen. Anders krijg je dtype object voor alle kolommen en het terug converteren ervan vereist meer woordenboekwerk.

Enkel dtype

pd.DataFrame(df.values, df.index, new)
   x098  y765  z432
0     1     3     5
1     2     4     6

Gemengd 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

Oplossing 4
Dit is een gimmicky truc met transpose en set_index. pd.DataFrame.set_index stelt ons in staat om een index inline in te stellen, maar er is geen corresponderende set_columns. Dus we kunnen transponeren, dan set_index, en terug transponeren. Dezelfde enkele dtype versus gemengde dtype waarschuwing van oplossing 3 is hier echter van toepassing.

Enkel dtype

df.T.set_index(np.asarray(new)).T
   x098  y765  z432
0     1     3     5
1     2     4     6

Gemengd 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

Oplossing 5
Gebruik een lambda in pd.DataFrame.rename die door elk element van new bladert.
In deze oplossing geven we een lambda door die x neemt, maar deze vervolgens negeert. Er is ook een y voor nodig, maar verwacht het niet. In plaats daarvan wordt een iterator als standaardwaarde gegeven en die kan ik dan gebruiken om er één voor één doorheen te bladeren, ongeacht wat de waarde van x is.

df.rename(columns=lambda x, y=iter(new): next(y))
   x098  y765  z432
0     1     3     5
1     2     4     6

En zoals mij is aangegeven door de mensen in de sopython-chat, als Ik voeg een * toe tussen x en y, ik kan mijn y-variabele beschermen. Maar in deze context geloof ik niet dat het bescherming nodig heeft. Het is nog steeds het vermelden waard.

df.rename(columns=lambda x, *, y=iter(new): next(y))
   x098  y765  z432
0     1     3     5
1     2     4     6

Antwoord 11, autoriteit 2%

Kolomnamen versus namen van series

Ik wil graag een beetje uitleggen wat er achter de schermen gebeurt.

Dataframes zijn een reeks reeksen.

Series zijn op hun beurt een uitbreiding van een numpy.array.

numpy.arrays hebben een eigenschap .name.

Dit is de naam van de serie. Het komt zelden voor dat Panda’s dit kenmerk respecteren, maar het blijft op sommige plaatsen hangen en kan worden gebruikt om sommige gedragingen van Panda’s te hacken.

De lijst met kolommen een naam geven

Veel antwoorden hier hebben het over het df.columns attribuut dat een list is, terwijl het in feite een Series is. Dit betekent dat het een .name-attribuut heeft.

Dit gebeurt er als u besluit de naam van de kolommen Series in te vullen:

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

Houd er rekening mee dat de naam van de index altijd een kolom lager komt.

Artefacten die blijven hangen

Het kenmerk .name blijft soms hangen. Als u df.columns = ['one', 'two'] instelt, wordt de df.one.name 'one'.

Als u df.one.name = 'three' instelt, geeft df.columns u nog steeds ['one', 'two'], en df.one.name geeft je 'three'.

MAAR

pd.DataFrame(df.one) zal terugkeren

Omdat Pandas de .name van de reeds gedefinieerde Series hergebruikt.

Kolomnamen op meerdere niveaus

Pandas heeft manieren om kolomnamen met meerdere lagen te maken. Er is niet zo veel magie bij betrokken, maar ik wilde dit ook in mijn antwoord behandelen, omdat ik niemand dit hier zie oppikken.

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

Dit is gemakkelijk te bereiken door kolommen in lijsten in te stellen, zoals deze:

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

Antwoord 12

Laten we begrijpen hernoemen aan de hand van een klein voorbeeld…

Kolommen hernoemen met toewijzing:

 df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}) # Creating a df with column name A and B
 df.rename({"A": "new_a", "B": "new_b"}, axis='columns', inplace =True) # Renaming column A with 'new_a' and B with 'new_b'
 Output:
    new_a  new_b
 0  1       4
 1  2       5
 2  3       6

De naam van index/rijnaam wijzigen met toewijzing:

 df.rename({0: "x", 1: "y", 2: "z"}, axis='index', inplace =True) # Row name are getting replaced by 'x', 'y', and 'z'.
 Output:
        new_a  new_b
     x  1       4
     y  2       5
     z  3       6

Antwoord 13

Stel dat dit uw dataframe is.

Je kunt de kolommen op twee manieren hernoemen.

dataframe.columns=[#list]

gebruiken
```
df.columns=['a','b','c','d','e']
```
De beperking van deze methode is dat als één kolom moet worden gewijzigd, de volledige kolomlijst moet worden doorgegeven. Deze methode is ook niet van toepassing op indexlabels.
Als je dit bijvoorbeeld hebt doorstaan:
```
df.columns = ['a','b','c','d']
```
Dit geeft een foutmelding. Lengte komt niet overeen: verwachte as heeft 5 elementen, nieuwe waarden hebben 4 elementen.
Een andere methode is de Pandas rename() methode die wordt gebruikt om een index, kolom of rij te hernoemen
```
df = df.rename(columns={'$a':'a'})
```

Op dezelfde manier kunt u alle rijen of kolommen wijzigen.

Antwoord 14

df = pd.DataFrame({'$a': [1], '$b': [1], '$c': [1], '$d': [1], '$e': [1]})

Als uw nieuwe lijst met kolommen in dezelfde volgorde staat als de bestaande kolommen, is de toewijzing eenvoudig:

new_cols = ['a', 'b', 'c', 'd', 'e']
df.columns = new_cols
>>> df
   a  b  c  d  e
0  1  1  1  1  1

Als u een woordenboek had ingetoetst op oude kolomnamen naar nieuwe kolomnamen, kunt u het volgende doen:

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

Als u geen lijst of woordenboektoewijzing heeft, kunt u het leidende $-symbool verwijderen via een lijstbegrip:

df.columns = [col[1:] if col[0] == '$' else col for col in df]

Antwoord 15

Als je het dataframe hebt, dumpt df.columns alles in een lijst die je kunt manipuleren en vervolgens opnieuw toewijzen aan je dataframe als de namen van kolommen…

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

Beste manier? Ik weet het niet. Een manier – ja.

Een betere manier om alle belangrijke technieken te evalueren die in de antwoorden op de vraag naar voren zijn gebracht, is hieronder door cProfile te gebruiken om geheugen en uitvoeringstijd te meten. @kadee, @kaitlyn en @eumiro hadden de functies met de snelste uitvoeringstijden – hoewel deze functies zo snel zijn, vergelijken we de afronding van 0,000 en 0,001 seconden voor alle antwoorden. Moraal: mijn antwoord hierboven is waarschijnlijk niet de ‘beste’ manier.

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

Antwoord 16

df.rename(index=str, columns={'A':'a', 'B':'b'})

pandas.DataFrame.rename

Antwoord 17

Een andere manier waarop we de originele kolomlabels kunnen vervangen, is door de ongewenste tekens (hier ‘$’) uit de originele kolomlabels te verwijderen.

Dit had kunnen worden gedaan door een for-lus over df.columns uit te voeren en de gestripte kolommen toe te voegen aan df.columns.

In plaats daarvan kunnen we dit netjes in één enkele instructie doen door lijstbegrip te gebruiken zoals hieronder:

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

(strip methode in Python stript het gegeven karakter vanaf het begin en einde van de string.)

Antwoord 18

Het is heel eenvoudig. Gebruik gewoon:

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

En het zal de kolomnamen toewijzen in de volgorde waarin u ze plaatst.

Antwoord 19

Je zou str.slice daarvoor:

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

Antwoord 20

Een andere optie is om de naam te wijzigen met een reguliere expressie:

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

Antwoord 21

Mijn methode is generiek, waarbij je extra scheidingstekens kunt toevoegen door de variabele delimiters= van elkaar te scheiden en toekomstbestendig te maken.

Werkcode:

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 ]

Uitvoer:

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

Antwoord 22

Merk op dat de benaderingen in eerdere antwoorden niet werken voor een MultiIndex. Voor een MultiIndex moet u zoiets als het volgende doen:

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

Antwoord 23

Als je te maken hebt met heel veel kolommen die door het leverende systeem worden genoemd en waar je geen controle over hebt, heb ik de volgende aanpak bedacht die een combinatie is van een algemene aanpak en specifieke vervangingen in één keer.

Maak eerst een woordenboek van de dataframe-kolomnamen met behulp van reguliere expressies om bepaalde bijlagen van kolomnamen weg te gooien en voeg vervolgens specifieke vervangingen toe aan het woordenboek om kernkolommen te benoemen, zoals later in de ontvangende database wordt verwacht.

Dit wordt dan in één keer toegepast op het dataframe.

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)

Antwoord 24

Naast de reeds geboden oplossing, kunt u alle kolommen vervangen terwijl u het bestand aan het lezen bent. We kunnen hiervoor names en header=0 gebruiken.

Eerst maken we een lijst met namen die we graag als kolomnamen gebruiken:

import pandas as pd
ufo_cols = ['city', 'color reported', 'shape reported', 'state', 'time']
ufo.columns = ufo_cols
ufo = pd.read_csv('link to the file you are using', names = ufo_cols, header = 0)

In dit geval worden alle kolomnamen vervangen door de namen die in uw lijst staan.

Antwoord 25

Hier is een handige kleine functie die ik graag gebruik om het typen te verminderen:

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 is een voorbeeld van hoe het werkt:

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

Antwoord 26

Ervan uitgaande dat u een reguliere expressie kunt gebruiken, verwijdert de noodzaak van handmatige codering met behulp van een reguliere expressie:

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

Antwoord 27

Ik moest functies voor XGBoost hernoemen, en het beviel geen van deze:

import re
regex = r"[!\"#$%&'()*+,\-.\/:;<=>?@[\\\]^_`{|}~ ]+"
X_trn.columns = X_trn.columns.str.replace(regex, '_', regex=True)
X_tst.columns = X_tst.columns.str.replace(regex, '_', regex=True)

Antwoord 28

Veel panda’s-functies hebben een ingebouwde parameter. Als u het instelt op True, is de transformatie rechtstreeks van toepassing op het dataframe waarop u het aanroept. Bijvoorbeeld:

df = pd.DataFrame({'$a':[1,2], '$b': [3,4]})
df.rename(columns={'$a': 'a'}, inplace=True)
df.columns
>>> Index(['a', '$b'], dtype='object')

Als alternatief zijn er gevallen waarin u het originele dataframe wilt behouden. Ik heb vaak mensen in deze zaak zien vallen als het maken van het dataframe een dure taak is. Als het maken van het dataframe bijvoorbeeld een query op een sneeuwvlokdatabase vereist. Zorg er in dit geval voor dat de parameter inplace is ingesteld op False.

df = pd.DataFrame({'$a':[1,2], '$b': [3,4]})
df2 = df.rename(columns={'$a': 'a'}, inplace=False)
df.columns
>>> Index(['$a', '$b'], dtype='object')
df2.columns
>>> Index(['a', '$b'], dtype='object')

Als je dit soort transformaties vaak doet, kun je ook kijken naar een aantal verschillende GUI-tools voor panda’s. Ik ben de maker van een genaamd Mito. Het is een spreadsheet die uw bewerkingen automatisch omzet in python-code.

Antwoord 29

Als je al een lijst hebt voor de nieuwe kolomnamen, kun je dit proberen:

new_names = ['a', 'b', 'c', 'd', 'e']
new_names_map = {df.columns[i]:new_cols[i] for i in range(len(new_cols))}
df.rename(new_names_map, axis=1, inplace=True)

Antwoord 30

Als je alleen het ‘$’-teken wilt verwijderen, gebruik dan de onderstaande code

df.columns = pd.Series(df.columns.str.replace("$", ""))

Kolomnamen hernoemen in Panda’s