গ্রুপফাই প্যান্ডস ডেটাফ্রেম এবং সর্বাধিক সাধারণ মান নির্বাচন করুন


99

আমার কাছে তিনটি স্ট্রিং কলাম সহ একটি ডেটা ফ্রেম রয়েছে। আমি জানি যে ২ য় কলামের একমাত্র মান প্রথম দুটি সংমিশ্রনের জন্য বৈধ। ডেটা পরিষ্কার করার জন্য আমাকে প্রথম দুটি কলাম দ্বারা ডেটা ফ্রেম অনুসারে গ্রুপ করতে হবে এবং প্রতিটি সংমিশ্রনের জন্য তৃতীয় কলামের সর্বাধিক সাধারণ মান নির্বাচন করতে হবে।

আমার কোড:

import pandas as pd
from scipy import stats

source = pd.DataFrame({'Country' : ['USA', 'USA', 'Russia','USA'], 
                  'City' : ['New-York', 'New-York', 'Sankt-Petersburg', 'New-York'],
                  'Short name' : ['NY','New','Spb','NY']})

print source.groupby(['Country','City']).agg(lambda x: stats.mode(x['Short name'])[0])

কোডের শেষ লাইনটি কাজ করে না, এটিতে "কী ত্রুটি 'সংক্ষিপ্ত নাম" "বলা আছে এবং যদি আমি কেবল সিটি দ্বারা গ্রুপ করার চেষ্টা করি তবে আমি একটি অ্যাসেসারেশন এরর পেয়েছি। আমি কি এটি ঠিক করতে পারি?

উত্তর:


145

আপনি value_counts()একটি গণনা সিরিজ পেতে এবং প্রথম সারিটি পেতে ব্যবহার করতে পারেন :

import pandas as pd

source = pd.DataFrame({'Country' : ['USA', 'USA', 'Russia','USA'], 
                  'City' : ['New-York', 'New-York', 'Sankt-Petersburg', 'New-York'],
                  'Short name' : ['NY','New','Spb','NY']})

source.groupby(['Country','City']).agg(lambda x:x.value_counts().index[0])

আপনি যদি .agg () এ অন্যান্য আক্রমণাত্মক ক্রিয়াকলাপগুলি সম্পাদন করার বিষয়ে ভাবছেন this

# Let's add a new col,  account
source['account'] = [1,2,3,3]

source.groupby(['Country','City']).agg(mod  = ('Short name', \
                                        lambda x: x.value_counts().index[0]),
                                        avg = ('account', 'mean') \
                                      )

আমি খুঁজে পেয়েছি যে স্ট্যাটাস.মোড স্ট্রিং ভেরিয়েবলের ক্ষেত্রে ভুল উত্তরগুলি প্রদর্শন করতে পারে। এই উপায়টি আরও নির্ভরযোগ্য দেখায়।
ভাইচাস্লাভ নেফেদভ

4
এটা কি হওয়া উচিত নয় .value_counts(ascending=False)?
প্রাইভেট

4
@ প্রাইভেট: ascending=Falseইতিমধ্যে ডিফল্ট মান, তাই স্পষ্টভাবে অর্ডার সেট করার দরকার নেই।
শ্মুদ্দি

4
জ্যাককোট যেমন বলেছেন, pd.Series.modeএখন আরও উপযুক্ত এবং দ্রুত।
দাইসুক শিবাতো

আমি কীভাবে এই সমাধানটিকে একাধিক বিভিন্ন একীকরণ ফাংশন সহ ব্যবহার করতে পারি, উদাহরণস্বরূপ যদি আমার কাছে "সংক্ষিপ্ত নাম" এর মতো একাধিক কলাম এবং অতিরিক্ত সংখ্যার কলামগুলি রয়েছে যা আমি একটি যোগফলের সাথে একত্রিত করতে চাই?
constiii

99

পান্ডাস> = 0.16

pd.Series.mode সহজলভ্য!

