blocks|key|190623|text|In+[1]:+df
Out[1]:
++++Sp++Mt+Value++count
0++MM1++S1+++++a++++++3
1++MM1++S1+++++n++++++2
2++MM1++S3++++cb++++++5
3++MM2++S3++++mk++++++8
4++MM2++S4++++bg+++++10
5++MM2++S4+++dgd++++++1
6++MM4++S2++++rd++++++2
7++MM4++S2++++cb++++++2
8++MM4++S2+++uyi++++++7

In+[2]:+df.groupby(['Mt'],+sort=False)['count'].max()
Out[2]:
Mt
S1+++++3
S3+++++8
S4++++10
S2+++++7
Name:+count|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|190624|要获取原始DF的索引，可以执行以下操作：|unstyled|190625|In+[3]:+idx+=+df.groupby(['Mt'])['count'].transform(max)+==+df['count']

In+[4]:+df[idx]
Out[4]:
++++Sp++Mt+Value++count
0++MM1++S1+++++a++++++3
3++MM2++S3++++mk++++++8
4++MM2++S4++++bg+++++10
8++MM4++S2+++uyi++++++7|190626|请注意，如果每个组有多个最大值，将返回所有值。|190627|更新|offset|length|style|BOLD|190628|在万岁玛丽的机会，这是操作员的要求：|190629|In+[5]:+df['count_max']+=+df.groupby(['Mt'])['count'].transform(max)

In+[6]:+df
Out[6]:
++++Sp++Mt+Value++count++count_max
0++MM1++S1+++++a++++++3++++++++++3
1++MM1++S1+++++n++++++2++++++++++3
2++MM1++S3++++cb++++++5++++++++++8
3++MM2++S3++++mk++++++8++++++++++8
4++MM2++S4++++bg+++++10+++++++++10
5++MM2++S4+++dgd++++++1+++++++++10
6++MM4++S2++++rd++++++2++++++++++7
7++MM4++S2++++cb++++++2++++++++++7
8++MM4++S2+++uyi++++++7++++++++++7|190630|entityMap^0|0|0|0|0|0|2|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|X|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$B|C]]|$1|I|3|J|5|F|7|Z|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|10|8|@$M|11|N|12|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|F|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$B|C]]|$1|U|3|-4|5|F|7|15|8|@]|9|@]|A|$]]]|V|$]]

<pre><code>In [1]: df
Out[1]:
 Sp Mt Value count
0 MM1 S1 a 3
1 MM1 S1 n 2
2 MM1 S3 cb 5
3 MM2 S3 mk 8
4 MM2 S4 bg 10
5 MM2 S4 dgd 1
6 MM4 S2 rd 2
7 MM4 S2 cb 2
8 MM4 S2 uyi 7

In [2]: df.groupby(['Mt'], sort=False)['count'].max()
Out[2]:
Mt
S1 3
S3 8
S4 10
S2 7
Name: count
</code></pre>

To get the indices of the original DF you can do:

<pre><code>In [3]: idx = df.groupby(['Mt'])['count'].transform(max) == df['count']

In [4]: df[idx]
Out[4]:
 Sp Mt Value count
0 MM1 S1 a 3
3 MM2 S3 mk 8
4 MM2 S4 bg 10
8 MM4 S2 uyi 7
</code></pre>

Note that if you have multiple max values per group, all will be returned.

Update

On a hail mary chance that this is what the OP is requesting:

<pre><code>In [5]: df['count_max'] = df.groupby(['Mt'])['count'].transform(max)

In [6]: df
Out[6]:
 Sp Mt Value count count_max
0 MM1 S1 a 3 3
1 MM1 S1 n 2 3
2 MM1 S3 cb 5 8
3 MM2 S3 mk 8 8
4 MM2 S4 bg 10 10
5 MM2 S4 dgd 1 10
6 MM4 S2 rd 2 7
7 MM4 S2 cb 2 7
8 MM4 S2 uyi 7 7
</code></pre>

