17 авг. 2022 г.
читать 1 мин
Вы можете использовать следующий синтаксис, чтобы быстро изменить порядок столбцов в кадре данных pandas:
df[['column2', 'column3', 'column1']]
В следующих примерах показано, как использовать этот синтаксис со следующими пандами DataFrame:
import pandas as pd
#create new DataFrame
df = pd.DataFrame({'points': [25, 12, 15, 14, 19, 23, 25, 29],
'assists': [5, 7, 7, 9, 12, 9, 9, 4],
'rebounds': [11, 8, 10, 6, 6, 5, 9, 12]})
#display DataFrame
df
points assists rebounds
0 25 5 11
1 12 7 8
2 15 7 10
3 14 9 6
4 19 12 6
5 23 9 5
6 25 9 9
7 29 4 12
Пример 1: изменение порядка столбцов по имени
В следующем коде показано, как изменить порядок столбцов в DataFrame на основе имени:
#change order of columns by name
df[['rebounds', 'assists', 'points']]
rebounds assists points
0 11 5 25
1 8 7 12
2 10 7 15
3 6 9 14
4 6 12 19
5 5 9 23
6 9 9 25
7 12 4 29
Пример 2: изменение порядка путем добавления нового первого столбца
В следующем коде показано, как изменить порядок столбцов в DataFrame, вставив новый столбец в первую позицию:
#define new column to add
steals = [2, 3, 3, 4, 3, 2, 1, 2]
#insert new column in first position
df.insert (0, 'steals', steals)
#display dataFrame
df
steals points assists rebounds
0 2 25 5 11
1 3 12 7 8
2 3 15 7 10
3 4 14 9 6
4 3 19 12 6
5 2 23 9 5
6 1 25 9 9
7 2 29 4 12
Пример 3: изменение порядка путем добавления нового последнего столбца
В следующем коде показано, как изменить порядок столбцов в DataFrame, вставив новый столбец в последнюю позицию DataFrame:
#define new column to add
steals = [2, 3, 3, 4, 3, 2, 1, 2]
#insert new column in last position
df.insert ( len(df.columns ), 'steals', steals)
#display dataFrame
df
points assists rebounds steals
0 25 5 11 2
1 12 7 8 3
2 15 7 10 3
3 14 9 6 4
4 19 12 6 3
5 23 9 5 2
6 25 9 9 1
7 29 4 12 2
Дополнительные ресурсы
Как вставить столбец в фрейм данных Pandas
Как удалить столбец индекса в Pandas
Как объединить два столбца в Pandas
- Список колонок в новом желаемом порядке в Pandas
вставитьновую колонку с расположением в Pandas- колонка реиндекс для заданного порядка в Pandas
Мы расскажем, как изменить порядок следования колонок DataFrame, с помощью различных методов, таких как назначение названий колонок в нужном нам порядке, с помощью insert и reindex.
Список колонок в новом желаемом порядке в Pandas
Самый простой способ — переназначить DataFrame со списком столбцов, или просто назначить имена столбцов в том порядке, в котором мы их хотим:
# python 3.x
import pandas as pd
df = pd.DataFrame({'a':['1','2','3','4'],
'b': [16,7,6,16],
'c':[61,57,16,36],
'd':['12','22','13','44'],
'e':['Green','Red','Blue','Yellow'],
'f':[1,11,23,66]})
print(df)
df = df[['e','c','b','f','d','a']]
print('Rearranging ..................')
print('..............................')
print(df)
Выход:
a b c d e f
0 1 16 61 12 Green 1
1 2 7 57 22 Red 11
2 3 6 16 13 Blue 23
3 4 16 36 44 Yellow 66
Rearranging ..................
..............................
e c b f d a
0 Green 61 16 1 12 1
1 Red 57 7 11 22 2
2 Blue 16 6 23 13 3
3 Yellow 36 16 66 44 4
вставить новую колонку с расположением в Pandas
Если мы создаем новую колонку, мы можем вставить ее в любое место:
# python 3.x
import pandas as pd
df = pd.DataFrame({'a':['1','2','3','4'],
'b': [16,7,6,16],
'c':[61,57,16,36],
'd':['12','22','13','44'],
'e':['Green','Red','Blue','Yellow'],
'f':[1,11,23,66]})
print(df)
print('Inserting ..................')
print('..............................')
df.insert(0, 'newColMean', df.mean(1))
print(df)
Выход:
newColMean a b c d e f
0 26.000000 1 16 61 12 Green 1
1 25.000000 2 7 57 22 Red 11
2 15.000000 3 6 16 13 Blue 23
3 39.333333 4 16 36 44 Yellow 66
колонка реиндекс для заданного порядка в Pandas
reindex — это, пожалуй, самый эффективный способ перестановки колонны:
# python 3.x
import pandas as pd
df = pd.DataFrame({'a':['1','2','3','4'],
'b': [16,7,6,16],
'c':[61,57,16,36],
'd':['12','22','13','44'],
'e':['Green','Red','Blue','Yellow'],
'f':[1,11,23,66]})
print(df)
print('Rearranging ..................')
print('..............................')
df = df.reindex(columns=['a','f','d','b','c','e'])
print(df)
Выход:
a b c d e f
0 1 16 61 12 Green 1
1 2 7 57 22 Red 11
2 3 6 16 13 Blue 23
3 4 16 36 44 Yellow 66
Rearranging ..................
..............................
a f d b c e
0 1 1 12 16 61 Green
1 2 11 22 7 57 Red
2 3 23 13 6 16 Blue
3 4 66 44 16 36 Yellow
One easy way would be to reassign the dataframe with a list of the columns, rearranged as needed.
This is what you have now:
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']
Rearrange cols in any way you want. This is how I moved the last element to the first position:
In [12]: cols = cols[-1:] + cols[:-1]
In [13]: cols
Out[13]: ['mean', 0L, 1L, 2L, 3L, 4L]
Then reorder the dataframe like this:
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
answered Oct 30, 2012 at 22:38
AmanAman
44.8k7 gold badges35 silver badges37 bronze badges
7
You could also do something like this:
df = df[['mean', '0', '1', '2', '3']]
You can get the list of columns with:
cols = list(df.columns.values)
The output will produce:
['0', '1', '2', '3', 'mean']
…which is then easy to rearrange manually before dropping it into the first function
answered May 19, 2014 at 15:20
freddygvfreddygv
8,7681 gold badge14 silver badges9 bronze badges
7
Just assign the column names in the order you want them:
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]]
Now, ‘mean’ column comes out in the front:
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
answered Apr 28, 2015 at 14:19
fixxxerfixxxer
15.2k15 gold badges58 silver badges76 bronze badges
5
In your case,
df = df.reindex(columns=['mean',0,1,2,3,4])
will do exactly what you want.
In my case (general form):
df = df.reindex(columns=sorted(df.columns))
df = df.reindex(columns=(['opened'] + list([a for a in df.columns if a != 'opened']) ))
Mr_and_Mrs_D
31.2k37 gold badges175 silver badges355 bronze badges
answered Aug 30, 2016 at 21:57
Alvaro SilvinoAlvaro Silvino
9,29111 gold badges51 silver badges80 bronze badges
3
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)
You can try out the following solutions :
Solution 1:
df = df[ ['mean'] + [ col for col in df.columns if col != 'mean' ] ]
Solution 2:
df = df[['mean', 'x', 'y', 'z']]
Solution 3:
col = df.pop("mean")
df = df.insert(0, col.name, col)
Solution 4:
df.set_index(df.columns[-1], inplace=True)
df.reset_index(inplace=True)
Solution 5:
cols = list(df)
cols = [cols[-1]] + cols[:-1]
df = df[cols]
solution 6:
order = [1,2,3,0] # setting column's order
df = df[[df.columns[i] for i in order]]
Time Comparison:
Solution 1:
CPU times: user 1.05 ms, sys: 35 µs, total: 1.08 ms Wall time: 995 µs
Solution 2:
CPU times: user 933 µs, sys: 0 ns, total: 933 µs
Wall time: 800 µs
Solution 3:
CPU times: user 0 ns, sys: 1.35 ms, total: 1.35 ms
Wall time: 1.08 ms
Solution 4:
CPU times: user 1.23 ms, sys: 45 µs, total: 1.27 ms
Wall time: 986 µs
Solution 5:
CPU times: user 1.09 ms, sys: 19 µs, total: 1.11 ms
Wall time: 949 µs
Solution 6:
CPU times: user 955 µs, sys: 34 µs, total: 989 µs
Wall time: 859 µs
answered Nov 9, 2019 at 6:24
PygirlPygirl
12.7k4 gold badges29 silver badges42 bronze badges
6
You need to create a new list of your columns in the desired order, then use df = df[cols] to rearrange the columns in this new order.
cols = ['mean'] + [col for col in df if col != 'mean']
df = df[cols]
You can also use a more general approach. In this example, the last column (indicated by -1) is inserted as the first column.
cols = [df.columns[-1]] + [col for col in df if col != df.columns[-1]]
df = df[cols]
You can also use this approach for reordering columns in a desired order if they are present in the 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]
answered Aug 21, 2015 at 2:18
AlexanderAlexander
102k29 gold badges196 silver badges191 bronze badges
0
Suppose you have df with columns A B C.
The most simple way is:
df = df.reindex(['B','C','A'], axis=1)
Asclepius
54.5k16 gold badges157 silver badges139 bronze badges
answered May 30, 2020 at 5:12
liangliliangli
1,1119 silver badges11 bronze badges
4
If your column names are too-long-to-type then you could specify the new order through a list of integers with the positions:
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
Generic example:
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
Although it might seem like I’m just explicitly typing the column names in a different order, the fact that there’s a column ‘mean’ should make it clear that new_order relates to actual positions and not column names.
For the specific case of OP’s question:
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
The main problem with this approach is that calling the same code multiple times will create different results each time, so one needs to be careful 
answered Aug 20, 2018 at 17:35
YucaYuca
5,9333 gold badges23 silver badges40 bronze badges
0
This question has been answered before but reindex_axis is deprecated now so I would suggest to use:
df = df.reindex(sorted(df.columns), axis=1)
For those who want to specify the order they want instead of just sorting them, here’s the solution spelled out:
df = df.reindex(['the','order','you','want'], axis=1)
Now, how you want to sort the list of column names is really not a pandas question, that’s a Python list manipulation question. There are many ways of doing that, and I think this answer has a very neat way of doing it.
Asclepius
54.5k16 gold badges157 silver badges139 bronze badges
answered Jan 4, 2013 at 6:04
dmviannadmvianna
14.6k18 gold badges78 silver badges105 bronze badges
7
You can reorder the dataframe columns using a list of names with:
df = df.filter(list_of_col_names)
answered Apr 13, 2021 at 13:36
Sam MurphySam Murphy
7859 silver badges23 bronze badges
I think this is a slightly neater solution:
df.insert(0, 'mean', df.pop("mean"))
This solution is somewhat similar to @JoeHeffer ‘s solution but this is one liner.
Here we remove the column "mean" from the dataframe and attach it to index 0 with the same column name.
Asclepius
54.5k16 gold badges157 silver badges139 bronze badges
answered Nov 5, 2019 at 16:33
erncyperncyp
1,56920 silver badges23 bronze badges
2
I ran into a similar question myself, and just wanted to add what I settled on. I liked the reindex_axis() method for changing column order. This worked:
df = df.reindex_axis(['mean'] + list(df.columns[:-1]), axis=1)
An alternate method based on the comment from @Jorge:
df = df.reindex(columns=['mean'] + list(df.columns[:-1]))
Although reindex_axis seems to be slightly faster in micro benchmarks than reindex, I think I prefer the latter for its directness.
answered Aug 27, 2014 at 19:49
clockerclocker
1,3569 silver badges16 bronze badges
2
This function avoids you having to list out every variable in your dataset just to order a few of them.
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
It takes two arguments, the first is the dataset, the second are the columns in the data set that you want to bring to the front.
So in my case I have a data set called Frame with variables A1, A2, B1, B2, Total and Date. If I want to bring Total to the front then all I have to do is:
frame = order(frame,['Total'])
If I want to bring Total and Date to the front then I do:
frame = order(frame,['Total','Date'])
EDIT:
Another useful way to use this is, if you have an unfamiliar table and you’re looking with variables with a particular term in them, like VAR1, VAR2,… you may execute something like:
frame = order(frame,[v for v in frame.columns if "VAR" in v])
answered Jul 29, 2014 at 19:30
seeiespiseeiespi
3,4782 gold badges34 silver badges37 bronze badges
Simply do,
df = df[['mean'] + df.columns[:-1].tolist()]
answered Apr 28, 2015 at 9:50
Napitupulu JonNapitupulu Jon
7,5532 gold badges21 silver badges23 bronze badges
7
Here’s a way to move one existing column that will modify the existing dataframe in place.
my_column = df.pop('column name')
df.insert(3, my_column.name, my_column) # Is in-place
Asclepius
54.5k16 gold badges157 silver badges139 bronze badges
answered Jan 4, 2018 at 13:25
Joe HefferJoe Heffer
6257 silver badges9 bronze badges
1
Just type the column name you want to change, and set the index for the new location.
def change_column_order(df, col_name, index):
cols = df.columns.tolist()
cols.remove(col_name)
cols.insert(index, col_name)
return df[cols]
For your case, this would be like:
df = change_column_order(df, 'mean', 0)
answered May 6, 2016 at 11:39
ccerhanccerhan
6326 silver badges7 bronze badges
0
You could do the following (borrowing parts from Aman’s answer):
cols = df.columns.tolist()
cols.insert(0, cols.pop(-1))
cols
>>>['mean', 0L, 1L, 2L, 3L, 4L]
df = df[cols]
answered Dec 8, 2016 at 15:22
ottehengotteheng
5941 gold badge8 silver badges26 bronze badges
Moving any column to any position:
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]
answered Feb 27, 2018 at 14:05
pomberpomber
22.3k10 gold badges79 silver badges92 bronze badges
I wanted to bring two columns in front from a dataframe where I do not know exactly the names of all columns, because they are generated from a pivot statement before.
So, if you are in the same situation: To bring columns in front that you know the name of and then let them follow by «all the other columns», I came up with the following general solution:
df = df.reindex_axis(['Col1','Col2'] + list(df.columns.drop(['Col1','Col2'])), axis=1)
Asclepius
54.5k16 gold badges157 silver badges139 bronze badges
answered Jul 27, 2017 at 9:21
matthhiasmatthhias
2013 silver badges6 bronze badges
1
Here is a very simple answer to this(only one line).
You can do that after you added the ‘n’ column into your df as follows.
import numpy as np
import pandas as pd
df = pd.DataFrame(np.random.rand(10, 5))
df['mean'] = df.mean(1)
df
0 1 2 3 4 mean
0 0.929616 0.316376 0.183919 0.204560 0.567725 0.440439
1 0.595545 0.964515 0.653177 0.748907 0.653570 0.723143
2 0.747715 0.961307 0.008388 0.106444 0.298704 0.424512
3 0.656411 0.809813 0.872176 0.964648 0.723685 0.805347
4 0.642475 0.717454 0.467599 0.325585 0.439645 0.518551
5 0.729689 0.994015 0.676874 0.790823 0.170914 0.672463
6 0.026849 0.800370 0.903723 0.024676 0.491747 0.449473
7 0.526255 0.596366 0.051958 0.895090 0.728266 0.559587
8 0.818350 0.500223 0.810189 0.095969 0.218950 0.488736
9 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 4
0 0.440439 0.929616 0.316376 0.183919 0.204560 0.567725
1 0.723143 0.595545 0.964515 0.653177 0.748907 0.653570
2 0.424512 0.747715 0.961307 0.008388 0.106444 0.298704
3 0.805347 0.656411 0.809813 0.872176 0.964648 0.723685
4 0.518551 0.642475 0.717454 0.467599 0.325585 0.439645
5 0.672463 0.729689 0.994015 0.676874 0.790823 0.170914
6 0.449473 0.026849 0.800370 0.903723 0.024676 0.491747
7 0.559587 0.526255 0.596366 0.051958 0.895090 0.728266
8 0.488736 0.818350 0.500223 0.810189 0.095969 0.218950
9 0.414752 0.258719 0.468106 0.459373 0.709510 0.178053
answered Jun 18, 2020 at 19:30
rrarra
7636 silver badges16 bronze badges
You can use a set which is an unordered collection of unique elements to do keep the «order of the other columns untouched»:
other_columns = list(set(df.columns).difference(["mean"])) #[0, 1, 2, 3, 4]
Then, you can use a lambda to move a specific column to the front by:
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 4
0 0.697253 0.600377 0.464852 0.938360 0.945293 0.537384
1 0.609213 0.703387 0.096176 0.971407 0.955666 0.319429
2 0.561261 0.791842 0.302573 0.662365 0.728368 0.321158
3 0.518720 0.710443 0.504060 0.663423 0.208756 0.506916
4 0.616316 0.665932 0.794385 0.163000 0.664265 0.793995
5 0.519757 0.585462 0.653995 0.338893 0.714782 0.305654
6 0.532584 0.434472 0.283501 0.633156 0.317520 0.994271
7 0.640571 0.732680 0.187151 0.937983 0.921097 0.423945
8 0.562447 0.790987 0.200080 0.317812 0.641340 0.862018
9 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 mean
0 0.938360 0.600377 0.464852 0.945293 0.537384 0.697253
1 0.971407 0.703387 0.096176 0.955666 0.319429 0.609213
2 0.662365 0.791842 0.302573 0.728368 0.321158 0.561261
3 0.663423 0.710443 0.504060 0.208756 0.506916 0.518720
4 0.163000 0.665932 0.794385 0.664265 0.793995 0.616316
5 0.338893 0.585462 0.653995 0.714782 0.305654 0.519757
6 0.633156 0.434472 0.283501 0.317520 0.994271 0.532584
7 0.937983 0.732680 0.187151 0.921097 0.423945 0.640571
8 0.317812 0.790987 0.200080 0.641340 0.862018 0.562447
9 0.396048 0.811533 0.662709 0.596528 0.348642 0.563092
answered Jul 4, 2020 at 10:19
Just flipping helps often.
df[df.columns[::-1]]
Or just shuffle for a look.
import random
cols = list(df.columns)
random.shuffle(cols)
df[cols]
answered Apr 10, 2020 at 11:39
plhnplhn
4,8374 gold badges43 silver badges47 bronze badges
You can use reindex which can be used for both axis:
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
answered Dec 18, 2017 at 15:24
silgonsilgon
6,7426 gold badges43 silver badges66 bronze badges
Hackiest method in the book
df.insert(0, "test", df["mean"])
df = df.drop(columns=["mean"]).rename(columns={"test": "mean"})
Asclepius
54.5k16 gold badges157 silver badges139 bronze badges
answered Apr 11, 2019 at 17:58
Kaustubh JKaustubh J
6928 silver badges9 bronze badges
A pretty straightforward solution that worked for me is to use .reindex on df.columns:
df = df[df.columns.reindex(['mean', 0, 1, 2, 3, 4])[0]]
Asclepius
54.5k16 gold badges157 silver badges139 bronze badges
answered May 8, 2020 at 15:42
CSQLCSQL
1061 silver badge3 bronze badges
Here is a function to do this for any number of columns.
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
answered Jan 29, 2018 at 18:57
freeBfreeB
913 bronze badges
A simple approach is using set(), in particular when you have a long list of columns and do not want to handle them manually:
cols = list(set(df.columns.tolist()) - set(['mean']))
cols.insert(0, 'mean')
df = df[cols]
Asclepius
54.5k16 gold badges157 silver badges139 bronze badges
answered Sep 12, 2017 at 2:06
ShoreshShoresh
2,5731 gold badge16 silver badges9 bronze badges
2
How about using T?
df = df.T.reindex(['mean', 0, 1, 2, 3, 4]).T
Asclepius
54.5k16 gold badges157 silver badges139 bronze badges
answered Jun 26, 2016 at 23:46
ZEEZEE
1881 silver badge11 bronze badges
I believe @Aman’s answer is the best if you know the location of the other column.
If you don’t know the location of mean, but only have its name, you cannot resort directly to cols = cols[-1:] + cols[:-1]. Following is the next-best thing I could come up with:
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
answered Mar 22, 2015 at 14:43
FooBarFooBar
15.4k18 gold badges78 silver badges164 bronze badges
Метод 1: использование reindex()
Вы можете изменить порядок столбцов, вызвав DataFrame.reindex() в исходном DataFrame с измененным списком столбцов в качестве аргумента.
new_dataframe = dataframe.reindex(columns=['a', 'c', 'b'])
Функция reindex() возвращает новый DataFrame с заданным порядком столбцов.
В следующей программе мы возьмем DataFrame со столбцами a, b, c и изменим порядок столбцов на a, c, b.
import pandas as pd #initialize a dataframe df = pd.DataFrame( [[21, 72, 67], [23, 78, 62], [32, 74, 54], [52, 54, 76]], columns=['a', 'b', 'c']) #change order of columns df_new = df.reindex(columns=['a', 'c', 'b']) #print new dataframe print(df_new)
Вывод:
a c b 0 21 67 72 1 23 62 78 2 32 54 74 3 52 76 54
Метод 2: использование индексации
Индексирование DataFrame может использоваться для изменения порядка столбцов в данном DataFrame.
Ниже приведен синтаксис для использования индексации DataFrame.
new_dataframe = dataframe[['a', 'c', 'b']]
В следующей программе мы возьмем DataFrame со столбцами a, b, c и изменим порядок столбцов на a, c, b.
import pandas as pd #initialize a dataframe df = pd.DataFrame( [[21, 72, 67], [23, 78, 62], [32, 74, 54], [52, 54, 76]], columns=['a', 'b', 'c']) #change order of columns df_new = df[['a', 'c', 'b']] #print new dataframe print(df_new)
Вывод:
a c b 0 21 67 72 1 23 62 78 2 32 54 74 3 52 76 54
Метод 3: использование конструктора
Вы также можете использовать конструктор DataFrame, чтобы изменить порядок столбцов. Создайте существующий DataFrame необработанными данными и создайте новый DataFrame с этими необработанными данными и желаемым порядком столбцов.
Ниже приведен синтаксис для создания DataFrame с обновленным порядком столбцов.
new_dataframe = pd.dataframe(raw_data, index=['a', 'c', 'b'])
В следующей программе мы возьмем DataFrame со столбцами a, b, c и изменим порядок столбцов на a, c, b.
import pandas as pd #initialize a dataframe df = pd.DataFrame( [[21, 72, 67], [23, 78, 62], [32, 74, 54], [52, 54, 76]], columns=['a', 'b', 'c']) #change order of columns df_new = pd.DataFrame(df, columns=['a', 'c', 'b']) #print new dataframe print(df_new)
Вывод:
a c b 0 21 67 72 1 23 62 78 2 32 54 74 3 52 76 54
В этом руководстве по Python мы узнали, как изменить порядок столбцов в DataFrame.
In this post, you’ll learn the different ways to reorder Pandas columns, including how to use the .reindex() method to reorder Pandas columns.
Loading a sample dataframe
Let’s start things off by loading a sample dataframe that you can use throughout the entire tutorial. We’ll only need to import Pandas for this tutorial:
import pandas as pd
df = pd.DataFrame.from_dict(
{
'Name': ['Joan', 'Devi', 'Melissa', 'Dave'],
'Age':[19, 43, 27, 32],
'Gender': ['Female', 'Female', 'Female', 'Male'],
'Education': ['High School', 'College', 'PhD', 'High School'],
'City': ['Atlanta', 'Toronto', 'New York City', 'Madrid']
}
)
print(df)This returns the following dataframe:
Name Age Gender Education City
0 Joan 19 Female High School Atlanta
1 Devi 43 Female College Toronto
2 Melissa 27 Female PhD New York City
3 Dave 32 Male High School MadridReorder Columns by Direct Assignment
The most direct way to reorder columns is by direct assignment (pardon the pun!).
What this means is to place columns in the order that you’d like them to be in as a list, and pass that into square brackets when re-assigning your dataframe.
Right now, the dataframe’s columns are in the following order: [‘Name’, ‘Age’, ‘Gender’, ‘Education’, ‘City’].
Imagine that you want to switch out the Age and Gender columns, you could write:
df = df[['Name', 'Gender', 'Age', 'Education', 'City']]
print(df)This returns the following dataframe, with its columns reordered:
Name Gender Age Education City
0 Joan Female 19 High School Atlanta
1 Devi Female 43 College Toronto
2 Melissa Female 27 PhD New York City
3 Dave Male 32 High School MadridCheck out some other Python tutorials on datagy, including our complete guide to styling Pandas and our comprehensive overview of Pivot Tables in Pandas!
Another way to reorder columns is to use the Pandas .reindex() method. This allows you to pass in the columns= parameter to pass in the order of columns that you want to use.
For the following example, let’s switch the Education and City columns:
df = df.reindex(columns=['Name', 'Gender', 'Age', 'City', 'Education'])
print(df)This returns the following dataframe:
Name Gender Age City Education
0 Joan Female 19 Atlanta High School
1 Devi Female 43 Toronto College
2 Melissa Female 27 New York City PhD
3 Dave Male 32 Madrid High SchoolReorder Pandas Columns using Pandas .insert()
Both of the above methods rely on your to manually type in the list of columns. If you’re working with a larger dataframe, this can be time consuming and just, plain, annoying!
If you know the position in which you want to insert the column, this is a much easier way to do so.
Let’s check out how to do this using Python. For the following example, let’s move the City column between Name and Gender (as the second column).
city = df['City']
df = df.drop(columns=['City'])
df.insert(loc=1, column='City', value=city)
print(df)Let’s take a quick look at what we’ve done here:
- We’ve assigned the df[‘City’] column to a series name city,
- We dropped that column from the dataframe, and finally
- We inserted that series back into the dataframe, at the first index with a column named ‘City’
This returns the following dataframe:
Name City Gender Age Education
0 Joan Atlanta Female 19 High School
1 Devi Toronto Female 43 College
2 Melissa New York City Female 27 PhD
3 Dave Madrid Male 32 High SchoolReorder Columns using a Custom Function
We can use the above method as a custom function, if you find yourself needing to move multiple columns around more frequently.
Let’s see how we do this with Python:
def reorder_columns(dataframe, col_name, position):
"""Reorder a dataframe's column.
Args:
dataframe (pd.DataFrame): dataframe to use
col_name (string): column name to move
position (0-indexed position): where to relocate column to
Returns:
pd.DataFrame: re-assigned dataframe
"""
temp_col = dataframe[col_name]
dataframe = dataframe.drop(columns=[col_name])
dataframe.insert(loc=position, column=col_name, value=temp_col)
return dataframe
df = reorder_columns(dataframe=df, col_name='Age', position=0)
print(df)This returns the following dataframe:
Age Name City Gender Education
0 19 Joan Atlanta Female High School
1 43 Devi Toronto Female College
2 27 Melissa New York City Female PhD
3 32 Dave Madrid Male High SchoolConclusion
In this post, you learned how to reorder columns, including how to use the Pandas .reindex() method and the .insert() method. In the end, you learned a custom function to help you reorder columns, if this is something you do frequently.
If you want to learn more about the Pandas .reindex()method, check out the official documentation here.
Additional Resources
To learn more about related topics, check out the resources below:
- How to Add / Insert a Row into a Pandas DataFrame
- Reorder Pandas Columns: Pandas Reindex and Pandas insert
- Insert a Blank Column to Pandas Dataframe
- Move a Pandas DataFrame Column to Position (Start and End)