Tôi có DataFrame( df):

import numpy as np
import pandas as pd

df = pd.DataFrame(np.random.rand(10, 5))

Tôi thêm nhiều cột bằng cách gán:

df['mean'] = df.mean(1)

Làm thế nào tôi có thể di chuyển cột mean ra phía trước, tức là đặt nó làm cột đầu tiên để lại thứ tự của các cột khác không bị ảnh hưởng?

Một cách dễ dàng là gán lại khung dữ liệu với danh sách các cột, được sắp xếp lại khi cần.

Đây là những gì bạn có bây giờ:

In [6]: df
Out[6]:
          0         1         2         3         4      mean
0  0.445598  0.173835  0.343415  0.682252  0.582616  0.445543
1  0.881592  0.696942  0.702232  0.696724  0.373551  0.670208
2  0.662527  0.955193  0.131016  0.609548  0.804694  0.632596
3  0.260919  0.783467  0.593433  0.033426  0.512019  0.436653
4  0.131842  0.799367  0.182828  0.683330  0.019485  0.363371
5  0.498784  0.873495  0.383811  0.699289  0.480447  0.587165
6  0.388771  0.395757  0.745237  0.628406  0.784473  0.588529
7  0.147986  0.459451  0.310961  0.706435  0.100914  0.345149
8  0.394947  0.863494  0.585030  0.565944  0.356561  0.553195
9  0.689260  0.865243  0.136481  0.386582  0.730399  0.561593

In [7]: cols = df.columns.tolist()

In [8]: cols
Out[8]: [0L, 1L, 2L, 3L, 4L, 'mean']

Sắp xếp lại colstheo bất kỳ cách nào bạn muốn. Đây là cách tôi di chuyển phần tử cuối cùng đến vị trí đầu tiên:

In [12]: cols = cols[-1:] + cols[:-1]

In [13]: cols
Out[13]: ['mean', 0L, 1L, 2L, 3L, 4L]

Sau đó sắp xếp lại khung dữ liệu như thế này:

In [16]: df = df[cols]  #    OR    df = df.ix[:, cols]

In [17]: df
Out[17]:
       mean         0         1         2         3         4
0  0.445543  0.445598  0.173835  0.343415  0.682252  0.582616
1  0.670208  0.881592  0.696942  0.702232  0.696724  0.373551
2  0.632596  0.662527  0.955193  0.131016  0.609548  0.804694
3  0.436653  0.260919  0.783467  0.593433  0.033426  0.512019
4  0.363371  0.131842  0.799367  0.182828  0.683330  0.019485
5  0.587165  0.498784  0.873495  0.383811  0.699289  0.480447
6  0.588529  0.388771  0.395757  0.745237  0.628406  0.784473
7  0.345149  0.147986  0.459451  0.310961  0.706435  0.100914
8  0.553195  0.394947  0.863494  0.585030  0.565944  0.356561
9  0.561593  0.689260  0.865243  0.136481  0.386582  0.730399

Bạn cũng có thể làm một cái gì đó như thế này:

df = df[['mean', '0', '1', '2', '3']]

Bạn có thể lấy danh sách các cột với:

cols = list(df.columns.values)

Đầu ra sẽ tạo ra:

['0', '1', '2', '3', 'mean']

... sau đó dễ dàng sắp xếp lại thủ công trước khi thả nó vào chức năng đầu tiên

Chỉ cần gán tên cột theo thứ tự bạn muốn:

In [39]: df
Out[39]: 
          0         1         2         3         4  mean
0  0.172742  0.915661  0.043387  0.712833  0.190717     1
1  0.128186  0.424771  0.590779  0.771080  0.617472     1
2  0.125709  0.085894  0.989798  0.829491  0.155563     1
3  0.742578  0.104061  0.299708  0.616751  0.951802     1
4  0.721118  0.528156  0.421360  0.105886  0.322311     1
5  0.900878  0.082047  0.224656  0.195162  0.736652     1
6  0.897832  0.558108  0.318016  0.586563  0.507564     1
7  0.027178  0.375183  0.930248  0.921786  0.337060     1
8  0.763028  0.182905  0.931756  0.110675  0.423398     1
9  0.848996  0.310562  0.140873  0.304561  0.417808     1