blocks|key|2816031|text|在相对较大的DataFrame+(大约400k行)上尝试了Zelazny建议的解决方案后，我发现它非常慢。这是一个替代方案，我发现它在我的数据集上运行的速度要快几个数量级。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2816032|df+=+pd.DataFrame({
++++'sp'+:+['MM1',+'MM1',+'MM1',+'MM2',+'MM2',+'MM2',+'MM4',+'MM4',+'MM4'],
++++'mt'+:+['S1',+'S1',+'S3',+'S3',+'S4',+'S4',+'S2',+'S2',+'S2'],
++++'val'+:+['a',+'n',+'cb',+'mk',+'bg',+'dgb',+'rd',+'cb',+'uyi'],
++++'count'+:+[3,2,5,8,10,1,2,2,7]
++++})

df_grouped+=+df.groupby(['sp',+'mt']).agg({'count':'max'})

df_grouped+=+df_grouped.reset_index()

df_grouped+=+df_grouped.rename(columns={'count':'count_max'})

df+=+pd.merge(df,+df_grouped,+how='left',+on=['sp',+'mt'])

df+=+df[df['count']+==+df['count_max']]|code-block|syntax|javascript|2816033|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Having tried the solution suggested by Zelazny on a relatively large DataFrame (~400k rows) I found it to be very slow. Here is an alternative that I found to run orders of magnitude faster on my data set.

<pre><code>df = pd.DataFrame({
 'sp' : ['MM1', 'MM1', 'MM1', 'MM2', 'MM2', 'MM2', 'MM4', 'MM4', 'MM4'],
 'mt' : ['S1', 'S1', 'S3', 'S3', 'S4', 'S4', 'S2', 'S2', 'S2'],
 'val' : ['a', 'n', 'cb', 'mk', 'bg', 'dgb', 'rd', 'cb', 'uyi'],
 'count' : [3,2,5,8,10,1,2,2,7]
 })

df_grouped = df.groupby(['sp', 'mt']).agg({'count':'max'})

df_grouped = df_grouped.reset_index()

df_grouped = df_grouped.rename(columns={'count':'count_max'})

df = pd.merge(df, df_grouped, how='left', on=['sp', 'mt'])

df = df[df['count'] == df['count_max']]
</code></pre>

blocks|key|192450|text|对我来说，最简单的解决方案是当count等于最大值时保持值。因此，下面一行命令就足够了：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|192451|df[df['count']+==+df.groupby(['Mt'])['count'].transform(max)]|code-block|syntax|javascript|192452|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

For me, the easiest solution would be keep value when count is equal to the maximum. Therefore, the following one line command is enough : 

<pre><code>df[df['count'] == df.groupby(['Mt'])['count'].transform(max)]
</code></pre>

blocks|key|2816057|text|您可以按计数对dataFrame进行排序，然后删除重复项。我认为这样更简单：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2816058|df.sort_values('count',+ascending=False).drop_duplicates(['Sp','Mt'])|code-block|syntax|javascript|2816059|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can sort the dataFrame by count and then remove duplicates. I think it's easier:

<pre><code>df.sort_values('count', ascending=False).drop_duplicates(['Sp','Mt'])
</code></pre>

blocks|key|3028496|text|简单的解决方案是应用：idxmax()函数来获取具有最大值的行的索引。这将过滤组中具有最大值的所有行。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3028497|In+[365]:+import+pandas+as+pd

In+[366]:+df+=+pd.DataFrame({
'sp'+:+['MM1',+'MM1',+'MM1',+'MM2',+'MM2',+'MM2',+'MM4',+'MM4','MM4'],
'mt'+:+['S1',+'S1',+'S3',+'S3',+'S4',+'S4',+'S2',+'S2',+'S2'],
'val'+:+['a',+'n',+'cb',+'mk',+'bg',+'dgb',+'rd',+'cb',+'uyi'],
'count'+:+[3,2,5,8,10,1,2,2,7]
})

