首页 文章

如何更改DataFrame列的顺序?

提问于
浏览
500

我有以下 DataFramedf ):

import numpy as np
import pandas as pd

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

我通过赋值添加更多列:

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

如何将列 mean 移动到前面,即将其设置为第一列,使其他列的顺序保持不变?

25 回答

  • 1

    在你的情况下,

    df = df.reindex_axis(['mean',0,1,2,3,4], axis=1)
    

    会做你想要的 .

    In my case (general form):

    df = df.reindex_axis(sorted(df.columns), axis=1)
    df = df.reindex_axis(['opened'] + list([a for a in df.columns if a != 'opened']), axis=1)
    

    更新2018年1月

    If you want to use reindex:

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

    set():

    一个简单的方法是使用 set() ,特别是当您有一长串列并且不想手动处理它们时:

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

    简单地说,

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

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

  • 197

    您可以执行以下操作(从Aman的答案中借用部分):

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

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

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

    这就是你现在拥有的:

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

    我按照Wes McKinney的建议尝试了 insert() 功能 .

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

    这得到了Timmie在一条线上想要的结果,而不需要移动最后一列 .

  • 2

    如果你知道另一列的位置,我相信@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
    
  • 22

    从2018年8月起:

    如果您的列名太长而无法输入,那么您可以通过具有以下位置的整数列表指定新订单:

    new_order = [3,2,1,4,5,0]
    df = df[df.columns[new_order]]
    print(df)  
    
            a         c         b      mean         d         e
    0  0.637589  0.634264  0.733961  0.617316  0.534911  0.545856
    1  0.854449  0.830046  0.883416  0.678389  0.183003  0.641032
    2  0.332996  0.195891  0.879472  0.545261  0.447813  0.870135
    3  0.902704  0.843252  0.348227  0.677614  0.635780  0.658107
    4  0.422357  0.529151  0.619282  0.412559  0.405749  0.086255
    5  0.251454  0.940245  0.068633  0.554269  0.691631  0.819380
    6  0.423781  0.179961  0.643971  0.361245  0.105050  0.453460
    7  0.680696  0.487651  0.255453  0.419046  0.330417  0.341014
    8  0.276729  0.473765  0.981271  0.690007  0.817877  0.900394
    9  0.964470  0.248088  0.609391  0.463661  0.128077  0.368279
    

    对于OP问题的具体情况:

    new_order = [-1,0,1,2,3,4]
    df = df[df.columns[new_order]]
    print(df)
    
          mean         a         b         c         d         e
    0  0.595177  0.329206  0.713246  0.712898  0.572263  0.648273
    1  0.638860  0.452519  0.598171  0.797982  0.858137  0.487490
    2  0.287636  0.100442  0.244445  0.288450  0.285795  0.519049
    3  0.653974  0.863342  0.460811  0.782644  0.827890  0.335183
    4  0.285233  0.004613  0.485135  0.014066  0.489957  0.432394
    5  0.430761  0.630070  0.328865  0.528100  0.031827  0.634943
    6  0.444338  0.102679  0.808613  0.389616  0.440022  0.480759
    7  0.536163  0.063105  0.420832  0.959125  0.643879  0.593874
    8  0.556107  0.716114  0.180603  0.668684  0.262900  0.952237
    9  0.416280  0.816816  0.064956  0.178113  0.377693  0.643820
    
  • 2

    你也可以这样做:

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

    您可以使用以下命令获取列列表:

    cols = list(df.columns.values)
    

    输出将产生:

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

    ...然后在将其放入第一个函数之前,可以手动重新排列

  • 238

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

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

    用“T”怎么样?

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

    此功能可以避免您必须列出数据集中的每个变量,只是为了订购其中的一些变量 .

    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 . 如果我想将道达尔带到前线那么我所要做的就是:

    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])
    
  • 50

    我喜欢Shoresh's answer使用set功能删除列,因为我需要保留原始列顺序(具有任意列标签) .

    我通过使用boltons包中的IndexedSet来实现这一点 .

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

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

    希望这对于搜索此线程以获得一般解决方案的任何人都有用 .

  • 554

    我自己遇到了一个类似的问题,只想添加我所确定的内容 . 我喜欢 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 略快,但我认为我更倾向于后者 .

  • 3

    最简单的方法是更改列名的顺序,如下所示

    df = df[['mean', Col1,Col2,Col3]]

  • 3

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

    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]
    
  • 8
  • 2

    只需键入要更改的列名称,然后设置新位置的索引 .

    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)
    
  • 2

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

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

    这个问题已经回答before但现在不推荐使用reindex_axis所以我建议使用:

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

    这是为任意数量的列执行此操作的函数 .

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

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

    @clocker:你的解决方案对我很有帮助,因为我想在前面带两列从我不确切知道所有列名称的数据框中,因为它们是之前从pivot语句生成的 . 所以,如果你处于相同的情况:要在前面列出你知道名称的列,然后让它们跟随“所有其他列”,我想出了以下一般解决方案;

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

相关问题