Bagaimana cara mengubah urutan kolom DataFrame?

880

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?

Timmie
sumber
1
Untuk solusi berbasis NumPy yang digeneralisasi, lihat Bagaimana cara memindahkan kolom dalam bingkai data panda , mengasumsikan hanya satu level kolom, yaitu no MultiIndex.
jpp
Setelah cukup mencari, saya mendapatkan tautan terbaik ini untuk kolom yang mengatur ulang banyak logika dalam istilah yang cukup sederhana [kolom menyusun kembali logika untuk panda] [ dataciencemadesimple.com/…
ravibeli

Jawaban:

853

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
Seorang pria
sumber
17
jika Anda mendapatkan "tidak dapat menggabungkan objek 'str' dan 'daftar'" pastikan Anda [] nilai str dalam cols: cols = [cols [7]] + cols [: 7] + cols [8:]
moeabdol
3
@ FooBar Itu bukan gabungan yang diatur, melainkan gabungan dari dua daftar yang dipesan.
Aman
3
@Aman, saya hanya menunjukkan bahwa kode Anda sudah usang. Penanganan posting Anda sesuai dengan kebijaksanaan Anda.
FooBar
2
@FooBar, jenisnya colsadalah list; bahkan memungkinkan duplikat (yang akan dibuang saat digunakan pada dataframe). Anda memikirkan Indexbenda.
alexis
8
Ini berarti menyalin SEMUA data, yang sangat tidak efisien. Saya berharap panda memiliki cara untuk melakukan itu tanpa membuat salinan.
Konstantin
442

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

freddygv
sumber
8
Anda juga bisa mendapatkan daftar kolom dengan daftar (df.columns)
Jim
8
ataudf.columns.tolist()
Jim
Untuk pemula seperti saya, atur ulang daftar yang Anda dapatkan dari cols. Kemudian df = df [cols] yaitu daftar yang disusun ulang akan jatuh ke ekspresi pertama tanpa hanya satu set tanda kurung.
Sid
Nama kolom akan berupa bilangan bulat dalam 3.x df = df[['mean1', 0, 1, 2, 3]]
prosti
1
Saya tidak berpikir ini adalah jawaban yang baik karena tidak memberikan kode cara mengubah urutan kolom dari setiap dataframe. Katakanlah saya mengimpor file csv sebagai panda pd as pd.read_csv(). Bagaimana jawaban Anda digunakan untuk mengubah urutan kolom?
Robvh
312

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
fixxxer
sumber
7
Apakah itu membuat salinan?
user3226167
21
@NicholasMorley - Ini bukan jawaban terbaik jika Anda memiliki, katakanlah, 1000 kolom di df Anda.
AGS
1
sepertinya Anda tidak menugaskan <df>.columnsseperti yang Anda klaim pada awalnya
penggemar nomor satu Bjorks
8
Ini adalah jawaban terbaik untuk sejumlah kecil kolom.
Dongkyu Choi
2
Ini hanyalah salinan dari jawaban @freddygv sebelumnya. Yang itu harus menjadi jawaban yang diterima, bukan ini.
James Hirschorn
134

Bagaimana tentang:

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

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

Wes McKinney
sumber
35
Mungkinkah ini fitur tambahan di masa depan pandas? sesuatu seperti df.move(0,df.mean)?
jason
Oh man, itu bahkan berfungsi seperti ini df_metadata.insert(0,'Db_name',"raw_data")(Kode tidak relevan dengan utas ini)
Aetos
3
Cantik. Dan itu terjadi juga.
cucu8
2
Ini adalah solusi terukur karena solusi lain mengetik nama kolom secara manual.
CKM
Ini berfungsi untuk pertanyaan OP, saat membuat kolom baru, tetapi itu tidak untuk memindahkan kolom; mencoba untuk memindahkan hasil dalam*** ValueError: cannot insert mean, already exists
spinup
122

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']) ))
Alvaro Joao
sumber
2
Saya mencoba mengatur copy=Falsetetapi sepertinya reindex_axismasih membuat salinan.
Konstantin
1
@Konstantin dapatkah Anda membuat pertanyaan lain tentang masalah ini? Akan lebih baik untuk memiliki lebih banyak konteks
Alvaro Joao
57

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]
Alexander
sumber
47
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