In+[367]:+df+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Out[367]:+
+++count++mt+++sp++val
0++++++3++S1++MM1++++a
1++++++2++S1++MM1++++n
2++++++5++S3++MM1+++cb
3++++++8++S3++MM2+++mk
4+++++10++S4++MM2+++bg
5++++++1++S4++MM2++dgb
6++++++2++S2++MM4+++rd
7++++++2++S2++MM4+++cb
8++++++7++S2++MM4++uyi


###+Apply+idxmax()+and+use+.loc()+on+dataframe+to+filter+the+rows+with+max+values:
In+[368]:+df.loc[df.groupby(["sp",+"mt"])["count"].idxmax()]+++++++++++++++++++++++++++++++++++++++++++++++++++++++
Out[368]:+
+++count++mt+++sp++val
0++++++3++S1++MM1++++a
2++++++5++S3++MM1+++cb
3++++++8++S3++MM2+++mk
4+++++10++S4++MM2+++bg
8++++++7++S2++MM4++uyi

###+Just+to+show+what+values+are+returned+by+.idxmax()+above:
In+[369]:+df.groupby(["sp",+"mt"])["count"].idxmax().values++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Out[369]:+array([0,+2,+3,+4,+8])|code-block|syntax|javascript|3028498|entityMap^0|B|O|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Easy solution would be to apply : idxmax() function to get indices of rows with max values. 
This would filter out all the rows with max value in the group.

<pre><code>In [365]: import pandas as pd

In [366]: df = pd.DataFrame({
'sp' : ['MM1', 'MM1', 'MM1', 'MM2', 'MM2', 'MM2', 'MM4', 'MM4','MM4'],
'mt' : ['S1', 'S1', 'S3', 'S3', 'S4', 'S4', 'S2', 'S2', 'S2'],
'val' : ['a', 'n', 'cb', 'mk', 'bg', 'dgb', 'rd', 'cb', 'uyi'],
'count' : [3,2,5,8,10,1,2,2,7]
})

In [367]: df 
Out[367]: 
 count mt sp val
0 3 S1 MM1 a
1 2 S1 MM1 n
2 5 S3 MM1 cb
3 8 S3 MM2 mk
4 10 S4 MM2 bg
5 1 S4 MM2 dgb
6 2 S2 MM4 rd
7 2 S2 MM4 cb
8 7 S2 MM4 uyi


### Apply idxmax() and use .loc() on dataframe to filter the rows with max values:
In [368]: df.loc[df.groupby(["sp", "mt"])["count"].idxmax()] 
Out[368]: 
 count mt sp val
0 3 S1 MM1 a
2 5 S3 MM1 cb
3 8 S3 MM2 mk
4 10 S4 MM2 bg
8 7 S2 MM4 uyi

### Just to show what values are returned by .idxmax() above:
In [369]: df.groupby(["sp", "mt"])["count"].idxmax().values 
Out[369]: array([0, 2, 3, 4, 8])
</code></pre>

