如何更改 DataFrame 列的顺序？

Posted 2023-03-11

【中文标题】如何更改 DataFrame 列的顺序？

【英文标题】：How to change the order of DataFrame columns?

【发布时间】：2012-10-20 08:23:16

【问题描述】：

我有以下DataFrame (df)：

import numpy as np
import pandas as pd

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

我通过分配添加更多列：

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

如何将mean 列移到前面，即将其设置为第一列，而其他列的顺序保持不变？

【问题讨论】：

Python Pandas - Re-ordering columns in a dataframe based on column name的可能重复

对于基于 NumPy 的通用解决方案，请参阅 How to move a column in a pandas dataframe，仅假定一个列级别，即没有 MultiIndex。

经过充分搜索，我得到了这个最佳链接，用于以非常简单的术语重新排列多个逻辑的列 [columns re-arrange logic for pandas] [datasciencemadesimple.com/…

【参考方案1】：

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

这就是你现在拥有的：

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

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

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

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

然后像这样重新排列数据框：

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

【讨论】：

如果你得到“无法连接 'str' 和 'list' 对象”，请确保 [] cols 中的 str 值：cols = [cols[7]] + cols[:7] + cols [8:]

@FooBar 这不是集合并集，它是两个有序列表的串联。

@Aman 我只是指出您的代码已被弃用。您对帖子的处理由您自行决定。

@FooBar，cols的类型是list；它甚至允许重复（在数据帧上使用时将被丢弃）。您正在考虑Index 对象。

这意味着复制所有数据，这是非常低效的。我希望 pandas 能够在不创建副本的情况下做到这一点。

【参考方案2】：

怎么样：

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

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

【讨论】：

这会是未来添加到pandas 的功能吗？类似df.move(0,df.mean)?

美丽。它也发生在原地。

这是一个可扩展的解决方案，因为其他解决方案是手动输入列名。

这适用于 OP 的问题，在创建新列时，但不适用于移动列；尝试将结果移动到*** ValueError: cannot insert mean, already exists

这是一个干净的解决方案。现代API方法是：df.insert(0, 'mean', df['mean'])

【参考方案3】：

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

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

对于那些想要指定他们想要的顺序而不是仅仅对它们进行排序的人，这里给出了解决方案：

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

现在，您希望如何对列名列表进行排序实际上不是pandas 问题，而是 Python 列表操作问题。有很多方法可以做到这一点，我认为this answer 有一种非常简洁的方法。

【讨论】：

不，那是不同的。在那里，用户想要按名称对所有列进行排序。在这里，他们希望将一列移动到第一列，同时保持其他列的顺序不变。

如果您不希望它们排序怎么办？

答案没有解决问题中的问题。

@mins 我希望上面的编辑足够清楚。 :)

您的编辑现在显示了该问题的有效解决方案。谢谢。

【参考方案4】：

你也可以这样做：

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

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

cols = list(df.columns.values)

输出将产生：

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

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

【讨论】：

您还可以通过 list(df.columns) 获取列列表

或df.columns.tolist()

对于像我这样的新手，重新排列从 cols 获得的列表。然后 df=df[cols] 即重新排列的列表被放入第一个表达式中，没有一组括号。

我认为这不是一个好的答案，因为它没有提供如何更改任何数据框的列顺序的代码。假设我将 csv 文件作为 pandas pd 导入为 pd.read_csv() 。您的答案如何用于更改列顺序？

@Robvh，第二行代码解释了如何获取现有的列名。从那里，您可以将输出复制到第一行代码中，并根据需要重新排列。唯一需要知道的其他信息是，如果没有标题，默认列名是整数，而不是字符串。

【参考方案5】：

此功能避免了您必须列出数据集中的每个变量来订购其中的几个。

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 

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

所以在我的例子中，我有一个名为 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])

【参考方案6】：

我自己也遇到过类似的问题，只是想补充一下我确定的内容。我喜欢 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 稍快一些，但我认为我更喜欢后者，因为它的直接性。

【讨论】：

这是一个不错的解决方案，但 reindex_axis 将被弃用。我使用了 reindex，效果很好。

我可能会错过一些东西，但 1/ 您可能忘记在第二个解决方案中包含 axis=1 以使用列，而不是行。 2/ 2020年，reindex解决方案改变了行/列的顺序，但也清除了数据（NaN无处不在）。

【参考方案7】：

如果您知道另一列的位置，我相信@Aman's answer 是最好的。

如果你不知道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 column
df.join(meanDf) # has mean as last column

【参考方案8】：

简单地做，

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

【讨论】：

TypeError: Can't convert 'int' object to str 隐式

可能是API变了，你也可以这样...order = df.columns.tolist()df['mean'] = df.mean(1)df.columns = ['mean'] + order

