熊猫-计算多个条件

Question

Having a dataframe in python:

CASE    TYPE
1          A
1          A
1          A
2          A
2          B
3          B
3          B
3          B

how can I create a result dataframe which would yield all cases and either an "A" if the case had only "A's" assigned, "B" if it was only "B's" or "MIXED" if the case had both A and B?

Result would be then:

Case     Type
1        A
2        MIXED
3        B

Answer 1

Here is an option, where we firstly collect the TYPE as list by group of CASE and then check the length of unique TYPE, if it is larger than 1 , return MIXED otherwise the TYPE by itself:

import pandas as pd
import numpy as np
groups = df.groupby('CASE').agg(lambda g: [g.TYPE.unique()]).
            apply(lambda row: np.where(len(row.TYPE) > 1, 'MIXED', row.TYPE[0]), axis = 1)
groups

# CASE
# 1           A
# 2       MIXED
# 3           B
# dtype: object

Answer 2

df['NTYPES'] = df.groupby('CASE').transform(lambda x: x.nunique())
df.loc[df.NTYPES > 1, 'TYPE'] = 'MIXED'
df.groupby('TYPE', as_index=False).first().drop('NTYPES', 1)

    TYPE  CASE
0      A     1
1      B     3
2  MIXED     2

Answer 3

here is one bit ugly, but not that slow solution:

In [154]: df
Out[154]:
    CASE TYPE
0      1    A
1      1    A
2      1    A
3      2    A
4      2    B
5      3    B
6      3    B
7      3    B
8      4    C
9      4    C
10     4    B

In [155]: %paste
(df.groupby('CASE')['TYPE']
   .apply(lambda x: x.head(1) if x.nunique() == 1 else pd.Series(['MIX']))
   .reset_index()
   .drop('level_1', 1)
)
## -- End pasted text --
Out[155]:
   CASE TYPE
0     1    A
1     2  MIX
2     3    B
3     4  MIX

Timing: against 800K rows DF:

In [191]: df = pd.concat([df] * 10**5, ignore_index=True)

In [192]: df.shape
Out[192]: (800000, 3)

In [193]: %timeit Psidom(df)
1 loop, best of 3: 235 ms per loop

In [194]: %timeit capitalistpug(df)
1 loop, best of 3: 419 ms per loop

In [195]: %timeit Alberto_Garcia_Raboso(df)
10 loops, best of 3: 112 ms per loop

In [196]: %timeit MaxU(df)
10 loops, best of 3: 80.4 ms per loop

Answer 4

Here is a (admittedly over-engineered) solution that avoids looping over groups and DataFrame.apply (these are slow, so avoiding them may become important if your dataset gets sufficiently large).

import pandas as pd
df = pd.DataFrame({'CASE': [1]*3 + [2]*2 + [3]*3,
                   'TYPE': ['A']*4 + ['B']*4})

We group by CASE and compute the relative frequencies of TYPE being A or B :

grouped = df.groupby('CASE')
vc = (grouped['TYPE'].value_counts(normalize=True)
                     .unstack(level=0)
                     .fillna(0))

Here's what vc looks like

CASE   1    2    3
TYPE
A      1.0  0.5  0.0
B      0.0  0.5  0.0

Notice that all the information is contained in the first row. Cutting said row into bins with pd.cut gives the desired result:

tolerance = 1e-10
bins = [-tolerance, tolerance, 1-tolerance, 1+tolerance]
types = pd.cut(vc.loc['A'], bins=bins, labels=['B', 'MIXED', 'A'])

We get:

CASE
1        A
2    MIXED
3        B
Name: A, dtype: category
Categories (3, object): [B < MIXED < A]

For good measure, we can rename the types series:

types.name = 'TYPE'