blocks|key|2816080|text|使用groupby和idxmax方法：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2816081|2816082|transfer+col+date+to+datetime：|ordered-list-item|2816083|2816084|df'date'=pd.to_datetime(df'date')|2816085|get+date列的max的索引，在groupyby+ad_id之后：|unordered-list-item|2816086|2816087|idx=df.groupby(by='ad_id')'date'.idxmax()|2816088|get需要的数据：|2816089|2816090|df_max=df.locidx，|2816091|Out54|2816092|ad_id++price+++++++date
7+++++22++++++2+2018-06-11
6+++++23++++++2+2018-06-22
2+++++24++++++2+2018-06-30
3+++++28++++++5+2018-06-22|code-block|syntax|javascript|2816093|entityMap^0|2|7|A|6|0|0|D|4|L|8|0|0|0|4|4|A|3|I|E|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|1B|8|@]|D|@]|E|$]]|$1|G|3|H|5|I|7|1C|8|@$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|1H|8|@]|D|@]|E|$]]|$1|K|3|L|5|6|7|1I|8|@]|D|@]|E|$]]|$1|M|3|N|5|O|7|1J|8|@$9|1K|A|1L|B|C]|$9|1M|A|1N|B|C]|$9|1O|A|1P|B|C]]|D|@]|E|$]]|$1|P|3|-4|5|6|7|1Q|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1R|8|@]|D|@]|E|$]]|$1|S|3|T|5|O|7|1S|8|@]|D|@]|E|$]]|$1|U|3|-4|5|6|7|1T|8|@]|D|@]|E|$]]|$1|V|3|W|5|6|7|1U|8|@]|D|@]|E|$]]|$1|X|3|Y|5|6|7|1V|8|@]|D|@]|E|$]]|$1|Z|3|10|5|11|7|1W|8|@]|D|@]|E|$12|13]]|$1|14|3|-4|5|6|7|1X|8|@]|D|@]|E|$]]]|15|$]]

Use <code>groupby</code> and <code>idxmax</code> methods:

<ol>
<li>transfer col <code>date</code> to <code>datetime</code>:

<pre><code>df['date']=pd.to_datetime(df['date'])
</code></pre></li>
<li>get the index of <code>max</code> of column <code>date</code>, after <code>groupyby ad_id</code>:

<pre><code>idx=df.groupby(by='ad_id')['date'].idxmax()
</code></pre></li>
<li>get the wanted data:

<pre><code>df_max=df.loc[idx,]
</code></pre></li>
</ol>

Out[54]:

<pre><code>ad_id price date
7 22 2 2018-06-11
6 23 2 2018-06-22
2 24 2 2018-06-30
3 28 5 2018-06-22
</code></pre>

blocks|key|192471|text|df+=+pd.DataFrame({
'sp'+:+['MM1',+'MM1',+'MM1',+'MM2',+'MM2',+'MM2',+'MM4',+'MM4','MM4'],
'mt'+:+['S1',+'S1',+'S3',+'S3',+'S4',+'S4',+'S2',+'S2',+'S2'],
'val'+:+['a',+'n',+'cb',+'mk',+'bg',+'dgb',+'rd',+'cb',+'uyi'],
'count'+:+[3,2,5,8,10,1,2,2,7]
})

df.groupby(['sp',+'mt']).apply(lambda+grp:+grp.nlargest(1,+'count'))|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|192472|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>df = pd.DataFrame({
'sp' : ['MM1', 'MM1', 'MM1', 'MM2', 'MM2', 'MM2', 'MM4', 'MM4','MM4'],
'mt' : ['S1', 'S1', 'S3', 'S3', 'S4', 'S4', 'S2', 'S2', 'S2'],
'val' : ['a', 'n', 'cb', 'mk', 'bg', 'dgb', 'rd', 'cb', 'uyi'],
'count' : [3,2,5,8,10,1,2,2,7]
})

df.groupby(['sp', 'mt']).apply(lambda grp: grp.nlargest(1, 'count'))
</code></pre>

blocks|key|194896|text|您可能不需要使用sort_values%2B+drop_duplicates来处理group+by|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|194897|df.sort_values('count').drop_duplicates(['Sp','Mt'],keep='last')
Out[190]:+
++++Sp++Mt+Value++count
0++MM1++S1+++++a++++++3
2++MM1++S3++++cb++++++5
8++MM4++S2+++uyi++++++7
3++MM2++S3++++mk++++++8
4++MM2++S4++++bg+++++10|code-block|syntax|javascript|194898|使用tail也是几乎相同的逻辑|194899|df.sort_values('count').groupby(['Sp',+'Mt']).tail(1)
Out[52]:+
++++Sp++Mt+Value++count
0++MM1++S1+++++a++++++3
2++MM1++S3++++cb++++++5
8++MM4++S2+++uyi++++++7
3++MM2++S3++++mk++++++8
4++MM2++S4++++bg+++++10|194900|entityMap^0|8|B|L|F|0|0|2|4|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|P|$]]

