DataFrame कॉलम के क्रम को कैसे बदलें?

Question

मेरे पास निम्नलिखित हैं DataFrame( df):

import numpy as np
import pandas as pd

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

मैं असाइनमेंट द्वारा और कॉलम जोड़ता हूं:

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

मैं कॉलम meanको सामने की ओर कैसे ले जा सकता हूं , अर्थात इसे दूसरे कॉलम के क्रम से अछूता छोड़कर पहला कॉलम सेट कर सकता हूं ?

Comments

पाइथन पंडों के

— लॉरेंस

एक सामान्यीकृत NumPy- आधारित समाधान के लिए एक पंडों के डेटाफ्रेम में एक कॉलम को स्थानांतरित करने का तरीका देखें , केवल एक कॉलम स्तर मान लेता है, अर्थात नहीं MultiIndex।

— जेपी

Answer 1

एक आसान तरीका यह होगा कि डेटाफ़्रेम को कॉलम की एक सूची के साथ फिर से असाइन किया जाए, जिसे आवश्यकतानुसार पुनर्व्यवस्थित किया जाए।

अब आपके पास यही है:

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

Comments

अगर आपको "स्ट्रैट" और 'लिस्ट' ऑब्जेक्ट्स नहीं मिला सकते हैं, तो सुनिश्चित करें कि आप जुकाम में: [cols = [cols [7]] + cols [: 7] + cols [8:]

— moeabdol

@FooBar यह एक सेट यूनियन नहीं है यह दो आदेशित सूचियों का एक संयोजन है।

— अमन

@Aman मैं इंगित कर रहा हूं कि आपका कोड हटा दिया गया है। आपके पद को संभालना आपके विवेक पर है।

— फूबार

@ फूबर, का प्रकार colsहै list; यह डुप्लिकेट को भी अनुमति देता है (जो डेटाफ़्रेम पर उपयोग किए जाने पर छोड़ दिया जाएगा)। आप Indexवस्तुओं के बारे में सोच रहे हैं ।

— एलेक्सिस

इसका मतलब है कि सभी डेटा की नकल करना, जो अत्यधिक अक्षम है। मेरी इच्छा थी कि पंडों के पास ऐसा तरीका हो जो बिना कॉपी तैयार किए हो।

— कॉन्सटेंटिन

Answer 2

आप भी कुछ ऐसा कर सकते हैं:

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

आप स्तंभों की सूची प्राप्त कर सकते हैं:

cols = list(df.columns.values)

उत्पादन होगा:

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

... जो पहले फ़ंक्शन में छोड़ने से पहले मैन्युअल रूप से पुनर्व्यवस्थित करना आसान है

Comments

आप सूची के साथ स्तंभों की सूची भी प्राप्त कर सकते हैं (df.columns)

— जिम

याdf.columns.tolist()

— जिम

मेरे जैसे नए लोगों के लिए, आपको उस सूची को फिर से व्यवस्थित करें जो आपको कॉल से मिलती है। फिर df = df [cols] यानी फिर से व्यवस्थित सूची कोष्ठक के केवल एक सेट के बिना पहली अभिव्यक्ति में गिरा दिया जाता है।

— सिड

कॉलम नाम 3.x में पूर्णांक हो जाएगा df = df[['mean1', 0, 1, 2, 3]]✓

— prosti

मुझे नहीं लगता कि यह एक अच्छा जवाब है क्योंकि यह कोड प्रदान नहीं करता है कि किसी भी डेटाफ़्रेम के कॉलम क्रम को कैसे बदला जाए। कहो मैं एक सीएसवी फ़ाइल को पांडा के रूप में पीडी के रूप में आयात करता हूं pd.read_csv()। कॉलम ऑर्डर को बदलने के लिए आपके उत्तर का उपयोग कैसे किया जा सकता है?

— रोबव जूल

Answer 3

आप उन्हें चाहते हैं उसी क्रम में कॉलम नाम निर्दिष्ट करें:

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

Comments

क्या यह एक प्रतिलिपि बनाता है?

— user3226167

@ निकोलस मॉर्ले - आपके df में 1000 कॉलम होने पर यह सबसे अच्छा उत्तर नहीं है।

— AGS

ऐसा लगता नहीं है कि आप <df>.columnsशुरू में दावा करना पसंद कर रहे हैं

— Bjorks नंबर एक प्रशंसक

कम संख्या में कॉलम के लिए यह सबसे अच्छा उत्तर है।

— डोंगकु चोई

यह सिर्फ @freddygv के पहले के उत्तर की एक प्रति है। यह एक स्वीकृत उत्तर होना चाहिए, यह नहीं।

— जेम्स हिर्सचोर्न

Answer 4

कैसा रहेगा:

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

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

Comments

क्या यह भविष्य की विशेषता हो सकती है pandas? कुछ पसंद है df.move(0,df.mean)?

— जेसन

अरे यार, यह भी इस तरह काम करता है df_metadata.insert(0,'Db_name',"raw_data")(कोड इस धागे के लिए प्रासंगिक नहीं)

— एटोस

सुंदर। और यह जगह में भी होता है।

— cucu8

यह एक स्केलेबल समाधान है क्योंकि अन्य समाधान मैन्युअल रूप से कॉलम नाम टाइप कर रहे हैं।

— CKM

यह ओपी के सवाल के लिए काम करता है, जब एक नया कॉलम बनाता है, लेकिन यह एक कॉलम को स्थानांतरित करने के लिए नहीं है; परिणाम का प्रयास करने के लिए*** ValueError: cannot insert mean, already exists

— स्पिनअप

Answer 5

आपके मामले में,

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

Comments

मैंने सेट करने की कोशिश की, copy=Falseलेकिन ऐसा लगता है कि reindex_axisअभी भी एक कॉपी बनाता है।

— कॉन्स्टेंटिन

@Konstantin क्या आप इस मुद्दे के बारे में एक और प्रश्न बना सकते हैं? अधिक संदर्भ के लिए बेहतर होगा

— अलावरो जोआओ

Answer 6

आपको वांछित क्रम में अपने स्तंभों की एक नई सूची बनाने की आवश्यकता है, फिर 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]