ব্যবহারের groupby, GroupBy.aggএবং প্রযোজ্য pd.Series.modeপ্রতিটি গ্রুপে ফাংশন:

source.groupby(['Country','City'])['Short name'].agg(pd.Series.mode)

Country  City            
Russia   Sankt-Petersburg    Spb
USA      New-York             NY
Name: Short name, dtype: object

এটি যদি ডেটা ফ্রেম হিসাবে প্রয়োজন হয় তবে ব্যবহার করুন

source.groupby(['Country','City'])['Short name'].agg(pd.Series.mode).to_frame()

                         Short name
Country City                       
Russia  Sankt-Petersburg        Spb
USA     New-York                 NY

দরকারী বিষয় Series.modeহ'ল এটি সর্বদা একটি সিরিজ ফেরত দেয়, এটি একেবারে সামঞ্জস্যপূর্ণ করে তোলে aggএবং applyবিশেষত যখন গ্রুপবাই আউটপুট পুনর্গঠন করে। এটিও দ্রুত।

# Accepted answer.
%timeit source.groupby(['Country','City']).agg(lambda x:x.value_counts().index[0])
# Proposed in this post.
%timeit source.groupby(['Country','City'])['Short name'].agg(pd.Series.mode)

5.56 ms ± 343 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
2.76 ms ± 387 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

একাধিক মোডের সাথে লেনদেন করা

Series.modeএকাধিক মোড থাকা অবস্থায় একটি ভাল কাজও করে :

source2 = source.append(
    pd.Series({'Country': 'USA', 'City': 'New-York', 'Short name': 'New'}),
    ignore_index=True)

# Now `source2` has two modes for the 
# ("USA", "New-York") group, they are "NY" and "New".
source2

  Country              City Short name
0     USA          New-York         NY
1     USA          New-York        New
2  Russia  Sankt-Petersburg        Spb
3     USA          New-York         NY
4     USA          New-York        New

source2.groupby(['Country','City'])['Short name'].agg(pd.Series.mode)

Country  City            
Russia   Sankt-Petersburg          Spb
USA      New-York            [NY, New]
Name: Short name, dtype: object

অথবা, আপনি যদি প্রতিটি মোডের জন্য পৃথক সারি চান, আপনি ব্যবহার করতে পারেন GroupBy.apply:

source2.groupby(['Country','City'])['Short name'].apply(pd.Series.mode)

Country  City               
Russia   Sankt-Petersburg  0    Spb
USA      New-York          0     NY
                           1    New
Name: Short name, dtype: object

যদি আপনি সেগুলির মধ্যে যে কোনও একটি হিসাবে মোডটি ফিরে আসার বিষয়টি যত্নশীল না হন তবে আপনার একটি ল্যাম্বডা লাগবে যা modeপ্রথম ফলাফলটি কল করে এবং নিষ্কাশন করবে।

source2.groupby(['Country','City'])['Short name'].agg(
    lambda x: pd.Series.mode(x)[0])

Country  City            
Russia   Sankt-Petersburg    Spb
USA      New-York             NY
Name: Short name, dtype: object

(না) বিকল্প বিবেচনা করুন

আপনি statistics.modeঅজগর থেকেও ব্যবহার করতে পারেন , তবে ...

source.groupby(['Country','City'])['Short name'].apply(statistics.mode)

Country  City            
Russia   Sankt-Petersburg    Spb
USA      New-York             NY
Name: Short name, dtype: object

... একাধিক মোড মোকাবেলা করার সময় এটি ভাল কাজ করে না; একটি StatisticsErrorউত্থাপিত হয়। এটি ডক্সে উল্লেখ করা হয়েছে:

যদি ডেটা খালি থাকে, বা যদি খুব সাধারণ কোনও মান না হয় তবে স্ট্যাটিস্টিকস এরর উত্থাপিত হয়।

তবে আপনি নিজের জন্য দেখতে পারেন ...

statistics.mode([1, 2])
# ---------------------------------------------------------------------------
# StatisticsError                           Traceback (most recent call last)
# ...
# StatisticsError: no unique mode; found 2 equally common values

