पंडों - स्तंभों में एक पदानुक्रमित सूचकांक को कैसे समतल करना है

325

मेरे पास अक्ष 1 (कॉलम) (एक groupby.aggऑपरेशन से) में एक पदानुक्रमित सूचकांक के साथ एक डेटा फ्रेम है :

     USAF   WBAN  year  month  day  s_PC  s_CL  s_CD  s_CNT  tempf       
                                     sum   sum   sum    sum   amax   amin
0  702730  26451  1993      1    1     1     0    12     13  30.92  24.98
1  702730  26451  1993      1    2     0     0    13     13  32.00  24.98
2  702730  26451  1993      1    3     1    10     2     13  23.00   6.98
3  702730  26451  1993      1    4     1     0    12     13  10.04   3.92
4  702730  26451  1993      1    5     3     0    10     13  19.94  10.94

मैं इसे समतल करना चाहता हूं, ताकि यह ऐसा लगे (नाम महत्वपूर्ण नहीं हैं - मैं नाम बदल सकता हूं):

     USAF   WBAN  year  month  day  s_PC  s_CL  s_CD  s_CNT  tempf_amax  tmpf_amin   
0  702730  26451  1993      1    1     1     0    12     13  30.92          24.98
1  702730  26451  1993      1    2     0     0    13     13  32.00          24.98
2  702730  26451  1993      1    3     1    10     2     13  23.00          6.98
3  702730  26451  1993      1    4     1     0    12     13  10.04          3.92
4  702730  26451  1993      1    5     3     0    10     13  19.94          10.94

मैं यह कैसे करु? (मैंने बहुत कोशिश की, कोई फायदा नहीं हुआ।)

एक सुझाव के अनुसार, यहाँ प्रमुख रूप में सिर है

{('USAF', ''): {0: '702730',
  1: '702730',
  2: '702730',
  3: '702730',
  4: '702730'},
 ('WBAN', ''): {0: '26451', 1: '26451', 2: '26451', 3: '26451', 4: '26451'},
 ('day', ''): {0: 1, 1: 2, 2: 3, 3: 4, 4: 5},
 ('month', ''): {0: 1, 1: 1, 2: 1, 3: 1, 4: 1},
 ('s_CD', 'sum'): {0: 12.0, 1: 13.0, 2: 2.0, 3: 12.0, 4: 10.0},
 ('s_CL', 'sum'): {0: 0.0, 1: 0.0, 2: 10.0, 3: 0.0, 4: 0.0},
 ('s_CNT', 'sum'): {0: 13.0, 1: 13.0, 2: 13.0, 3: 13.0, 4: 13.0},
 ('s_PC', 'sum'): {0: 1.0, 1: 0.0, 2: 1.0, 3: 1.0, 4: 3.0},
 ('tempf', 'amax'): {0: 30.920000000000002,
  1: 32.0,
  2: 23.0,
  3: 10.039999999999999,
  4: 19.939999999999998},
 ('tempf', 'amin'): {0: 24.98,
  1: 24.98,
  2: 6.9799999999999969,
  3: 3.9199999999999982,
  4: 10.940000000000001},
 ('year', ''): {0: 1993, 1: 1993, 2: 1993, 3: 1993, 4: 1993}}

python pandas dataframe

— रॉस आर
स्रोत

5

क्या आप df[:5].to_dict()अपने डेटासेट में पढ़ने के लिए दूसरों के उदाहरण के रूप में आउटपुट जोड़ सकते हैं ?

— ज़ेलाज़ी 7

अच्छा विचार। क्या यह ऊपर था क्योंकि यह टिप्पणी के लिए बहुत लंबा था।

— रोस आर

इसके लिए एक समर्पित पद्धति को लागू करने के लिए pandasमुद्दा ट्रैकर पर एक सुझाव है ।

— जॉएलोस्टब्लोम जूल

2

