Tôi có DataFrame bằng cách sử dụng gấu trúc và nhãn cột mà tôi cần chỉnh sửa để thay thế nhãn cột ban đầu.

Tôi muốn thay đổi tên cột trong DataFrame Atrong đó tên cột ban đầu là:

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

đến

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

Tôi có các tên cột đã chỉnh sửa được lưu trong danh sách, nhưng tôi không biết cách thay thế tên cột.

Chỉ cần gán nó cho .columnsthuộc tính:

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

RENAME CỤ THỂ CỤ THỂ

Sử dụng df.rename()chức năng và giới thiệu các cột sẽ được đổi tên. Không phải tất cả các cột phải được đổi tên:

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)

Ví dụ mã tối thiểu

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

Tất cả các phương pháp sau đây đều hoạt động và tạo ra cùng một đầu ra:

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

Hãy nhớ gán kết quả lại, vì sửa đổi là không đúng chỗ. Ngoài ra, chỉ định 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

Từ v0.25, bạn cũng có thể chỉ định errors='raise'tăng lỗi nếu chỉ định đổi tên cột không hợp lệ. Xem tài liệu v0.25rename() .

TIÊU ĐỀ CUNG CẤP

Sử dụng df.set_axis()với axis=1và inplace=False(để trả lại một bản sao).

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

Điều này trả về một bản sao, nhưng bạn có thể sửa đổi DataFrame tại chỗ bằng cách cài đặt inplace=True(đây là hành vi mặc định cho các phiên bản <= 0,24 nhưng có thể sẽ thay đổi trong tương lai).

Bạn cũng có thể gán tiêu đề trực tiếp:

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

Các renamephương pháp có thể mất một chức năng , ví dụ:

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)

Như tài liệu trong Làm việc với dữ liệu văn bản :

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

Gấu trúc 0,21+ Trả lời

Đã có một số cập nhật quan trọng để đổi tên cột trong phiên bản 0.21.

• Các renamephương pháp đã được thêm vào các axistham số có thể được thiết lập để columnshoặc 1. Bản cập nhật này làm cho phương thức này khớp với phần còn lại của API gấu trúc. Nó vẫn có các tham số indexvà columnsnhưng bạn không còn bị buộc phải sử dụng chúng.
• Các set_axisphương pháp với các inplacethiết lập để Falsecho phép bạn đổi tên tất cả các chỉ số hoặc cột nhãn với một danh sách.

Ví dụ cho Pandas 0,21+

Xây dựng DataFrame mẫu:

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

Sử dụng renamevới axis='columns'hoặcaxis=1

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

hoặc là

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

Cả hai kết quả sau:

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

Vẫn có thể sử dụng chữ ký phương thức cũ:

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

Các renamechức năng cũng chấp nhận chức năng đó sẽ được áp dụng cho mỗi tên cột.

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

hoặc là

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

Sử dụng set_axisvới một danh sách vàinplace=False

Bạn có thể cung cấp một danh sách cho set_axisphương thức có độ dài bằng với số cột (hoặc chỉ mục). Hiện tại, inplacemặc định là True, nhưng inplacesẽ được mặc định Falsetrong các bản phát hành trong tương lai.

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

hoặc là

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

Tại sao không sử dụng df.columns = ['a', 'b', 'c', 'd', 'e']?

Không có gì sai khi gán các cột trực tiếp như thế này. Đó là một giải pháp hoàn toàn tốt.

Ưu điểm của việc sử dụng set_axislà nó có thể được sử dụng như một phần của chuỗi phương thức và nó trả về một bản sao mới của DataFrame. Nếu không có nó, bạn sẽ phải lưu các bước trung gian của chuỗi vào một biến khác trước khi gán lại các cột.

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

Vì bạn chỉ muốn xóa dấu $ trong tất cả các tên cột, bạn chỉ có thể làm:

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

HOẶC LÀ

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

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

Nó sẽ thay thế các tên hiện có bằng các tên bạn cung cấp, theo thứ tự bạn cung cấp.

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)

Bằng cách này bạn có thể tự chỉnh sửa new_namestheo ý muốn. Hoạt động tuyệt vời khi bạn chỉ cần đổi tên một vài cột để sửa lỗi chính tả, dấu trọng âm, xóa các ký tự đặc biệt, v.v.

