如何更改DataFrame列的顺序？

一种简单的方法是使用列列表重新分配数据框，根据需要重新排列。

这就是你现在所拥有的：

In [6]: dfOut[6]:0         1         2         3         4      mean0  0.445598  0.173835  0.343415  0.682252  0.582616  0.4455431  0.881592  0.696942  0.702232  0.696724  0.373551  0.6702082  0.662527  0.955193  0.131016  0.609548  0.804694  0.6325963  0.260919  0.783467  0.593433  0.033426  0.512019  0.4366534  0.131842  0.799367  0.182828  0.683330  0.019485  0.3633715  0.498784  0.873495  0.383811  0.699289  0.480447  0.5871656  0.388771  0.395757  0.745237  0.628406  0.784473  0.5885297  0.147986  0.459451  0.310961  0.706435  0.100914  0.3451498  0.394947  0.863494  0.585030  0.565944  0.356561  0.5531959  0.689260  0.865243  0.136481  0.386582  0.730399  0.561593
In [7]: cols = df.columns.tolist()
In [8]: colsOut[8]: [0L, 1L, 2L, 3L, 4L, 'mean']

以您想要的任何方式重新排列cols。这就是我将最后一个元素移动到第一个位置的方式：

In [12]: cols = cols[-1:] + cols[:-1]
In [13]: colsOut[13]: ['mean', 0L, 1L, 2L, 3L, 4L]

然后像这样重新排序数据帧：

In [16]: df = df[cols]  #    OR    df = df.ix[:, cols]
In [17]: dfOut[17]:mean         0         1         2         3         40  0.445543  0.445598  0.173835  0.343415  0.682252  0.5826161  0.670208  0.881592  0.696942  0.702232  0.696724  0.3735512  0.632596  0.662527  0.955193  0.131016  0.609548  0.8046943  0.436653  0.260919  0.783467  0.593433  0.033426  0.5120194  0.363371  0.131842  0.799367  0.182828  0.683330  0.0194855  0.587165  0.498784  0.873495  0.383811  0.699289  0.4804476  0.588529  0.388771  0.395757  0.745237  0.628406  0.7844737  0.345149  0.147986  0.459451  0.310961  0.706435  0.1009148  0.553195  0.394947  0.863494  0.585030  0.565944  0.3565619  0.561593  0.689260  0.865243  0.136481  0.386582  0.730399

对于>=1.3的熊猫（2022年编辑）：

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

如何（对于熊猫<1.3，原始答案）

df.insert(0, 'mean', df['mean'])

https://pandas.pydata.org/pandas-docs/stable/user_guide/dsintro.html#column-selection-addition-deletion

这个问题已经回答了之前，但reindex_axis现在已弃用，所以我建议使用：

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

对于那些想要指定他们想要的顺序而不仅仅是对它们进行排序的人来说，这里有详细说明的解决方案：

df = df.reindex(['the','order','you','want'], axis=1)

现在，你想如何对列名列表进行排序实际上不是一个pandas问题，这是一个Python列表操作问题。有很多方法可以做到这一点，我认为这个答案有一个非常巧妙的方法。

你也可以这样做：

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

您可以通过以下方式获取列列表：

cols = list(df.columns.values)

输出将产生：

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

…然后很容易在将其放入第一个函数之前手动重新排列

此函数避免了您必须列出数据集中的每个变量才能对其中的一些变量进行排序。

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

它需要两个参数，第一个是数据集，第二个是要放在前面的数据集中的列。

所以在我的例子中，我有一个名为Frame的数据集，其中包含变量A1、A2、B1、B2、Total和Date。如果我想把Total放在前面，那么我所要做的就是：

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

如果我想把Total和Date放在前面，那么我做：

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

编辑：

另一种有用的使用方法是，如果您有一个不熟悉的表，并且您正在查找其中包含特定术语的变量，例如VAR1、VAR2……您可以执行以下操作：

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

我自己也遇到了一个类似的问题，只是想添加我决定的内容。我喜欢更改列顺序的reindex_axis() method。这奏效了：

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

基于@Jorge的评论的替代方法：

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

虽然reindex_axis在微基准测试中似乎比reindex略快，但我认为我更喜欢后者，因为它的直接性。