@joelostblom और यह वास्तव में लागू किया गया है (पांडा 0.24.0 और ऊपर)। मैंने एक उत्तर पोस्ट किया है लेकिन अनिवार्य रूप से अब आप बस कर सकते हैं dat.columns = dat.columns.to_flat_index()। अंतर्निहित पांडा समारोह।

— केवल

471

मुझे लगता है कि ऐसा करने का सबसे आसान तरीका कॉलम को शीर्ष स्तर पर सेट करना होगा:

df.columns = df.columns.get_level_values(0)

नोट: यदि स्तर का एक नाम है, तो आप इसे 0 के बजाय, इसके द्वारा भी एक्सेस कर सकते हैं।

।

यदि आप joinअपने MultiIndex को एक इंडेक्स में संयोजित करना चाहते हैं (यह मानकर कि आपके कॉलम में आपके पास सिर्फ स्ट्रिंग प्रविष्टियाँ हैं) :

df.columns = [' '.join(col).strip() for col in df.columns.values]

नोट: stripजब कोई दूसरा इंडेक्स न हो तो हमें व्हाट्सएप करना चाहिए ।

In [11]: [' '.join(col).strip() for col in df.columns.values]
Out[11]: 
['USAF',
 'WBAN',
 'day',
 'month',
 's_CD sum',
 's_CL sum',
 's_CNT sum',
 's_PC sum',
 'tempf amax',
 'tempf amin',
 'year']

— एंडी हेडन
स्रोत

14

df.reset_index (inplace = True) एक वैकल्पिक समाधान हो सकता है।

— टोबियास

8

एक छोटी सी टिप्पणी ... यदि आप संयोजन बहुस्तरीय के लिए _ का उपयोग करना चाहते हैं .. तो आप इसका उपयोग कर सकते हैं ... df.columns = ['_'। (col) .strip () को df.columns में कॉल के लिए शामिल करें। मान]

— ihightower

30

मामूली शामिल होने के लिए अंडरस्कोर बनाए रखने के लिए मामूली संशोधन:['_'.join(col).rstrip('_') for col in df.columns.values]

— सेइजी आर्मस्ट्रांग

यह बहुत अच्छा काम करता है, अगर आप सिर्फ दूसरा कॉलम उपयोग करना चाहते हैं: df.columns = [col [1] कर्नल के लिए df.columns.values] में

— user3078500

1

यदि आप sum s_CDइसके बजाय उपयोग करना चाहते हैं s_CD sum, तो कोई भी कर सकता है df.columns = ['_'.join(col).rstrip('_') for col in [c[::-1] for c in df.columns.values]]।

— irene

82

pd.DataFrame(df.to_records()) # multiindex become columns and new index is integers only

— ग्लीब यारनिख
स्रोत

3

यह काम करता है, लेकिन स्तंभ नाम के पीछे छोड़ देता है जो प्रोग्रामेटिक रूप से एक्सेस करना मुश्किल है और क्वेरिएबल नहीं है

— dmeu

1

यह पांडा के नवीनतम संस्करण के साथ काम नहीं करेगा। यह 0.18 के साथ काम करता है लेकिन 0.20 के साथ नहीं (अब के रूप में नवीनतम)

— TH22

1

स्तंभ नामों को संरक्षित करने के लिए @dmeupd.DataFrame(df.to_records(), columns=df.index.names + list(df.columns))

— Teoretic

1

यह मेरे लिए स्तूप के नाम के रूप में स्तंभों को संरक्षित कर रहा है, और सूचकांक का उपयोग करने के लिए मैं रखता हूं:pd.DataFrame(df_volume.to_records(), index=df_volume.index).drop('index', axis=1)

— Jayen

54

इस थ्रेड पर वर्तमान सभी उत्तर थोड़े दिनांकित होने चाहिए। pandasसंस्करण के रूप में 0.24.0, वह .to_flat_index()करता है जो आपको चाहिए।

पांडा के अपने दस्तावेज से :

MultiIndex.to_flat_index ()

एक मल्टीआंडेक्स को स्तर मूल्यों वाले टुपल्स के सूचकांक में परिवर्तित करें।

