මට පහත 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]

ඩේටා ෆ්‍රේම් හි තීරු තිබේ නම් අපේක්ෂිත අනුපිළිවෙලට නැවත පෙළගැස්වීම සඳහා ඔබට මෙම ප්‍රවේශය භාවිතා කළ හැකිය.

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.05 ms, sys: 35 µs, එකතුව: 1.08 ms බිත්ති කාලය: 995 µs

විසඳුම 2 :

CPU වේලාවන්: පරිශීලක 933, s, sys: 0 ns, එකතුව: 933 Walls බිත්ති කාලය: 800 µs

විසඳුම 3 :

CPU වේලාවන්: පරිශීලක 0 ns, sys: 1.35 ms, එකතුව: 1.35 ms බිත්ති කාලය: 1.08 ms

විසඳුම 4 :

CPU වේලාවන්: පරිශීලක 1.23 ms, sys: 45 µs, එකතුව: 1.27 ms බිත්ති කාලය: 986 µs

විසඳුම 5 :

CPU වේලාවන්: පරිශීලක 1.09 ms, sys: 19 µs, එකතුව: 1.11 ms බිත්ති කාලය: 949 µs

විසඳුම 6 :

CPU වේලාවන්: පරිශීලක 955, s, sys: 34 µs, එකතුව: 989 Walls බිත්ති කාලය: 859 µs

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

      

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

මෙම ප්‍රවේශයේ ඇති ප්‍රධාන ගැටළුව නම් එකම කේතය කිහිප වතාවක් ඇමතීමෙන් සෑම අවස්ථාවකම විවිධ ප්‍රති results ල ලැබෙනු ඇත, එබැවින් යමෙක් ප්‍රවේශම් විය යුතුය :)

මමත් ඒ හා සමාන ප්‍රශ්නයකට මුහුණ දුන් අතර, මා නිරාකරණය කළ දේ එකතු කිරීමට අවශ්‍ය විය. reindex_axis() methodතීරු අනුපිළිවෙල වෙනස් කිරීම සඳහා මම කැමතියි . මෙය ක්‍රියාත්මක විය:

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

@ ජෝර්ජ්ගේ අදහස මත පදනම් වූ විකල්ප ක්‍රමයක්:

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

reindex_axisක්ෂුද්‍ර මිණුම් සලකුණු වලට වඩා තරමක් වේගවත් බවක් පෙනෙන්නට තිබුණද reindex, මම සිතන්නේ එහි සෘජු බව සඳහා දෙවැන්න වඩා කැමතියි.

මෙම ශ්‍රිතය මඟින් ඔබේ දත්ත කට්ටලයේ සෑම විචල්‍යයක්ම ලැයිස්තු ගත කිරීම වළක්වයි.

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, එකතුව සහ දිනය යන විචල්‍යයන් සහිත Frame නමින් දත්ත කට්ටලයක් තිබේ. මට ටෝටල් පෙරමුණට ගෙන ඒමට අවශ්‍ය නම් මා කළ යුත්තේ:

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

මට මුළු හා දිනය ඉදිරියට ගෙන ඒමට අවශ්‍ය නම් මම කරන්නේ:

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

සංස්කරණය කරන්න:

මෙය භාවිතා කිරීමට තවත් ප්‍රයෝජනවත් ක්‍රමයක් නම්, ඔබට නුහුරු නුපුරුදු වගුවක් තිබේ නම් සහ VAR1, VAR2 වැනි නිශ්චිත යෙදුමක් සහිත විචල්‍යයන් සමඟ ඔබ සොයන්නේ නම් ... ඔබට මෙවැනි දෙයක් ක්‍රියාත්මක කළ හැකිය:

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

සරලව කරන්න,

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)

මම හිතන්නේ මෙය තරමක් පිළිවෙලට විසඳුමක්:

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

මෙම විසඳුම @ ජෝ හෙෆර්ගේ විසඳුමට තරමක් සමාන නමුත් මෙය එක් ලයිනර් ය.

මෙන්න අපි "mean"දත්ත රාමුවෙන් තීරුව ඉවත් කර එය 0එකම තීරුවේ නම සහිත දර්ශකයට අනුයුක්ත කරමු .

