পান্ডস - কলামগুলিতে একটি শ্রেণিবিন্যাস সূচক কীভাবে সমতল করা যায়


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}}

5
df[:5].to_dict()আপনার ডেটাसेटে অন্যের পড়ার জন্য উদাহরণ হিসাবে আউটপুট যুক্ত করতে পারেন ?
জেলাজনি 7

ভাল ধারণা. মন্তব্যটি করার জন্য এটি দীর্ঘ ছিল বলে এটি উপরে করেছেন।
রস আর

ইস্যু ট্র্যাকার এর জন্য একটি উত্সর্গীকৃত পদ্ধতি বাস্তবায়নের জন্য একটি পরামর্শpandas আছে ।
joelostblom

2
@ জোওয়েলস্টব্লম এবং এটি বাস্তবে বাস্তবায়িত হয়েছে (0.24.0 এবং উপরে)। আমি একটি উত্তর পোস্ট করেছি তবে মূলত এখন আপনি কেবল পারেন dat.columns = dat.columns.to_flat_index()। অন্তর্নির্মিত পান্ডাস ফাংশন।
justphantom

উত্তর:


471

আমি মনে করি এটির সবচেয়ে সহজ উপায় হ'ল কলামগুলি শীর্ষ স্তরে সেট করা:

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

দ্রষ্টব্য: যদি স্তরটির একটি নাম থাকে তবে আপনি 0 এর পরিবর্তে এটির মাধ্যমেও এটি অ্যাক্সেস করতে পারবেন।

যদি আপনি / joinআপনার মাল্টিআইডেক্সকে একটি সূচকে একত্রিত করতে চান (ধরে নিবেন যে আপনার কলামগুলিতে কেবল স্ট্রিং এন্ট্রি রয়েছে) আপনি করতে পারেন:

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 (insert = true) বিকল্প সমাধান হতে পারে।
টোবিয়াস

8
একটি ছোট্ট মন্তব্য ... আপনি যদি কলামটি মাল্টিলেভিলের জন্য _ ব্যবহার করতে চান .. আপনি এটি ব্যবহার করতে পারেন ... df.colouts = ['_'। join (কল)। স্ট্রিপ () df.colলামে কল করার জন্য। মান]
ihightower

30
শুধুমাত্র যোগদান করা কলগুলির জন্য আন্ডারস্কোর বজায় রাখার জন্য সামান্য পরিবর্তন:['_'.join(col).rstrip('_') for col in df.columns.values]
সেজি আর্মস্ট্রং

এটি দুর্দান্ত কাজ করেছে, যদি আপনি কেবল দ্বিতীয় কলামটি ব্যবহার করতে চান: df.collines = [কল [1] df.collines.values] এ কল করার জন্য
ব্যবহারকারী 3078500

1
আপনি যদি এর sum s_CDপরিবর্তে ব্যবহার করতে চান s_CD sumতবে একটি করতে পারেন df.columns = ['_'.join(col).rstrip('_') for col in [c[::-1] for c in df.columns.values]]
আয়রিন

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

3
এটি কাজ করে, তবে কলামের নামগুলি রেখে যায় যা প্রোগ্রামিয়ালি অ্যাক্সেস করা কঠিন এবং জিজ্ঞাস্য নয়
ডেমিউ

1
এটি পান্ডার সর্বশেষ সংস্করণটির সাথে কাজ করবে না। এটি 0.18 দিয়ে কাজ করে তবে 0.20 দিয়ে নয় (এখনকার সর্বশেষ)
TH22

1
@dmeu কলামের নাম সংরক্ষণ করতে pd.DataFrame(df.to_records(), columns=df.index.names + list(df.columns))
তেওরেটিক

1
এটি কলামের নামগুলিকে আমার জন্য টিউপস হিসাবে সংরক্ষণ করে এবং আমি যে সূচকটি ব্যবহার করি তা রাখতে:pd.DataFrame(df_volume.to_records(), index=df_volume.index).drop('index', axis=1)
জয়েন

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

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
থিওড্রোসকে ধন্যবাদ! এটিই একমাত্র সঠিক সমাধান যা সমস্ত ক্ষেত্রে পরিচালনা করে!
CanCeylan


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

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

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 = ভুয়া) বা .reset_index () হিসাবে একই.agg(...)
    • ----- 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
  • একাধিক ভেরিয়েবল, একাধিক সমষ্টি : ফলস্বরূপ ভেরিয়েবলের নাম (ভেরনাম) _ (স্ট্যাটাম) :

    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 এবং @ Nola 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.20.0 যেহেতু অবচিত সঙ্গে 0.23 হিসাবে কোন পর্যাপ্ত বিকল্প )

    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()নিয়মিত উপায়ে গ্রুপ-সহ কলামগুলির সাথে কাজ করতে সক্ষম হতে চাই , তাই এটি ডিফল্টরূপে এটি করে

সত্যিই মহান উত্তর, আপনি '[ "দয়া করে করতে পারেন এর উপর কাজ ব্যাখ্যা " .join (tuple (মানচিত্রে (STR, টি))) rstrip। ( " , ধন্যবাদ a.columns.values মধ্যে T জন্য")]' আগাম
ভিনিত

@ ভিনিট আমি আমার পোস্টটি আপডেট করে তা নির্দেশ করেছিলাম যে আমি উল্লেখ করেছি যে স্নিপেটটি আমার সমাধানের সাথে একই রকম প্রভাব ফেলেছে। কেন tuple()প্রয়োজন হয় সে সম্পর্কে বিশদ জানতে চাইলে আপনি জেক্সস্তানফোর্ডের পোস্টে মন্তব্য করতে চাইতে পারেন। অন্যথায়, এটি পরিদর্শন করা সহায়ক হতে পারে .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" এ ফলাফল,
নিকোলে

5

একটি সাধারণ সমাধান যা একাধিক স্তর এবং মিশ্রিত প্রকারগুলি পরিচালনা করে:

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

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)

1
আমি এটা পছন্দ করি. কলামগুলি শ্রেণিবদ্ধ নয় এমন ক্ষেত্রে রেখে দেওয়ার ফলে এটি অনেক সহজ করা যায়:df.columns = ["_".join(filter(None, c)) for c in df.columns]
Gigo

3

@ জ্যাকস্টানফোর্ড এবং @ টিভিt173 অনুসরণ করে আমি একটি দ্রুত ফাংশন লিখেছি যা কৌশলটি করা উচিত, স্ট্রিং / ইন্টি কলামের নাম নির্বিশেষে:

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

1

আপনি নীচের হিসাবে করতে পারে। dfআপনার ডেটাফ্রেম হিসাবে বিবেচনা করুন এবং একটি দ্বি স্তরের সূচক ধরে নিন (আপনার উদাহরণে যেমন রয়েছে)

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

অন্যান্য ডেটাফ্রেম পদ্ধতির একটি শৃঙ্খলের অভ্যন্তরে একটি মাল্টিআইন্ডেক্সকে সমতল করতে, একটি ফাংশনটিকে এভাবে সংজ্ঞায়িত করুন:

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পদ্ধতি পর DataFrame পদ্ধতির চেন এই ফাংশন প্রয়োগ করতে, groupbyএবং aggকিন্তু চেন অন্য কোন পদ্ধতি আগে:

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

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
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.