You may not need to do with group by , using <code>sort_values</code>+ <code>drop_duplicates</code>

<pre><code>df.sort_values('count').drop_duplicates(['Sp','Mt'],keep='last')
Out[190]: 
 Sp Mt Value count
0 MM1 S1 a 3
2 MM1 S3 cb 5
8 MM4 S2 uyi 7
3 MM2 S3 mk 8
4 MM2 S4 bg 10
</code></pre>

Also almost same logic by using <code>tail</code>

<pre><code>df.sort_values('count').groupby(['Sp', 'Mt']).tail(1)
Out[52]: 
 Sp Mt Value count
0 MM1 S1 a 3
2 MM1 S3 cb 5
8 MM4 S2 uyi 7
3 MM2 S3 mk 8
4 MM2 S4 bg 10
</code></pre>

blocks|key|192825|text|我已经在许多组操作中使用了这种函数风格：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|192826|df+=+pd.DataFrame({
+++'Sp'+:+['MM1',+'MM1',+'MM1',+'MM2',+'MM2',+'MM2',+'MM4',+'MM4',+'MM4'],
+++'Mt'+:+['S1',+'S1',+'S3',+'S3',+'S4',+'S4',+'S2',+'S2',+'S2'],
+++'Val'+:+['a',+'n',+'cb',+'mk',+'bg',+'dgb',+'rd',+'cb',+'uyi'],
+++'Count'+:+[3,2,5,8,10,1,2,2,7]
})

df.groupby('Mt')\
++.apply(lambda+group:+group[group.Count+==+group.Count.max()])\
++.reset_index(drop=True)

++++sp++mt++val++count
0++MM1++S1++++a++++++3
1++MM4++S2++uyi++++++7
2++MM2++S3+++mk++++++8
3++MM2++S4+++bg+++++10|code-block|syntax|javascript|192827|.reset_index(drop=True)通过删除group-index返回到原始索引。|offset|length|style|CODE|192828|entityMap^0|0|0|0|N|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I've been using this functional style for many group operations:

<pre><code>df = pd.DataFrame({
 'Sp' : ['MM1', 'MM1', 'MM1', 'MM2', 'MM2', 'MM2', 'MM4', 'MM4', 'MM4'],
 'Mt' : ['S1', 'S1', 'S3', 'S3', 'S4', 'S4', 'S2', 'S2', 'S2'],
 'Val' : ['a', 'n', 'cb', 'mk', 'bg', 'dgb', 'rd', 'cb', 'uyi'],
 'Count' : [3,2,5,8,10,1,2,2,7]
})

df.groupby('Mt')\
 .apply(lambda group: group[group.Count == group.Count.max()])\
 .reset_index(drop=True)

 sp mt val count
0 MM1 S1 a 3
1 MM4 S2 uyi 7
2 MM2 S3 mk 8
3 MM2 S4 bg 10
</code></pre>

<code>.reset_index(drop=True)</code> gets you back to the original index by dropping the group-index.

blocks|key|2816165|text|意识到将“最大”应用于groupby+object的效果也很好：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|2816166|其他优势-如果需要，还可以获取的前n个值：|2816167|In+[85]:+import+pandas+as+pd

In+[86]:+df+=+pd.DataFrame({
++++...:+'sp'+:+['MM1',+'MM1',+'MM1',+'MM2',+'MM2',+'MM2',+'MM4',+'MM4','MM4'],
++++...:+'mt'+:+['S1',+'S1',+'S3',+'S3',+'S4',+'S4',+'S2',+'S2',+'S2'],
++++...:+'val'+:+['a',+'n',+'cb',+'mk',+'bg',+'dgb',+'rd',+'cb',+'uyi'],
++++...:+'count'+:+[3,2,5,8,10,1,2,2,7]
++++...:+})