Giải pháp một dòng hoặc đường ống

Tôi sẽ tập trung vào hai điều:

1. OP nêu rõ

   Tôi có các tên cột đã chỉnh sửa được lưu trong danh sách, nhưng tôi không biết cách thay thế tên cột.

   Tôi không muốn giải quyết vấn đề làm thế nào để thay thế '$'hoặc loại bỏ ký tự đầu tiên khỏi mỗi tiêu đề cột. OP đã thực hiện bước này. Thay vào đó tôi muốn tập trung vào việc thay thế columnsđối tượng hiện tại bằng một đối tượng mới được cung cấp một danh sách các tên cột thay thế.

2. df.columns = newtrong đó newdanh sách các tên cột mới là đơn giản như nó được. Hạn chế của phương pháp này là nó yêu cầu chỉnh sửa columnsthuộc tính của khung dữ liệu hiện có và nó không được thực hiện nội tuyến. Tôi sẽ chỉ ra một vài cách để thực hiện điều này thông qua đường ống mà không cần chỉnh sửa khung dữ liệu hiện có.

Thiết lập 1
Để tập trung vào nhu cầu đổi tên tên cột thay thế bằng danh sách có sẵn, tôi sẽ tạo một khung dữ liệu mẫu mới dfvới tên cột ban đầu và tên cột mới không liên quan.

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

Giải pháp 1
pd.DataFrame.rename

Người ta đã nói rằng nếu bạn có một từ điển ánh xạ các tên cột cũ thành các tên cột mới, bạn có thể sử dụng 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

Tuy nhiên, bạn có thể dễ dàng tạo từ điển đó và đưa nó vào cuộc gọi đến rename. Điều sau đây lợi dụng thực tế là khi lặp đi lặp lại df, chúng ta lặp lại qua từng tên cột.

# 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

Điều này hoạt động tuyệt vời nếu tên cột ban đầu của bạn là duy nhất. Nhưng nếu họ không, thì điều này bị phá vỡ.

Thiết lập 2
cột không duy nhất

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

Giải pháp 2
pd.concat sử dụng keysđối số

Đầu tiên, hãy chú ý những gì xảy ra khi chúng tôi cố gắng sử dụng giải pháp 1:

df.rename(columns=dict(zip(df, new)))

   y765  y765  z432
0     1     3     5
1     2     4     6

Chúng tôi đã không ánh xạ newdanh sách như các tên cột. Chúng tôi đã kết thúc lặp lại y765. Thay vào đó, chúng ta có thể sử dụng keysđối số của pd.concathàm trong khi lặp qua các cột của df.

pd.concat([c for _, c in df.items()], axis=1, keys=new) 

   x098  y765  z432
0     1     3     5
1     2     4     6

Giải pháp 3
Tái thiết. Điều này chỉ nên được sử dụng nếu bạn có một dtypecột cho tất cả các cột. Mặt khác, bạn sẽ kết thúc với dtype objecttất cả các cột và chuyển đổi chúng trở lại đòi hỏi nhiều công việc từ điển hơn.

Độc thân dtype

pd.DataFrame(df.values, df.index, new)

   x098  y765  z432
0     1     3     5
1     2     4     6

Trộn 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

Giải pháp 4
Đây là một mánh khóe phô trương với transposevà set_index. pd.DataFrame.set_indexcho phép chúng ta thiết lập một chỉ mục nội tuyến nhưng không có tương ứng set_columns. Vì vậy, chúng ta có thể chuyển đổi, sau đó set_index, và chuyển đổi trở lại. Tuy nhiên, cùng một cảnh báo dtypeso với hỗn hợp dtypetừ giải pháp 3 áp dụng ở đây.

Độc thân dtype

df.T.set_index(np.asarray(new)).T

   x098  y765  z432
0     1     3     5
1     2     4     6

Trộn 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

Giải pháp 5
Sử dụng một lambdatrong pd.DataFrame.renameđó chu kỳ thông qua từng yếu tố của new
Trong giải pháp này, chúng tôi vượt qua một lambda mất xnhưng sau đó bỏ qua nó. Nó cũng mất một ynhưng không mong đợi nó. Thay vào đó, một trình vòng lặp được đưa ra như một giá trị mặc định và sau đó tôi có thể sử dụng nó để quay vòng qua một lần mà không cần quan tâm đến giá trị của xnó là gì.

