data    field   bcorr
0   A   cs1 0.8
1   A   cs2 0.9
2   A   cs3 0.7
3   A   pq1 0.4
4   A   pq2 0.6
5   A   pq3 0.5
6   B   cs1 0.8
7   B   cs2 0.9
8   B   cs3 0.7
9   B   pq1 0.4
10  B   pq2 0.6
11  B   pq3 0.5

प्रत्येक डेटा A और B के लिए data कॉलम में, cs और pq फ़ील्ड को field कॉलम से अलग करें, और फिर 2 प्राप्त करने के लिए एग्रीगेट करें bcorr का अधिकतम मान।

नमूना परिणाम इस प्रकार होगा:

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

इसके लिए, एक विकल्प यह है कि रिकॉर्ड की सूची बनाते समय ऐसा किया जाए, जिसमें स्पष्ट रूप से उच्च जटिलता होगी।

दूसरा, मैं इसे पांडा डेटाफ्रेम के साथ करना चाहता हूं, जहां मैंने data कॉलम पर groupby का उपयोग किया, फिर स्रोत प्राप्त करने के लिए startswith लागू किया field और फिर लागू करें max

-2
ggupta 14 जिंदा 2022, 11:59

4 जवाब

सबसे पहले, प्रत्येक फ़ील्ड (पहले अक्षर) के सामान्य भाग को निकालें, फिर मानों को क्रमबद्ध करें (उच्चतम मान नीचे जाएं)। अंत में 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] का उपयोग कर सकते हैं।

0
Corralien 14 जिंदा 2022, 12:10

आप दिनांक पर 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()
0
sophocles 14 जिंदा 2022, 12:30
अधिकतम bcorr नहीं मिल रहा है
 – 
ggupta
14 जिंदा 2022, 12:07
उत्तर संपादित किया। पहले मूल्यों को क्रमबद्ध करने की आवश्यकता थी।
 – 
sophocles
14 जिंदा 2022, 12:09
बहुत अच्छा होता अगर हम df.field.str[:2] भाग का सामान्यीकरण कर सकें। यदि हमारे पास cs, abc से शुरू होने वाला क्षेत्र है तो यह काम नहीं करेगा।
 – 
ggupta
14 जिंदा 2022, 12:19
नहीं, ऐसा नहीं होगा यदि आपके पास समूह करने के लिए 2 से अधिक वर्ण हैं। लेकिन अगर आपके पास वह है, तो आप केवल गैर अंकों वाले वर्णों का उपयोग करके समूहबद्ध कर सकते हैं, जो काम करना चाहिए
 – 
sophocles
14 जिंदा 2022, 12:21
मैंने उस लचीलेपन की अनुमति देने के लिए उत्तर संपादित किया है, कृपया एक नज़र डालें। आप @ Corralien के उत्तर पर भी एक नज़र डाल सकते हैं, यह इस लचीलेपन की अनुमति भी दे रहा है।
 – 
sophocles
14 जिंदा 2022, 12:30

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

(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
-1
enke 14 जिंदा 2022, 12:12

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

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

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

-1
Trilokinath Modi 14 जिंदा 2022, 15:46