इसके प्रलेखन से एक सरल उदाहरण:

import pandas as pd
print(pd.__version__) # '0.23.4'
index = pd.MultiIndex.from_product(
        [['foo', 'bar'], ['baz', 'qux']],
        names=['a', 'b'])

print(index)
# MultiIndex(levels=[['bar', 'foo'], ['baz', 'qux']],
#           codes=[[1, 1, 0, 0], [0, 1, 0, 1]],
#           names=['a', 'b'])

लागू to_flat_index():

index.to_flat_index()
# Index([('foo', 'baz'), ('foo', 'qux'), ('bar', 'baz'), ('bar', 'qux')], dtype='object')

मौजूदा `pandas`कॉलम को बदलने के लिए इसका उपयोग करना

आप इसका उपयोग कैसे करेंगे dat, इसका एक उदाहरण है , जो MultiIndexकॉलम के साथ डेटाफ़्रेम है :

dat = df.loc[:,['name','workshop_period','class_size']].groupby(['name','workshop_period']).describe()
print(dat.columns)
# MultiIndex(levels=[['class_size'], ['count', 'mean', 'std', 'min', '25%', '50%', '75%', 'max']],
#            codes=[[0, 0, 0, 0, 0, 0, 0, 0], [0, 1, 2, 3, 4, 5, 6, 7]])

dat.columns = dat.columns.to_flat_index()
print(dat.columns)
# Index([('class_size', 'count'),  ('class_size', 'mean'),
#     ('class_size', 'std'),   ('class_size', 'min'),
#     ('class_size', '25%'),   ('class_size', '50%'),
#     ('class_size', '75%'),   ('class_size', 'max')],
#  dtype='object')

— onlyphantom
स्रोत

42

एंडी हेडन का जवाब निश्चित रूप से सबसे आसान तरीका है - यदि आप डुप्लिकेट कॉलम लेबल से बचना चाहते हैं तो आपको थोड़ा ट्विक करने की आवश्यकता है

In [34]: df
Out[34]: 
     USAF   WBAN  day  month  s_CD  s_CL  s_CNT  s_PC  tempf         year
                               sum   sum    sum   sum   amax   amin      
0  702730  26451    1      1    12     0     13     1  30.92  24.98  1993
1  702730  26451    2      1    13     0     13     0  32.00  24.98  1993
2  702730  26451    3      1     2    10     13     1  23.00   6.98  1993
3  702730  26451    4      1    12     0     13     1  10.04   3.92  1993
4  702730  26451    5      1    10     0     13     3  19.94  10.94  1993


In [35]: mi = df.columns

In [36]: mi
Out[36]: 
MultiIndex
[(USAF, ), (WBAN, ), (day, ), (month, ), (s_CD, sum), (s_CL, sum), (s_CNT, sum), (s_PC, sum), (tempf, amax), (tempf, amin), (year, )]


In [37]: mi.tolist()
Out[37]: 
[('USAF', ''),
 ('WBAN', ''),
 ('day', ''),
 ('month', ''),
 ('s_CD', 'sum'),
 ('s_CL', 'sum'),
 ('s_CNT', 'sum'),
 ('s_PC', 'sum'),
 ('tempf', 'amax'),
 ('tempf', 'amin'),
 ('year', '')]

In [38]: ind = pd.Index([e[0] + e[1] for e in mi.tolist()])

In [39]: ind
Out[39]: Index([USAF, WBAN, day, month, s_CDsum, s_CLsum, s_CNTsum, s_PCsum, tempfamax, tempfamin, year], dtype=object)

In [40]: df.columns = ind




In [46]: df
Out[46]: 
     USAF   WBAN  day  month  s_CDsum  s_CLsum  s_CNTsum  s_PCsum  tempfamax  tempfamin  \
