Cómo reemplazar los valores NA en una tabla para columnas seleccionadas

Hay muchas publicaciones sobre cómo reemplazar los valores de NA. Soy consciente de que se podrían reemplazar las NA en la siguiente tabla / marco con lo siguiente:

x[is.na(x)]<-0

Pero, ¿qué pasa si quiero restringirlo solo a ciertas columnas? Déjame mostrarte un ejemplo.

Primero, comencemos con un conjunto de datos.

set.seed(1234)
x <- data.frame(a=sample(c(1,2,NA), 10, replace=T),
                b=sample(c(1,2,NA), 10, replace=T), 
                c=sample(c(1:5,NA), 10, replace=T))

Lo que da:

    a  b  c
1   1 NA  2
2   2  2  2
3   2  1  1
4   2 NA  1
5  NA  1  2
6   2 NA  5
7   1  1  4
8   1  1 NA
9   2  1  5
10  2  1  1

Ok, entonces solo quiero restringir el reemplazo a las columnas 'a' y 'b'. Mi intento fue:

x[is.na(x), 1:2]<-0

y:

x[is.na(x[1:2])]<-0

Que no funciona.

Mi intento de data.table, donde y<-data.table(x), obviamente, nunca iba a funcionar:

y[is.na(y[,list(a,b)]), ]

Quiero pasar columnas dentro del argumento is.na, pero eso obviamente no funcionaría.

Me gustaría hacer esto en un data.frame y un data.table. Mi objetivo final es recodificar el 1: 2 a 0: 1 en 'a' y 'b' manteniendo 'c' como está, ya que no es una variable lógica. Tengo un montón de columnas, así que no quiero hacerlo una por una. Y me gustaría saber cómo hacer esto.

¿Tienes alguna sugerencia?

Tu puedes hacer:

x[, 1:2][is.na(x[, 1:2])] <- 0

o mejor (en mi humilde opinión), use los nombres de las variables:

x[c("a", "b")][is.na(x[c("a", "b")])] <- 0

En ambos casos, 1:2o c("a", "b")puede ser reemplazado por un vector predefinido.

Editar 2020-06-15

Desde data.table1.12.4 (octubre de 2019), data.tableobtiene dos funciones para facilitar esto: nafilly setnafill.

nafill opera en columnas:

cols = c('a', 'b')
y[ , (cols) := lapply(.SD, nafill, fill=0), .SDcols = cols]

setnafill opera en tablas (los reemplazos ocurren por referencia / en el lugar)

setnafill(y, cols=cols, fill=0)
# print y to show the effect
y[]

Esto también será más eficiente que las otras opciones; Para ?nafillobtener más información, consulte las versiones de NAimputación de la última observación trasladada hacia adelante (LOCF) y la siguiente observación trasladada hacia atrás (NOCB) para series de tiempo.

Esto funcionará para su data.tableversión:

for (col in c("a", "b")) y[is.na(get(col)), (col) := 0]

Alternativamente, como señala David Arenburg a continuación, puede usar set(beneficio adicional: puede usarlo en data.frameo data.table):

for (col in 1:2) set(x, which(is.na(x[[col]])), col, 0)

Sobre la base de la tidyr::replace_na()respuesta de @Robert McDonald's , aquí hay algunas dplyropciones para controlar qué columnas NAse reemplazan las s:

library(tidyverse)

# by column type:
x %>%
  mutate_if(is.numeric, ~replace_na(., 0))

# select columns defined in vars(col1, col2, ...):
x %>%
  mutate_at(vars(a, b, c), ~replace_na(., 0))

# all columns:
x %>%
  mutate_all(~replace_na(., 0))

Esto ahora es trivial en tidyr con replace_na (). La función parece funcionar tanto para data.tables como para data.frames:

tidyr::replace_na(x, list(a=0, b=0))

No estoy seguro si esto es más conciso, pero esta función también encontrará y permitirá el reemplazo de NA (o cualquier valor que desee) en columnas seleccionadas de una tabla de datos:

update.mat <- function(dt, cols, criteria) {
  require(data.table)
  x <- as.data.frame(which(criteria==TRUE, arr.ind = TRUE))
  y <- as.matrix(subset(x, x$col %in% which((names(dt) %in% cols), arr.ind = TRUE)))
  y
}

Para aplicarlo:

y[update.mat(y, c("a", "b"), is.na(y))] <- 0

La función crea una matriz de las columnas y filas seleccionadas (coordenadas de celda) que cumplen con los criterios de entrada (en este caso es.na == VERDADERO).

Podemos resolverlo de data.tablemanera con tidyr::repalce_nafunción ylapply

library(data.table)
library(tidyr)
setDT(df)
df[,c("a","b","c"):=lapply(.SD,function(x) replace_na(x,0)),.SDcols=c("a","b","c")]

De esta forma, también podemos resolver pegar columnas con NAstring. ¡Primero, nosotros replace_na(x,""), luego podemos usar stringr::str_cpara combinar columnas!

Para una columna específica, existe una alternativa con sapply

DF <- data.frame(A = letters[1:5],
             B = letters[6:10],
             C = c(2, 5, NA, 8, NA))

DF_NEW <- sapply(seq(1, nrow(DF)),
                    function(i) ifelse(is.na(DF[i,3]) ==
                                       TRUE,
                                       0,
                                       DF[i,3]))

DF[,3] <- DF_NEW
DF

es bastante útil con {data.table} y {stringr}

library(data.table)
library(stringr)

x[, lapply(.SD, function(xx) {str_replace_na(xx, 0)})]

FYI

A partir de data.table y, puede escribir:
y[, (cols):=lapply(.SD, function(i){i[is.na(i)] <- 0; i}), .SDcols = cols]
No se olvide library(data.table)antes de crear yy ejecutar este comando.

Esto funciona bien para mi

DataTable DT = new DataTable();

DT = DT.AsEnumerable().Select(R =>
{
      R["Campo1"] = valor;
      return (R);
}).ToArray().CopyToDataTable();