වඩාත්ම සරල ක්‍රමය ඔබට dfතීරු තිබේ යැයි සිතමු A B C, ඔබට එය කළ හැකියdf.reindex(['B','C','A'],axis=1)

ඕනෑම තීරුවක් ඕනෑම ස්ථානයකට ගෙන යාම:

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]

පවත්නා දත්ත රාමුව වෙනස් කරන දැනට පවතින එක් තීරුවක් ගෙනයාමේ ක්‍රමයක් මෙන්න.

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

“අනෙක් තීරුවල අනුපිළිවෙල ස්පර්ශ නොකිරීමට ” ඔබට අද්විතීය අංග එකතුවක් වන කට්ටලයක් භාවිතා කළ හැකිය :

other_columns = list(set(df.columns).difference(["mean"])) #[0, 1, 2, 3, 4]

ඉන්පසුව, ඔබට නිශ්චිත තීරුවක් ඉදිරිපස දෙසට ගෙනයාමට ලැම්බඩා භාවිතා කළ හැකිය:

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

පෙරළීම බොහෝ විට උපකාරී වේ.

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

නැතහොත් බැලීමට පමණක් මාරු වන්න.

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

"ටී" භාවිතා කරන්නේ කෙසේද?

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

loclocker: සියලු තීරුවල නම් හරියටම නොදන්නා දත්ත රාමුවකින් තීරු දෙකක් ඉදිරියට ගෙන ඒමට මට අවශ්‍ය වූ නිසා ඔබේ විසඳුම මට බෙහෙවින් උපකාරී විය. එබැවින්, ඔබ එකම තත්වයක සිටී නම්: ඔබ නම දන්නා තීරු ඉදිරියෙන් ගෙන ඒම සහ "අනෙක් සියලුම තීරු" අනුගමනය කිරීමට ඉඩ දීම සඳහා, මම පහත සඳහන් පොදු විසඳුම ඉදිරිපත් කළෙමි;

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]

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

මා වෙනුවෙන් වැඩ කළ ඉතා සරල විසඳුමක් වන්නේ .reindex df.columns මත භාවිතා කිරීමයි:

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

ඔබ ස්ථානය නොදන්නා විට තීරු ඉවත් කිරීම සඳහා කට්ටල ක්‍රියාකාරිත්වය භාවිතා කිරීමට ෂෝරෙෂ්ගේ පිළිතුරට මම කැමතියි , කෙසේ වෙතත් මුල් තීරු අනුපිළිවෙල (අත්තනෝමතික තීරු ලේබල ඇති) තබා ගැනීමට අවශ්‍ය බැවින් මෙය මගේ අරමුණ සඳහා ක්‍රියාත්මක නොවීය.

භාවිතා වුවද මම වැඩ කිරීමට මෙම වී IndexedSet මෙම boltons පැකේජය සිට.

මට තීරු ලේබල් කිහිපයක් නැවත එක් කිරීමට අවශ්‍ය විය, එබැවින් වඩාත් සාමාන්‍ය අවස්ථාවක් සඳහා මම පහත කේතය භාවිතා කළෙමි:

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

සාමාන්‍ය විසඳුමක් සඳහා මෙම ත්‍රෙඩ් එක සොයන ඕනෑම කෙනෙකුට මෙය ප්‍රයෝජනවත් වේ යැයි සිතමු.

ඕනෑම තීරු ගණනක් සඳහා මෙය කිරීමට ශ්‍රිතයක් මෙන්න.

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

මෙම ප්‍රශ්නයට මීට පෙර පිළිතුරු ලබා දී ඇති නමුත් reindex_axis දැන් අතහැර දමා ඇත, එබැවින් මම භාවිතා කිරීමට යෝජනා කරමි:

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

පොතේ හැකීස්ට් ක්‍රමය

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

මෙන්න මේ සඳහා ඉතා සරල පිළිතුරකි (එක් පේළියක් පමණි).

පහත දැක්වෙන පරිදි ඔබේ ඩීඑෆ් වෙත 'එන්' තීරුව එකතු කිරීමෙන් පසුව ඔබට එය කළ හැකිය.

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

මම විශ්වාස කරනවා @ අනෙක් තීරුවේ පිහිටීම ඔබ දන්නේ නම් අමන්ගේ පිළිතුර හොඳම ය.

ඔබ සිටින ස්ථානය නොදන්නා 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