我相信@阿曼的回答是最好的，如果你知道其他列的位置。

如果你不知道mean的位置，但只有它的名字，你不能直接求助于cols = cols[-1:] + cols[:-1]。以下是我能想到的次好的事情：

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 columndf.join(meanDf) # has mean as last column

简单地做，

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

只需按照您想要的顺序分配列名：

In [39]: dfOut[39]:0         1         2         3         4  mean0  0.172742  0.915661  0.043387  0.712833  0.190717     11  0.128186  0.424771  0.590779  0.771080  0.617472     12  0.125709  0.085894  0.989798  0.829491  0.155563     13  0.742578  0.104061  0.299708  0.616751  0.951802     14  0.721118  0.528156  0.421360  0.105886  0.322311     15  0.900878  0.082047  0.224656  0.195162  0.736652     16  0.897832  0.558108  0.318016  0.586563  0.507564     17  0.027178  0.375183  0.930248  0.921786  0.337060     18  0.763028  0.182905  0.931756  0.110675  0.423398     19  0.848996  0.310562  0.140873  0.304561  0.417808     1
In [40]: df = df[['mean', 4,3,2,1]]

现在，“意思”列出现在前面：

In [41]: dfOut[41]:mean         4         3         2         10     1  0.190717  0.712833  0.043387  0.9156611     1  0.617472  0.771080  0.590779  0.4247712     1  0.155563  0.829491  0.989798  0.0858943     1  0.951802  0.616751  0.299708  0.1040614     1  0.322311  0.105886  0.421360  0.5281565     1  0.736652  0.195162  0.224656  0.0820476     1  0.507564  0.586563  0.318016  0.5581087     1  0.337060  0.921786  0.930248  0.3751838     1  0.423398  0.110675  0.931756  0.1829059     1  0.417808  0.304561  0.140873  0.310562

您需要按照所需的顺序创建列的新列表，然后使用df = df[cols]按新顺序重新排列列。

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

您还可以使用更通用的方法。在此示例中，最后一列（由-1指示）被插入为第一列。

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

如果列存在于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]

只需键入要更改的列名，然后为新位置设置索引。

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

对于您的情况，这将是：

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

如何使用T？

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

在你的情况下，

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

会做你想做的事。

在我的情况下（一般形式）：

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

你可以这样做（从阿曼的回答中借用部分）：

cols = df.columns.tolist()cols.insert(0, cols.pop(-1))
cols>>>['mean', 0L, 1L, 2L, 3L, 4L]
df = df[cols]

我想在数据框前面添加两列，因为我不知道所有列的确切名称，因为它们是从之前的pivot语句生成的。所以，如果你在相同的情况下：把列在前面，你知道的名称，然后让他们跟随“所有其他列”，我想出了以下一般解决方案：

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

DataFrame.sort_index(axis=1)很干净。点击此处查看文档。然后concat

一个简单的方法是使用#0，特别是当您有一长串列并且不想手动处理它们时：

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

我喜欢肖尔什的回答在您不知道位置时使用设置功能删除列，但这并不符合我的目的，因为我需要保留原始列顺序（具有任意列标签）。

我得到了这个工作，但通过使用索引集类型博尔顿包。

我还需要重新添加多个列标签，因此对于更一般的情况，我使用了以下代码：

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

希望这对任何搜索此线程以获取通用解决方案的人都有用。

您可以使用reindex，它可以用于两个轴：

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

这是一种移动一个现有列的方法，该列将修改现有的数据框。

my_column = df.pop('column name')df.insert(3, my_column.name, my_column)  # Is in-place

这里有一个函数可以对任意数量的列执行此操作。

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

将任何列移动到任何位置：

import pandas as pddf = 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]

如果您的列名太长而无法键入，那么您可以通过包含以下位置的整数列表指定新顺序：

