Amir's questions

Este é meu DataFrame:

import pandas as pd
df = pd.DataFrame({
    'a': [10, 20, 30, 50, 50, 50, 4, 100],
    'b': [30, 3, 200, 25, 24, 31, 29, 2],
    'd': list('aaabbbcc')
})

Saída esperada:

    a    b  d
0  10   30  a
1  20    3  a
2  30  200  a

O agrupamento é por coluna d. Quero retornar os grupos que têm pelo menos duas instâncias desta máscara

m = (df.b.gt(df.a))

Foi isso que eu tentei. Funciona, mas me pergunto se há uma maneira melhor/mais eficiente de fazer isso.

out = df.groupby('d').filter(lambda x: len(x.loc[x.b.gt(x.a)]) >= 2)

Este é meu DataFrame:

import pandas as pd
df = pd.DataFrame({
    'a': [10, 20, 30, 1, 20, 3, 4, 0],
    'b': [30, 3, 11, 25, 24, 31, 29, 2],
    'c': [True, True, True, False, False, True, True, True]
})

A saída esperada é criar a coluna d:

    a   b      c    d
0  10  30   True    NaN
1  20   3   True    10
2  30  11   True    20
3   1  25  False    NaN
4  20  24  False    NaN
5   3  31   True    NaN
6   4  29   True    30
7   0   2   True    4

Primeiro de tudo, os valores em bque cestão Truesão selecionados. Explico o processo a partir da linha 1porque é mais fácil de entender.

O valor em bé 3, então todos os valores acima dele devem ser verificados. E o valor MAIS PRÓXIMO em aque for maior que 3 deve ser selecionado. Então 10 é selecionado.

para a linha número 2, o valor é 11. O valor mais próximo deste que é maior que ele aé 20.

Para as linhas 3 e 4, cis False. NaNdeve ser selecionado.

Para a linha 5, como não há valores anteriores maiores que 31 em a, , NaNé selecionado.

Para a linha 6, o valor mais próximo que afor maior que 29 é 30.

Foi isso que tentei até agora. Não me dá a saída. Acho que a abordagem que estou tomando pode estar correta.

t = df['a'].to_numpy()
h = df['b'].to_numpy()

m2 = t < h[:, None]
df['d'] = np.nanmax(np.where(m2, t, np.nan), axis=1)

Este é meu DataFrame:

import pandas as pd
df = pd.DataFrame(
    {
        'group': list('xxxxyyy'),
        'open': [100, 150, 200, 160, 300, 150, 170],
        'close': [105, 150, 200, 160, 350, 150, 170],
        'stop': [104, 104, 104, 104, 400, 400, 400]
    }
)

A saída esperada é retornar um grupo xcom base na groupcoluna:

  group  open  close  stop
0     x   100    105   104
1     x   150    150   104
2     x   200    200   104
3     x   160    160   104

Lógica:

Quero verificar se df.stop.iloc[0]para cada grupo está entre df.open.iloc[0]e df.close.iloc[0]. E se estiver entre esses dois, quero retornar todo o grupo.

Esta é minha tentativa. Funciona, mas acho que há uma maneira melhor de fazer isso. Note que na ifcláusula, ambas as condições precisam ser verificadas.

def func(df):
    s = df.stop.iloc[0]
    o = df.open.iloc[0]
    c = df.close.iloc[0]

    if (o <= s <= c) or (c <= s <= o):
        return df

out = df.groupby('group').apply(func).reset_index(drop=True)

Este é meu DataFrame:

import pandas as pd 
df = pd.DataFrame(
    {
        'a': ['long', 'long', 'short', 'long', 'short', 'short', 'short'],
        'b': [1, -1, 1, 1, -1, -1, 1],
    }
)

A saída esperada é criar a coluna a_1:

        a    b       a_1
0     long   1       long
1     long  -1       long
2    short   1      short
3     long   1       long
4    short  -1       long
5    short  -1       long
6    short   1      short

Lógica:

a_1deve ser criado assim:

df.loc[df.b.eq(-1), 'a_1'] = 'long'
df['a_1'] = df.a_1.fillna(df.a)

