En R, ¿hay alguna forma de manejar NA en una columna entera de un data.frame para que los valores de NA no se incluyan al subconjunto?

Question

Tengo un hoja.de.datos así:

(t=structure(list(count = c(NA, 2, NA, NA, NA, 8, NA, NA, NA)), .Names = "count", row.names = c(NA,-9L), class = "data.frame")) 
    count 
1 NA 
2  2 
3 NA 
4 NA 
5 NA 
6  8 
7 NA 
8 NA 
9 NA 

Es muy bueno que R tiene el valor NA pero a veces me muerdo. A menudo me olvido de esto y trato de hacer subconjuntos como este

> t[t$count>=1,] 
[1] NA 2 NA NA NA 8 NA NA NA 

Y la salida incluye todas las filas de NA. (Que no me gusta)

Después de una hora de búsqueda de errores que cambie el código para esto y eso es lo que yo quiero (imaginan gran trama de datos una gran cantidad de resultados mencionan los no-NA y sólo unos pocos "bien escondido "AN):

> t[t$count>=1&!is.na(t$count),] 
[1] 2 8 

1. ¿hay una característica de la "función as.integer" para que yo pudiera hacer algo como esto:

t [as.integer.EXCLUDE.NA (t $ count)> = 1,]

Me gustaría utilizar dicha función en otras funciones de .xxxx también. Básicamente, fuerce a R a dejar de pensar como un estadístico y tratar NA de manera diferente (por ejemplo, como NULL (no estoy seguro de que NULL resuelva mi problema) (esto no funcionó: t $ count [3] < -NULL por alguna razón)

2. o cómo iba a funcionar

transform(t, replace all NAs from count columns with 0) 

o incluso mejor

transform(t, replace all NA from all numeric columns with 0 in t) 

3. las observaciones genéricas sobre cómo hacer olvidar R AN son bienvenidos?

Answer 1

No me gustan las opciones que se hicieron en el momento de diseñar cómo "[" maneja los valores de NA. El enfoque que tomo cuando quiero extraer valores usando una prueba lógica es ajustar la expresión lógica en which. Esto convierte el resultado de un conjunto de números y la indexación tiene éxito sin arrastrar a lo largo de los no deseados de NA:

> t[ which(t$count >= 1), ] 
[1] 2 8 
# Or if you still want a dataframe result 
> t[ which(t$count >= 1), , drop=FALSE] 
    count 
2  2 
6  8 

También uso subset ya que se encarga de NA en la misma manera que which(logical). El que se obtiene es cuando se usa which con un signo "-" para recuperar el conjunto del complemento. Si no hay elementos en el conjunto que satisfagan la condición lógica, tampoco habrá elementos en el formulario -which(logical). Así que simplemente no uso el -which combinado:

> t[ -which(t$count < 1), , drop=FALSE] 
[1] count 
<0 rows> (or 0-length row.names) 
> t[ which(t$count < 1), , drop=FALSE] 
[1] count 
<0 rows> (or 0-length row.names) 

Answer 2

bastante fácil de hacer (2) en la lista (reemplace todas AN):

t$count[is.na(t$count)] <- something.else 

La pregunta es, por supuesto, ¿qué te haces cargo de something.else. NA existen para resolver un problema. Si desea prohibir su uso de R, tendrá que averiguar qué quiere hacer con las observaciones que faltan, además de tratarlas como faltantes.

La belleza de NA es que generalmente se propaga a través de, lo que le indica al final de su análisis que en algún lugar de allí tenía alguna falta, que será mejor que piense mucho. No hay sustituto para pensar mucho acerca de la pérdida.

Answer 3

En data.table funciona como a usted le gustaría w.r.t. NA, si entiendo correctamente. Además, no necesita usar $ y tampoco le importa si olvida la coma.

dt = as.data.table(t) 
t[count>=1] # NA's are treated as FALSE 

La lista de diferencias entre data.table y data.frame es en FAQ 2.17 here.

Si piensa que todas estas diferencias rompen la compatibilidad, no es así.Todavía puede pasar un data.table a cualquier paquete y cuando esos paquetes usan la sintaxis R estándar en el data.table, todavía funciona.

Como dijiste grandedata.frame, data.table puede valer la pena mirar de todos modos.

Estos son los 3 puntos de FAQ 2.17 (donde DT significa data.table y DF significa data.frame):

• DT[NA] devuelve 1 fila de NA, pero DF[NA] devuelve una copia de la totalidad de DF contiene NA en todo. El símbolo NA es tipo lógico en R, y es , por lo tanto reciclado por [.data.frame. La intención fue probablemente DF[NA_integer_]. [.data.table hace esto automáticamente para conveniencia.

• DT[c(TRUE,NA,FALSE)] trata del NA como FALSE, pero DF[c(TRUE,NA,FALSE),] vuelve una fila NA para cada NA

• DT[ColA==ColB] es más simple que DF[!is.na(ColA) & !is.na(ColB) & ColA==ColB,]