数据说明：

          0         1         2         3         4      mean0  0.397312  0.361846  0.719802  0.575223  0.449205  0.5006781  0.287256  0.522337  0.992154  0.584221  0.042739  0.4857412  0.884812  0.464172  0.149296  0.167698  0.793634  0.4919233  0.656891  0.500179  0.046006  0.862769  0.651065  0.5433824  0.673702  0.223489  0.438760  0.468954  0.308509  0.4226835  0.764020  0.093050  0.100932  0.572475  0.416471  0.3893906  0.259181  0.248186  0.626101  0.556980  0.559413  0.4499727  0.400591  0.075461  0.096072  0.308755  0.157078  0.2075928  0.639745  0.368987  0.340573  0.997547  0.011892  0.4717499  0.050582  0.714160  0.168839  0.899230  0.359690  0.438500

通用示例：

new_order = [3,2,1,4,5,0]print(df[df.columns[new_order]])
3         2         1         4      mean         00  0.575223  0.719802  0.361846  0.449205  0.500678  0.3973121  0.584221  0.992154  0.522337  0.042739  0.485741  0.2872562  0.167698  0.149296  0.464172  0.793634  0.491923  0.8848123  0.862769  0.046006  0.500179  0.651065  0.543382  0.6568914  0.468954  0.438760  0.223489  0.308509  0.422683  0.6737025  0.572475  0.100932  0.093050  0.416471  0.389390  0.7640206  0.556980  0.626101  0.248186  0.559413  0.449972  0.2591817  0.308755  0.096072  0.075461  0.157078  0.207592  0.4005918  0.997547  0.340573  0.368987  0.011892  0.471749  0.6397459  0.899230  0.168839  0.714160  0.359690  0.438500  0.050582

虽然看起来我只是以不同的顺序显式键入列名，但有一个列“平均值”的事实应该清楚地表明new_order与实际位置有关，而不是列名。

对于OP提问的具体案例：

new_order = [-1,0,1,2,3,4]df = df[df.columns[new_order]]print(df)
mean         0         1         2         3         40  0.500678  0.397312  0.361846  0.719802  0.575223  0.4492051  0.485741  0.287256  0.522337  0.992154  0.584221  0.0427392  0.491923  0.884812  0.464172  0.149296  0.167698  0.7936343  0.543382  0.656891  0.500179  0.046006  0.862769  0.6510654  0.422683  0.673702  0.223489  0.438760  0.468954  0.3085095  0.389390  0.764020  0.093050  0.100932  0.572475  0.4164716  0.449972  0.259181  0.248186  0.626101  0.556980  0.5594137  0.207592  0.400591  0.075461  0.096072  0.308755  0.1570788  0.471749  0.639745  0.368987  0.340573  0.997547  0.0118929  0.438500  0.050582  0.714160  0.168839  0.899230  0.359690

这种方法的主要问题是多次调用相同的代码每次都会产生不同的结果，所以需要小心：）

书中最简单的方法

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

大多数答案都没有足够的泛化，熊猫reindex_axis方法有点乏味，因此我提供了一个简单的函数来使用字典将任意数量的列移动到任何位置，其中key=列名和值=要移动到的位置。如果你的数据帧很大，传递True到'big_data'，那么该函数将返回有序列列表。你可以使用这个列表来切片你的数据。