Esse problema é realmente estranho. Quando tento, fillnanão funciona. Eu tentei com a versão 1.2.4 do pandas e funcionou, mas com a versão 2.1.4 não funciona. Esta versão é a versão padrão do Colab atualmente e eu executei este código no Colab.

Meu DataFrame é:

import pandas as pd 
df = pd.DataFrame(
    {
        'a': [20, 30, 2, 5, 10]
    }
)

A saída esperada é pct_change()de a:

    a  pct_change
0  20  -50.000000
1  30   50.000000
2   2  -93.333333
3   5  150.000000
4  10  100.000000

Quero comparar df.a.iloc[0]com 40 para o primeiro valor de pct_change. Se eu usar df['pct_change'] = df.a.pct_change().mul(100), o primeiro valor será NaN.

Minha tentativa:

def percent(a, b):
    result = ((a - b) / b) * 100
    return result.round(2)

df.loc[df.index[0], 'pct_change'] = percent(df.a.iloc[0], 40)

Existe uma maneira melhor/mais eficiente?

Esta é uma extensão desta resposta aceita .

Meu DataFrame:

import pandas as pd
df = pd.DataFrame(
    {
        'a': [-3, -1, -2, -5, 10, -3, -13, -3, -2, 1, 2, -100],
        'b': [1, 2, 3, 4, 5, 10, 80, 90, 100, 99, 1, 12]
    }
)

Resultado esperado:

      a    b
5    -3   10
6   -13   80
7    -3   90
8    -2  100

Lógica:

a) Selecionando a sequência mais longa de negativos em a.

b) Se por exemplo houver duas listras com o mesmo tamanho, quero aquela que tenha uma soma maior de b. Tem dfduas listras de tamanho 4 mas quero a segunda porque a soma bé maior.

Minha tentativa:

import numpy as np
s = np.sign(df['a'])
df['g'] = s.ne(s.shift()).cumsum()
df['size'] = df.groupby('g')['g'].transform('size')
df['b_sum'] = df.groupby('g')['b'].transform('sum')

Meu DataFrame é:

import pandas as pd
df = pd.DataFrame(
    {
        'a': [-3, -1, -2, -5, 10, -3, -13, -3, -2, 1, 2, -100],
    }
)

Resultado esperado:

      a
0    -3
1    -1
2    -2
3    -5

Lógica:

Quero retornar a maior sequência de números negativos. E se houver mais de uma sequência maior, quero devolver a primeira sequência. Existem dfduas listras negativas com tamanho 4, então a primeira é retornada.

Esta é minha tentativa, mas sempre que uso idxmax()em meu código, quero verificar novamente porque às vezes fica complicado em alguns cenários.

import numpy as np 
df['sign'] = np.sign(df.a)
df['sign_streak'] = df.sign.ne(df.sign.shift(1)).cumsum()
m = df.sign.eq(-1)

group_sizes = df.groupby('sign_streak').size()
largest_group = group_sizes.idxmax()
largest_group_df = df[df['sign_streak'] == largest_group]

Este é o meu DataFrame:

import pandas as pd
df = pd.DataFrame(
    {
        'a': [3, 1, 2, 5, 10, 3, 13, 3, 2],
    }
)

A saída esperada é criar um a_maxe a_min:

  a  a_max  a_min
0   3    NaN    NaN
1   1      3      1
2   2      3      1
3   5      3      1
4  10      3      1
5   3     10      3
6  13     10      3
7   3     13      3
8   2     13      2

Lógica:

Explico a lógica linha por linha. Existe uma janela dinâmica para isso dfque para a primeira instância da janela apenas a primeira linha é considerada. Para a segunda instância da janela são consideradas as duas primeiras linhas. O mesmo que abaixo:

Estas são as primeiras quatro janelas. Ele se expande de acordo.

Para cada janela preciso encontrar o valor máximo e depois preciso encontrar o valor mínimo ABAIXO desse valor máximo.

Começo a explicar pela janela amarela. Para esta janela o valor máximo é 3 e o valor mínimo ABAIXO é 1. É por isso que a_maxe a_minpara esta janela são 3 e 1.