In [40]: df = df[['mean', 4,3,2,1]]

Bây giờ, cột 'có nghĩa' xuất hiện ở phía trước:

In [41]: df
Out[41]: 
   mean         4         3         2         1
0     1  0.190717  0.712833  0.043387  0.915661
1     1  0.617472  0.771080  0.590779  0.424771
2     1  0.155563  0.829491  0.989798  0.085894
3     1  0.951802  0.616751  0.299708  0.104061
4     1  0.322311  0.105886  0.421360  0.528156
5     1  0.736652  0.195162  0.224656  0.082047
6     1  0.507564  0.586563  0.318016  0.558108
7     1  0.337060  0.921786  0.930248  0.375183
8     1  0.423398  0.110675  0.931756  0.182905
9     1  0.417808  0.304561  0.140873  0.310562

Làm thế nào về:

df.insert(0, 'mean', df.mean(1))

http://pandas.pydata.org/pandas-docs/urdy/dsintro.html#column-selection-addition-deletion

Trong trường hợp của bạn,

df = df.reindex(columns=['mean',0,1,2,3,4])

sẽ làm chính xác những gì bạn muốn.

Trong trường hợp của tôi (mẫu chung):

df = df.reindex(columns=sorted(df.columns))
df = df.reindex(columns=(['opened'] + list([a for a in df.columns if a != 'opened']) ))

Bạn cần tạo một danh sách mới các cột theo thứ tự mong muốn, sau đó sử dụng df = df[cols]để sắp xếp lại các cột theo thứ tự mới này.

cols = ['mean']  + [col for col in df if col != 'mean']
df = df[cols]

Bạn cũng có thể sử dụng một cách tiếp cận tổng quát hơn. Trong ví dụ này, cột cuối cùng (được biểu thị bằng -1) được chèn làm cột đầu tiên.

cols = [df.columns[-1]] + [col for col in df if col != df.columns[-1]]
df = df[cols]

Bạn cũng có thể sử dụng phương pháp này để sắp xếp lại các cột theo thứ tự mong muốn nếu chúng có mặt trong DataFrame.

inserted_cols = ['a', 'b', 'c']
cols = ([col for col in inserted_cols if col in df] 
        + [col for col in df if col not in inserted_cols])
df = df[cols]

import numpy as np
import pandas as pd
df = pd.DataFrame()
column_names = ['x','y','z','mean']
for col in column_names: 
    df[col] = np.random.randint(0,100, size=10000)

Bạn có thể thử các giải pháp sau:

Giải pháp 1:

df = df[ ['mean'] + [ col for col in df.columns if col != 'mean' ] ]

Giải pháp 2:

df = df[['mean', 'x', 'y', 'z']]

Giải pháp 3:

col = df.pop("mean")
df = df.insert(0, col.name, col)

Giải pháp 4:

df.set_index(df.columns[-1], inplace=True)
df.reset_index(inplace=True)

Giải pháp 5:

cols = list(df)
cols = [cols[-1]] + cols[:-1]
df = df[cols]

giải pháp 6:

order = [1,2,3,0] # setting column's order
df = df[[df.columns[i] for i in order]]

So sánh thời gian:

Giải pháp 1:

Thời gian CPU: người dùng 1,05 ms, sys: 35 Lời, tổng cộng: 1,08 ms Thời gian trên tường: 995 lượt

Giải pháp 2 :

Thời gian CPU: người dùng 933 Phát, sys: 0 ns, tổng cộng: 933 Bangs Thời gian trên tường: 800 bài

Giải pháp 3 :

Thời gian CPU: người dùng 0 ns, sys: 1,35 ms, tổng: 1,35 ms Thời gian trên tường: 1,08 ms

Giải pháp 4 :

Thời gian CPU: người dùng 1,23 ms, sys: 45 Lời, tổng cộng: 1,27 ms Thời gian trên tường: 986 lượt

Giải pháp 5 :

Thời gian CPU: người dùng 1,09 ms, sys: 19 sự kiện, tổng cộng: 1,11 ms Thời gian trên tường: 949

Giải pháp 6 :

Thời gian CPU: người dùng 955 lượt, sys: 34 lượt, tổng: 989 lượt Thời gian tường: 859 lượt

Từ tháng 8 năm 2018:

Nếu tên cột của bạn quá dài để nhập thì bạn có thể chỉ định thứ tự mới thông qua danh sách các số nguyên với các vị trí:

Dữ liệu:

          0         1         2         3         4      mean
0  0.397312  0.361846  0.719802  0.575223  0.449205  0.500678
1  0.287256  0.522337  0.992154  0.584221  0.042739  0.485741
2  0.884812  0.464172  0.149296  0.167698  0.793634  0.491923
3  0.656891  0.500179  0.046006  0.862769  0.651065  0.543382
4  0.673702  0.223489  0.438760  0.468954  0.308509  0.422683
5  0.764020  0.093050  0.100932  0.572475  0.416471  0.389390
6  0.259181  0.248186  0.626101  0.556980  0.559413  0.449972
7  0.400591  0.075461  0.096072  0.308755  0.157078  0.207592
8  0.639745  0.368987  0.340573  0.997547  0.011892  0.471749
9  0.050582  0.714160  0.168839  0.899230  0.359690  0.438500

Ví dụ chung:

new_order = [3,2,1,4,5,0]
print(df[df.columns[new_order]])  

          3         2         1         4      mean         0
0  0.575223  0.719802  0.361846  0.449205  0.500678  0.397312
1  0.584221  0.992154  0.522337  0.042739  0.485741  0.287256
2  0.167698  0.149296  0.464172  0.793634  0.491923  0.884812
3  0.862769  0.046006  0.500179  0.651065  0.543382  0.656891
4  0.468954  0.438760  0.223489  0.308509  0.422683  0.673702
5  0.572475  0.100932  0.093050  0.416471  0.389390  0.764020
6  0.556980  0.626101  0.248186  0.559413  0.449972  0.259181
7  0.308755  0.096072  0.075461  0.157078  0.207592  0.400591
8  0.997547  0.340573  0.368987  0.011892  0.471749  0.639745
9  0.899230  0.168839  0.714160  0.359690  0.438500  0.050582

Và đối với trường hợp cụ thể của câu hỏi của OP:

new_order = [-1,0,1,2,3,4]
df = df[df.columns[new_order]]
print(df)

       mean         0         1         2         3         4
0  0.500678  0.397312  0.361846  0.719802  0.575223  0.449205
1  0.485741  0.287256  0.522337  0.992154  0.584221  0.042739
2  0.491923  0.884812  0.464172  0.149296  0.167698  0.793634
3  0.543382  0.656891  0.500179  0.046006  0.862769  0.651065
4  0.422683  0.673702  0.223489  0.438760  0.468954  0.308509
5  0.389390  0.764020  0.093050  0.100932  0.572475  0.416471
6  0.449972  0.259181  0.248186  0.626101  0.556980  0.559413
7  0.207592  0.400591  0.075461  0.096072  0.308755  0.157078
8  0.471749  0.639745  0.368987  0.340573  0.997547  0.011892
9  0.438500  0.050582  0.714160  0.168839  0.899230  0.359690

Vấn đề chính với cách tiếp cận này là việc gọi cùng một mã nhiều lần sẽ tạo ra kết quả khác nhau mỗi lần, vì vậy người ta cần phải cẩn thận :)

Hàm này tránh cho bạn phải liệt kê ra mọi biến trong tập dữ liệu của bạn chỉ để đặt một vài trong số chúng.

def order(frame,var):
    if type(var) is str:
        var = [var] #let the command take a string or list
    varlist =[w for w in frame.columns if w not in var]
    frame = frame[var+varlist]
    return frame 

Phải mất hai đối số, đầu tiên là tập dữ liệu, thứ hai là các cột trong tập dữ liệu mà bạn muốn đưa ra phía trước.

Vì vậy, trong trường hợp của tôi, tôi có một bộ dữ liệu được gọi là Khung với các biến A1, A2, B1, B2, Tổng và Ngày. Nếu tôi muốn đưa Total lên phía trước thì tất cả những gì tôi phải làm là:

frame = order(frame,['Total'])

Nếu tôi muốn đưa Tổng và Ngày lên trước thì tôi làm:

frame = order(frame,['Total','Date'])

BIÊN TẬP:

Một cách hữu ích khác để sử dụng điều này là, nếu bạn có một bảng không quen thuộc và bạn đang tìm kiếm các biến có một thuật ngữ cụ thể trong chúng, như VAR1, VAR2, ... bạn có thể thực hiện một cái gì đó như:

frame = order(frame,[v for v in frame.columns if "VAR" in v])

Tôi đã gặp phải một câu hỏi tương tự, và chỉ muốn thêm những gì tôi đã giải quyết. Tôi thích việc reindex_axis() methodthay đổi thứ tự cột. Điều này đã làm việc:

df = df.reindex_axis(['mean'] + list(df.columns[:-1]), axis=1)

Một phương pháp thay thế dựa trên nhận xét từ @Jorge:

df = df.reindex(columns=['mean'] + list(df.columns[:-1]))

Mặc dù reindex_axisdường như nhanh hơn một chút về điểm chuẩn vi mô so với reindex, tôi nghĩ rằng tôi thích cái sau vì tính trực tiếp của nó.

Đơn giản chỉ cần làm

df = df[['mean'] + df.columns[:-1].tolist()]

Bạn có thể làm như sau (mượn các phần từ câu trả lời của Aman):

cols = df.columns.tolist()
cols.insert(0, cols.pop(-1))

cols
>>>['mean', 0L, 1L, 2L, 3L, 4L]

df = df[cols]

Chỉ cần nhập tên cột bạn muốn thay đổi và đặt chỉ mục cho vị trí mới.

def change_column_order(df, col_name, index):
    cols = df.columns.tolist()
    cols.remove(col_name)
    cols.insert(index, col_name)
    return df[cols]

Đối với trường hợp của bạn, điều này sẽ giống như:

df = change_column_order(df, 'mean', 0)

Di chuyển bất kỳ cột đến vị trí bất kỳ:

import pandas as pd
df = pd.DataFrame({"A": [1,2,3], 
                   "B": [2,4,8], 
                   "C": [5,5,5]})

cols = df.columns.tolist()
column_to_move = "C"
new_position = 1

cols.insert(new_position, cols.pop(cols.index(column_to_move)))
df = df[cols]

Tôi nghĩ rằng đây là một giải pháp gọn gàng hơn:

df.insert(0,'mean', df.pop("mean"))

Giải pháp này có phần giống với giải pháp của @JoeHeffer nhưng đây là một giải pháp.

Ở đây chúng tôi loại bỏ cột "mean"khỏi khung dữ liệu và đính kèm nó vào chỉ mục 0với cùng tên cột.

Đây là một cách để di chuyển một cột hiện có sẽ sửa đổi khung dữ liệu hiện có.

my_column = df.pop('column name')
df.insert(3, my_column.name, my_column)

Câu hỏi này đã được trả lời trước đây nhưng reindex_axis hiện không được chấp nhận vì vậy tôi khuyên bạn nên sử dụng:

df.reindex(sorted(df.columns), axis=1)

Làm thế nào về việc sử dụng "T"?

df.T.reindex(['mean',0,1,2,3,4]).T

@clocker: Giải pháp của bạn rất hữu ích cho tôi, vì tôi muốn đưa hai cột phía trước từ một khung dữ liệu mà tôi không biết chính xác tên của tất cả các cột, vì chúng được tạo từ một câu lệnh xoay vòng trước đó. Vì vậy, nếu bạn ở trong tình huống tương tự: Để đưa các cột ở phía trước mà bạn biết tên của và sau đó để chúng theo sau bởi "tất cả các cột khác", tôi đã đưa ra giải pháp chung sau đây;

df = df.reindex_axis(['Col1','Col2'] + list(df.columns.drop(['Col1','Col2'])), axis=1)

set():

Một cách tiếp cận đơn giản đang sử dụng set(), đặc biệt khi bạn có một danh sách dài các cột và không muốn xử lý chúng theo cách thủ công:

cols = list(set(df.columns.tolist()) - set(['mean']))
cols.insert(0, 'mean')
df = df[cols]

Tôi thích câu trả lời của Shoresh để sử dụng chức năng thiết lập để xóa các cột khi bạn không biết vị trí, tuy nhiên điều này không hoạt động vì mục đích của tôi vì tôi cần giữ thứ tự cột ban đầu (có nhãn cột tùy ý).

Tôi đã làm điều này để làm việc mặc dù bằng cách sử dụng Indexedset từ gói boltons.

