나는 다음과 같은 것을 가지고있다 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 :

CPU 시간 : 사용자 1.05ms, 시스템 : 35µs, 총계 : 1.08ms 월 시간 : 995µs

해결책 2 :

CPU 시간 : 사용자 933 µs, sys : 0 ns, 총계 : 933 µs 월 시간 : 800 µs

해결책 3 :

CPU 시간 : 사용자 0ns, sys : 1.35ms, 총계 : 1.35ms 월 시간 : 1.08ms

해결책 4 :

CPU 시간 : 사용자 1.23ms, 시스템 : 45µs, 총계 : 1.27ms 월 시간 : 986µs

해결책 5 :

CPU 시간 : 사용자 1.09ms, 시스템 : 19µs, 총계 : 1.11ms 월 타임 : 949µs

해결책 6 :

CPU 시간 : 사용자 955µs, 시스템 : 34µs, 총계 : 989µs 월 시간 : 859µs

2018 년 8 월부터 :

열 이름이 너무 길어서 입력 할 수없는 경우 위치가있는 정수 목록을 통해 새 순서를 지정할 수 있습니다.

데이터:

          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

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

이 접근법의 주요 문제점은 동일한 코드를 여러 번 호출하면 매번 다른 결과를 생성하므로주의해야합니다.

이 함수를 사용하면 데이터 세트의 모든 변수를 나열하여 변수 중 일부를 주문할 필요가 없습니다.

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 

두 개의 인수가 필요합니다. 첫 번째는 데이터 세트이고, 두 번째는 데이터 세트에서 맨 앞에 가져 오려는 열입니다.

그래서 내 경우에는 변수 A1, A2, B1, B2, Total 및 Date가있는 Frame이라는 데이터 세트가 있습니다. 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()]

다음을 수행 할 수 있습니다 (Aman의 답변에서 부품을 빌리는 것).

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]

Shoresh의 답변이 마음에 들었 습니다.위치를 모르는 경우 열을 제거하기 위해 set 기능을 사용 이 원래 열 순서 (임의의 열 레이블이 있음)를 유지해야하므로 목적에 맞지 않습니다.

boltons 패키지에서 IndexedSet 을 사용 하여이 작업을 수행했습니다 .

또한 여러 열 레이블을 다시 추가해야하므로보다 일반적인 경우에는 다음 코드를 사용했습니다.

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]

대부분의 답변이 충분히 일반화되지 않았고 팬더 reindex_axis 방법은 약간 지루하므로 키 = 열 이름 및 값 = 이동할 위치 사전을 사용하여 임의의 수의 열을 원하는 위치로 이동하는 간단한 기능을 제공합니다. 데이터 프레임이 큰 경우 'big_data'에 True를 전달하면이 함수는 정렬 된 열 목록을 반환합니다. 이 목록을 사용하여 데이터를 슬라이스 할 수 있습니다.

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)

나를 위해 일한 아주 간단한 해결책은 df.columns에서 .reindex를 사용하는 것입니다.

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