पंडों में तालिका के सामने नाम से स्तंभ ले जाएँ

Question

यहाँ मेरा df है:

                             Net   Upper   Lower  Mid  Zsore
Answer option                                                
More than once a day          0%   0.22%  -0.12%   2    65 
Once a day                    0%   0.32%  -0.19%   3    45
Several times a week          2%   2.45%   1.10%   4    78
Once a week                   1%   1.63%  -0.40%   6    65

मैं "Mid"तालिका के सामने ( ) नाम से ( ) नाम से एक कॉलम को कैसे स्थानांतरित कर सकता हूं । यह वही है जो परिणाम की तरह दिखना चाहिए:

                             Mid   Upper   Lower  Net  Zsore
Answer option                                                
More than once a day          2   0.22%  -0.12%   0%    65 
Once a day                    3   0.32%  -0.19%   0%    45
Several times a week          4   2.45%   1.10%   2%    78
Once a week                   6   1.63%  -0.40%   1%    65

मेरा वर्तमान कोड कॉलम को इंडेक्स द्वारा df.columns.tolist()स्थानांतरित करता है, लेकिन मैं इसे नाम से स्थानांतरित करना चाहता हूं।

Answer 1

हम ixएक सूची पास करके पुन: उपयोग कर सकते हैं :

In [27]:
# get a list of columns
cols = list(df)
# move the column to head of list using index, pop and insert
cols.insert(0, cols.pop(cols.index('Mid')))
cols
Out[27]:
['Mid', 'Net', 'Upper', 'Lower', 'Zsore']
In [28]:
# use ix to reorder
df = df.ix[:, cols]
df
Out[28]:
                      Mid Net  Upper   Lower  Zsore
Answer_option                                      
More_than_once_a_day    2  0%  0.22%  -0.12%     65
Once_a_day              3  0%  0.32%  -0.19%     45
Several_times_a_week    4  2%  2.45%   1.10%     78
Once_a_week             6  1%  1.63%  -0.40%     65

एक अन्य विधि स्तंभ का संदर्भ लेना और इसे सामने लाना है:

In [39]:
mid = df['Mid']
df.drop(labels=['Mid'], axis=1,inplace = True)
df.insert(0, 'Mid', mid)
df
Out[39]:
                      Mid Net  Upper   Lower  Zsore
Answer_option                                      
More_than_once_a_day    2  0%  0.22%  -0.12%     65
Once_a_day              3  0%  0.32%  -0.19%     45
Several_times_a_week    4  2%  2.45%   1.10%     78
Once_a_week             6  1%  1.63%  -0.40%     65

आप locउसी परिणाम को प्राप्त करने के लिए भी उपयोग कर सकते हैं ixजैसा कि 0.20.0आगे के पांडा के भविष्य के संस्करण में पदावनत किया जाएगा :

df = df.loc[:, cols]

Answer 2

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

सामने का स्तंभ:

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

या यदि इसके बजाय, आप इसे पीछे ले जाना चाहते हैं:

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

या यदि आप एक से अधिक कॉलम स्थानांतरित करना चाहते हैं:

cols_to_move = ['Mid', 'Zsore']
df           = df[ cols_to_move + [ col for col in df.columns if col not in cols_to_move ] ]

Comments

किसी और के लिए, आप विकल्प का उपयोग 3. एकाधिक स्तंभों के साथ विकल्प 1 नहीं हटेंगे एकाधिक स्तंभों के लिए सुनिश्चित कर लें Midऔर Zscoreमूल स्थिति से स्तंभ से। मुझे यह पता लगाने में Grouperत्रुटि हुई कि जब एक ही कॉलम दो बार था, तो समूह बनाने की कोशिश कर रहा था।

— 775

Answer 3

आप पंडों में df.reindex () फ़ंक्शन का उपयोग कर सकते हैं। df है

                      Net  Upper   Lower  Mid  Zsore
Answer option                                      
More than once a day  0%  0.22%  -0.12%    2     65
Once a day            0%  0.32%  -0.19%    3     45
Several times a week  2%  2.45%   1.10%    4     78
Once a week           1%  1.63%  -0.40%    6     65

स्तंभ नामों की सूची परिभाषित करें

cols = df.columns.tolist()
cols
Out[13]: ['Net', 'Upper', 'Lower', 'Mid', 'Zsore']

आप जहां चाहें कॉलम का नाम ले जाएं

cols.insert(0, cols.pop(cols.index('Mid')))
cols
Out[16]: ['Mid', 'Net', 'Upper', 'Lower', 'Zsore']

फिर df.reindex()फ़ंक्शन को फिर से उपयोग करने के लिए

df = df.reindex(columns= cols)

आउट पुट है: df

                      Mid  Upper   Lower Net  Zsore
Answer option                                      
More than once a day    2  0.22%  -0.12%  0%     65
Once a day              3  0.32%  -0.19%  0%     45
Several times a week    4  2.45%   1.10%  2%     78
Once a week             6  1.63%  -0.40%  1%     65