def order_column(df, columns, big_data = False):
"""Re-Orders dataFrame column(s)Parameters :df      -- dataframecolumns -- a dictionary:key   = current column position/index or column namevalue = position to move it tobig_data -- booleanTrue = returns only the ordered columns as a listthe user user can then slice the data using thisordered columnFalse = 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]

我认为这是一个稍微简洁的解决方案：

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

这个解决方案有点类似于@JoeHeffer的解决方案，但这是一个班轮。

在这里，我们从数据框中删除列"mean"并将其附加到具有相同列名的索引0。

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

您可以尝试以下解决方案：

解决方案1：

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

解决方案2：

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

解决方案3：

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

解决方案4：

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

解决方案5：

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

解决方案6：

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

时间比较：

解决方案1：

CPU时间：用户1.05 ms，系统：35µs，总：1.08 ms墙时间：995µs

解决方案2：

CPU时间：用户933µs，系统：0 ns，总计：933µs壁面时间：800µs

解决方案3：

CPU时间：用户0 ns，系统：1.35 ms，总：1.35 ms挂载时间：1.08 ms

解决方案4：

CPU时间：用户1.23 ms，系统：45µs，总：1.27 ms壁面时间：986µs

解决方案5：

CPU时间：用户1.09 ms，系统：19µs，总：1.11 ms壁面时间：949µs

解决方案6：

CPU时间：用户955µs，系统：34µs，总计：989µs壁面时间：859µs

我有一个非常具体的用例，用于在熊猫中重新排序列名。有时我在基于现有列的数据框中创建一个新列。默认情况下，熊猫将在末尾插入我的新列，但我希望新列插入到它派生的现有列旁边。

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 - listinput_item_to_move - item in list to moveinput_item_insert_here - item in list, insert before
returns:output_list'''# make copy for output, make sure it's a listoutput_list = list(input_list)
# index of item to moveidx_move = output_list.index(input_item_to_move)
# pop off the item to moveitm_move = output_list.pop(idx_move)
# index of item to insert hereidx_insert = output_list.index(input_item_insert_here)
# insert item to move into hereoutput_list.insert(idx_insert, itm_move)
return output_list

import pandas as pd
# step 1: create sample dataframedf = 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 initialdf['change_odometer'] = df['final_odometer']-df['initial_odometer']print('Step 2: add new column')display(df)print()
# step 3: rearrange columnsls_cols = df.columnsls_cols = rearrange_list(ls_cols, 'change_odometer', 'final_odometer')df=df[ls_cols]print('Step 3: rearrange columns')display(df)

我认为这个函数更直接。你只需要在开始或结束或两者都指定列的子集：

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 + endreturn df[cols]

只是翻转帮助经常。

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

或者只是随便看看。

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

一个对我有效的非常简单的解决方案是在df.columns上使用.reindex：

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

假设你有df和ABC列。

最简单的方法是：

df = df.reindex(['B','C','A'], axis=1)

这里有一个非常简单的答案（只有一行）。

您可以在将“n”列添加到df后执行此操作，如下所示。

import numpy as npimport pandas as pd
df = pd.DataFrame(np.random.rand(10, 5))df['mean'] = df.mean(1)df0           1           2           3           4        mean0   0.929616    0.316376    0.183919    0.204560    0.567725    0.4404391   0.595545    0.964515    0.653177    0.748907    0.653570    0.7231432   0.747715    0.961307    0.008388    0.106444    0.298704    0.4245123   0.656411    0.809813    0.872176    0.964648    0.723685    0.8053474   0.642475    0.717454    0.467599    0.325585    0.439645    0.5185515   0.729689    0.994015    0.676874    0.790823    0.170914    0.6724636   0.026849    0.800370    0.903723    0.024676    0.491747    0.4494737   0.526255    0.596366    0.051958    0.895090    0.728266    0.5595878   0.818350    0.500223    0.810189    0.095969    0.218950    0.4887369   0.258719    0.468106    0.459373    0.709510    0.178053    0.414752

### here you can add below line and it should work# Don't forget the two (()) 'brackets' around columns names.Otherwise, it'll give you an error.
df = df[list(('mean',0, 1, 2,3,4))]df
mean           0           1           2           3           40   0.440439    0.929616    0.316376    0.183919    0.204560    0.5677251   0.723143    0.595545    0.964515    0.653177    0.748907    0.6535702   0.424512    0.747715    0.961307    0.008388    0.106444    0.2987043   0.805347    0.656411    0.809813    0.872176    0.964648    0.7236854   0.518551    0.642475    0.717454    0.467599    0.325585    0.4396455   0.672463    0.729689    0.994015    0.676874    0.790823    0.1709146   0.449473    0.026849    0.800370    0.903723    0.024676    0.4917477   0.559587    0.526255    0.596366    0.051958    0.895090    0.7282668   0.488736    0.818350    0.500223    0.810189    0.095969    0.2189509   0.414752    0.258719    0.468106    0.459373    0.709510    0.178053

您可以使用唯一元素的无序集合的集合来保持“其他列的顺序不变”：

other_columns = list(set(df.columns).difference(["mean"])) #[0, 1, 2, 3, 4]

然后，您可以使用lambda将特定列移动到前面：

In [1]: import numpy as np
In [2]: import pandas as pd
In [3]: df = pd.DataFrame(np.random.rand(10, 5))
In [4]: df["mean"] = df.mean(1)
In [5]: move_col_to_front = lambda df, col: df[[col]+list(set(df.columns).difference([col]))]
In [6]: move_col_to_front(df, "mean")Out[6]:mean         0         1         2         3         40  0.697253  0.600377  0.464852  0.938360  0.945293  0.5373841  0.609213  0.703387  0.096176  0.971407  0.955666  0.3194292  0.561261  0.791842  0.302573  0.662365  0.728368  0.3211583  0.518720  0.710443  0.504060  0.663423  0.208756  0.5069164  0.616316  0.665932  0.794385  0.163000  0.664265  0.7939955  0.519757  0.585462  0.653995  0.338893  0.714782  0.3056546  0.532584  0.434472  0.283501  0.633156  0.317520  0.9942717  0.640571  0.732680  0.187151  0.937983  0.921097  0.4239458  0.562447  0.790987  0.200080  0.317812  0.641340  0.8620189  0.563092  0.811533  0.662709  0.396048  0.596528  0.348642
In [7]: move_col_to_front(df, 2)Out[7]:2         0         1         3         4      mean0  0.938360  0.600377  0.464852  0.945293  0.537384  0.6972531  0.971407  0.703387  0.096176  0.955666  0.319429  0.6092132  0.662365  0.791842  0.302573  0.728368  0.321158  0.5612613  0.663423  0.710443  0.504060  0.208756  0.506916  0.5187204  0.163000  0.665932  0.794385  0.664265  0.793995  0.6163165  0.338893  0.585462  0.653995  0.714782  0.305654  0.5197576  0.633156  0.434472  0.283501  0.317520  0.994271  0.5325847  0.937983  0.732680  0.187151  0.921097  0.423945  0.6405718  0.317812  0.790987  0.200080  0.641340  0.862018  0.5624479  0.396048  0.811533  0.662709  0.596528  0.348642  0.563092

要根据其名称将现有列设置为另一个列的右/左：

def df_move_column(df, col_to_move, col_left_of_destiny="", right_of_col_bool=True):cols = list(df.columns.values)index_max = len(cols) - 1
if not right_of_col_bool:# set left of a column "c", is like putting right of column previous to "c"# ... except if left of 1st column, then recursive call to set rest right to itaux = cols.index(col_left_of_destiny)if not aux:for g in [x for x in cols[::-1] if x != col_to_move]:df = df_move_column(df,col_to_move=g,col_left_of_destiny=col_to_move)return dfcol_left_of_destiny = cols[aux - 1]
index_old = cols.index(col_to_move)index_new = 0if len(col_left_of_destiny):index_new = cols.index(col_left_of_destiny) + 1
if index_old == index_new:return df
if index_new < index_old:index_new = np.min([index_new, index_max])cols = (cols[:index_new]+ [cols[index_old]]+ cols[index_new:index_old]+ cols[index_old + 1 :])else:cols = (cols[:index_old]+ cols[index_old + 1 : index_new]+ [cols[index_old]]+ cols[index_new:])
df = df[cols]return df

例如。

cols = list("ABCD")df2 = pd.DataFrame(np.arange(4)[np.newaxis, :], columns=cols)for k in cols:print(30 * "-")for g in [x for x in cols if x != k]:df_new = df_move_column(df2, k, g)print(f"{k} after {g}:  {df_new.columns.values}")for k in cols:print(30 * "-")for g in [x for x in cols if x != k]:df_new = df_move_column(df2, k, g, right_of_col_bool=False)print(f"{k} before {g}:  {df_new.columns.values}")

输出：

与上面的答案类似，还有一种使用deque（）及其rotate（）方法的替代方法。rotate方法获取列表中的最后一个元素并将其插入到开头：

from collections import deque
columns = deque(df.columns.tolist())columns.rotate()
df = df[columns]

您可以使用以下名称列表重新排序数据框列：

df = df.filter(list_of_col_names)

我想到了和Dmitriy Work一样的，显然最简单的答案：

df["mean"] = df.mean(1)l =  list(np.arange(0,len(df.columns) -1 ))l.insert(0,-1)df.iloc[:,l]

我试着做一个订单函数，你可以重新排序/移动列（S）与状态的订单命令的参考。

def order(dataframe,cols,f_or_l=None,before=None, after=None):
#만든이: 김완석, Stata로 뚝딱뚝딱 저자, blog.naver.com/sanzo213 운영# 갖다 쓰시거나 수정을 하셔도 되지만 출처는 꼭 밝혀주세요# cols옵션 및 befor/after옵션에 튜플이 가능하게끔 수정했으며, 오류문구 수정함(2021.07.12,1)# 칼럼이 멀티인덱스인 상태에서 reset_index()메소드 사용했을 시 적용안되는 걸 수정함(2021.07.12,2)
import pandas as pdif (type(cols)==str) or (type(cols)==int) or (type(cols)==float) or (type(cols)==bool) or type(cols)==tuple:cols=[cols]    
dd=list(dataframe.columns)for i in cols:idd.remove(i) #cols요소를 제거함    
if (f_or_l==None) & ((before==None) & (after==None)):print('f_or_l옵션을 쓰시거나 아니면 before옵션/after옵션 쓰셔야되요')    
if ((f_or_l=='first') or (f_or_l=='last')) & ~((before==None) & (after==None)):print('f_or_l옵션 사용시 before after 옵션 사용불가입니다.')    
if (f_or_l=='first') & (before==None) & (after==None):new_order=cols+dddataframe=dataframe[new_order]return dataframe
if (f_or_l=='last') & (before==None) & (after==None):new_order=dd+colsdataframe=dataframe[new_order]return dataframe    
if (before!=None) & (after!=None):print('before옵션 after옵션 둘다 쓸 수 없습니다.')    

if (before!=None) & (after==None) & (f_or_l==None):
if not((type(before)==str) or (type(before)==int) or (type(before)==float) or(type(before)==bool) or ((type(before)!=list)) or((type(before)==tuple))):print('before옵션은 칼럼 하나만 입력가능하며 리스트 형태로도 입력하지 마세요.')    
else:b=dd[:dd.index(before)]a=dd[dd.index(before):]        
new_order=b+cols+adataframe=dataframe[new_order]return dataframe    
if (after!=None) & (before==None) & (f_or_l==None):
if not((type(after)==str) or (type(after)==int) or (type(after)==float) or(type(after)==bool) or ((type(after)!=list)) or((type(after)==tuple))):            
print('after옵션은 칼럼 하나만 입력가능하며 리스트 형태로도 입력하지 마세요.')
else:b=dd[:dd.index(after)+1]a=dd[dd.index(after)+1:]        
new_order=b+cols+adataframe=dataframe[new_order]return dataframe

下面的Python代码是我制作的订单函数的示例。我希望你可以使用我的订单函数如此轻松地重新排序列：）

# module
import pandas as pdimport numpy as npfrom order import order # call order function from order.py file
# make a dataset
columns='a b c d e f g h i j k'.split()dic={}
n=-1for i in columns:    
n+=1dic[i]=list(range(1+n,10+1+n))data=pd.DataFrame(dic)print(data)
# use order function (1) : order column e in the first
data2=order(data,'e',f_or_l='first')print(data2)
# use order function (2): order column e in the last , "data" dataframe
print(order(data,'e',f_or_l='last'))

# use order function (3) : order column i before column c in "data" dataframe
print(order(data,'i',before='c'))

# use order function (4) : order column g after column b in "data" dataframe
print(order(data,'g',after='b'))
# use order function (4) : order columns ['c', 'd', 'e'] after column i in "data" dataframe
print(order(data,['c', 'd', 'e'],after='i'))

另一种选择是使用#0方法，然后使用#1。请注意，我们首先pop()我们打算移动到数据框前面的列，这样我们就可以在重置索引时避免名称冲突：

df.set_index(df.pop('column_name'), inplace=True)df.reset_index(inplace=True)

有关详细信息，请参阅如何更改熊猫数据框列的顺序。

这是一个超级简单的方法的例子。如果您要从excel复制标题，请使用.split('\t')

df = df['FILE_NAME DISPLAY_PATH SHAREPOINT_PATH RETAILER LAST_UPDATE'.split()]