df.rename(columns=lambda x, y=iter(new): next(y))

   x098  y765  z432
0     1     3     5
1     2     4     6

Và như được chỉ ra cho tôi bởi những người trong trò chuyện sopython , nếu tôi thêm một *ở giữa xvà y, tôi có thể bảo vệ ybiến của mình . Mặc dù, trong bối cảnh này, tôi không tin rằng nó cần được bảo vệ. Nó vẫn còn đáng nói.

df.rename(columns=lambda x, *, y=iter(new): next(y))

   x098  y765  z432
0     1     3     5
1     2     4     6

Tên cột so với Tên của Sê-ri

Tôi muốn giải thích một chút những gì xảy ra đằng sau hậu trường.

Dataframes là một bộ Series.

Lần lượt là một phần mở rộng của một numpy.array

numpy.arrays có một tài sản .name

Đây là tên của bộ truyện. Rất hiếm khi gấu trúc tôn trọng thuộc tính này, nhưng nó tồn tại ở những nơi và có thể được sử dụng để hack một số hành vi của gấu trúc.

Đặt tên cho danh sách các cột

Rất nhiều câu trả lời ở đây nói về df.columnsthuộc tính listkhi thực tế nó là một Series. Điều này có nghĩa là nó có một .namethuộc tính.

Đây là những gì xảy ra nếu bạn quyết định điền vào tên của các cột 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

Lưu ý rằng tên của chỉ mục luôn thấp hơn một cột.

Cổ vật nán lại

Các .namethuộc tính kéo dài đôi khi. Nếu bạn đặt df.columns = ['one', 'two']thì df.one.namesẽ được 'one'.

Nếu bạn đặt df.one.name = 'three'thì df.columnsvẫn sẽ cho bạn ['one', 'two'], và df.one.namesẽ cho bạn'three'

NHƯNG

pd.DataFrame(df.one) sẽ trở lại

    three
0       1
1       2
2       3

Bởi vì gấu trúc tái sử dụng .namecái đã được xác định Series.

Tên cột đa cấp

Gấu trúc có cách làm tên cột nhiều lớp. Không có quá nhiều phép thuật liên quan nhưng tôi cũng muốn đề cập đến câu trả lời này vì tôi không thấy ai nhặt được thứ này ở đây.

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

Điều này có thể dễ dàng đạt được bằng cách đặt các cột thành danh sách, như thế này:

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

Nếu bạn đã có khung dữ liệu, df.column sẽ bỏ mọi thứ vào một danh sách mà bạn có thể thao tác và sau đó gán lại vào khung dữ liệu của bạn dưới dạng tên của các cột ...

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

Cách tốt nhất? IDK. Một cách - có.

Một cách tốt hơn để đánh giá tất cả các kỹ thuật chính được đưa ra trong các câu trả lời cho câu hỏi dưới đây là sử dụng cProfile để đo thời gian thực hiện bộ nhớ và thời gian thực hiện. @kadee, @kaitlyn, & @eumiro có các chức năng với thời gian thực hiện nhanh nhất - mặc dù các chức năng này rất nhanh, chúng tôi đang so sánh làm tròn 0,000 và 0,001 giây cho tất cả các câu trả lời. Về mặt đạo đức: câu trả lời của tôi ở trên có thể không phải là cách 'Tốt nhất'.

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

Hãy nói rằng đây là khung dữ liệu của bạn.

Bạn có thể đổi tên các cột bằng hai phương thức.