Answer 4

मैं इस समाधान को पसंद करता हूं:

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

यह अन्य सुझाए गए उत्तरों की तुलना में पढ़ने में तेज और सरल है।

def move_column_inplace(df, col, pos):
    col = df.pop(col)
    df.insert(pos, col.name, col)

---

प्रदर्शन का आंकलन:

इस परीक्षण के लिए, प्रत्येक पुनरावृत्ति में वर्तमान में अंतिम कॉलम को सामने की ओर ले जाया जाता है। इन-प्लेस विधियां आम तौर पर बेहतर प्रदर्शन करती हैं। जबकि सिटीनॉर्मन के समाधान को इन-प्लेस बनाया जा सकता है, एड चुम की विधि .locऔर साचिनम की विधि आधारित reindexनहीं हो सकती है।

जबकि अन्य विधियां सामान्य हैं, शहरनॉर्मन का समाधान सीमित है pos=0। मैंने किसी भी प्रदर्शन अंतर के बीच अंतर नहीं किया , df.loc[cols]और df[cols]यही वजह है कि मैंने कुछ अन्य सुझावों को शामिल नहीं किया।

मैंने मैकबुक प्रो (मध्य 2015) पर अजगर 3.6.8 और पांडा 0.24.2 के साथ परीक्षण किया।

import numpy as np
import pandas as pd

n_cols = 11
df = pd.DataFrame(np.random.randn(200000, n_cols),
                  columns=range(n_cols))

def move_column_inplace(df, col, pos):
    col = df.pop(col)
    df.insert(pos, col.name, col)

def move_to_front_normanius_inplace(df, col):
    move_column_inplace(df, col, 0)
    return df

def move_to_front_chum(df, col):
    cols = list(df)
    cols.insert(0, cols.pop(cols.index(col)))
    return df.loc[:, cols]

def move_to_front_chum_inplace(df, col):
    col = df[col]
    df.drop(col.name, axis=1, inplace=True)
    df.insert(0, col.name, col)
    return df

def move_to_front_elpastor(df, col):
    cols = [col] + [ c for c in df.columns if c!=col ]
    return df[cols] # or df.loc[cols]

def move_to_front_sachinmm(df, col):
    cols = df.columns.tolist()
    cols.insert(0, cols.pop(cols.index(col)))
    df = df.reindex(columns=cols, copy=False)
    return df

def move_to_front_citynorman_inplace(df, col):
    # This approach exploits that reset_index() moves the index
    # at the first position of the data frame.
    df.set_index(col, inplace=True)
    df.reset_index(inplace=True)
    return df

def test(method, df):
    col = np.random.randint(0, n_cols)
    method(df, col)

col = np.random.randint(0, n_cols)
ret_mine = move_to_front_normanius_inplace(df.copy(), col)
ret_chum1 = move_to_front_chum(df.copy(), col)
ret_chum2 = move_to_front_chum_inplace(df.copy(), col)
ret_elpas = move_to_front_elpastor(df.copy(), col)
ret_sach = move_to_front_sachinmm(df.copy(), col)
ret_city = move_to_front_citynorman_inplace(df.copy(), col)

# Assert equivalence of solutions.
assert(ret_mine.equals(ret_chum1))
assert(ret_mine.equals(ret_chum2))
assert(ret_mine.equals(ret_elpas))
assert(ret_mine.equals(ret_sach))
assert(ret_mine.equals(ret_city))

परिणाम :

# For n_cols = 11:
%timeit test(move_to_front_normanius_inplace, df)
# 1.05 ms ± 42.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
%timeit test(move_to_front_citynorman_inplace, df)
# 1.68 ms ± 46.1 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
%timeit test(move_to_front_sachinmm, df)
# 3.24 ms ± 96.5 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit test(move_to_front_chum, df)
# 3.84 ms ± 114 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit test(move_to_front_elpastor, df)
# 3.85 ms ± 58.3 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit test(move_to_front_chum_inplace, df)
# 9.67 ms ± 101 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)


# For n_cols = 31:
%timeit test(move_to_front_normanius_inplace, df)
# 1.26 ms ± 31.6 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit test(move_to_front_citynorman_inplace, df)
# 1.95 ms ± 260 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit test(move_to_front_sachinmm, df)
# 10.7 ms ± 348 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit test(move_to_front_chum, df)
# 11.5 ms ± 869 µs per loop (mean ± std. dev. of 7 runs, 100 loops each
%timeit test(move_to_front_elpastor, df)
# 11.4 ms ± 598 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit test(move_to_front_chum_inplace, df)
# 31.4 ms ± 1.89 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

Comments

महान समाधान। हालाँकि, हमें मूल df में सम्मिलित कॉलम के साथ संशोधित df को स्पष्ट रूप से निर्दिष्ट नहीं करना चाहिए। इसलिए इसके बजाय df = df.insert(0, col.name, col)हमें करने की जरूरत है df.insert(0, col.name, col)। आपके पास फ़ंक्शन में यह सही है, move_column_inplace()हालांकि।