Pygirl
sumber
1
Jawaban yang sangat indah, terima kasih.
qasimalbaqali
1
solusi 1 adalah apa yang saya butuhkan karena saya memiliki terlalu banyak kolom (53), terima kasih
ratnesh
@Pygirl nilai yang menunjukkan waktu comsumed nyata? (pengguna, sys, total atau waktu dinding)
sergzemsk
1
Ini bagi saya jawaban terbaik untuk masalah ini. Begitu banyak solusi (termasuk yang saya butuhkan) dan pendekatan sederhana. Terima kasih!
Gustavo Rottgering
1
Solusi 6 (tanpa pemahaman daftar):df = df.iloc[:, [1, 2, 3, 0]]
Dmitriy Work
43

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 :)

Yuca
sumber
17

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])
seeiespi
sumber
17

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.

pencatat waktu
sumber
6
Ini adalah solusi yang bagus, tetapi reindex_axis akan ditinggalkan. Saya menggunakan reindex, dan itu bekerja dengan baik.
Jorge
15

Lakukan saja,

df = df[['mean'] + df.columns[:-1].tolist()]
Napitupulu Jon
sumber
TypeError: Tidak dapat mengonversi objek 'int' ke str secara implisit
parvij
Bisa jadi API telah berubah, Anda juga bisa melakukan ini ... order = df.columns.tolist() df['mean'] = df.mean(1) df.columns = ['mean'] + order
Napitupulu Jon
1
Variasi ini bekerja dengan baik untuk saya. Dengan daftar yang ada headers,, yang digunakan untuk membuat dict yang kemudian digunakan untuk membuat DataFrame, saya menelepon df.reindex(columns=headers). Satu-satunya masalah yang saya temui adalah saya sudah menelepon df.set_index('some header name', inplace=True), jadi ketika reindex selesai, itu menambahkan kolom lain bernama some header namesejak kolom asli sekarang indeks. Adapun sintaks yang ditentukan di atas, ['mean'] + df.columnsdalam interpreter python memberi sayaIndex(u'meanAddress', u'meanCity', u'meanFirst Name'...
hlongmore
1
@hlongmore: Saya tidak tahu kode Anda sebelumnya, tetapi hasil edit harus bekerja (menggunakan 0.19.2)
Napitupulu Jon
Hasil edit memang bekerja (saya di 0.20.2). Dalam kasus saya, saya sudah mendapatkan kolom yang saya inginkan, jadi saya pikir df.reindex () adalah apa yang harus saya gunakan.
hlongmore
11

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]
otteheng
sumber
10

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)
ccerhan
sumber
Ini diremehkan
zelusp
8

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

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.

erncyp
sumber
5

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)
Joe Heffer
sumber
5

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

df.reindex(sorted(df.columns), axis=1)
dmvianna
sumber
19
Tidak, itu berbeda. Di sana pengguna ingin mengurutkan semua kolom berdasarkan nama. Di sini mereka ingin memindahkan satu kolom ke kolom pertama sambil membiarkan urutan kolom lainnya tidak tersentuh.
smci
1
Bagaimana jika Anda tidak ingin mereka diurutkan?
Chankey Pathak
ini mengembalikan salinan, tidak bekerja di tempat
spinup
3

Bagaimana kalau menggunakan "T"?

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

@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)
matthhias
sumber
3

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]
Shoresh
sumber
2
Satu peringatan: urutan kolom hilang jika Anda memasukkannya ke dalam set
pvarma
Menarik! @ user1930402 Saya telah mencoba pendekatan di atas pada beberapa kesempatan dan tidak pernah punya masalah. Saya akan periksa lagi.
Shoresh
2

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.

Jamelade
sumber
Saya sedikit terkejut! Saya menggunakan setuntuk tujuan ini cukup sering dan tidak pernah harus berurusan dengan pemesanan.
Shoresh
2

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
silgon
sumber
2

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
gratisB
sumber
2

Metode paling rahasia dalam buku ini

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

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]
hayj
sumber
1

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
FooBar
sumber
1

Membalik saja sering membantu.

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

Atau hanya mengocok untuk melihatnya.

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

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 })

>>>

keluaran

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]
escha
sumber
0

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.

masukkan deskripsi gambar di sini

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)
pk2019
sumber
0

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