Tôi cũng cần phải thêm lại nhiều nhãn cột, vì vậy trong trường hợp tổng quát hơn, tôi đã sử dụng mã sau:

from boltons.setutils import IndexedSet
cols = list(IndexedSet(df.columns.tolist()) - set(['mean', 'std']))
cols[0:0] =['mean', 'std']
df = df[cols]

Hy vọng điều này hữu ích cho bất cứ ai tìm kiếm chủ đề này cho một giải pháp chung.

Bạn có thể sử dụng reindexcó thể được sử dụng cho cả hai trục:

df
#           0         1         2         3         4      mean
# 0  0.943825  0.202490  0.071908  0.452985  0.678397  0.469921
# 1  0.745569  0.103029  0.268984  0.663710  0.037813  0.363821
# 2  0.693016  0.621525  0.031589  0.956703  0.118434  0.484254
# 3  0.284922  0.527293  0.791596  0.243768  0.629102  0.495336
# 4  0.354870  0.113014  0.326395  0.656415  0.172445  0.324628
# 5  0.815584  0.532382  0.195437  0.829670  0.019001  0.478415
# 6  0.944587  0.068690  0.811771  0.006846  0.698785  0.506136
# 7  0.595077  0.437571  0.023520  0.772187  0.862554  0.538182
# 8  0.700771  0.413958  0.097996  0.355228  0.656919  0.444974
# 9  0.263138  0.906283  0.121386  0.624336  0.859904  0.555009

df.reindex(['mean', *range(5)], axis=1)

#        mean         0         1         2         3         4
# 0  0.469921  0.943825  0.202490  0.071908  0.452985  0.678397
# 1  0.363821  0.745569  0.103029  0.268984  0.663710  0.037813
# 2  0.484254  0.693016  0.621525  0.031589  0.956703  0.118434
# 3  0.495336  0.284922  0.527293  0.791596  0.243768  0.629102
# 4  0.324628  0.354870  0.113014  0.326395  0.656415  0.172445
# 5  0.478415  0.815584  0.532382  0.195437  0.829670  0.019001
# 6  0.506136  0.944587  0.068690  0.811771  0.006846  0.698785
# 7  0.538182  0.595077  0.437571  0.023520  0.772187  0.862554
# 8  0.444974  0.700771  0.413958  0.097996  0.355228  0.656919
# 9  0.555009  0.263138  0.906283  0.121386  0.624336  0.859904

Đây là một chức năng để làm điều này cho bất kỳ số lượng cột.

def mean_first(df):
    ncols = df.shape[1]        # Get the number of columns
    index = list(range(ncols)) # Create an index to reorder the columns
    index.insert(0,ncols)      # This puts the last column at the front
    return(df.assign(mean=df.mean(1)).iloc[:,index]) # new df with last column (mean) first

Phương pháp mạnh nhất trong cuốn sách

df.insert(0,"test",df["mean"])
df=df.drop(columns=["mean"]).rename(columns={"test":"mean"})

Tôi nghĩ rằng chức năng này là đơn giản hơn. Bạn chỉ cần chỉ định một tập hợp con các cột ở đầu hoặc cuối hoặc cả hai:

def reorder_df_columns(df, start=None, end=None):
    """
        This function reorder columns of a DataFrame.
        It takes columns given in the list `start` and move them to the left.
        Its also takes columns in `end` and move them to the right.
    """
    if start is None:
        start = []
    if end is None:
        end = []
    assert isinstance(start, list) and isinstance(end, list)
    cols = list(df.columns)
    for c in start:
        if c not in cols:
            start.remove(c)
    for c in end:
        if c not in cols or c in start:
            end.remove(c)
    for c in start + end:
        cols.remove(c)
    cols = start + cols + end
    return df[cols]

Tôi tin rằng câu trả lời của @ Aman là tốt nhất nếu bạn biết vị trí của cột khác.

Nếu bạn không biết vị trí của mean, nhưng chỉ có tên của nó, bạn không thể trực tiếp đến cols = cols[-1:] + cols[:-1]. Sau đây là điều tốt nhất tiếp theo tôi có thể nghĩ ra:

meanDf = pd.DataFrame(df.pop('mean'))
# now df doesn't contain "mean" anymore. Order of join will move it to left or right:
meanDf.join(df) # has mean as first column
df.join(meanDf) # has mean as last column

Chỉ cần lật thường xuyên.

df[df.columns[::-1]]

Hoặc chỉ xáo trộn cho một cái nhìn.

import random
cols = list(df.columns)
random.shuffle(cols)
df[cols]

Hầu hết các câu trả lời không khái quát đủ và phương pháp reindex_axis của gấu trúc hơi tẻ nhạt, do đó tôi cung cấp một hàm đơn giản để di chuyển một số cột tùy ý sang bất kỳ vị trí nào bằng cách sử dụng từ điển trong đó key = name name và value = vị trí để di chuyển đến. Nếu khung dữ liệu của bạn lớn vượt qua Đúng với 'big_data' thì hàm sẽ trả về danh sách cột được sắp xếp. Và bạn có thể sử dụng danh sách này để cắt dữ liệu của bạn.

def order_column(df, columns, big_data = False):

    """Re-Orders dataFrame column(s)
       Parameters : 
       df      -- dataframe
       columns -- a dictionary:
                  key   = current column position/index or column name
                  value = position to move it to  
       big_data -- boolean 
                  True = returns only the ordered columns as a list
                          the user user can then slice the data using this
                          ordered column
                  False = default - return a copy of the dataframe
    """
    ordered_col = df.columns.tolist()

    for key, value in columns.items():

        ordered_col.remove(key)
        ordered_col.insert(value, key)

    if big_data:

        return ordered_col

    return df[ordered_col]

# e.g.
df = pd.DataFrame({'chicken wings': np.random.rand(10, 1).flatten(), 'taco': np.random.rand(10,1).flatten(),
                          'coffee': np.random.rand(10, 1).flatten()})
df['mean'] = df.mean(1)

df = order_column(df, {'mean': 0, 'coffee':1 })

>>>

col = order_column(df, {'mean': 0, 'coffee':1 }, True)

col
>>>
['mean', 'coffee', 'chicken wings', 'taco']

# you could grab it by doing this

df = df[col]

Tôi có một trường hợp sử dụng rất cụ thể để sắp xếp lại tên cột trong gấu trúc. Đôi khi tôi đang tạo một cột mới trong khung dữ liệu dựa trên một cột hiện có. Theo mặc định, gấu trúc sẽ chèn cột mới của tôi vào cuối, nhưng tôi muốn cột mới được chèn bên cạnh cột hiện có mà nó xuất phát từ đó.

def rearrange_list(input_list, input_item_to_move, input_item_insert_here):
    '''
    Helper function to re-arrange the order of items in a list.
    Useful for moving column in pandas dataframe.

    Inputs:
        input_list - list
        input_item_to_move - item in list to move
        input_item_insert_here - item in list, insert before 

    returns:
        output_list
    '''
    # make copy for output, make sure it's a list
    output_list = list(input_list)

    # index of item to move
    idx_move = output_list.index(input_item_to_move)

    # pop off the item to move
    itm_move = output_list.pop(idx_move)

    # index of item to insert here
    idx_insert = output_list.index(input_item_insert_here)

    # insert item to move into here
    output_list.insert(idx_insert, itm_move)

    return output_list


import pandas as pd

# step 1: create sample dataframe
df = pd.DataFrame({
    'motorcycle': ['motorcycle1', 'motorcycle2', 'motorcycle3'],
    'initial_odometer': [101, 500, 322],
    'final_odometer': [201, 515, 463],
    'other_col_1': ['blah', 'blah', 'blah'],
    'other_col_2': ['blah', 'blah', 'blah']
})
print('Step 1: create sample dataframe')
display(df)
print()

# step 2: add new column that is difference between final and initial
df['change_odometer'] = df['final_odometer']-df['initial_odometer']
print('Step 2: add new column')
display(df)
print()

# step 3: rearrange columns
ls_cols = df.columns
ls_cols = rearrange_list(ls_cols, 'change_odometer', 'final_odometer')
df=df[ls_cols]
print('Step 3: rearrange columns')
display(df)

Một giải pháp khá đơn giản phù hợp với tôi là sử dụng .reindex trên df.columns:

df=df[df.columns.reindex(['mean',0,1,2,3,4])[0]]