##+Apply+nlargest(1)+to+find+the+max+val+df,+and+nlargest(n)+gives+top+n+values+for+df:
In+[87]:+df.groupby(["sp",+"mt"]).apply(lambda+x:+x.nlargest(1,+"count")).reset_index(drop=True)
Out[87]:
+++count++mt+++sp++val
0++++++3++S1++MM1++++a
1++++++5++S3++MM1+++cb
2++++++8++S3++MM2+++mk
3+++++10++S4++MM2+++bg
4++++++7++S2++MM4++uyi|code-block|syntax|javascript|2816168|entityMap^0|3|5|B|E|0|A|A|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|W|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|N|$]]

Realizing that "applying" "nlargest" to groupby object works just as fine:

Additional advantage - also can fetch top n values if required:

<pre><code>In [85]: import pandas as pd

In [86]: df = pd.DataFrame({
 ...: 'sp' : ['MM1', 'MM1', 'MM1', 'MM2', 'MM2', 'MM2', 'MM4', 'MM4','MM4'],
 ...: 'mt' : ['S1', 'S1', 'S3', 'S3', 'S4', 'S4', 'S2', 'S2', 'S2'],
 ...: 'val' : ['a', 'n', 'cb', 'mk', 'bg', 'dgb', 'rd', 'cb', 'uyi'],
 ...: 'count' : [3,2,5,8,10,1,2,2,7]
 ...: })

## Apply nlargest(1) to find the max val df, and nlargest(n) gives top n values for df:
In [87]: df.groupby(["sp", "mt"]).apply(lambda x: x.nlargest(1, "count")).reset_index(drop=True)
Out[87]:
 count mt sp val
0 3 S1 MM1 a
1 5 S3 MM1 cb
2 8 S3 MM2 mk
3 10 S4 MM2 bg
4 7 S2 MM4 uyi
</code></pre>

blocks|key|3028637|text|尝试在groupby对象上使用“using”。使用that的优点是，它返回从中提取“n个最大项”的行的索引。注意:我们对索引的第二(1)个元素进行切片，因为在本例中，我们的索引由元组组成(例如(s1，0))。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3028638|df+=+pd.DataFrame({
'sp'+:+['MM1',+'MM1',+'MM1',+'MM2',+'MM2',+'MM2',+'MM4',+'MM4','MM4'],
'mt'+:+['S1',+'S1',+'S3',+'S3',+'S4',+'S4',+'S2',+'S2',+'S2'],
'val'+:+['a',+'n',+'cb',+'mk',+'bg',+'dgb',+'rd',+'cb',+'uyi'],
'count'+:+[3,2,5,8,10,1,2,2,7]
})

d+=+df.groupby('mt')['count'].nlargest(1)+#+pass+1+since+we+want+the+max

df.iloc[[i[1]+for+i+in+d.index],+:]+#+pass+the+index+of+d+as+list+comprehension|code-block|syntax|javascript|3028639|enter+image+description+here|offset|length|3028640|entityMap|0|LINK|mutability|MUTABLE|url|https://i.stack.imgur.com/F2h7N.png^0|0|0|0|S|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

Try using "nlargest" on the groupby object. The advantage of using nlargest is that it returns the index of the rows where "the nlargest item(s)" were fetched from. 
Note: we slice the second(1) element of our index since our index in this case consist of tuples(eg.(s1, 0)).

<pre><code>df = pd.DataFrame({
'sp' : ['MM1', 'MM1', 'MM1', 'MM2', 'MM2', 'MM2', 'MM4', 'MM4','MM4'],
'mt' : ['S1', 'S1', 'S3', 'S3', 'S4', 'S4', 'S2', 'S2', 'S2'],
'val' : ['a', 'n', 'cb', 'mk', 'bg', 'dgb', 'rd', 'cb', 'uyi'],
'count' : [3,2,5,8,10,1,2,2,7]
})