0  702730  26451    1      1       12        0        13        1      30.92      24.98   
1  702730  26451    2      1       13        0        13        0      32.00      24.98   
2  702730  26451    3      1        2       10        13        1      23.00       6.98   
3  702730  26451    4      1       12        0        13        1      10.04       3.92   
4  702730  26451    5      1       10        0        13        3      19.94      10.94   




   year  
0  1993  
1  1993  
2  1993  
3  1993  
4  1993

— थियोड्रोस ज़ेलेके
स्रोत

2

धन्यवाद थियोड्रोस! यह एकमात्र सही समाधान है जो सभी मामलों को संभालता है!

— कैन्यन जूल

17

df.columns = ['_'.join(tup).rstrip('_') for tup in df.columns.values]

— tvt173
स्रोत

14

और यदि आप मल्टीनेडेक्स के दूसरे स्तर से किसी भी एकत्रीकरण की जानकारी को बनाए रखना चाहते हैं, तो आप यह कोशिश कर सकते हैं:

In [1]: new_cols = [''.join(t) for t in df.columns]
Out[1]:
['USAF',
 'WBAN',
 'day',
 'month',
 's_CDsum',
 's_CLsum',
 's_CNTsum',
 's_PCsum',
 'tempfamax',
 'tempfamin',
 'year']

In [2]: df.columns = new_cols

— Zelazny7
स्रोत

new_colsपरिभाषित नहीं है।

— समतुल्यता

11

mapफ़ंक्शन का उपयोग करने के लिए ऐसा करने का सबसे पायथोनिक तरीका ।

df.columns = df.columns.map(' '.join).str.strip()

आउटपुट print(df.columns):

Index(['USAF', 'WBAN', 'day', 'month', 's_CD sum', 's_CL sum', 's_CNT sum',
       's_PC sum', 'tempf amax', 'tempf amin', 'year'],
      dtype='object')

पाय स्ट्रिंग के साथ पायथन 3.6+ का उपयोग करके अपडेट करें:

df.columns = [f'{f} {s}' if s != '' else f'{f}' 
              for f, s in df.columns]

print(df.columns)

आउटपुट:

Index(['USAF', 'WBAN', 'day', 'month', 's_CD sum', 's_CL sum', 's_CNT sum',
       's_PC sum', 'tempf amax', 'tempf amin', 'year'],
      dtype='object')

— स्कॉट बोस्टन
स्रोत

9

मेरे लिए सबसे आसान और सबसे सहज समाधान get_level_values का उपयोग करके कॉलम नामों को संयोजित करना था । जब आप एक ही कॉलम पर एक से अधिक एकत्रीकरण करते हैं तो यह डुप्लिकेट कॉलम नामों को रोकता है:

level_one = df.columns.get_level_values(0).astype(str)
level_two = df.columns.get_level_values(1).astype(str)
df.columns = level_one + level_two

यदि आप स्तंभों के बीच एक विभाजक चाहते हैं, तो आप ऐसा कर सकते हैं। यह उसी बात को वापस कर देगा जैसे कि सिजी आर्मस्ट्रांग की स्वीकृत उत्तर पर टिप्पणी है जिसमें केवल दोनों सूचकांक स्तरों के मान वाले कॉलम के लिए अंडरस्कोर शामिल हैं:

level_one = df.columns.get_level_values(0).astype(str)
level_two = df.columns.get_level_values(1).astype(str)
column_separator = ['_' if x != '' else '' for x in level_two]
df.columns = level_one + column_separator + level_two

मुझे पता है कि यह एंडी हेडन के महान जवाब के रूप में एक ही बात करता है, लेकिन मुझे लगता है कि यह इस तरह से थोड़ा अधिक सहज है और याद रखना आसान है (इसलिए मुझे इस धागे का जिक्र नहीं करना है), खासकर नौसिखिए पांडा उपयोगकर्ताओं के लिए ।

यह विधि उस मामले में भी अधिक विस्तृत है जहां आपके पास 3 कॉलम स्तर हो सकते हैं।