@ জোশফ্রিডল্যান্ডার df.groupby(cols).agg(pd.Series.mode)মনে হয় আমার পক্ষে কাজ করে। যদি এটি কাজ না করে তবে আমার দ্বিতীয় অনুমানটি হবে df.groupby(cols).agg(lambda x: pd.Series.mode(x).values[0])
সিএস 95

ধন্যবাদ (সর্বদা হিসাবে!) আপনার দ্বিতীয় বিকল্পটি আমার জন্য জিনিসগুলির উন্নতি করে, তবে আমি একটি পাচ্ছি IndexError: index 0 is out of bounds for axis 0 with size 0(সম্ভবত এমন গ্রুপ রয়েছে যেগুলিতে একটি সিরিজে কেবল ন্যান থাকে)। যোগ করার পদ্ধতি dropna=Falseসমাধান এই , কিন্তু বাড়াতে বলে মনে হয় '<' not supported between instances of 'float' and 'str'(আমার সিরিজ স্ট্রিং যায়)। (আপনি যদি এটি পছন্দ করেন তবে এটি একটি নতুন প্রশ্নে পরিণত করতে পেরে খুশি))
জোশ ফ্রাইডল্যান্ডার ২

4
@ জোশফ্রিডল্যান্ডার সংজ্ঞা দিন def foo(x): m = pd.Series.mode(x); return m.values[0] if not m.empty else np.nanএবং তারপরে ব্যবহার করুন df.groupby(cols).agg(foo)। যদি এটি কাজ না করে তবে fooকিছুটা বাস্তবায়নের জন্য মজার। যদি আপনি এখনও সমস্যা শুরু করে থাকেন তবে আমি একটি নতুন প্রশ্ন খোলার পরামর্শ দিচ্ছি
সিএস 95

4
আমার যুক্ত করা উচিত যে আপনি যদি গণনা অন্তর্ভুক্ত করতে চান তবে আপনারা সম্পর্কের কোনও যত্ন নেই এবং কেবল একটি মোড চান তা ধরে নিয়ে কেউ মোডের np.nanমাধ্যমে এটি করতে পারে df.groupy(cols).agg(lambda x: x.mode(dropna=False).iloc[0])
আয়রিন

17

কারণ agg, ল্যাম্বা ফাংশনটি একটি পায় Series, যার কোনও 'Short name'বৈশিষ্ট্য নেই।

stats.mode দুটি অ্যারের একটি দ্বিগুণ ফিরিয়ে দেয়, সুতরাং আপনাকে এই টিপলটিতে প্রথম অ্যারের প্রথম উপাদানটি নিতে হবে।

এই দুটি সাধারণ পরিবর্তন সহ:

source.groupby(['Country','City']).agg(lambda x: stats.mode(x)[0][0])

প্রত্যাবর্তন

                         Short name
Country City                       
Russia  Sankt-Petersburg        Spb
USA     New-York                 NY

4
@ ভাইচেস্লাভনেফিডভ - হ্যাঁ, তবে @ এইচআইআরওয়াই এর সমাধানটি নিন, যাতে খাঁটি পান্ডাস ব্যবহার করা হয়। দরকার নেই scipy.stats
ইউরোমো

14

এখানে খেলাটি থেকে একটু দেরি হয়ে গেছে, তবে আমি এইচআইআরওয়াইয়ের সমাধান নিয়ে কিছু পারফরম্যান্সের সমস্যার মধ্যে দিয়ে যাচ্ছিলাম, সুতরাং আমাকে অন্য একটি নিয়ে আসতে হয়েছিল।

এটি প্রতিটি কী-মানটির ফ্রিকোয়েন্সি সন্ধান করে এবং তারপরে, প্রতিটি কীগুলির জন্য, কেবলমাত্র সেই মানটিই প্রায়শই প্রদর্শিত হয় যা এটি প্রায়শই প্রদর্শিত হয় keeping

একাধিক মোড সমর্থন করে এমন একটি অতিরিক্ত সমাধানও রয়েছে।

