Modificando um subconjunto de linhas em um dataframe do pandas

Suponha que eu tenho um DataFrame do pandas com duas colunas, A e B. Eu gostaria de modificar esse DataFrame (ou criar uma cópia) para que B seja sempre NaN sempre que A for 0. Como eu conseguiria isso?

Eu tentei o seguinte

df['A'==0]['B'] = np.nan

e

df['A'==0]['B'].values.fill(np.nan)

sem sucesso.

Use .locpara indexação baseada em etiqueta:

df.loc[df.A==0, 'B'] = np.nan

A df.A==0expressão cria uma série booleana que indexa as linhas, 'B'seleciona a coluna. Você também pode usar isso para transformar um subconjunto de uma coluna, por exemplo:

df.loc[df.A==0, 'B'] = df.loc[df.A==0, 'B'] / 2

Não sei o suficiente sobre os internos do pandas para saber exatamente por que isso funciona, mas o problema básico é que, às vezes, a indexação em um DataFrame retorna uma cópia do resultado e, às vezes, retorna uma exibição no objeto original. De acordo com a documentação aqui , esse comportamento depende do comportamento numpy subjacente. Descobri que acessar tudo em uma operação (em vez de [uma] [duas]) é mais provável que funcione na configuração.

Aqui está dos documentos do pandas sobre indexação avançada:

A seção explicará exatamente o que você precisa! Acontece que df.loc(como .ix foi descontinuado - como muitos apontaram abaixo) pode ser usado para fatiar / cortar dados em um quadro de dados. E. Também pode ser usado para definir as coisas.

df.loc[selection criteria, columns I want] = value

Então a resposta de Bren está dizendo 'encontre-me todos os lugares onde df.A == 0, selecione a coluna Be defina-a como np.nan'

A partir de pandas, 0,20 ix está obsoleto . O caminho certo é usar o df.loc

aqui está um exemplo de trabalho

>>> import pandas as pd 
>>> import numpy as np 
>>> df = pd.DataFrame({"A":[0,1,0], "B":[2,0,5]}, columns=list('AB'))
>>> df.loc[df.A == 0, 'B'] = np.nan
>>> df
   A   B
0  0 NaN
1  1   0
2  0 NaN
>>> 

Explicação:

Conforme explicado no documento aqui , .loc é principalmente baseado em rótulo, mas também pode ser usado com uma matriz booleana .

Portanto, o que estamos fazendo acima é a aplicação df.loc[row_index, column_index]de:

• Explorando o fato de que locpodemos usar uma matriz booleana como uma máscara que diz aos pandas em que subconjunto de linhas queremos alterarrow_index
• A exploração do fato loctambém é baseada em rótulo para selecionar a coluna usando o rótulo 'B'nocolumn_index

Podemos usar lógica, condição ou qualquer operação que retorne uma série de booleanos para construir a matriz de booleanos. No exemplo acima, queremos rowsque contenha um 0, para que possamos usar df.A == 0, como você pode ver no exemplo abaixo, isso retorna uma série de booleanos.

>>> df = pd.DataFrame({"A":[0,1,0], "B":[2,0,5]}, columns=list('AB'))
>>> df 
   A  B
0  0  2
1  1  0
2  0  5
>>> df.A == 0 
0     True
1    False
2     True
Name: A, dtype: bool
>>> 

Em seguida, usamos a matriz de booleanos acima para selecionar e modificar as linhas necessárias:

>>> df.loc[df.A == 0, 'B'] = np.nan
>>> df
   A   B
0  0 NaN
1  1   0
2  0 NaN

Para mais informações, consulte a documentação avançada de indexação aqui .

Para um grande aumento de velocidade, use a função where do NumPy.

Configuração

Crie um DataFrame de duas colunas com 100.000 linhas com alguns zeros.

df = pd.DataFrame(np.random.randint(0,3, (100000,2)), columns=list('ab'))

Solução rápida com numpy.where

df['b'] = np.where(df.a.values == 0, np.nan, df.b.values)

Horários

%timeit df['b'] = np.where(df.a.values == 0, np.nan, df.b.values)
685 µs ± 6.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

%timeit df.loc[df['a'] == 0, 'b'] = np.nan
3.11 ms ± 17.2 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

Numpy whereé cerca de 4x mais rápido

Para substituir várias colunas, converta em matriz numpy usando .values:

df.loc[df.A==0, ['B', 'C']] = df.loc[df.A==0, ['B', 'C']].values / 2