level_one = df.columns.get_level_values(0).astype(str)
level_two = df.columns.get_level_values(1).astype(str)
level_three = df.columns.get_level_values(2).astype(str)
df.columns = level_one + level_two + level_three

— bodily11
स्रोत

6

सभी उत्तरों को पढ़ने के बाद, मैं इसे लेकर आया:

def __my_flatten_cols(self, how="_".join, reset_index=True):
    how = (lambda iter: list(iter)[-1]) if how == "last" else how
    self.columns = [how(filter(None, map(str, levels))) for levels in self.columns.values] \
                    if isinstance(self.columns, pd.MultiIndex) else self.columns
    return self.reset_index() if reset_index else self
pd.DataFrame.my_flatten_cols = __my_flatten_cols

उपयोग:

एक डेटा फ्रेम दिया:

df = pd.DataFrame({"grouper": ["x","x","y","y"], "val1": [0,2,4,6], 2: [1,3,5,7]}, columns=["grouper", "val1", 2])

  grouper  val1  2
0       x     0  1
1       x     2  3
2       y     4  5
3       y     6  7

एकल एकत्रीकरण विधि : परिणामी चर को स्रोत के समान नाम दिया गया है :
```
df.groupby(by="grouper").agg("min").my_flatten_cols()
```
- के रूप में ही df.groupby(by="grouper", as_index = झूठी) या .agg(...).reset_index ()
- ```
----- before -----
           val1  2
  grouper         

------ after -----
  grouper  val1  2
0       x     0  1
1       y     4  5
```

एकल स्रोत चर, एकाधिक एकत्रीकरण : परिणामी चर नाम आँकड़ों के नाम पर :

df.groupby(by="grouper").agg({"val1": [min,max]}).my_flatten_cols("last")

के रूप में ही a = df.groupby(..).agg(..); a.columns = a.columns.droplevel(0); a.reset_index()।

----- before -----
            val1    
           min max
  grouper         

------ after -----
  grouper  min  max
0       x    0    2
1       y    4    6

एकाधिक चर, कई एकत्रीकरण : परिणामी चर नाम (varname) _ (statname) :
```
df.groupby(by="grouper").agg({"val1": min, 2:[sum, "size"]}).my_flatten_cols()
# you can combine the names in other ways too, e.g. use a different delimiter:
#df.groupby(by="grouper").agg({"val1": min, 2:[sum, "size"]}).my_flatten_cols(" ".join)
```
- a.columns = ["_".join(filter(None, map(str, levels))) for levels in a.columns.values]हुड के नीचे चलाता है ( स्तंभों agg()में इस परिणाम के रूप में MultiIndex)।
- यदि आपके पास my_flatten_colsसहायक नहीं है , तो @ सिगिजी द्वारा सुझाए गए समाधान में टाइप करना आसान हो सकता है : a.columns = ["_".join(t).rstrip("_") for t in a.columns.values]जो इस मामले में समान रूप से काम करता है (लेकिन यदि आपके पास स्तंभों पर संख्यात्मक लेबल हैं तो विफल रहता है)
- स्तंभों पर संख्यात्मक लेबल को संभालने के लिए, आप @jxstanford और @Nolan Conaway ( a.columns = ["_".join(tuple(map(str, t))).rstrip("_") for t in a.columns.values]) द्वारा सुझाए गए समाधान का उपयोग कर सकते हैं , लेकिन मुझे समझ नहीं आता है कि tuple()कॉल की आवश्यकता क्यों है, और मेरा मानना rstrip()है कि केवल आवश्यक है कि कुछ कॉलमों में विवरणकर्ता हो ("colname", "")( यदि आप reset_index()ठीक करने की कोशिश कर रहे हैं, तो ऐसा हो सकता है .columns)
- ```
----- before -----
           val1           2     
           min       sum    size
  grouper              

------ after -----
  grouper  val1_min  2_sum  2_size
0       x         0      4       2
1       y         4     12       2
```

आप परिणामी चर को मैन्युअल रूप से नाम देना चाहते हैं: (यह 0.23 के समान पर्याप्त विकल्प के साथ पांडा 0.20.0 के बाद से निकाला गया है )