স্কেল টেস্টে যে ডেটা নিয়ে আমি কাজ করছি তার প্রতিনিধি, এই রানটাইমটি 37.4s থেকে 0.5s এ হ্রাস পেয়েছে!

সমাধানের কোড, কিছু উদাহরণ ব্যবহার এবং স্কেল পরীক্ষার জন্য এখানে রয়েছে:

import numpy as np
import pandas as pd
import random
import time

test_input = pd.DataFrame(columns=[ 'key',          'value'],
                          data=  [[ 1,              'A'    ],
                                  [ 1,              'B'    ],
                                  [ 1,              'B'    ],
                                  [ 1,              np.nan ],
                                  [ 2,              np.nan ],
                                  [ 3,              'C'    ],
                                  [ 3,              'C'    ],
                                  [ 3,              'D'    ],
                                  [ 3,              'D'    ]])

def mode(df, key_cols, value_col, count_col):
    '''                                                                                                                                                                                                                                                                                                                                                              
    Pandas does not provide a `mode` aggregation function                                                                                                                                                                                                                                                                                                            
    for its `GroupBy` objects. This function is meant to fill                                                                                                                                                                                                                                                                                                        
    that gap, though the semantics are not exactly the same.                                                                                                                                                                                                                                                                                                         

    The input is a DataFrame with the columns `key_cols`                                                                                                                                                                                                                                                                                                             
    that you would like to group on, and the column                                                                                                                                                                                                                                                                                                                  
    `value_col` for which you would like to obtain the mode.                                                                                                                                                                                                                                                                                                         

    The output is a DataFrame with a record per group that has at least one mode                                                                                                                                                                                                                                                                                     
    (null values are not counted). The `key_cols` are included as columns, `value_col`                                                                                                                                                                                                                                                                               
    contains a mode (ties are broken arbitrarily and deterministically) for each                                                                                                                                                                                                                                                                                     
    group, and `count_col` indicates how many times each mode appeared in its group.                                                                                                                                                                                                                                                                                 
    '''
    return df.groupby(key_cols + [value_col]).size() \
             .to_frame(count_col).reset_index() \
             .sort_values(count_col, ascending=False) \
             .drop_duplicates(subset=key_cols)

def modes(df, key_cols, value_col, count_col):
    '''                                                                                                                                                                                                                                                                                                                                                              
    Pandas does not provide a `mode` aggregation function                                                                                                                                                                                                                                                                                                            
    for its `GroupBy` objects. This function is meant to fill                                                                                                                                                                                                                                                                                                        
    that gap, though the semantics are not exactly the same.                                                                                                                                                                                                                                                                                                         

    The input is a DataFrame with the columns `key_cols`                                                                                                                                                                                                                                                                                                             
    that you would like to group on, and the column                                                                                                                                                                                                                                                                                                                  
    `value_col` for which you would like to obtain the modes.                                                                                                                                                                                                                                                                                                        

    The output is a DataFrame with a record per group that has at least                                                                                                                                                                                                                                                                                              
    one mode (null values are not counted). The `key_cols` are included as                                                                                                                                                                                                                                                                                           
    columns, `value_col` contains lists indicating the modes for each group,                                                                                                                                                                                                                                                                                         
    and `count_col` indicates how many times each mode appeared in its group.                                                                                                                                                                                                                                                                                        
    '''
    return df.groupby(key_cols + [value_col]).size() \
             .to_frame(count_col).reset_index() \
             .groupby(key_cols + [count_col])[value_col].unique() \
             .to_frame().reset_index() \
             .sort_values(count_col, ascending=False) \
             .drop_duplicates(subset=key_cols)

print test_input
print mode(test_input, ['key'], 'value', 'count')
print modes(test_input, ['key'], 'value', 'count')

scale_test_data = [[random.randint(1, 100000),
                    str(random.randint(123456789001, 123456789100))] for i in range(1000000)]
scale_test_input = pd.DataFrame(columns=['key', 'value'],
                                data=scale_test_data)

