Modificar un subconjunto de filas en un marco de datos de pandas

Suponga que tengo un DataFrame de pandas con dos columnas, A y B. Me gustaría modificar este DataFrame (o crear una copia) para que B siempre sea NaN siempre que A sea 0. ¿Cómo lo lograría?

Probé lo siguiente

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

y

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

sin éxito.

Uso .locpara indexación basada en etiquetas:

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

La df.A==0expresión crea una serie booleana que indexa las filas, 'B'selecciona la columna. También puede usar esto para transformar un subconjunto de una columna, por ejemplo:

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

No sé lo suficiente sobre los elementos internos de los pandas para saber exactamente por qué eso funciona, pero el problema básico es que a veces la indexación en un DataFrame devuelve una copia del resultado, y a veces devuelve una vista del objeto original. Según la documentación aquí , este comportamiento depende del comportamiento numpy subyacente. He descubierto que acceder a todo en una operación (en lugar de [uno] [dos]) es más probable que funcione para la configuración.

Aquí hay documentos de pandas sobre indexación avanzada:

¡La sección explicará exactamente lo que necesita! Resulta que df.loc(como .ix ha quedado en desuso, como muchos han señalado a continuación) se puede usar para cortar / cortar en frío un marco de datos. Y. También se puede usar para configurar cosas.

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

Así que la respuesta de Bren está diciendo 'yo encontrar todos los lugares donde df.A == 0, seleccione la columna By la puso a np.nan'

A partir de pandas 0.20 ix está en desuso . La forma correcta es usar df.loc

aquí hay un ejemplo de trabajo

>>> 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
>>> 

Explicación:

Como se explica en el documento aquí , .loc se basa principalmente en etiquetas, pero también se puede usar con una matriz booleana .

Entonces, lo que estamos haciendo arriba es aplicar df.loc[row_index, column_index]por:

• Explotando el hecho de que locpuede tomar una matriz booleana como una máscara que le dice a los pandas en qué subconjunto de filas queremos cambiarrow_index
• La explotación del hecho loctambién se basa en la etiqueta para seleccionar la columna utilizando la etiqueta 'B'en elcolumn_index

Podemos usar lógica, condición o cualquier operación que devuelva una serie de booleanos para construir la matriz de booleanos. En el ejemplo anterior, queremos cualquiera rowsque contenga un 0, para eso podemos usar df.A == 0, como puede ver en el ejemplo a continuación, esto devuelve una serie 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
>>> 

Luego, usamos la matriz de booleanos anterior para seleccionar y modificar las filas necesarias:

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

Para obtener más información, consulte la documentación de indexación avanzada aquí .

Para un aumento masivo de la velocidad, use la función where de NumPy.

Preparar

Cree un DataFrame de dos columnas con 100,000 filas con algunos ceros.

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

Solución rápida con numpy.where

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

Tiempos

%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's wherees aproximadamente 4 veces más rápido

Para reemplazar las columnas múltiples, conviértalas en una matriz numpy usando .values:

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