df.groupby(by="grouper").agg({"val1": {"sum_of_val1": "sum", "count_of_val1": "count"},
                                   2: {"sum_of_2":    "sum", "count_of_2":    "count"}}).my_flatten_cols("last")

अन्य सुझावों में शामिल हैं : स्तंभों को मैन्युअल रूप से सेट करना: res.columns = ['A_sum', 'B_sum', 'count']या .join()कई groupbyकथनों को निगलना।

----- before -----
                   val1                      2         
          count_of_val1 sum_of_val1 count_of_2 sum_of_2
  grouper                                              

------ after -----
  grouper  count_of_val1  sum_of_val1  count_of_2  sum_of_2
0       x              2            2           2         4
1       y              2           10           2        12

सहायक कार्य द्वारा मामले को संभाला जाता है

स्तर के नाम गैर-स्ट्रिंग हो सकते हैं, उदाहरण के लिए जब स्तंभ नाम पूर्णांक होते हैं , तो स्तंभ संख्याओं द्वारा सूचकांक पांडस डेटाफ्रेम , इसलिए हमें इसके साथ बदलना होगाmap(str, ..)
वे भी खाली हो सकते हैं, इसलिए हमें करना होगा filter(None, ..)
एकल-स्तरीय स्तंभों के लिए (जैसे कि मल्टीइंडेक्स के अलावा कुछ भी), columns.valuesनाम लौटाता है ( str, टुपल्स नहीं)
इस बात पर निर्भर करता है कि आपने किस तरह से उपयोग किया है, .agg()आपको एक कॉलम के लिए सबसे अधिक लेबल रखने या कई लेबल को संक्षिप्त करने की आवश्यकता हो सकती है
(चूंकि मैं पांडा के लिए नया हूं;) अधिक बार नहीं, मैं reset_index()नियमित रूप से समूह-दर कॉलम के साथ काम करने में सक्षम होना चाहता हूं , इसलिए यह डिफ़ॉल्ट रूप से करता है

— Nickolay
स्रोत

वास्तव में महान जवाब है, आप '[ "कृपया कर सकते की पर काम कर समझाने " .join (टपल (मानचित्र (str, टी))) rstrip। ( " , धन्यवाद a.columns.values में टी के लिए")]' पहले से

— विनीत

@ विनीत ने यह बताने के लिए अपनी पोस्ट को अपडेट किया कि मैंने उल्लेख किया है कि सुझाव देने के लिए स्निपेट का मेरे समाधान पर समान प्रभाव पड़ता है। यदि आप इस बात का विवरण चाहते हैं कि tuple()आवश्यकता क्यों है, तो आप jxstanford की पोस्ट पर टिप्पणी करना चाहते हैं। अन्यथा, .columns.valuesप्रदान किए गए उदाहरण में निरीक्षण करना सहायक हो सकता है [('val1', 'min'), (2, 'sum'), (2, 'size')]:। 1) for t in a.columns.valuesकॉलम पर छोरों, दूसरे कॉलम के लिए t == (2, 'sum'); 2) प्रत्येक "स्तर" map(str, t)पर लागू होता str()है, जिसके परिणामस्वरूप ('2', 'sum'); 3) "_".join(('2','sum'))"2_sum" में परिणाम,

— Nickolay

5

एक सामान्य समाधान जो कई स्तरों और मिश्रित प्रकारों को संभालता है:

df.columns = ['_'.join(tuple(map(str, t))) for t in df.columns.values]

— jxstanford
स्रोत

1

मामले में गैर-पदानुक्रमित कॉलम भी हैं:df.columns = ['_'.join(tuple(map(str, t))).rstrip('_') for t in df.columns.values]

— नोलन कॉनवे

धन्यवाद। बहुत दिनों से खोज रहा था। चूंकि मेरे बहुस्तरीय सूचकांक में पूर्णांक मान शामिल थे। इसने मेरी समस्या हल कर दी :)