start = time.time()
mode(scale_test_input, ['key'], 'value', 'count')
print time.time() - start

start = time.time()
modes(scale_test_input, ['key'], 'value', 'count')
print time.time() - start

start = time.time()
scale_test_input.groupby(['key']).agg(lambda x: x.value_counts().index[0])
print time.time() - start

এই কোডটি চালানো এমন কিছু মুদ্রণ করবে:

   key value
0    1     A
1    1     B
2    1     B
3    1   NaN
4    2   NaN
5    3     C
6    3     C
7    3     D
8    3     D
   key value  count
1    1     B      2
2    3     C      2
   key  count   value
1    1      2     [B]
2    3      2  [C, D]
0.489614009857
9.19386196136
37.4375009537

আশাকরি এটা সাহায্য করবে!


দ্রুততম পথে আমি এগিয়ে আসছি .. ধন্যবাদ!
FtoTheZ

4
এই অ্যাপ্রোচ ব্যবহার করার কোনও উপায় কি তবে সরাসরি আগ্রাসনের প্যারামিটারের ভিতরে ?, উদাঃ agg({'f1':mode,'f2':np.sum})
পাবলো

4
@ পাবলোএ দুর্ভাগ্যক্রমে নয়, কারণ ইন্টারফেসটি এক রকম নয়। আমি এটি একটি পৃথক অপারেশন হিসাবে করার পরামর্শ দিয়েছি এবং তারপরে আপনার ফলাফলগুলিতে যোগদান করুন And এবং অবশ্যই, যদি পারফরম্যান্স কোনও উদ্বেগের বিষয় না হয় তবে আপনি আপনার কোডটি আরও সংক্ষিপ্ত রাখতে HYRY এর সমাধানটি ব্যবহার করতে পারেন।
abw333

@ abw333 আমি এইচআইআরওয়ির সমাধানটি ব্যবহার করেছি, তবে আমি পারফরম্যান্সের বিষয়গুলিতে চলে আসছি ... আমি আশা করি যে পান্ডস দেব টিম aggপদ্ধতিতে আরও ফাংশন সমর্থন করবে ।
পাবলো

অবশ্যই বড় ডেটা ফ্রেমের জন্য যাওয়ার উপায়। আমি 83M সারি এবং 2.5M অনন্য গ্রুপ ছিল। এটি প্রতি কলামে 28 সেকেন্ড সময় নিয়েছে, যখন আগ্রাসনে প্রতি কলামে 11 মিনিটের বেশি সময় লেগেছে।
ALOLZ

5

এখানে শীর্ষ দুটি উত্তর প্রস্তাব:

df.groupby(cols).agg(lambda x:x.value_counts().index[0])

বা, পছন্দসই

df.groupby(cols).agg(pd.Series.mode)

তবে এখানে উভয়ই সাধারণ প্রান্তের ক্ষেত্রে ব্যর্থ হয়েছে:

df = pd.DataFrame({
    'client_id':['A', 'A', 'A', 'A', 'B', 'B', 'B', 'C'],
    'date':['2019-01-01', '2019-01-01', '2019-01-01', '2019-01-01', '2019-01-01', '2019-01-01', '2019-01-01', '2019-01-01'],
    'location':['NY', 'NY', 'LA', 'LA', 'DC', 'DC', 'LA', np.NaN]
})

প্রথম:

df.groupby(['client_id', 'date']).agg(lambda x:x.value_counts().index[0])

ফলন IndexError(কারণ খালি সিরিজ দলবদ্ধভাবে ফিরে এসেছে C)। দ্বিতীয়:

df.groupby(['client_id', 'date']).agg(pd.Series.mode)

প্রত্যাবর্তন হয় ValueError: Function does not reduce, যেহেতু প্রথম গোষ্ঠী দুটিটির তালিকা দেয় (যেহেতু দুটি মোড রয়েছে)। ( এখানে দলিল হিসাবে , প্রথম গোষ্ঠী একটি একক মোড ফিরিয়ে দিলে এটি কার্যকর হবে!)