Answer 7

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 total, कुल: 1.08 ms दीवार समय: 995 µs

समाधान 2 :

CPU समय: उपयोगकर्ता 933 :s, sys: 0 ns, कुल: 933 times दीवार समय: 800 33s

समाधान 3 :

CPU समय: उपयोगकर्ता 0 ns, sys: 1.35 एमएस, कुल: 1.35 एमएस दीवार समय: 1.08 एमएस

समाधान 4 :

CPU समय: उपयोगकर्ता 1.23 ms, sys: 45 total, कुल: 1.27 एमएस दीवार समय: 986 23s

समाधान 5 :

CPU समय: उपयोगकर्ता 1.09 ms, sys: 19 9s, कुल: 1.11 एमएस दीवार समय: 949 9s

समाधान 6 :

CPU समय: उपयोगकर्ता 955 55s, sys: 34 totals, कुल: 989 times दीवार समय: 85% 55

Comments

इतना सुन्दर जवाब, धन्यवाद।

— क़ासिमालबाकली

समाधान 1 जो मुझे चाहिए था क्योंकि मेरे पास बहुत सारे कॉलम हैं (53), धन्यवाद

— रत्नेश

@ गर्ल वॉच वैल्यू से पता चलता है कि असली कॉमसुम टाइम है? (उपयोगकर्ता, sys, कुल या दीवार का समय)

— sergzemsk

यह मेरे लिए समस्या का सबसे अच्छा जवाब है। इतने सारे समाधान (एक जिसकी मुझे ज़रूरत थी सहित) और सरल दृष्टिकोण। धन्यवाद!

— गुस्तावो रॉटगैरिंग

समाधान 6 (कोई सूची समझ नहीं):df = df.iloc[:, [1, 2, 3, 0]]

— दिमित्री कार्य

Answer 8

अगस्त 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

इस दृष्टिकोण के साथ मुख्य समस्या यह है कि एक ही कोड को कई बार कॉल करने से हर बार अलग परिणाम बनेंगे, इसलिए किसी को सावधान रहने की आवश्यकता है :)

Answer 9

यह फ़ंक्शन आपको उनमें से कुछ को ऑर्डर करने के लिए अपने डेटासेट में प्रत्येक चर को सूचीबद्ध करने से बचता है।

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 

इसमें दो तर्क दिए गए हैं, पहला डेटासेट है, दूसरा डेटा सेट के कॉलम हैं जिन्हें आप सामने लाना चाहते हैं।

तो मेरे मामले में मेरे पास एक डेटा सेट है जिसे फ़्रेम ए 1, ए 2, ए 2, बी 1, बी 2, कुल और तारीख के साथ कहा जाता है। अगर मुझे कुल को सामने लाना है तो मुझे बस इतना करना है:

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

अगर मैं टोटल और डेट को सामने लाना चाहता हूं तो मैं यह करता हूं:

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

संपादित करें:

इसका उपयोग करने का एक और उपयोगी तरीका है, यदि आपके पास कोई अपरिचित तालिका है और आप VAR1, VAR2 जैसे किसी विशेष शब्द के साथ चर देख रहे हैं, तो आप कुछ ऐसा निष्पादित कर सकते हैं:

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

Answer 10

मैं खुद भी इसी तरह के सवाल पर भागा था, और जो कुछ मैंने तय किया था उसे जोड़ना चाहता था। मुझे 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लगता है, मुझे लगता है कि मैं इसके निर्देशन के लिए बाद को पसंद करता हूं।

Comments

यह एक अच्छा समाधान था, लेकिन reindex_axis को हटा दिया जाएगा। मैंने reindex का उपयोग किया, और यह ठीक काम किया।

— जॉर्ज

Answer 11

बस करो,

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

Comments

TypeError: अंतर्निहित रूप से 'int' ऑब्जेक्ट को परिवर्तित नहीं कर सकते हैं

— parvij

एपीआई बदल सकता है, आप यह भी कर सकते हैं ... order = df.columns.tolist() df['mean'] = df.mean(1) df.columns = ['mean'] + order

— नेपिटुपुलु जॉन

इस भिन्नता ने मेरे लिए अच्छा काम किया। एक मौजूदा सूची के साथ, headersइसका उपयोग एक तानाशाही बनाने के लिए किया गया था जो तब डेटाफ़्रेम बनाने के लिए उपयोग किया जाता था, मैंने कॉल किया df.reindex(columns=headers)। एकमात्र समस्या जो मैं भाग गया था, मुझे पहले से ही फोन किया गया था df.set_index('some header name', inplace=True), इसलिए जब रेनडेक्स किया गया था, तो इसने एक और कॉलम जोड़ा था जिसका नाम some header nameमूल कॉलम था अब सूचकांक था। ऊपर वर्णित वाक्यविन्यास के लिए, ['mean'] + df.columnsअजगर दुभाषिया में मुझे देता हैIndex(u'meanAddress', u'meanCity', u'meanFirst Name'...

— hlongmore

@ लोंगमोर: मुझे नहीं पता कि आपका पूर्व कोड क्या है, लेकिन संपादन में काम करना चाहिए (0.19.2 का उपयोग करके)

— नेपिटुपुलु जॉन

संपादन वास्तव में काम करता है (मैं 0.20.2 पर हूं)। मेरे मामले में, मुझे पहले से ही मेरे इच्छित कॉलम मिल गए हैं, इसलिए मुझे लगता है कि df.reindex () वही है जो मुझे वास्तव में उपयोग करना चाहिए।

— हलोंमोर

Answer 12

आप निम्नलिखित कर सकते हैं (अमन के जवाब से पुर्जे उधार लेना):

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

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

df = df[cols]

Answer 13

जिस कॉलम का नाम आप बदलना चाहते हैं, उसे टाइप करें और नए स्थान के लिए इंडेक्स सेट करें।

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)

Comments

यह

— रेखांकित किया गया है

Answer 14

किसी भी कॉलम को किसी भी स्थिति में ले जाना:

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]

Answer 15

मुझे लगता है कि यह एक छोटा सा समाधान है:

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

यह समाधान कुछ हद तक @JoeHeffer के समाधान के समान है लेकिन यह एक लाइनर है।

यहां हम कॉलम "mean"को डेटाफ्रेम से हटाते हैं और इसे 0उसी कॉलम नाम के साथ इंडेक्स से जोड़ते हैं ।

Answer 16

यहां एक मौजूदा कॉलम को स्थानांतरित करने का एक तरीका है जो मौजूदा डेटा फ्रेम को जगह में बदल देगा।

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

Answer 17

इस प्रश्न का उत्तर दिया गया है इससे पहले कि लेकिन reindex_axis अब पदावनत है तो मैं उपयोग करने के लिए सुझाव है:

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

Comments

नहीं, वह अलग है। वहाँ उपयोगकर्ता नाम से सभी स्तंभों को क्रमबद्ध करना चाहता है। यहाँ वे एक कॉलम को पहले कॉलम पर ले जाना चाहते हैं जबकि दूसरे कॉलम के ऑर्डर को अछूता छोड़ते हैं।

— एसएमसीआई

यदि आप उन्हें छांटना नहीं चाहते तो क्या होगा?

— चन्नी पाठक

यह प्रति लौटाता है, इन-प्लेस काम नहीं करता है

— २३:१५ पर

Answer 18

कैसे "टी" का उपयोग कर के बारे में?

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

Answer 19