1. Sử dụng dataframe.columns=[#list]

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

   

   Hạn chế của phương pháp này là nếu một cột phải được thay đổi, danh sách cột đầy đủ phải được thông qua. Ngoài ra, phương pháp này không áp dụng trên nhãn chỉ mục. Ví dụ: nếu bạn đã vượt qua điều này:

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

   Điều này sẽ ném một lỗi. Độ dài không khớp: Trục dự kiến ​​có 5 phần tử, giá trị mới có 4 phần tử.

2. Một phương thức khác là phương thức Pandas rename()được sử dụng để đổi tên bất kỳ chỉ mục, cột hoặc hàng nào

   df = df.rename(columns={'$a':'a'})

   

Tương tự, bạn có thể thay đổi bất kỳ hàng hoặc cột.

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

Nếu danh sách cột mới của bạn theo cùng thứ tự với các cột hiện có, việc gán đơn giản:

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

Nếu bạn có một từ điển được khóa trên tên cột cũ thành tên cột mới, bạn có thể làm như sau:

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

Nếu bạn không có danh sách hoặc ánh xạ từ điển, bạn có thể loại bỏ $biểu tượng hàng đầu thông qua việc hiểu danh sách:

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/urdy/generated/pandas.DataFrame.rename.html

Hãy hiểu đổi tên bằng một ví dụ nhỏ ...

1.Renaming cột sử dụng ánh xạ:

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

2.Renaming index / Row_Name bằng cách sử dụng ánh xạ:

df.rename({0: "x", 1: "y", 2: "z"},axis='index',inplace =True) #Row name are getting replaced by 'x','y','z'.

output:
       new_a  new_b
    x  1       4
    y  2       5
    z  3       6

Một cách khác để chúng ta có thể thay thế các nhãn cột ban đầu là bằng cách tước các ký tự không mong muốn (ở đây '$') khỏi các nhãn cột ban đầu.

Điều này có thể đã được thực hiện bằng cách chạy một vòng lặp for trên df.column và nối thêm các cột bị tước vào df.columns.

Thay vào đó, chúng ta có thể thực hiện điều này một cách gọn gàng trong một tuyên bố bằng cách sử dụng khả năng hiểu danh sách như dưới đây:

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

( stripphương thức trong Python loại bỏ ký tự đã cho từ đầu và cuối chuỗi.)

Thực sự đơn giản chỉ cần sử dụng

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

và nó sẽ gán tên cột theo thứ tự bạn đặt chúng

Bạn có thể sử dụng str.slicecho điều đó:

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

Tôi biết câu hỏi và câu trả lời này đã bị nhai cho đến chết. Nhưng tôi đã đề cập đến nó để truyền cảm hứng cho một trong những vấn đề tôi đang gặp phải. Tôi đã có thể giải quyết nó bằng cách sử dụng các bit và các mảnh từ các câu trả lời khác nhau do đó cung cấp phản hồi của tôi trong trường hợp bất cứ ai cần nó.

Phương pháp của tôi là chung trong đó bạn có thể thêm các dấu phân cách bổ sung bằng cách phân tách dấu phẩy delimiters=và chứng minh tương lai.

Mã làm việc:

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 ]

Đầu ra:

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

Lưu ý rằng các phương pháp này không hoạt động đối với Đa chỉ số. Đối với Đa chỉ số, bạn cần thực hiện một số thao tác như sau:

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

Một tùy chọn khác là đổi tên bằng biểu thức chính quy:

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

Nếu bạn phải đối phó với vô số cột được đặt tên bởi hệ thống cung cấp ngoài tầm kiểm soát của bạn, tôi đã đưa ra cách tiếp cận sau đây là sự kết hợp giữa cách tiếp cận chung và thay thế cụ thể trong một lần.

Trước tiên, hãy tạo một từ điển từ các tên cột của khung dữ liệu bằng cách sử dụng các biểu thức regex để loại bỏ các phụ lục nhất định của các tên cột và sau đó thêm các thay thế cụ thể vào từ điển để đặt tên cho các cột lõi như dự kiến ​​sau này trong cơ sở dữ liệu nhận.

Điều này sau đó được áp dụng cho khung dữ liệu trong một lần.

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)

Ngoài giải pháp đã được cung cấp, bạn có thể thay thế tất cả các cột trong khi bạn đang đọc tệp. Chúng ta có thể sử dụng namesvàheader=0 để làm điều đó.

Đầu tiên, chúng tôi tạo một danh sách các tên mà chúng tôi muốn sử dụng làm tên cột của chúng tôi:

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)

Trong trường hợp này, tất cả các tên cột sẽ được thay thế bằng các tên bạn có trong danh sách của bạn.

Đây là một chức năng nhỏ tiện lợi mà tôi muốn sử dụng để cắt giảm việc gõ:

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   

Dưới đây là một ví dụ về cách thức hoạt động của nó:

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

Đổi tên cột trong gấu trúc là một nhiệm vụ dễ dàng.

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

Giả sử bạn có thể sử dụng biểu thức chính quy. Giải pháp này loại bỏ nhu cầu mã hóa thủ công bằng 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