এই মামলার দুটি সম্ভাব্য সমাধান হ'ল:

import scipy
x.groupby(['client_id', 'date']).agg(lambda x: scipy.stats.mode(x)[0])

এবং সমাধানটি আমাকে এখানে মন্তব্যগুলিতে সিএস 95 দ্বারা প্রদত্ত :

def foo(x): 
    m = pd.Series.mode(x); 
    return m.values[0] if not m.empty else np.nan
df.groupby(['client_id', 'date']).agg(foo)

তবে এগুলি সমস্ত ধীর এবং বড় ডেটাসেটের জন্য উপযুক্ত নয়। একটি সমাধান যা আমি ব্যবহার করে শেষ করেছি) ক) এই কেসগুলি মোকাবেলা করতে পারে এবং খ) অনেক বেশি দ্রুত, এটি আবদু 33 এর উত্তরের হালকা পরিবর্তিত সংস্করণ (যা আরও বেশি হওয়া উচিত):

def get_mode_per_column(dataframe, group_cols, col):
    return (dataframe.fillna(-1)  # NaN placeholder to keep group 
            .groupby(group_cols + [col])
            .size()
            .to_frame('count')
            .reset_index()
            .sort_values('count', ascending=False)
            .drop_duplicates(subset=group_cols)
            .drop(columns=['count'])
            .sort_values(group_cols)
            .replace(-1, np.NaN))  # restore NaNs

group_cols = ['client_id', 'date']    
non_grp_cols = list(set(df).difference(group_cols))
output_df = get_mode_per_column(df, group_cols, non_grp_cols[0]).set_index(group_cols)
for col in non_grp_cols[1:]:
    output_df[col] = get_mode_per_column(df, group_cols, col)[col].values

মূলত, পদ্ধতিটি একবারে একটি কর্নে কাজ করে এবং একটি ডিএফ আউটপুট দেয়, তার পরিবর্তে concat, যা নিবিড় হয়, আপনি প্রথমে একটি ডিএফ হিসাবে বিবেচনা করেন এবং তারপরে পুনরাবৃত্তভাবে values.flatten()ডিএফ-এ একটি কলাম হিসাবে আউটপুট অ্যারে ( ) যুক্ত করুন ।


3

আনুষ্ঠানিকভাবে, সঠিক উত্তরটি হ'ল ইউমিও সলিউশন। @ এইচআইআরওয়াই সমাধানের সমস্যাটি হ'ল যখন আপনার [1,2,3,4] এর মতো সংখ্যার সিক্যুয়েন্স থাকবে তখন সমাধানটি ভুল, অর্থাত্ আপনার মোডটি নেই । উদাহরণ:

>>> import pandas as pd
>>> df = pd.DataFrame(
        {
            'client': ['A', 'B', 'A', 'B', 'B', 'C', 'A', 'D', 'D', 'E', 'E', 'E', 'E', 'E', 'A'], 
            'total': [1, 4, 3, 2, 4, 1, 2, 3, 5, 1, 2, 2, 2, 3, 4], 
            'bla': [10, 40, 30, 20, 40, 10, 20, 30, 50, 10, 20, 20, 20, 30, 40]
        }
    )

আপনি যদি @HYRY এর মতো গণনা করেন তবে আপনি পান:

>>> print(df.groupby(['client']).agg(lambda x: x.value_counts().index[0]))
        total  bla
client            
A           4   30
B           4   40
C           1   10
D           3   30
E           2   20

যা স্পষ্টতই ভুল ( এটির মান দেখুন যা 1 হবে এবং 4 হবে না কারণ এটি অনন্য মান হ্যান্ডেল করতে পারে না)।

সুতরাং, অন্যান্য সমাধানটি সঠিক:

>>> import scipy.stats
>>> print(df.groupby(['client']).agg(lambda x: scipy.stats.mode(x)[0][0]))
        total  bla
client            
A           1   10
B           4   40
C           1   10
D           3   30
E           2   20