@ क्लोकर: आपका समाधान मेरे लिए बहुत मददगार था, क्योंकि मैं एक डेटाफ़्रेम से दो कॉलम सामने लाना चाहता था, जहाँ मुझे सभी कॉलमों के नाम ठीक-ठीक नहीं पता हैं, क्योंकि वे पहले एक धुरी कथन से उत्पन्न होते हैं। इसलिए, यदि आप एक ही स्थिति में हैं: सामने कॉलम लाने कि आप का नाम पता है और फिर उन्हें "सभी स्तंभों" से अनुसरण करने दें करने के लिए, मैं निम्नलिखित सामान्य समाधान के साथ आया,

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

Answer 20

set():

एक सरल दृष्टिकोण का उपयोग कर रहा है set(), विशेष रूप से जब आपके पास स्तंभों की एक लंबी सूची है और उन्हें मैन्युअल रूप से संभालना नहीं चाहते हैं:

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

Comments

एक सावधानी: यदि आप इसे सेट में रखते हैं तो स्तंभों का क्रम

— समाप्त

दिलचस्प! @ user1930402 मैंने कई मौकों पर ऊपर के दृष्टिकोण की कोशिश की है और कभी कोई समस्या नहीं हुई। मैं दोबारा जांच कराऊंगा।

— शोरेश

Answer 21

मैं इसे पसंद किया Shoresh के जवाबजब आप स्थान नहीं जानते हैं, तो स्तंभों को हटाने के लिए सेट कार्यक्षमता का उपयोग करने के लिए , हालांकि यह मेरे उद्देश्य के लिए काम नहीं किया क्योंकि मुझे मूल कॉलम ऑर्डर (जिसमें मनमाना कॉलम लेबल) रखने की आवश्यकता है।

मुझे यह काम करने के लिए मिला है, लेकिन बोल्टसेट पैकेज से IndexedSet का उपयोग करके ।

मुझे कई कॉलम लेबलों को फिर से जोड़ने की आवश्यकता थी, इसलिए एक अधिक सामान्य मामले के लिए मैंने निम्नलिखित कोड का उपयोग किया:

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

आशा है कि यह किसी के लिए एक सामान्य समाधान के लिए इस धागे को खोजने के लिए उपयोगी है।

Comments

मैं थोड़ा हैरान हूं! मैं setइस उद्देश्य के लिए बहुत बार उपयोग करता हूं और कभी भी ऑर्डर देने से निपटना नहीं था।

— शोरेश

Answer 22

आप उपयोग कर सकते हैं 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

Answer 23

यहां किसी भी संख्या में कॉलम के लिए ऐसा करने के लिए एक फ़ंक्शन है।

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

Answer 24

पुस्तक में हैकिएस्ट विधि

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

Answer 25

मुझे लगता है कि यह कार्य अधिक सीधा है। आपको बस शुरुआत या अंत या दोनों पर कॉलम का सबसेट निर्दिष्ट करना होगा:

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]

Answer 26

मेरा मानना है कि अगर आप दूसरे कॉलम का स्थान जानते हैं तो अमन का जवाब सबसे अच्छा है।

यदि आपको इसके स्थान का पता नहीं है 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

Answer 27

बस फ़्लिप करना अक्सर मदद करता है।

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

या सिर्फ एक नज़र के लिए फेरबदल।

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

Answer 28

अधिकांश उत्तरों ने पर्याप्त रूप से सामान्यीकरण नहीं किया और पांडा reindex_axis विधि थोड़ा थकाऊ है, इसलिए मैं एक शब्दकोश में किसी भी स्थिति में कॉलम की मनमानी संख्या को स्थानांतरित करने के लिए एक सरल फ़ंक्शन प्रदान करता हूं जहां कुंजी = स्तंभ नाम और मान = स्थिति को स्थानांतरित करने के लिए। यदि आपका डेटाफ्रेम बड़े पास ट्रू '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]

Answer 29

पंडों में कॉलम नामों को फिर से आदेश देने के लिए मेरे पास एक बहुत विशिष्ट उपयोग का मामला है। कभी-कभी मैं डेटाफ़्रेम में एक नया कॉलम बना रहा हूं जो मौजूदा कॉलम पर आधारित है। डिफ़ॉल्ट रूप से पांडा मेरे नए कॉलम को अंत में सम्मिलित करेंगे, लेकिन मैं चाहता हूं कि जो नया कॉलम मौजूदा कॉलम से लिया गया है, उसके बगल में डाला जाए।

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)

Answer 30

मेरे लिए काम करने वाला एक बहुत ही सरल समाधान dre.columns पर .reindex का उपयोग करना है:

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