पांडा में ग्रुपबी के बाद कॉलम पर शर्त लागू करें और फिर 2 अधिकतम मूल्य प्राप्त करने के लिए एकत्र करें

सबसे पहले, प्रत्येक फ़ील्ड (पहले अक्षर) के सामान्य भाग को निकालें, फिर मानों को क्रमबद्ध करें (उच्चतम मान नीचे जाएं)। अंत में data कॉलम और field सीरीज के आधार पर ग्रुप करें, फिर दो आखिरी वैल्यू (उच्चतम) रखें:

field = df['field'].str.extract('([^\d]+)', expand=False)
out = df.sort_values('bcorr').groupby(['data', field]).tail(2).sort_index()
print(out)

# Output
   data field  bcorr
0     A   cs1    0.8
1     A   cs2    0.9
4     A   pq2    0.6
5     A   pq3    0.5
6     B   cs1    0.8
7     B   cs2    0.9
10    B   pq2    0.6
11    B   pq3    0.5

यदि आपके पास फ़ील्ड निर्धारित करने के लिए केवल दो निश्चित अक्षर हैं, तो आप df['field'].str.extract(...) के बजाय df['field'].str[:2] का उपयोग कर सकते हैं।

आप दिनांक पर groupby कर सकते हैं और str[:2] का उपयोग करके फ़ील्ड कॉलम को प्रतिस्थापित कर सकते हैं जो 2 तक के वर्णों को पकड़ लेता है, और head(2) का उपयोग करता है।

head पहली n पंक्तियां लौटाता है, इसलिए आपको पहले डेटा को सॉर्ट करना होगा।

df.sort_values(by=['data','bcorr'],ascending=False).groupby(['data',df.field.str[:2]]).head(2).sort_index()

  data field  bcorr
0     A   cs1    0.8
1     A   cs2    0.9
4     A   pq2    0.6
5     A   pq3    0.5
6     B   cs1    0.8
7     B   cs2    0.9
10    B   pq2    0.6
11    B   pq3    0.5

उपरोक्त तर्क के बाद, tail(2) का उपयोग करके और डेटा को दूसरी तरफ सॉर्ट करने से आपको वही आउटपुट मिलता है:

df.sort_values(by=['data','bcorr']).groupby(['data',df.field.str[:2]]).tail(2).sort_index()

संपादित करें यदि आप अपने फ़ील्ड कॉलम में गैर-अंकीय वर्णों की मनमानी संख्या की अनुमति देने के लिए सामान्यीकृत करना चाहते हैं, तो आप str.replace का उपयोग अपने groupby में सभी संख्यात्मक वर्णों को खाली से बदलने के लिए कर सकते हैं:

df.sort_values(by=['data','bcorr']).groupby(['data',df.field.str.replace(r"[0-9]",'')]).tail(2).sort_index()

यहाँ एक तरीका है:

(i) पहले तत्वों का चयन करके field से एक नया कॉलम field_name बनाएं और data और field_name पर groupby का उपयोग करें और nlargest का उपयोग करके खोजें श्रृंखला बनाने के लिए प्रत्येक समूह के लिए दो सबसे बड़े मान temp

(ii) (i) में निर्मित temp की अनुक्रमणिका का उपयोग करके, df फ़िल्टर करें

(iii) (ii) से फ़िल्टर किए गए डेटाफ़्रेम के bcorr कॉलम में temp असाइन करें

temp = df.assign(field_name=df['field'].str[:2]).groupby(['data','field_name'])['bcorr'].nlargest(2).droplevel([0,1]).sort_index()
out = df.loc[temp.index]
out['bcorr'] = temp

आउटपुट:

   data field  bcorr
0     A   cs1    0.8
1     A   cs2    0.9
4     A   pq2    0.6
5     A   pq3    0.5
6     B   cs1    0.8
7     B   cs2    0.9
10    B   pq2    0.6
11    B   pq3    0.5

मेरा मानना ​​है कि यह कुछ ऐसा है जिसे आप हासिल करने की कोशिश कर रहे हैं

import pandas as pd

df = {'data': ['A', 'A', 'A', 'A', 'A', 'A', 'B', 'B', 'B', 'B', 'B', 'B'],
      'fie': ['cs1', 'cs2', 'cs3', 'pq1', 'pq2', 'pq3', 'cs1', 'cs2', 'cs3', 'pq1', 'pq2', 'pq3'],
      'bcorr': [0.8, 0.9, 0.7, 0.4, 0.6, 0.5, 0.8, 0.9, 0.7, 0.4, 0.6, 0.5]}

df = {'data': df['data'], 'fie_c': [x[:2] for x in df['fie']], 'fie_n': [x[2] for x in df['fie']],
      'bcorr': df['bcorr']}
df = pd.DataFrame(data=df)
df = df.sort_values('bcorr', ascending=False).groupby(by=['data', 'fie_c']).head(2).sort_values('data')
df['fie'] = df[['fie_c', 'fie_n']].apply(lambda x: '{}{}'.format(x[0], x[1]), axis=1)
df = df.drop(columns=['fie_c', 'fie_n'])
df = df[['data', 'fie', 'bcorr']]
print(df)

उत्पादन

   data  fie  bcorr
1     A  cs2    0.9
0     A  cs1    0.8
4     A  pq2    0.6
5     A  pq3    0.5
7     B  cs2    0.9
6     B  cs1    0.8
10    B  pq2    0.6
11    B  pq3    0.5

ध्यान दें कि पहली कुछ पंक्तियाँ अधिक स्पष्ट हो सकती हैं लेकिन मेरा ध्यान रेखा पर था

df = df.sort_values('bcorr', ascending=False).groupby(by=['data', 'fie_c']).head(2).sort_values('data')

जो अधिकांश महत्वपूर्ण कार्य करता है।