Início / coding / Perguntas / 78246775
Accepted
x_Amir_x
Asked: 2024-03-30 11:51:48 +0800 CST

Como posso alterar a coluna groupby para encontrar a primeira linha que atende às condições de uma máscara se o groupby inicial não conseguiu encontrá-la?

  • 772

Este é o meu DataFrame:

import pandas as pd
df = pd.DataFrame(
    {
        'main': ['x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'y', 'y', 'y', 'y', 'y', 'y', 'y'],
        'sub': ['c', 'c', 'c', 'd', 'd', 'e', 'e', 'e', 'e', 'f', 'f', 'f', 'f', 'g', 'g', 'g'],
        'num_1': [10, 9, 80, 80, 99, 101, 110, 222, 90, 1, 7, 10, 2, 10, 95, 10],
        'num_2': [99, 99, 99, 102, 102, 209, 209, 209, 209, 100, 100, 100, 100, 90, 90, 90]
    }
)

E este é o meu resultado esperado. Quero adicionar coluna result:

   main sub  num_1  num_2  result
0     x   c     10     99     101
1     x   c      9     99     101
2     x   c     80     99     101
3     x   d     80    102     110
4     x   d     99    102     110
5     x   e    101    209     222
6     x   e    110    209     222
7     x   e    222    209     222
8     x   e     90    209     222
9     y   f      1    100     NaN
10    y   f      7    100     NaN
11    y   f     10    100     NaN
12    y   f      2    100     NaN
13    y   g     10     90      95
14    y   g     95     90      95
15    y   g     10     90      95

A máscara é:

mask = (df.num_1 > df.num_2)

O processo começa assim:

a) A groupbycoluna ésub

b) Encontrar a primeira linha que atenda à condição da máscara para cada grupo.

c) Coloque o valor de num_1noresult

Se não houver linhas que atendam à condição da máscara, a groupbycoluna será alterada para mainpara encontrar a primeira linha de mask. Há condição para esta fase:

O anterior subsnão deve ser considerado ao usar maincomo groupbycoluna.

Um exemplo das etapas acima para agrupar dna subcoluna:

a) subé a groupbycoluna.

b) Não há linhas no dgrupo quedf.num_1 > df.num_2

Então agora para group d, seu maingrupo é pesquisado. No entanto, o grupo ctambém está neste maingrupo. Como é anterior a group d, group cnão deve contar para esta etapa.

Nesta imagem mostrei de onde vêm esses valores:

insira a descrição da imagem aqui

E esta é a minha tentativa. Resolve parcialmente o problema para alguns grupos, mas não para todos:

def step_a(g):
    mask = (g.num_1 > g.num_2)

    g.loc[mask.cumsum().eq(1) & mask, 'result'] = g.num_1
    g['result'] = g.result.ffill().bfill()
    return g

a = df.groupby('sub').apply(step_a)
python

2 respostas

  1. Código

    definir função personalizada

    def get_result(d):
    cond = d['num_1'].gt(d['num_2'])
    if cond.sum() > 0:
        target = d['num_1'].where(cond).bfill().iloc[0]        
    else:
        df1 = df[df['main'].eq(d['main'].iloc[0])]
        s1 = df1['num_2'].where(df1['sub'].eq(d['sub'].iloc[0])).ffill()
        target = df1['num_1'].where(df1['num_1'].gt(s1)).bfill().iloc[0]

    return pd.Series(target, index=d.index)

    fazer resultcoluna

    df['result'] = df.groupby(['main', 'sub'], group_keys=False).apply(get_result)

    df:

       main sub  num_1  num_2  result
0     x   c     10     99   101.0
1     x   c      9     99   101.0
2     x   c     80     99   101.0
3     x   d     80    102   110.0
4     x   d     99    102   110.0
5     x   e    101    209   222.0
6     x   e    110    209   222.0
7     x   e    222    209   222.0
8     x   e     90    209   222.0
9     y   f      1    100     NaN
10    y   f      7    100     NaN
11    y   f     10    100     NaN
12    y   f      2    100     NaN
13    y   g     10     90    95.0
14    y   g     95     90    95.0
15    y   g     10     90    95.0
    • 1
  2. Best Answer

    IIUC, você pode usar a transmissão para formar uma máscara por "principal" e usá-la para encontrar o primeiro num1> num2 considerando apenas os próximos grupos:

    def find(g):
    # get sub as 0,1,2…
    sub = pd.factorize(g['sub'])[0]
    # convert inputs to numpy
    n1 = g['num_1'].to_numpy()
    n2 = g.loc[~g['sub'].duplicated(), 'num_2'].to_numpy()
    # form mask
    # (n1[:, None] > n2) -> num_1 > num_2
    # (sub[:, None] >= np.arange(len(n2))) -> exclude previous groups
    m = (n1[:, None] > n2) & (sub[:, None] >= np.arange(len(n2)))
    # find first True per column
    return pd.Series(np.where(m.any(0), n1[m.argmax(0)], np.nan)[sub],
                     index=g.index)


df['result'] = df.groupby('main', group_keys=False).apply(find)

    Observe que você pode facilmente ajustar as máscaras para executar outras lógicas (pesquisar nos próximos n grupos, excluir todos os grupos anteriores, exceto o anterior imediato, etc.).

    Saídas:

    # example 1                               # example 2 (from comments)
   main sub  num_1  num_2  result            main sub  num_1  num_2  result
0     x   c     10     99   101.0         0     x   d     10    102   110.0
1     x   c      9     99   101.0         1     x   d      9    102   110.0
2     x   c     80     99   101.0         2     x   c     80     99   101.0
3     x   d     80    102   110.0         3     x   c     80     99   101.0
4     x   d     99    102   110.0         4     x   c     99     99   101.0
5     x   e    101    209   222.0         5     x   e    101    209   222.0
6     x   e    110    209   222.0         6     x   e    110    209   222.0
7     x   e    222    209   222.0         7     x   e    222    209   222.0
8     x   e     90    209   222.0         8     x   e     90    209   222.0
9     y   f      1    100     NaN         9     y   f      1    100     NaN
10    y   f      7    100     NaN         10    y   f      7    100     NaN
11    y   f     10    100     NaN         11    y   f     10    100     NaN
12    y   f      2    100     NaN         12    y   f      2    100     NaN
13    y   g     10     90    95.0         13    y   g     10     90    95.0
14    y   g     95     90    95.0         14    y   g     95     90    95.0
15    y   g     10     90    95.0         15    y   g     10     90    95.0

    Máscaras intermediárias m, aqui para o segundo exemplo:

    # main == 'x'
#          99    102    209
array([[False, False, False],  #  10
       [False, False, False],  #   9
       [False, False, False],  #  80
       [False, False, False],  #  80
       [False, False, False],  #  99
       [False,  True, False],  # 101
       [ True,  True, False],  # 110
       [ True,  True,  True],  # 222
       [False, False, False]]) #  90
# out:    110    101    222


# main == 'y'
#         100     90
array([[False, False],  #   1
       [False, False],  #   7
       [False, False],  #  10
       [False, False],  #   1
       [False, False],  #  10
       [False,  True],  #  95
       [False, False]]) #  90
# out:    NaN     95
    • 1

relate perguntas