Agora para a janela laranja o valor máximo é 5 mas como não existem valores nesta janela ABAIXO deste valor que seja menor que 5, os anteriores a_maxe a_minsão repetidos.

E a lógica continua para o restante das linhas.

Esta é minha tentativa:

df['a_max'] = df.a.cummax()
df['a_min'] = df.a.cummin()

Meu DataFrame é:

import pandas as pd
df = pd.DataFrame(
    {
        'x': ['a', 'a', 'a','b', 'b','c', 'c', 'c',],
        'y': list(range(8))
    }
)

E este é o resultado esperado. Quero criar uma coluna z:

   x  y    z
0  a  0    NaN
1  a  1    NaN 
2  a  2    NaN
3  b  3    3
4  b  4    NaN
5  c  5    NaN
6  c  6    NaN
7  c  7    NaN

A lógica é:

Quero encontrar a primeira linha após o primeiro grupo de linhas duplicadas. Por exemplo, em column x, o valor aé o primeiro valor duplicado. Quero encontrar uma linha após o atérmino dos valores. E então coloque o ydessa linha por zcoluna.

Esta é a minha tentativa que não me deu o resultado:

m = (df.x.duplicated())
out = df[m]

Este é o meu DataFrame:

import pandas as pd
import numpy as np
df = pd.DataFrame(
    {
        'a': [np.nan, np.nan, np.nan, 20, 12, 42, 33, 32, 31],
        'b': [np.nan, np.nan, np.nan, np.nan, 2333, np.nan, np.nan, 12323, np.nan]
    }
)

Máscara é:

mask = (
    (df.a.notna()) &
    (df.b.notna())
)

Resultado esperado: fatiar dfaté a primeira instância do mask. Observe que a primeira linha do maskestá INCLUÍDA:

      a        b
0   NaN      NaN
1   NaN      NaN
2   NaN      NaN
3  20.0      NaN
4  12.0   2333.0

Esta primeira instância maské row 4. Portanto, dividi-lo nesse índice é o objetivo.

Estas são minhas tentativas. O primeiro funciona, mas não tenho certeza se a abordagem está correta:

# attempt 1
idx = df.loc[mask.cumsum().eq(1) & mask].index[0]
df = df.loc[:idx]
print(df)
# attempt 2
out = df[~mask.cummax()]

Este é o meu DataFrame:

import pandas as pd
df = pd.DataFrame(
    {
        'a': [4, 3, 2, 2, 6]
    }
)

E esta é a saída esperada: quero criar uma coluna id:

   a   id
0  4  x_0
1  3  x_1
2  2  x_2
3  2  x_3
4  6  x_4

Posso criar idassim, mas acho que existe uma linha única para isso:

df['id'] = np.arange(len(df))
df['id'] = 'x_' + df.id.astype(str)

Eu prefiro uma solução que não use index.

Esta é uma extensão deste post .

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': [97, 90, 105, 2100, 1000, 101, 110, 222, 90, 100, 99, 90, 2, 92, 95, 93],
        'num_2': [100, 100, 100, 102, 102, 209, 209, 209, 209, 100, 100, 100, 100, 90, 90, 90],
        'num_3': [99, 110, 110, 110, 110, 222, 222, 222, 222, 150, 101, 200, 5, 95, 95, 100],
        'label': ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p']
    }
)

E este é o resultado esperado. Quero criar uma coluna result:

   main sub  num_1  num_2  num_3 label result
0     x   c     97    100     99     a      b
1     x   c     90    100    110     b      b
2     x   c    105    100    110     c      b
3     x   d   2100    102    110     d      f
4     x   d   1000    102    110     e      f
5     x   e    101    209    222     f      f
6     x   e    110    209    222     g      f
7     x   e    222    209    222     h      f
8     x   e     90    209    222     i      f
9     y   f    100    100    150     j      k
10    y   f     99    100    101     k      k
11    y   f     90    100    200     l      k
12    y   f      2    100      5     m      k
13    y   g     92     90     95     n    NaN
14    y   g     95     90     95     o    NaN
15    y   g     93     90    100     p    NaN