d = df.groupby('mt')['count'].nlargest(1) # pass 1 since we want the max

df.iloc[[i[1] for i in d.index], :] # pass the index of d as list comprehension
</code></pre>

<a href="https://i.stack.imgur.com/F2h7N.png" rel="noreferrer">enter image description here</a>

blocks|key|194967|text|总而言之，有很多方法，但哪一种更快？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|194968|import+pandas+as+pd
import+numpy+as+np
import+time

df+=+pd.DataFrame(np.random.randint(1,10,size=(1000000,+2)),+columns=list('AB'))

start_time+=+time.time()
df1idx+=+df.groupby(['A'])['B'].transform(max)+==+df['B']
df1+=+df[df1idx]
print("---1+)+%25s+seconds+---"+%25+(time.time()+-+start_time))

start_time+=+time.time()
df2+=+df.sort_values('B').groupby(['A']).tail(1)
print("---2+)+%25s+seconds+---"+%25+(time.time()+-+start_time))

start_time+=+time.time()
df3+=+df.sort_values('B').drop_duplicates(['A'],keep='last')
print("---3+)+%25s+seconds+---"+%25+(time.time()+-+start_time))

start_time+=+time.time()
df3b+=+df.sort_values('B',+ascending=False).drop_duplicates(['A'])
print("---3b)+%25s+seconds+---"+%25+(time.time()+-+start_time))

start_time+=+time.time()
df4+=+df[df['B']+==+df.groupby(['A'])['B'].transform(max)]
print("---4+)+%25s+seconds+---"+%25+(time.time()+-+start_time))

start_time+=+time.time()
d+=+df.groupby('A')['B'].nlargest(1)
df5+=+df.iloc[[i[1]+for+i+in+d.index],+:]
print("---5+)+%25s+seconds+---"+%25+(time.time()+-+start_time))|code-block|syntax|javascript|194969|获胜者是..。|194970|194971|--1+)+0.03337574005126953秒-|unordered-list-item|194972|--2)+0.1346898078918457秒-|194973|--3)+0.10243558883666992秒-|194974|--3b)+0.1004343032836914秒-|194975|<代码>H110--4)+0.028397560119628906秒-<代码>H211<代码>H112--5)+0.07552886009216309秒-<代码>H213<代码>F214|194976|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|10|8|@]|9|@]|A|$]]|$1|M|3|N|5|L|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|L|7|12|8|@]|9|@]|A|$]]|$1|Q|3|R|5|L|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

Summarizing, there are many ways, but which one is faster?
<pre><code>import pandas as pd
import numpy as np
import time

df = pd.DataFrame(np.random.randint(1,10,size=(1000000, 2)), columns=list('AB'))

start_time = time.time()
df1idx = df.groupby(['A'])['B'].transform(max) == df['B']
df1 = df[df1idx]
print(&quot;---1 ) %s seconds ---&quot; % (time.time() - start_time))

start_time = time.time()
df2 = df.sort_values('B').groupby(['A']).tail(1)
print(&quot;---2 ) %s seconds ---&quot; % (time.time() - start_time))

start_time = time.time()
df3 = df.sort_values('B').drop_duplicates(['A'],keep='last')
print(&quot;---3 ) %s seconds ---&quot; % (time.time() - start_time))

start_time = time.time()
df3b = df.sort_values('B', ascending=False).drop_duplicates(['A'])
print(&quot;---3b) %s seconds ---&quot; % (time.time() - start_time))

start_time = time.time()
df4 = df[df['B'] == df.groupby(['A'])['B'].transform(max)]
print(&quot;---4 ) %s seconds ---&quot; % (time.time() - start_time))

