Aşağıdaki DataFrame( df) var:

import numpy as np
import pandas as pd

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

Atamaya göre daha fazla sütun ekliyorum:

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

Sütunu meanöne nasıl taşıyabilirim , yani diğer sütunların sırasına dokunulmadan ilk sütun olarak nasıl ayarlayabilirim?

Kolay bir yol, veri çerçevesini gerektiğinde yeniden düzenlenen sütunların bir listesiyle yeniden atamaktır.

Şu an sahip olduğunuz şey:

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İstediğiniz şekilde yeniden düzenleyin . Bu şekilde son elemanı ilk konuma taşıdım:

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

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

Ardından veri çerçevesini şu şekilde yeniden sıralayın:

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

Bunun gibi bir şey de yapabilirsiniz:

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

Aşağıdaki sütunların listesini alabilirsiniz:

cols = list(df.columns.values)

Çıktı üretecek:

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

... daha sonra ilk işleve bırakmadan önce manuel olarak yeniden düzenlemek kolaydır

Sütun adlarını istediğiniz sırada atamanız yeterlidir:

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

Şimdi, 'ortalama' sütunu öne çıkıyor:

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

Nasıl olur:

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

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

Senin durumunda,

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

tam olarak ne istediğinizi yapacak.

Benim durumumda (genel form):

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

İstediğiniz sırayla sütunlarınızın yeni bir listesini oluşturmanız ve ardından df = df[cols]bu yeni sırayla sütunları yeniden düzenlemek için kullanmanız gerekir.

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

Daha genel bir yaklaşım da kullanabilirsiniz. Bu örnekte, son sütun (-1 ile gösterilir) ilk sütun olarak eklenir.

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

Bu yaklaşımı, DataFrame'de varsa sütunları istenen sırada yeniden sıralamak için de kullanabilirsiniz.

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)

Aşağıdaki çözümleri deneyebilirsiniz:

Çözüm 1:

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

Çözüm 2:

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

Çözüm 3:

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

Çözüm 4:

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

Çözüm 5:

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

çözüm 6:

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

Zaman Karşılaştırması:

Çözüm 1:

CPU süreleri: kullanıcı 1.05 ms, sys: 35 µs, toplam: 1.08 ms Duvar süresi: 995 µs

Çözüm 2 :

CPU süreleri: kullanıcı 933 µs, sys: 0 ns, toplam: 933 µs Duvar süresi: 800 µs

Çözüm 3 :

CPU süreleri: kullanıcı 0 ns, sys: 1.35 ms, toplam: 1.35 ms Duvar süresi: 1.08 ms

Çözüm 4 :

CPU süreleri: kullanıcı 1.23 ms, sys: 45 µs, toplam: 1.27 ms Duvar süresi: 986 µs

Çözüm 5 :

CPU süreleri: kullanıcı 1.09 ms, sys: 19 µs, toplam: 1.11 ms Duvar süresi: 949 µs

Çözüm 6 :

CPU süreleri: kullanıcı 955 µs, sys: 34 µs, toplam: 989 µs Duvar süresi: 859 µs

Ağustos 2018'den itibaren:

Sütun adlarınız yazmak için çok uzunsa, yeni siparişi, konumlara sahip bir tamsayı listesi aracılığıyla belirtebilirsiniz:

Veri:

          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

Genel örnek:

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

Ve OP sorusunun özel durumu için:

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

Bu yaklaşımla ilgili temel sorun, aynı kodu birden çok kez çağırmanın her seferinde farklı sonuçlar yaratmasıdır, bu yüzden dikkatli olmak gerekir :)

Bu işlev, yalnızca birkaçını sipariş etmek için veri kümenizdeki her değişkeni listelemenizden kaçınır.

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 

İki argüman alır, birincisi veri kümesidir, ikincisi veri kümesinde öne getirmek istediğiniz sütunlardır.

Benim durumumda, A1, A2, B1, B2, Toplam ve Tarih değişkenleriyle Frame adlı bir veri kümem var. Total'i öne getirmek istersem tek yapmam gereken:

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

Toplamı ve Tarihi öne getirmek istersem:

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

DÜZENLE:

Bunu kullanmanın başka bir yararlı yolu, bilmediğiniz bir tablonuz varsa ve VAR1, VAR2 gibi belirli bir terimi olan değişkenlerle bakıyorsanız ... gibi bir şey yürütebilirsiniz:

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

Ben de benzer bir soru ile karşılaştım ve sadece yerleştiğimi eklemek istedim. Ben reindex_axis() methodsütun sırasını değiştirmek için sevdim . Bu işe yaradı:

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