1

আপনি যদি এটির সমাধানের জন্য অন্য কোনও পন্থা চান তবে তা নির্ভর করে না value_countsবা scipy.statsআপনি Counterসংগ্রহটি ব্যবহার করতে পারেন

from collections import Counter
get_most_common = lambda values: max(Counter(values).items(), key = lambda x: x[1])[0]

যা উপরের উদাহরণটিতে এভাবে প্রয়োগ করা যেতে পারে

src = pd.DataFrame({'Country' : ['USA', 'USA', 'Russia','USA'], 
              'City' : ['New-York', 'New-York', 'Sankt-Petersburg', 'New-York'],
              'Short_name' : ['NY','New','Spb','NY']})

src.groupby(['Country','City']).agg(get_most_common)

এটি এর চেয়ে দ্রুত pd.Series.modeবা pd.Series.value_counts().iloc[0]- তবে আপনার যদি গণনা করতে চান এমন NaN মান থাকে তবে এটি ব্যর্থ হবে। প্রতিটি NaN এর উপস্থিতি অন্যান্য NaN এর থেকে পৃথক হিসাবে দেখা যাবে, সুতরাং প্রতিটি NAN গণনা করা হয় বলে গণনা করা হয় 1। দেখুন stackoverflow.com/questions/61102111/...
আইরিন

1

আপনি যদি NaN মানগুলি অন্তর্ভুক্ত করতে না চান তবে ব্যবহারের Counterচেয়ে অনেক বেশি দ্রুত pd.Series.modeবা pd.Series.value_counts()[0]:

def get_most_common(srs):
    x = list(srs)
    my_counter = Counter(x)
    return my_counter.most_common(1)[0][0]

df.groupby(col).agg(get_most_common)

কাজ করা উচিত. আপনার যখন NaN মান থাকবে তখন এটি ব্যর্থ হবে, কারণ প্রতিটি NaN আলাদাভাবে গণনা করা হবে।


0

সমস্যা এখানে কর্মক্ষমতা, যদি তোমরা সারি অনেক আছে এটা একটা সমস্যা হবে।

যদি এটি আপনার ক্ষেত্রে হয় তবে দয়া করে এটি ব্যবহার করে দেখুন:

import pandas as pd

source = pd.DataFrame({'Country' : ['USA', 'USA', 'Russia','USA'], 
              'City' : ['New-York', 'New-York', 'Sankt-Petersburg', 'New-York'],
              'Short_name' : ['NY','New','Spb','NY']})

source.groupby(['Country','City']).agg(lambda x:x.value_counts().index[0])

source.groupby(['Country','City']).Short_name.value_counts().groupby['Country','City']).first()

0

বৃহত্তর ডেটাসেটের জন্য কিছুটা ক্লামিয়ার কিন্তু দ্রুত পদ্ধতির মধ্যে সুদের কলামের জন্য গণনা পাওয়া, গণনাগুলিকে সর্বাধিক থেকে নিম্নতমে বাছাই করা এবং তারপরে কেবল বৃহত্তম বৃহত্তম ক্ষেত্রে ধরে রাখার জন্য সাবসেটে ডি-সদৃশ জড়িত। কোড উদাহরণটি অনুসরণ করছে:

>>> import pandas as pd
>>> source = pd.DataFrame(
        {
            'Country': ['USA', 'USA', 'Russia', 'USA'], 
            'City': ['New-York', 'New-York', 'Sankt-Petersburg', 'New-York'],
            'Short name': ['NY', 'New', 'Spb', 'NY']
        }
    )
>>> grouped_df = source\
        .groupby(['Country','City','Short name'])[['Short name']]\
        .count()\
        .rename(columns={'Short name':'count'})\
        .reset_index()\
        .sort_values('count', ascending=False)\
        .drop_duplicates(subset=['Country', 'City'])\
        .drop('count', axis=1)
>>> print(grouped_df)
  Country              City Short name
1     USA          New-York         NY
0  Russia  Sankt-Petersburg        Spb
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.