start_time = time.time()
d = df.groupby('A')['B'].nlargest(1)
df5 = df.iloc[[i[1] for i in d.index], :]
print(&quot;---5 ) %s seconds ---&quot; % (time.time() - start_time))
</code></pre>
And the winner is...
<ul>
<li>--1 ) 0.03337574005126953 seconds ---</li>
<li>--2 ) 0.1346898078918457 seconds ---</li>
<li>--3 ) 0.10243558883666992 seconds ---</li>
<li>--3b) 0.1004343032836914 seconds ---</li>
<li>--4 ) 0.028397560119628906 seconds ---</li>
<li>--5 ) 0.07552886009216309 seconds ---</li>
</ul>

blocks|key|190784|text|如果您对DataFrame进行排序，则排序将保留在groupby中。然后，您可以抓取第一个或最后一个元素并重置索引。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|190785|df+=+pd.DataFrame({
++++'sp'+:+['MM1',+'MM1',+'MM1',+'MM2',+'MM2',+'MM2',+'MM4',+'MM4','MM4'],
++++'mt'+:+['S1',+'S1',+'S3',+'S3',+'S4',+'S4',+'S2',+'S2',+'S2'],
++++'val'+:+['a',+'n',+'cb',+'mk',+'bg',+'dgb',+'rd',+'cb',+'uyi'],
++++'count'+:+[3,2,5,8,10,1,2,2,7]
})

df.sort_values("count",+ascending=False).groupby(["sp",+"mt"]).first().reset_index()|code-block|syntax|javascript|190786|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If you sort your DataFrame that ordering will be preserved in the groupby. You can then just grab the first or last element and reset the index.
<pre><code>df = pd.DataFrame({
 'sp' : ['MM1', 'MM1', 'MM1', 'MM2', 'MM2', 'MM2', 'MM4', 'MM4','MM4'],
 'mt' : ['S1', 'S1', 'S3', 'S3', 'S4', 'S4', 'S2', 'S2', 'S2'],
 'val' : ['a', 'n', 'cb', 'mk', 'bg', 'dgb', 'rd', 'cb', 'uyi'],
 'count' : [3,2,5,8,10,1,2,2,7]
})

df.sort_values(&quot;count&quot;, ascending=False).groupby([&quot;sp&quot;, &quot;mt&quot;]).first().reset_index()
</code></pre>

How do I find all rows in a pandas data frame which have the max value for <code>count</code> column, after grouping by <code>['Sp','Mt']</code> columns?
Example 1: the following dataFrame, which I group by <code>['Sp','Mt']</code>:
<pre><code> Sp Mt Value count
0 MM1 S1 a **3**
1 MM1 S1 n 2
2 MM1 S3 cb **5**
3 MM2 S3 mk **8**
4 MM2 S4 bg **10**
5 MM2 S4 dgd 1
6 MM4 S2 rd 2
7 MM4 S2 cb 2
8 MM4 S2 uyi **7**
</code></pre>
Expected output: get the result rows whose count is max between the groups, like:
<pre><code>0 MM1 S1 a **3**
2 MM1 S3 cb **5**
3 MM2 S3 mk **8**
4 MM2 S4 bg **10** 
8 MM4 S2 uyi **7**
</code></pre>
Example 2: this dataframe, which I group by <code>['Sp','Mt']</code>:
<pre><code> Sp Mt Value count
4 MM2 S4 bg 10
5 MM2 S4 dgd 1
6 MM4 S2 rd 2
7 MM4 S2 cb 8
8 MM4 S2 uyi 8
</code></pre>
For the above example, I want to get all the rows where <code>count</code> equals max, in each group e.g :
<pre><code>MM2 S4 bg 10
MM4 S2 cb 8
MM4 S2 uyi 8
</code></pre>

Get the row(s) which have the max value in groups using groupby

在按['Sp','Mt']列分组后，如何找到pandas数据框中count列的最大值的所有行？示例1:下面的dataFrame，我根据['Sp','Mt']对其进行分组   Sp   Mt Value   count0  MM1  S1   a     **3**1  MM1  S1   n       22  MM1...

问使用groupby获取组中具有最大值的行
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用groupby获取组中具有最大值的行EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用groupby获取组中具有最大值的行
EN