9.3: Errores comunes en las secuencias de comandos R

Última actualización
Guardar como PDF

Page ID: 150117

$ \newcommand{\vecs}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} } $ $ \newcommand{\vecd}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash {#1}}} $$\newcommand{\id}{\mathrm{id}}$ $ \newcommand{\Span}{\mathrm{span}}$ $ \newcommand{\kernel}{\mathrm{null}\,}$ $ \newcommand{\range}{\mathrm{range}\,}$ $ \newcommand{\RealPart}{\mathrm{Re}}$ $ \newcommand{\ImaginaryPart}{\mathrm{Im}}$ $ \newcommand{\Argument}{\mathrm{Arg}}$ $ \newcommand{\norm}[1]{\| #1 \|}$ $ \newcommand{\inner}[2]{\langle #1, #2 \rangle}$ $ \newcommand{\Span}{\mathrm{span}}$ $\newcommand{\id}{\mathrm{id}}$ $ \newcommand{\Span}{\mathrm{span}}$ $ \newcommand{\kernel}{\mathrm{null}\,}$ $ \newcommand{\range}{\mathrm{range}\,}$ $ \newcommand{\RealPart}{\mathrm{Re}}$ $ \newcommand{\ImaginaryPart}{\mathrm{Im}}$ $ \newcommand{\Argument}{\mathrm{Arg}}$ $ \newcommand{\norm}[1]{\| #1 \|}$ $ \newcommand{\inner}[2]{\langle #1, #2 \rangle}$ $ \newcommand{\Span}{\mathrm{span}}$$\newcommand{\AA}{\unicode[.8,0]{x212B}}$

Paciente: Doc, me duele cuando hago esto.

Doctor: No haga eso.

A aquellos lectores que quieran profundizar, esta sección continúa explicando por qué los scripts R a veces no funcionan, y cómo resolver estos problemas.

Consejos

Usa la Fuente, Lucas!..

La forma más efectiva de saber lo que está pasando es mirar la fuente de la función R de interés.

La forma más sencilla de acceder a la fuente es escribir el nombre de la función sin paretheses. Si la función está enterrada más profundamente, entonces intente usar methods () y getAnywhere ().

En algunos casos, las funciones en realidad no son código R, sino C o incluso Fortran. Descarga fuente R, ábrela y descúbrelo. Este último método (fuente de descarga) también funciona bien para casos más simples.

Mantenlo simple

Intenta no usar ningún paquete externo, ninguna gráfica complicada, ninguna función personalizada e incluso algunas funciones básicas (como subset ()) sin necesidad absoluta. Esto aumenta la reproducibilidad y te facilita la vida.

Análogamente, es mejor evitar correr R a través de cualquier sistema externo. Incluso el shell macOS R puede traer problemas (¿recuerdas los problemas del historial?). RStudio es una gran pieza de software pero es propenso al mismo problema.

Aprende a amar los errores y advertencias

¡Ellos ayudan! Si el código emite error o advertencia, es un síntoma de algo mal. Mucho peor es cuando el código no emite nada más que produce resultados poco confiables.

No obstante, las advertencias a veces son realmente aburridas, sobre todo si sabes lo que está pasando y por qué las tienes. En macOS es aún peor porque colorearon en rojo... Así que usa la función suppressWarnings (), pero nuevamente, solo cuando sepas lo que estás haciendo. Se puede pensar en ello como pastillas para el dolor de cabeza: útiles pero potencialmente peligrosas.

Subseleccionar por nombres, no números

Seleccionar columnas por números (como árboles [, 2:3]) es conveniente pero peligroso si cambiaste tu objeto del original. Siempre es mejor usar un enfoque más largo y seleccionar por nombres, como

Código$\PageIndex{1}$ (R):

trees[, c("Height", "Volume")]

Cuando selecciones por nombre, ten en cuenta dos cosas. Primero, la selección por un nombre devolverá NULL y podrá hacer nueva columna si aything asignado en el lado derecho. Esto solo funciona para [[y $:

Código$\PageIndex{2}$ (R):

trees[, "aaa"]

Código$\PageIndex{3}$ (R):

trees[["aaa"]]
trees$aaa

(Ver también “Un Caso de Identidad” a continuación.)

Segundo, la selección negativa solo funciona con números:

Código$\PageIndex{4}$ (R):

trees[, -c("Height", "Volume")]

Código$\PageIndex{5}$ (R):

trees[, -which(names(trees) %in% c("Height", "Volume"))]

Acerca de las palabras reservadas, otra vez

Intenta evitar nombrar tus objetos con palabras reservadas (? Reservado). Ten especial cuidado con T, F y regresa. Si los asignas a cualquier otro objeto, las consecuencias podrían ser impredecibles. Esto es, por cierto, otra buena razón para escribir VERDADERO en lugar de T y FALSO en lugar de F (no se puede asignar nada a VERDADERO y FALSO).

También es una muy mala idea asignar cualquier cosa a .last.value. Sin embargo, usando el valor predeterminado .last.value (no es una función, ver?. last.value) podría ser una idea fructífera.

Si modificaste los datos internos y quieres restaurarlos, usa algo así como datos (árboles).

El libro de casos del usuario Advanced R

La aventura del factor String

Por defecto, R convierte la cadena textual en factores. Es útil hacer contrastes pero traer problemas a muchas otras aplicaciones.

Para evitar este comportamiento en read.table (), use la opción AS.is=True, y en las operaciones de marco de datos, use stringsasFactors=False (o la opción global del mismo nombre). Además, siempre controla el modo de tus objetos con str ().

Un caso de WERE-objetos

Cuando el objeto R sufre algunos cambios automáticos, tarde o temprano verás que cambia el tipo, modo o estructura y por lo tanto se escapa de tu control. Normalmente, sucede cuando haces un objeto más pequeño:

Código$\PageIndex{6}$ (R):

mode(trees)
trees2 <- trees[, 2:3]
mode(trees2)
trees1 <- trees2[, 2]
mode(trees1)

Los marcos de datos y las matrices normalmente caen dimensiones después de la reducción. Para evitar esto, use el argumento [,, drop=False]. Incluso hay función mat.or.vec (), por favor verifique cómo funciona.

Los factores, por otro lado, no bajan los niveles después de las reducciones. Para prevenir, usa [, drop= VERDADERO].

Los objetos zombis vacíos aparecen cuando aplicas la condición de selección malformada:

Código$\PageIndex{7}$ (R):

trees.new <- trees[trees[, 1] < 0, ]
str(trees.new)

Para evitar este tipo de situaciones (hay más trampas de este tipo), intente usar str () (o Str () de asmisc.r) cada vez que cree un nuevo objeto.

Un caso de falta Comparar

Si los datos faltantes están presentes, las comparaciones deben pensarse cuidadosamente:

Código$\PageIndex{8}$ (R):

aa <- c(1, NA, 3)
aa[aa != 1] # bad idea
aa[aa != 1 & !is.na(aa)] # good idea

Un caso de parámetros forajidos

Considera lo siguiente:

Código$\PageIndex{9}$ (R):

mean(trees[, 1])
mean(trees[, 1], .2)
mean(trees[, 1], t=.2)
mean(trees[, 1], tr=.2)
mean(trees[, 1], tri=.2)
mean(trees[, 1], trim=.2)
mean(trees[, 1], trimm=.2) # why?!
mean(trees[, 1], anyweirdoption=1) # what?!

El problema es que R frecuentemente ignora parámetros ilegales. En algunos casos, esto dificulta la depuración.

Sin embargo, no todas las funciones son iguales:

Código$\PageIndex{10}$ (R):

IQR(trees[, 1])
IQR(trees[, 1], t=8)
IQR(trees[, 1], type=8)
IQR(trees[, 1], types=8)

Código$\PageIndex{11}$ (R):

IQR(trees[, 1], anyweirdoption=1)

Y algunas funciones son aún más raras:

Código$\PageIndex{12}$ (R):

bb <- boxplot(1:20, plot=FALSE)
bxp(bb, horiz=T) # plots OK
boxplot(1:20, horiz=T) # does not plot horizontally!
boxplot(1:20, horizontal=T) # this is what you need

La razón general de todos estos comportamientos diferentes es que las funciones anteriores son internamente diferentes. El primer caso es especialmente dañino porque R no reacciona ante tus erratas. Ten cuidado.

Un caso de identidad

Similar por consecuencias es un ejemplo cuando algo fue seleccionado de la lista pero el nombre fue mal escrito:

Código$\PageIndex{13}$ (R):

prop.test(3, 23)
pval <- prop.test(3, 23)$pvalue
pval
pval <- prop.test(3, 23)$p.value # correct identity!
pval

Esto no es un error sino una característica de listas y marcos de datos. Por ejemplo, permitirá cultivarlos sin problemas. Sin embargo, los tipos erróneos no generan ningún error y por lo tanto esto podría ser un problema cuando depuras.

La aventura del punto flotante

Esto es bien conocido por todos los informáticos pero podría ser nuevo para usuarios inexpertos:

Código$\PageIndex{14}$ (R):

aa <- sqrt(2)
aa * aa == 2
aa * aa - 2

¿Qué está pasando? Elemental, mi querido lector. Las computadoras funcionan solo con 0 y 1 y no conocen los números de puntos flotantes.

En lugar de la comparación exacta, use “casi exacto” all.equal () que es consciente de esta situación:

Código$\PageIndex{15}$ (R):

all.equal(aa * aa, 2)
all.equal(aa * aa - 2, 0)

Un caso de archivos gemelos

Haga este pequeño ejercicio, preferiblemente en dos computadoras, una bajo Windows y otra bajo Linux:

Código$\PageIndex{16}$ (R):

pdf("Ex.pdf")
plot(1)
dev.off()
pdf("ex.pdf")
plot(1:3)
dev.off()

En Linux, hay dos archivos con números adecuados de puntos en cada uno, pero en Windows, ¡solo hay un archivo llamado Ex.pdf pero con tres puntos! Esto es aún peor en macOS, porque la instalación típica se comporta como Windows pero también hay otras variantes.

No utilice mayúsculas en los nombres de archivo. Y no use ningún otro símbolo (incluidos los espacios) excepto letras ASCII minúsculas, guión bajo, números 0—9 y punto para extensión. Esto ayudará a que tu trabajo sea portátil.

Un caso de mala gramática

El estilo de tus guiones podría ser cuestión de gustos, pero no siempre. Considera lo siguiente:

Código$\PageIndex{17}$ (R):

aa<-3

Esto podría interpretarse como

Código$\PageIndex{18}$ (R):

aa <- 3

Código$\PageIndex{19}$ (R):

aa < -3

Siempre mantenga espacios alrededor de las tareas. Los espacios después de las comas no son tan importantes pero ayudarán a leer tu guión.

Un Caso de Doble Inmersión

¡Las comparaciones dobles no funcionan! Utilice la concatenación lógica en su lugar.

Código$\PageIndex{20}$ (R):

aa <- 3
0 < aa < 10

Código$\PageIndex{21}$ (R):

aa <- 3
aa > 0 & aa < 10

Un caso de factor Join

No hay c () para factores en R, el resultado no será un factor sino códigos numéricos. Esto está concertado con una naturaleza de factores.

No obstante, si realmente quieres concatenar factores y devolver el resultado como factor,? c página de ayuda recomienda:

Código$\PageIndex{22}$ (R):

c(factor(LETTERS[1:3]), factor(letters[1:3]))
c.factor <- function(..., recursive=TRUE) unlist(list(...), recursive=recursive)
c(factor(LETTERS[1:3]), factor(letters[1:3]))

Un caso de mala fuente

Aquí hay un error particularmente desagradable:

Código$\PageIndex{23}$ (R):

ll <- seq(0, 1, 1ength=10)

Desafortunadamente, problema bien conocido. Siempre es mejor usar buena fuente monoespaciada visualmente discernible. Evite también la “l” minúscula, por si acaso. Usa “j” en su lugar, es mucho más fácil de detectar.

Por cierto, mensaje de error muestra el problema porque deja de imprimir exactamente dónde está algo mal.