Saya memiliki yang berikut DataFrame( df):

import numpy as np
import pandas as pd

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

Saya menambahkan lebih banyak kolom berdasarkan tugas:

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

Bagaimana saya bisa memindahkan kolom meanke depan, yaitu mengaturnya sebagai kolom pertama meninggalkan urutan kolom lainnya tidak tersentuh?

Salah satu cara mudah adalah dengan menugaskan kembali dataframe dengan daftar kolom, disusun ulang sesuai kebutuhan.

Inilah yang Anda miliki sekarang:

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

Atur ulang colsdengan cara apa pun yang Anda inginkan. Inilah cara saya memindahkan elemen terakhir ke posisi pertama:

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

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

Kemudian susun ulang susunan data seperti ini:

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

Anda juga dapat melakukan sesuatu seperti ini:

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

Anda bisa mendapatkan daftar kolom dengan:

cols = list(df.columns.values)

Output akan menghasilkan:

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

... yang kemudian mudah diatur ulang secara manual sebelum menjatuhkannya ke fungsi pertama

Cukup berikan nama kolom sesuai urutan yang Anda inginkan:

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

Sekarang, kolom 'berarti' keluar di depan:

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

Bagaimana tentang:

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

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

Dalam kasus anda,

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

akan melakukan apa yang Anda inginkan.

Dalam kasus saya (bentuk umum):

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

Anda perlu membuat daftar baru kolom Anda dalam urutan yang diinginkan, kemudian gunakan df = df[cols]untuk mengatur ulang kolom dalam urutan baru ini.

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

Anda juga dapat menggunakan pendekatan yang lebih umum. Dalam contoh ini, kolom terakhir (ditunjukkan oleh -1) dimasukkan sebagai kolom pertama.

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

Anda juga dapat menggunakan pendekatan ini untuk menyusun ulang kolom dalam urutan yang diinginkan jika mereka hadir dalam 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)

Anda dapat mencoba solusi berikut:

Solusi 1:

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

Solusi 2:

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

Solusi 3:

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

Solusi 4:

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

Solusi 5:

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

solusi 6:

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

Perbandingan waktu:

Solusi 1:

Waktu CPU: pengguna 1.05 ms, sistem: 35 µs, total: 1.08 ms Waktu dinding: 995 µs

Solusi 2 :

Waktu CPU: pengguna 933 µs, sistem: 0 ns, total: 933 μs Waktu dinding: 800 µs

Solusi 3 :

Waktu CPU: pengguna 0 ns, sistem: 1,35 ms, total: 1,35 ms Waktu dinding: 1,08 ms

Solusi 4 :

Waktu CPU: pengguna 1,23 ms, sistem: 45 μs, total: 1,27 ms Waktu dinding: 986 μs

Solusi 5 :

Waktu CPU: pengguna 1,09 ms, sistem: 19 μs, total: 1,11 ms Waktu dinding: 949 μs

Solusi 6 :

Waktu CPU: pengguna 955 µs, sistem: 34 µs, total: 989 µs Waktu dinding: 859 µs

Dari Agustus 2018:

Jika nama kolom Anda terlalu panjang untuk diketik maka Anda dapat menentukan pesanan baru melalui daftar bilangan bulat dengan posisi:

Data:

          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

Contoh umum:

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

Dan untuk kasus spesifik pertanyaan 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

Masalah utama dengan pendekatan ini adalah bahwa memanggil kode yang sama beberapa kali akan menghasilkan hasil yang berbeda setiap kali, jadi kita harus berhati-hati :)

Fungsi ini menghindari Anda harus membuat daftar setiap variabel dalam dataset Anda hanya untuk memesan beberapa dari mereka.

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 

Dibutuhkan dua argumen, yang pertama adalah dataset, yang kedua adalah kolom dalam kumpulan data yang ingin Anda bawa ke depan.

Jadi dalam kasus saya, saya memiliki satu set data yang disebut Frame dengan variabel A1, A2, B1, B2, Total dan Tanggal. Jika saya ingin membawa Total ke depan maka yang harus saya lakukan adalah:

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

Jika saya ingin membawa Total dan Tanggal ke depan maka saya lakukan:

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

EDIT:

Cara lain yang bermanfaat untuk menggunakan ini adalah, jika Anda memiliki tabel asing dan Anda sedang mencari variabel dengan istilah tertentu di dalamnya, seperti VAR1, VAR2, ... Anda dapat menjalankan sesuatu seperti:

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

Saya mengalami pertanyaan serupa, dan hanya ingin menambahkan apa yang saya setujui. Saya menyukai reindex_axis() methoduntuk mengubah urutan kolom. Ini berhasil:

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