— मेलीहॉजबेक

साभार @normanius डेक्सटर की प्रयोगशाला में मैं कड़ी मेहनत कर रहा हूँ। :-) महान समाधान। ओकेम का रेजर। सरल और सुरुचिपूर्ण।

— ब्रजियो

मैं इस समाधान को भी पसंद करता हूं :)

— user88484

Answer 5

मुझे यह पसंद नहीं आया कि मुझे अन्य समाधानों में अन्य सभी स्तंभों को स्पष्ट रूप से कैसे निर्दिष्ट करना है, इसलिए यह मेरे लिए सबसे अच्छा काम करता है। हालांकि यह बड़े डेटाफ्रेम के लिए धीमा हो सकता है ...?

df = df.set_index('Mid').reset_index()

Comments

यह शोषण करता है कि reset_index()पहली स्थिति में गिरा सूचकांक डालें। हालाँकि, ध्यान दें कि यह व्यवहार डॉक्स में निर्दिष्ट नहीं है ।

— ३

प्रदर्शन के लिए, मेरा उत्तर देखें। यह inplace=Trueदोनों के लिए उपयोग करने के लिए फायदेमंद है set_index()और reset_index()।

— ३.२

Answer 6

यहां कोड का एक सामान्य सेट है जिसे मैं अक्सर कॉलम की स्थिति को पुनर्व्यवस्थित करने के लिए उपयोग करता हूं। आपको यह उपयोगी लग सकता है।

cols = df.columns.tolist()
n = int(cols.index('Mid'))
cols = [cols[n]] + cols[:n] + cols[n+1:]
df = df[cols]

Comments

आदर्श रूप से, अपने उत्तर की व्याख्या करें और क्या यह एक अच्छा समाधान बनाता है, और न केवल कोड का एक टुकड़ा पोस्ट करें। आप नीचे की ओर बढ़ रहे हैं

— टेजो

Answer 7

किसी DataFrame की पंक्तियों को फिर से व्यवस्थित करने के लिए बस एक सूची का उपयोग करें।

df = df[['Mid', 'Net', 'Upper', 'Lower', 'Zsore']]

यह बहुत स्पष्ट करता है कि बाद में कोड पढ़ते समय क्या किया गया था। इसका भी प्रयोग करें:

df.columns
Out[1]: Index(['Net', 'Upper', 'Lower', 'Mid', 'Zsore'], dtype='object')

फिर काटें और फिर से पेस्ट करें।

---

कई स्तंभों वाले डेटाफ़्रेम के लिए, स्तंभ की सूची को एक चर में संग्रहीत करें और वांछित कॉलम को सूची के सामने रखें। यहाँ एक उदाहरण है:

cols = [str(col_name) for col_name in range(1001)]
data = np.random.rand(10,1001)
df = pd.DataFrame(data=data, columns=cols)

mv_col = cols.pop(cols.index('77'))
df = df[[mv_col] + cols]

अब df.columnsहै।

Index(['77', '0', '1', '2', '3', '4', '5', '6', '7', '8',
       ...
       '991', '992', '993', '994', '995', '996', '997', '998', '999', '1000'],
      dtype='object', length=1001)

Comments

यदि आप 1001 कॉलम वाले डेटाफ़्रेम के साथ काम करते हैं तो क्या होगा?

— normanius

अवधारणा समान है, हालांकि कई स्तंभों के साथ कॉलम को एक सूची में संग्रहीत किया जाना चाहिए और सूची में हेरफेर किया जाना चाहिए। एक उदाहरण के लिए ऊपर मेरे संपादन देखें। मेरा उदाहरण प्रभावी रूप से stackoverflow.com/a/51009742/5827921 के समान है ।

— डस्टिन हेलविवेल

Answer 8

यहाँ इसका बहुत ही सरल उत्तर है।

स्तंभों के नामों के चारों ओर दो ()) 'कोष्ठक' न भूलें। इसके अलावा, यह आपको एक त्रुटि देगा।

# here you can add below line and it should work 
df = df[list(('Mid','Upper', 'Lower', 'Net','Zsore'))]
df

                             Mid   Upper   Lower  Net  Zsore
Answer option                                                
More than once a day          2   0.22%  -0.12%   0%    65 
Once a day                    3   0.32%  -0.19%   0%    45
Several times a week          4   2.45%   1.10%   2%    78
Once a week                   6   1.63%  -0.40%   1%    65

Comments

स्पष्ट रूप से ओपी स्पष्ट रूप से कॉलम नामों को स्पष्ट नहीं करना चाहता है। बहुत विस्तृत डेटाफ़्रेम वाले कुछ मामलों में यह संभव भी नहीं हो सकता है।

— लेजर यू

Answer 9

सबसे सरल बात आप कोशिश कर सकते हैं:

df=df[[ 'Mid',   'Upper',   'Lower', 'Net'  , 'Zsore']]