这个变体对我来说效果很好。使用现有列表headers，它用于创建一个字典，然后用于创建 DataFrame，我称之为df.reindex(columns=headers)。我遇到的唯一问题是我已经调用了df.set_index('some header name', inplace=True)，所以当重新索引完成时，它添加了另一个名为some header name 的列，因为原来的列现在是索引。至于上面指定的语法，python解释器中的['mean'] + df.columns给了我Index(u'meanAddress', u'meanCity', u'meanFirst Name'...

@hlongmore：我不知道你之前的代码是什么，但编辑应该可以工作（使用 0.19.2）

编辑确实有效（我在 0.20.2 上）。就我而言，我已经得到了我想要的列，所以我认为 df.reindex() 是我真正应该使用的。

【参考方案9】：

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

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

现在，'mean' 列出现在前面：

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

【讨论】：

会复印吗？

@NicholasMorley - 如果您的 df 中有 1000 列，这不是最佳答案。

看起来你分配给<df>.columns 不像你最初声称的那样

这是少数列的最佳答案。

这只是@freddygv 早期答案的副本。那个应该是公认的答案，而不是这个。

【参考方案10】：

您需要按所需顺序创建一个新的列列表，然后使用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]

【参考方案11】：

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

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)

【参考方案12】：

用T怎么样？

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

【参考方案13】：

在你的情况下，

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

【讨论】：

我尝试设置copy=False，但看起来reindex_axis 仍在创建副本。

@Konstantin 你能就这个问题提出另一个问题吗？最好有更多的上下文

@Konstantin 只是好奇，您是否调试看到copy=False 创建了一个副本？文档声称，当copy=True、reindex 返回一个新对象时，表明否则它将是同一个旧对象；如果是同一个对象，怎么可能是副本？

【参考方案14】：

您可以执行以下操作（从 Aman 的答案中借用部分内容）：

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

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

df = df[cols]

【参考方案15】：

我想从我不确切知道所有列的名称的数据框中将两列放在前面，因为它们是从之前的数据透视语句生成的。 因此，如果您处于相同的情况：要将知道名称的列放在前面，然后让它们跟在“所有其他列”之后，我想出了以下通用解决方案：

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

【参考方案16】：

DataFrame.sort_index(axis=1) 很干净。Check doc here。 然后concat

【讨论】：

虽然函数sort_index 很干净，但我很遗憾地说，但我不认为它解决了这个问题，这更多是关于重新排列列（可能会或可能不会跟随任何特定顺序）而不是对它们进行排序。

【参考方案17】：

一种简单的方法是使用 set()，特别是当您有很长的列列表并且不想手动处理它们时：

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

【讨论】：

一个警告：如果你把它放入集合中，列的顺序就会消失

有趣！ @user1930402 我曾多次尝试上述方法，从未遇到任何问题。我会再次检查。

【参考方案18】：

我喜欢 Shoresh's answer 在您不知道位置时使用设置功能来删除列，但这对我的目的不起作用，因为我需要保持原始列顺序（具有任意列标签）。

我通过使用 Boltons 包中的 IndexedSet 来实现这一点。

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

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

希望这对任何在此线程中寻找通用解决方案的人有用。

【讨论】：

我有点惊讶！我经常为此目的使用set，而不必处理订购问题。

【参考方案19】：

您可以使用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

【参考方案20】：

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

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

【讨论】：

这几乎是唯一的好方法，因为它是就地的。大多数其他方法都不是就地的，因此不可扩展。

【参考方案21】：

这是一个对任意数量的列执行此操作的函数。

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

【参考方案22】：

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

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]

【参考方案23】：

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

数据：

          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

通用示例：

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

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

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

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

【参考方案24】：

书中最简单的方法

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

【参考方案25】：

大多数答案都不够概括，pandas reindex_axis 方法有点乏味，因此我提供了一个简单的函数来使用字典将任意数量的列移动到任何位置，其中键 = 列名和值 = 要移动的位置到。如果您的数据框很大，则将 True 传递给“big_data”，则该函数将返回有序列列表。您可以使用此列表对数据进行切片。

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]

【参考方案26】：

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

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

此解决方案与@JoeHeffer 的解决方案有些相似，但这是一个班轮。

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

【讨论】：

这很好，但如果你想让它在最后呢？

您创建的任何新列都会添加到末尾，所以我猜应该是df["mean"] = df.pop("mean")

【参考方案27】：

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)

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

解决方案 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 order
df = df[[df.columns[i] for i in order]]

时间对比：

解决方案 1：

CPU 时间：用户 1.05 毫秒，系统：35 微秒，总计：1.08 毫秒挂壁时间：995 微秒

解决方案 2：

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

解决方案 3：

CPU 时间：用户 0 ns，系统：1.35 毫秒，总计：1.35 毫秒 挂墙时间：1.08 毫秒

解决方案 4：

CPU 时间：用户 1.23 毫秒，系统：45 微秒，总计：1.27 毫秒 挂壁时间：986 µs

解决方案 5：

CPU 时间：用户 1.09 毫秒，系统：19 微秒，总计：1.11 毫秒 挂壁时间：949 µs

解决方案 6：

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

【讨论】：

解决方案 1 是我需要的，因为我有太多列 (53)，谢谢

@Pygirl 的值显示实际消耗时间？ （用户、系统、总时间或挂壁时间）

这对我来说是解决问题的最佳答案。这么多解决方案（包括我需要的一个）和简单的方法。谢谢！

解决方案 6（没有列表理解）：df = df.iloc[:, [1, 2, 3, 0]]

@sergzemsk：***.com/a/55702033/6660373。我按墙上时间比较。

【参考方案28】：

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

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)

【参考方案29】：

我认为这个功能更直接。您只需要在开头或结尾或两者都指定列的子集：

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]

【参考方案30】：

经常翻转会有所帮助。

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

或者只是随便看看。

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