@Jorge'un açıklamasına dayanan alternatif bir yöntem:

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

Her ne kadar reindex_axisdaha mikro kriterler içinde biraz daha hızlı gibi görünüyor reindex, ben onun direkt için ikincisi tercih ederim.

Basitçe yapın,

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

Aşağıdakileri yapabilirsiniz (Aman'ın cevabından parçalar ödünç almak):

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

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

df = df[cols]

Değiştirmek istediğiniz sütun adını yazın ve yeni konumun dizinini ayarlayın.

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

Sizin durumunuz için bu şöyle olur:

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

Herhangi bir sütunu herhangi bir konuma taşıma:

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]

Bence bu biraz daha temiz bir çözüm:

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

Bu çözüm, @JoeHeffer'ın çözümüne biraz benzer, ancak bu bir astardır.

Burada sütunu veri "mean"çerçevesinden kaldırıyoruz ve 0aynı sütun adıyla dizine ekliyoruz .

İşte mevcut veri çerçevesini değiştirecek mevcut bir sütunu taşımanın bir yolu.

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

Bu soru yanıtlandı önce ama kullanımına öneririm böylece artık önerilmemektedir reindex_axis:

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

"T" kullanmaya ne dersiniz?

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

@clocker: Daha önce bir pivot deyiminden üretildikleri için, tüm sütunların adlarını tam olarak bilmediğim bir veri çerçevesinden iki sütun öne getirmek istediğim için çözümünüz benim için çok yardımcı oldu. Yani, aynı durumdaysanız: Adını bildiğiniz sütunları öne getirmek ve daha sonra "tüm diğer sütunlar" izlemelerine izin vermek için aşağıdaki genel çözümü buldum;

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

set():

Basit bir yaklaşım, set()özellikle uzun bir sütun listeniz olduğunda ve bunları manuel olarak işlemek istemiyorsanız:

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

Konumu bilmediğinizde sütunları kaldırmak için ayar işlevselliğini kullanmak için Shoresh'in cevabını beğendim , ancak orijinal sütun sırasını (ki rastgele sütun etiketlerine sahip) tutmam gerektiğinden bu benim amacım için işe yaramadı.

Gerçi kullanarak çalışmalarına bu var IndexedSet Boltons paketten.

Ayrıca, daha genel bir durum için aşağıdaki kodu kullandığım için birden çok sütun etiketi yeniden eklemek gerekiyordu:

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

Umarım bu konu genel bir çözüm arayan herkes için yararlıdır.

Her reindexiki eksen için kullanılabilecek olanı kullanabilirsiniz:

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

İşte herhangi bir sayıda sütun için bunu yapmak için bir işlev.

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

Kitaptaki en çılgın yöntem

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

Bu fonksiyonun daha basit olduğunu düşünüyorum. Sadece başlangıçta veya sonunda sütunların bir alt kümesini veya her ikisini birden belirtmeniz gerekir:

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]

Diğer sütunun yerini biliyorsanız @ Aman'ın cevabının en iyisi olduğuna inanıyorum .

Konumunu bilmiyorsanız mean, ancak yalnızca adına sahipseniz, doğrudan başvuramazsınız cols = cols[-1:] + cols[:-1]. Ben gelip bir sonraki en iyi şey aşağıdadır:

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

Sadece çevirme sık sık yardımcı olur.

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

Ya da sadece bir bakış için karıştırın.

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

Cevapların çoğu yeterince genelleştirmedi ve pandalar reindex_axis yöntemi biraz sıkıcı, bu yüzden key = column name ve value = position konumuna taşınacak bir sözlük kullanarak herhangi bir konuma rasgele sayıda sütun taşımak için basit bir işlev sunuyoruz. Veri kareniz büyükse True değerini 'big_data' değerine geçirirseniz, işlev sıralı sütunlar listesini döndürür. Ve verilerinizi dilimlemek için bu listeyi kullanabilirsiniz.

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]

Pandalarda sütun adlarını yeniden sıralamak için çok özel bir kullanım durumum var. Bazen mevcut bir sütuna dayanan bir veri çerçevesinde yeni bir sütun oluşturuyorum. Varsayılan olarak pandalar yeni sütunumu sonuna ekler, ancak yeni sütunun türetildiği varolan sütunun yanına eklenmesini istiyorum.

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)

Benim için çalışan oldukça basit bir çözüm .reindex'i df.columns üzerinde kullanmaktır:

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