Metode alternatif berdasarkan komentar dari @Jorge:

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

Meskipun reindex_axistampaknya sedikit lebih cepat dalam benchmark mikro daripada reindex, saya pikir saya lebih suka yang terakhir karena keterusterangannya.

Lakukan saja,

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

Anda dapat melakukan hal berikut (meminjam bagian dari jawaban Aman):

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

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

df = df[cols]

Cukup ketikkan nama kolom yang ingin Anda ubah, dan atur indeks untuk lokasi baru.

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

Untuk kasus Anda, ini akan seperti:

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

Memindahkan kolom apa saja ke posisi apa pun:

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]

Saya pikir ini adalah solusi yang sedikit lebih rapi:

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

Solusi ini agak mirip dengan solusi @JoeHeffer tetapi ini adalah satu liner.

Di sini kita menghapus kolom "mean"dari kerangka data dan melampirkannya untuk diindeks 0dengan nama kolom yang sama.

Berikut adalah cara untuk memindahkan satu kolom yang ada yang akan mengubah kerangka data yang ada di tempatnya.

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

Pertanyaan ini telah dijawab sebelumnya tetapi reindex_axis sudah usang sekarang jadi saya akan menyarankan untuk menggunakan:

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

Bagaimana kalau menggunakan "T"?

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

@clocker: Solusi Anda sangat membantu bagi saya, karena saya ingin membawa dua kolom di depan dari kerangka data di mana saya tidak tahu persis nama semua kolom, karena mereka dihasilkan dari pernyataan pivot sebelumnya. Jadi, jika Anda berada dalam situasi yang sama: Untuk membawa kolom di depan yang Anda tahu nama dan kemudian membiarkannya diikuti oleh "semua kolom lainnya", saya datang dengan solusi umum berikut;

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

set():

Pendekatan sederhana digunakan set(), khususnya ketika Anda memiliki daftar kolom yang panjang dan tidak ingin menanganinya secara manual:

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

Saya menyukai jawaban Shoresh untuk menggunakan fungsi yang ditetapkan untuk menghapus kolom ketika Anda tidak tahu lokasi, namun ini tidak berfungsi untuk tujuan saya karena saya harus menjaga urutan kolom asli (yang memiliki label kolom sewenang-wenang).

Saya mendapatkan ini berfungsi meskipun dengan menggunakan IndexedSet dari paket boltons.

Saya juga perlu menambahkan kembali beberapa label kolom, jadi untuk kasus yang lebih umum saya menggunakan kode berikut:

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

Semoga ini bermanfaat bagi siapa pun yang mencari utas ini untuk solusi umum.

Anda dapat menggunakan reindexyang dapat digunakan untuk kedua sumbu:

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

Berikut adalah fungsi untuk melakukan ini untuk sejumlah kolom.

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

Metode paling rahasia dalam buku ini

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

Saya pikir fungsi ini lebih mudah. Anda hanya perlu menentukan subset kolom di awal atau di akhir atau keduanya:

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]

Saya percaya jawaban Aman adalah yang terbaik jika Anda tahu lokasi kolom lainnya.

Jika Anda tidak tahu lokasi mean, tetapi hanya memiliki namanya, Anda tidak dapat menggunakan langsung cols = cols[-1:] + cols[:-1]. Berikut ini adalah hal terbaik berikutnya yang bisa saya buat:

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

Membalik saja sering membantu.

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

Atau hanya mengocok untuk melihatnya.

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

Sebagian besar jawaban tidak cukup menggeneralisasi dan metode reindex_axis panda sedikit membosankan, maka saya menawarkan fungsi sederhana untuk memindahkan jumlah kolom sewenang-wenang ke posisi apa pun menggunakan kamus di mana kunci = nama kolom dan nilai = posisi untuk pindah. Jika dataframe Anda besar, lewati True ke 'big_data', maka fungsinya akan mengembalikan daftar kolom yang diurutkan. Dan Anda bisa menggunakan daftar ini untuk mengiris data Anda.

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]

Saya memiliki kasus penggunaan yang sangat spesifik untuk memesan ulang nama kolom dalam panda. Terkadang saya membuat kolom baru dalam kerangka data yang didasarkan pada kolom yang ada. Secara default panda akan memasukkan kolom baru saya di akhir, tapi saya ingin kolom baru dimasukkan di sebelah kolom yang sudah ada.

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)

Solusi yang cukup mudah dan berhasil bagi saya adalah dengan menggunakan .reindex di df.columns:

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