У мене є таке DataFrame( df):

import numpy as np
import pandas as pd

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

Я додаю більше стовпців (-ів) за призначенням:

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

Як я можу перемістити стовпчик meanна фронт, тобто встановити його як перший стовпець, залишаючи порядок інших стовпців недоторканим?

Одним із простих способів було б перепризначення фрейму даних із списком стовпців, переставленим за потребою.

Ось що у вас зараз:

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

Ви також можете зробити щось подібне:

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

Список стовпців можна отримати за допомогою:

cols = list(df.columns.values)

Вихід буде давати:

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

... яку потім легко переставити вручну перед тим, як скинути її на першу функцію

Просто призначте назви стовпців у тому порядку, який вам потрібно:

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

Тепер стовпець "середній" виходить на передній частині:

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

Як щодо:

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

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

У вашому випадку,

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

Потрібно створити новий список своїх стовпців у потрібному порядку, а потім використати 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]

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:

Час процесора: користувач 1,05 мс, систем: 35 мкс, всього: 1,08 мс Час стіни: 995 мкс

Рішення 2 :

Час процесора: користувач 933 µs, sys: 0 ns, всього: 933 µs Час стіни: 800 µs

Рішення 3 :

Час CPU: користувач 0 ns, sys: 1,35 ms, всього: 1,35 ms Час стіни: 1,08 мс

Рішення 4 :

Час процесора: користувач 1,23 мс, система: 45 мкс, всього: 1,27 мс Час стіни: 986 мкс

Рішення 5 :

Час процесора: користувач 1,09 мс, систем: 19 мкс, всього: 1,11 мс Час стіни: 949 мкс

Рішення 6 :

Час процесора: користувач 955 мкс, системний: 34 мкс, всього: 989 мкс Час стіни: 859 мкс

З серпня 2018 року:

Якщо назви стовпців занадто довгі для введення, ви можете вказати новий порядок через список цілих чисел із позиціями:

Дані:

          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 = [-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

Основна проблема такого підходу полягає в тому, що виклик одного і того ж коду кілька разів створюватиме різні результати кожен раз, тому потрібно бути обережним :)

Ця функція дозволяє уникнути необхідності перераховувати кожну змінну у вашому наборі даних лише для того, щоб замовити декілька з них.

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

Я сам наткнувся на подібне питання і просто хотів додати те, на чому я вирішив. Мені сподобалось 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, але я думаю, що я віддаю перевагу останнім за його прямоту.

Просто робіть,

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

Ви можете зробити наступне (запозичивши частини з відповіді Амана):

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

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

df = df[cols]

Просто введіть назву стовпця, який ви хочете змінити, і встановіть індекс для нового місця розташування.

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)

Переміщення будь-якого стовпця в будь-яку позицію:

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]

Я думаю, що це трохи акуратніше рішення:

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

Це рішення дещо схоже на рішення @JoeHeffer, але це один вкладиш.

Тут ми видаляємо стовпець "mean"із фрейму даних і додаємо його до індексу 0з тим самим ім'ям стовпця.

Ось спосіб перемістити один існуючий стовпець, який змінить існуючий кадр даних на місці.

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

Це питання було дано відповіді , перш ніж , але reindex_axis засуджується в даний час , так що я б запропонував використовувати:

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

Як щодо використання "T"?

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

@ clocker: Ваше рішення було дуже корисним для мене, оскільки я хотів вивести два стовпчики напроти з фрейму даних, де я не знаю точно назв усіх стовпців, тому що вони генеруються із зведеного оператора раніше. Отже, якщо ви перебуваєте в тій самій ситуації: Щоб привести стовпчики навпроти, яким ви знаєте ім'я, а потім дозволити їм слідувати за "всіма іншими колонками", я придумав таке загальне рішення;

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

set():

Простий підхід застосовується set(), особливо коли у вас довгий список стовпців і не хочете обробляти їх вручну:

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

Мені сподобалась відповідь Шореша використання функціоналу набору для видалення стовпців, коли ви не знаєте місцезнаходження, однак це не спрацювало для моєї мети, оскільки мені потрібно зберегти початковий порядок стовпців (який має довільні позначки стовпців).

Я змусив це працювати, хоча використовуючи IndexedSet з пакету boltons.

Мені також потрібно було повторно додати кілька міток стовпців, тому для більш загального випадку я використав наступний код:

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

Сподіваюся, це корисно для всіх, хто шукає цю тему для загального рішення.

Ви можете використовувати, 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

Ось функція робити це для будь-якої кількості стовпців.

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

Метод Хаккіста в книзі

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

Я думаю, що ця функція є більш зрозумілою. Вам просто потрібно вказати підмножину стовпців на початку або в кінці або обидва:

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]

Я вважаю , що відповідь @ Амана найкраща, якщо ви знаєте місце розташування іншого стовпця.

Якщо ви не знаєте місцезнаходження 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

Просто гортання допомагає часто.

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

Або просто перемішати для погляду.

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

Більшість відповідей недостатньо узагальнено, і метод 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]

У мене дуже специфічний випадок використання для переупорядкування імен стовпців у пандах. Іноді я створюю новий стовпчик у кадрі даних, який базується на наявному стовпчику. За замовчуванням панди вставлять мій новий стовпець наприкінці, але я хочу, щоб новий стовпець був вставлений поруч із існуючим стовпцем, з якого він походить.

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)

Досить простим рішенням, яке працювало для мене, є використання .reindex на df.column:

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