A máscara é:

mask = (
    (df.num_1 < df.num_2) & 
    (df.num_2 < df.num_3)
)

O processo começa assim:

a) A coluna groupby ésub

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

c) Coloque o valor de labelno resultado

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

Os s anteriores subnão devem ser considerados ao usar maincomo groupbycoluna.

Um exemplo das etapas acima para grupo dna subcoluna:

a) sub é a coluna groupby.

b) Não há linhas no dgrupo que df.num_2está entre df.num_1e df.num_3(a condição de mask)

Então agora para group d, seu grupo principal é pesquisado. No entanto, o grupo ctambém está neste grupo principal. Como é anterior a group d, group cnão deve contar para esta etapa. Portanto, no xgrupo, a primeira linha do rótulo maskpossui f(101 <102 <222).

Uma coisa a notar é que para cada subgrupo num_2não muda em todo o grupo. Por exemplo, para todo o grupo c num_2é 100.

Esta é minha tentativa baseada nesta resposta , mas não funciona:

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

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

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:

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)

Este é o meu DataFrame.

import pandas as pd
df = pd.DataFrame(
    {
        'a': [100, 1123, 9999, 100, 1, 954, 1],
        'b': [1000, 11123, 1123, 0, 55, 0, 1],
    },
)

A saída esperada é a criação da coluna c:

      a      b       c
0   100   1000     NaN
1  1123  11123     NaN
2  9999   1123  9999.0
3   100      0     NaN
4     1     55     NaN
5   954      0     NaN
6     1      1     NaN

A máscara é:

mask = ((df.a > df.b))

Quero pegar a primeira linha que atenda às condições desta máscara SE APENAS estiver nas 3 primeiras linhas e colocar df.apara criar c. Para este exemplo este código funciona:

df.loc[mask.cumsum().eq(1) & mask, 'c'] = df.a

Mas para este DataFrame ele deve retornar NaNporque ca primeira instância de masknão está nas 3 primeiras linhas. Mas não funciona.

df = pd.DataFrame(
    {
        'a': [0, 0, 0, 0, 0, 954, 1],
        'b': [1000, 11123, 1123, 0, 55, 0, 1],
    },
)

Este é o meu DataFrame:

import pandas as pd

df = pd.DataFrame(
    {
        'a': [100, 1123, 123, 100, 1, 0, 1],
        'b': [1000, 11123, 1123, 0, 55, 0, 1],
    },
    index=range(100, 107)
)

E este é o resultado esperado. Quero criar uma coluna c:

       a      b      c
100   100   1000    NaN
101  1123  11123    NaN
102   123   1123    NaN
103   100      0    3.0
104     1     55    NaN
105     0      0    NaN
106     1      1    NaN

A máscara usada é:

mask = ((df.a > df.b))

Quero obter o índice da primeira linha que maskocorre. Quero preservar o índice original, mas obter o reset_index()valor. Neste exemplo, a primeira instância da máscara está em index 3.

Posso obter a primeira instância da máscara assim:

df.loc[mask.cumsum().eq(1) & mask, 'c'] = 'the first row'

Mas não sei como obter o índice.

Este é o meu DataFrame.

import pandas as pd 
import numpy as np
df = pd.DataFrame(
    {
        'a': [2, 2, 2, -4, np.nan, np.nan, 4, -3, 2, -2, -6],
        'b': [2, 2, 2, 4, 4, 4, 4, 3, 2, 2, 6]
    }
)

Quero adicionar um sinal de mais para números positivos apenas para colunas aao exportar para Excel. Por exemplo, 1 torna-se +1. NaNObserve que também tenho valores. Quero que sejam células vazias no Excel, semelhantes ao comportamento padrão do Pandas ao lidar com NaNvalores no Excel.to_excel.

Eu tentei muitas soluções. Este é um deles. Mas não funcionou no Excel.

df.style.format({'a': '{:+g}'}).to_excel(r'df.xlsx', sheet_name='xx', index=False)

Meu DataFrame é:

df = pd.DataFrame(
    {
       'a': [20, 9, 31, 40],
       'b': [1, 10, 17, 30],
    }
)

Resultado esperado: Criando coluna cename

    a   b   c    name
0  20   1  20    NaN
1   9  10  20    NaN
2  31  17  17    NaN
3  40  30  40    a 

Passos:

a) cé criado pordf['c'] = np.fmax(df['a'].shift().bfill(), df['b'])

b) para a última linha: df['c'] = df[['a', 'b']].max(). Já para a última linha a > b40 é escolhida.

c) Obtenha o nome do valor máximo entre aou bpara a última linha.

Minha tentativa:

df['c'] = np.fmax(df['a'].shift().bfill(), df['b'])
df.loc[df.index[-1], 'c'] = df.loc[df.index[-1], ['a', 'b']].max()
df.loc[df.index[-1], 'name'] = df.loc[df.index[-1], ['a', 'b']].idxmax()

É a maneira mais limpa/melhor abordagem?

Meu DataFrame é:

import pandas as pd
df = pd.DataFrame(
    {
       'a': [20, 9, 31, 40],
       'b': [1, 10, 17, 30],
    }
)

Resultado esperado: Criando colunac

    a   b   c
0  20   1  20
1   9  10  20
2  31  17  17
3  40  30  31

Passos:

cé o valor máximo entre df.be df.a.shift(1).bfill().

Minha tentativa:

df['temp'] = df.a.shift(1).bfill()
df['c'] = df[['temp', 'b']].max(axis=1)

É a maneira mais limpa/melhor abordagem?

Este é o meu DataFrame:

import pandas as pd
df = pd.DataFrame(
    {
        'a': [101, 90, 11, 120, 1]
    }
)

E esta é a saída que eu quero. Quero criar uma coluna y:

     a    y
0  101    101.0
1   90    101.0
2   11    90.0
3  120    120.0
4    1    120.0

Basicamente, os valores in asão comparados com o valor anterior, e o maior é selecionado.

Por exemplo, para row 1, 90 é comparado com 101. 101 é maior, por isso é selecionado.

Eu fiz desta maneira:

df['x'] = df.a.shift(1)
df['y'] = df[['a', 'x']].max(axis=1)

Existe um limpador ou algum tipo de maneira integrada de fazer isso?

Este é o meu dataframe:

df = pd.DataFrame(
    {
        'a': [0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0],
        'b': [1, -1, -1, -1, 1, -1, 1, 1, -1, 1, 1, -1, 1, 1, -1, 1, 1]    
    }
)

E esta é a saída que eu quero. Quero criar uma coluna c:

   a  b  c
0   0  1  0
1   0 -1  0
2   1 -1  0
3   1 -1  0
4   1  1  1
5   1 -1  1
6   0  1  0
7   0  1  0
8   0 -1  0
9   1  1  1
10  1  1  1
11  1 -1  1
12  0  1  0
13  0  1  0
14  1 -1  0
15  1 -1  1
16  0  1  0

Esta é basicamente uma extensão deste post . As linhas destacadas abaixo resumem a maneira como isso precisa ser feito.

Primeiro de tudo, na coluna a, os grupos são criados por sequência de 1s e uma linha após o término da sequência. As linhas destacadas na coluna asão esses grupos. A solução para esta etapa está aqui .

Agora o que preciso é verificar a coluna bde cada grupo no arquivo a. Encontre o primeiro valor que é 1 pol bpara cada grupo. E então qualquer valor que vier antes disso se tornará 0. É assim que a coluna cé criada.

Por exemplo, para o primeiro grupo em a, o primeiro valor da coluna bé 1 é o número da linha 4. Os valores anteriores nesse grupo tornam-se 0. E o resultado é o primeiro grupo destacado na coluna c.

Observe que se para um grupo todos os valores bNÃO forem 1, o grupo correspondente se ctornará todos 0s.

Isto é o que eu tentei, mas não consigo encontrar a solução completa:

g = df.loc[::-1, 'a'].eq(0).cumsum()
x = df.groupby(g).filter(lambda x: x.b.iloc[0] == 1)