— AnksG

4

थोड़ी देर हो सकती है, लेकिन अगर आप डुप्लिकेट कॉलम नामों के बारे में चिंतित नहीं हैं:

df.columns = df.columns.tolist()

— नील्स
स्रोत

मेरे लिए, यह स्तम्भों के नामों को तुच्छ होने के लिए बदलता है: (year, )और(tempf, amax)

— निकोले

3

यदि आप स्तरों के बीच नाम में विभाजक रखना चाहते हैं, तो यह फ़ंक्शन अच्छी तरह से काम करता है।

def flattenHierarchicalCol(col,sep = '_'):
    if not type(col) is tuple:
        return col
    else:
        new_col = ''
        for leveli,level in enumerate(col):
            if not level == '':
                if not leveli == 0:
                    new_col += sep
                new_col += level
        return new_col

df.columns = df.columns.map(flattenHierarchicalCol)

— agartland
स्रोत

1

मुझें यह पसंद है। इस मामले को छोड़ना जहां कॉलम पदानुक्रमिक नहीं हैं, इसे बहुत सरल बनाया जा सकता है:df.columns = ["_".join(filter(None, c)) for c in df.columns]

— गिगो

3

@Jxstanford और @ tvt173 के बाद, मैंने एक क्विक फंक्शन लिखा, जो स्ट्रिंग / इंट कॉलम नामों की परवाह किए बिना ट्रिक को करना चाहिए:

def flatten_cols(df):
    df.columns = [
        '_'.join(tuple(map(str, t))).rstrip('_') 
        for t in df.columns.values
        ]
    return df

— नोलन कावटे
स्रोत

1

आप नीचे भी कर सकते हैं। पर विचार करें dfअपने dataframe होने के लिए और एक दो स्तर सूचकांक मान (मामले अपने उदाहरण में है के रूप में)

df.columns = [(df.columns[i][0])+'_'+(datadf_pos4.columns[i][1]) for i in range(len(df.columns))]

— पवित्र गाय
स्रोत

1

मैं एक सीधा-सीधा रास्ता साझा करूंगा जिसने मेरे लिए काम किया।

[" ".join([str(elem) for elem in tup]) for tup in df.columns.tolist()]
#df = df.reset_index() if needed

— झुक ब्रावो
स्रोत

0

अन्य DataFrame विधियों की एक श्रृंखला के अंदर एक MultiIndex को समतल करने के लिए, एक फ़ंक्शन को इस तरह परिभाषित करें:

def flatten_index(df):
  df_copy = df.copy()
  df_copy.columns = ['_'.join(col).rstrip('_') for col in df_copy.columns.values]
  return df_copy.reset_index()

फिर डेटा फ़ंक्शन विधियों की श्रृंखला में इस फ़ंक्शन को लागू करने के लिए pipeविधि का उपयोग करें , श्रृंखला में किसी भी अन्य तरीकों से पहले groupbyऔर बाद aggमें:

my_df \
  .groupby('group') \
  .agg({'value': ['count']}) \
  .pipe(flatten_index) \
  .sort_values('value_count')

— ianmcook
स्रोत

0

एक और सरल दिनचर्या।

def flatten_columns(df, sep='.'):
    def _remove_empty(column_name):
        return tuple(element for element in column_name if element)
    def _join(column_name):
        return sep.join(column_name)

    new_columns = [_join(_remove_empty(column)) for column in df.columns.values]
    df.columns = new_columns

— यूएफओ
स्रोत

पंडों - स्तंभों में एक पदानुक्रमित सूचकांक को कैसे समतल करना है

मौजूदा pandasकॉलम को बदलने के लिए इसका उपयोग करना

पाय स्ट्रिंग के साथ पायथन 3.6+ का उपयोग करके अपडेट करें:

उपयोग:

सहायक कार्य द्वारा मामले को संभाला जाता है

मौजूदा `pandas`कॉलम को बदलने के लिए इसका उपयोग करना