5 Modificación de Valores

¿Estás listo para jugar algunos juegos con tu mazo virtual? ¡No tan rápido! El sistema de puntos en su mazo de cartas no se alinea bien con muchos juegos de cartas. Por ejemplo, en la guerra y el póquer, los ases suelen tener una puntuación más alta que los reyes. Tendrían un valor en puntos de 14, no de 1.

En esta tarea, cambiará el sistema de puntos de su mazo tres veces para que coincida con tres juegos diferentes: guerra, corazones y blackjack. Cada uno de estos juegos te enseñará algo diferente sobre cómo modificar los valores dentro de un conjunto de datos. Comience por hacer una copia de mazo que pueda manipular. Esto asegurará que siempre tenga una copia impecable de mazo a la que recurrir (en caso de que las cosas salgan mal):

mazo2 <- mazo

5.0.1 Cambio de Valores en el Lugar

Puede usar el sistema de notación de R para modificar valores dentro de un objeto de R. Primero, describa el valor (o valores) que desea modificar. Luego use el operador de asignación <- para sobrescribir esos valores. R actualizará los valores seleccionados en el objeto original. Pongamos esto en práctica con un ejemplo real:

vec <- c(0, 0, 0, 0, 0, 0)
vec
##  0 0 0 0 0 0

Así es como puede seleccionar el primer valor de vec:

vec[1]
##  0

Y así es como puedes modificarlo:

vec[1] <- 1000
vec
## 1000    0    0    0    0    0

Puede reemplazar varios valores a la vez siempre que la cantidad de valores nuevos sea igual a la cantidad de valores seleccionados:

vec[c(1, 3, 5)] <- c(1, 1, 1)
vec
##  1 0 1 0 1 0

vec[4:6] <- vec[4:6] + 1
vec
## 1 0 1 1 2 1

También puede crear valores que aún no existen en su objeto. R expandirá el objeto para acomodar los nuevos valores:

vec[7] <- 0
vec
## 1 0 1 1 2 1 0

Esto proporciona una excelente manera de agregar nuevas variables a su conjunto de datos:

mazo2$nuevo <- 1:52

head(mazo2)
##   cara  palo valor nuevo
##    rey picas    13   1
##  reina picas    12   2
##   jota picas    11   3
##   diez picas    10   4
##  nueve picas     9   5
##   ocho picas     8   6

También puede eliminar columnas de un data frame (y elementos de una lista) asignándoles el símbolo NULL:

mazo2$nuevo <- NULL

head(mazo2)
##   cara  palo valor 
##    rey picas    13
##  reina picas    12
##   jota picas    11
##   diez picas    10
##  nueve picas     9
##   ocho picas     8

En el juego de la guerra, los ases son el rey (en sentido figurado). Reciben el valor más alto de todas las cartas, que sería algo así como 14. Todas las demás cartas obtienen el valor que ya tienen en el mazo. Para jugar a la guerra, solo necesitas cambiar los valores de tus ases del 1 al 14.

Siempre que no hayas barajado tu mazo, sabes dónde están los ases. Aparecen cada 13 cartas. Por lo tanto, puede describirlos con el sistema de notación de R:

mazo2[c(13, 26, 39, 52), ]
##  cara      palo valor
##    as     picas     1
##    as  treboles     1
##    as diamantes     1
##    as corazones     1

Puede seleccionar solo los valores de los ases subdividiendo la dimensión de las columnas de mazo2. O, mejor aún, puede crear un subconjunto del vector de columna mazo2$valor:

mazo2[c(13, 26, 39, 52), 3]
## 1 1 1 1

mazo2$valor[c(13, 26, 39, 52)]
## 1 1 1 1

Ahora todo lo que tiene que hacer es asignar un nuevo conjunto de valores a estos valores antiguos. El conjunto de valores nuevos deberá tener el mismo tamaño que el conjunto de valores que está reemplazando. Por lo tanto, podría guardar c(14, 14, 14, 14) en los valores as, o simplemente podría guardar 14 y confiar en las reglas de reciclaje de R para expandir 14 a c(14, 14, 14, 14):

mazo2$valor[c(13, 26, 39, 52)] <- c(14, 14, 14, 14)

# or

mazo2$valor[c(13, 26, 39, 52)] <- 14

Observe que los valores cambian en su lugar. No terminas con una copia modificada de mazo2; los nuevos valores aparecerán dentro de mazo2:

head(mazo2, 13)
##   cara  palo valor
##    rey picas    13
##  reina picas    12
##   jota picas    11
##   diez picas    10
##  nueve picas     9
##   ocho picas     8
##  siete picas     7
##   seis picas     6
##  cinco picas     5
## cuatro picas     4
##   tres picas     3
##    dos picas     2
##     as picas    14

La misma técnica funcionará ya sea que almacene sus datos en un vector, matriz, arreglo, lista o data frame. Simplemente describa los valores que desea cambiar con el sistema de notación de R, luego asigne sobre esos valores con el operador de asignación de R.

Las cosas funcionaron muy fácilmente en este ejemplo porque sabías exactamente dónde estaba cada as. Las cartas se ordenaron de manera ordenada y apareció un as cada 13 filas.

Pero, ¿y si se hubiera barajado la baraja? Podrías mirar todas las cartas y anotar las ubicaciones de los ases, pero eso sería tedioso. Si su data frame fuera más grande, podría ser imposible:

mazo3 <- barajar(mazo)

¿Dónde están los ases ahora?

head(mazo3)
##  cara      palo valor
## reina  treboles    12
##   rey  treboles    13
##    as     picas     1   # un as
## nueve  treboles     9
## siete     picas     7
## reina diamantes    12

¿Por qué no pedirle a R que encuentre los ases por ti? Puede hacer esto con subconjuntos lógicos. La creación de subconjuntos lógicos proporciona una forma de realizar una extracción y modificación específicas con objetos R, una especie de misión de búsqueda y destrucción dentro de sus propios conjuntos de datos.

5.0.2 Subconjunto Lógico

¿Recuerdas el sistema de índice lógico de R, lógicos? Para recapitular, puede seleccionar valores con un vector de TRUE y FALSE. El vector debe tener la misma longitud que la dimensión que desea dividir en subconjuntos. R devolverá todos los elementos que coincidan con un VERDADERO:

vec
## 1 0 1 1 2 1 0

vec[c(FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE)]
## 2

A primera vista, este sistema puede parecer poco práctico. ¿Quién quiere escribir largos vectores de TRUE y FALSE? Nadie. Pero no tienes que hacerlo. Puede dejar que una prueba lógica cree un vector de VERDADEROS y FALSOS para usted.

5.0.2.1 Pruebas Lógicas

Una prueba lógica es una comparación como “¿es uno menos que dos?”, 1 < 2 o “¿tres son mayores que cuatro?”, 3 > 4. R proporciona siete operadores lógicos que puede usar para hacer comparaciones, que se muestran en la tabla Tabla 5.1.

Tabla 5.1: Operadores Lógicos de R

Operador	Sintaxis	Pruebas
`>`	`a > b`	¿Es a mayor que b?
`>=`	`a >= b`	¿Es a mayor que o igual que b?
`<`	`a < b`	¿Es a menor que b?
`<=`	`a <= b`	¿Es a menor que o igual que b?
`==`	`a == b`	¿Es a igual que b?
`!=`	`a != b`	¿Es a distinto que b?
`%in%`	`a %in% c(a, b, c)`	¿Es a en el grupo c(a, b, c)?

Cada operador devuelve un TRUE o un FALSE. Si usa un operador para comparar vectores, R hará comparaciones por elementos, tal como lo hace con los operadores aritméticos:

1 > 2
## FALSE

1 > c(0, 1, 2)
## TRUE FALSE FALSE

c(1, 2, 3) == c(3, 2, 1)
## FALSE  TRUE FALSE

%in% es el único operador que no realiza una ejecución normal de elementos. %in% comprueba si los valores del lado izquierdo están en el vector del lado derecho. Si proporciona un vector en el lado izquierdo, %in% no emparejará los valores de la izquierda con los valores de la derecha y luego realizará pruebas por elementos. En su lugar, %in% probará de forma independiente si cada valor de la izquierda está en algún lugar en el vector de la derecha:

1 %in% c(3, 4, 5)
## FALSE

c(1, 2) %in% c(3, 4, 5)
## FALSE FALSE

c(1, 2, 3) %in% c(3, 4, 5)
## FALSE FALSE  TRUE

c(1, 2, 3, 4) %in% c(3, 4, 5)
## FALSE FALSE  TRUE  TRUE

Tenga en cuenta que comprueba la igualdad con un signo igual doble, ==, y no con un solo signo igual, =, que es otra forma de escribir <-. Es fácil olvidar y usar a = b para probar si a es igual a b. Desafortunadamente, te llevarás una desagradable sorpresa. R no devolverá un TRUE o FALSE, porque no tendrá que hacerlo: a será igual a b, porque acabas de ejecutar el equivalente de a <- b.

= es un operador de asignación

Tenga cuidado de no confundir = con ==. = hace lo mismo que <-: asigna un valor a un objeto.

Puede comparar dos objetos R cualquiera con un operador lógico; sin embargo, los operadores lógicos tienen más sentido si compara dos objetos del mismo tipo de datos. Si compara objetos de diferentes tipos de datos, R usará sus reglas de coerción para forzar los objetos al mismo tipo antes de realizar la comparación.

Ejercicio 7.1 ¿Cuántas ases? Extraiga la columna cara de mazo2 y pruebe si cada valor es igual a as. Como desafío, use R para contar rápidamente cuántas cartas son iguales a as.

Solución. Puede extraer la columna cara con la notación $ de R:

mazo2$cara
##  "rey"  "reina" "jota"  "diez"   "nueve" 
##  "ocho" "siete" "seis"   "cinco"  "cuatro" 
##  "tres" "dos"   "as" "rey"  "reina"
##  "jota"  "diez"   "nueve"  "ocho" "siete"
##  "seis"   "cinco"  "cuatro"  "tres" "dos"  
##  "as"   "rey"  "reina" "jota"  "diez"  
##  "nueve"  "ocho" "siete" "seis"   "cinco" 
##  "cuatro"  "tres" "dos"   "as"   "rey" 
##  "reina" "jota"  "diez"   "nueve"  "ocho"
##  "siete" "seis"   "cinco"  "cuatro"  "tres"
##  "dos"   "as"

A continuación, puede utilizar el operador == para probar si cada valor es igual a as. En el siguiente código, R usará sus reglas de reciclaje para comparar individualmente cada valor de mazo2$cara con "as". Tenga en cuenta que las comillas son importantes. Si los omite, R intentará encontrar un objeto llamado as para compararlo con mazo2$cara:

mazo2$cara == "as"
##  FALSE FALSE FALSE FALSE FALSE FALSE FALSE
##  FALSE FALSE FALSE FALSE FALSE  TRUE FALSE
##  FALSE FALSE FALSE FALSE FALSE FALSE FALSE
##  FALSE FALSE FALSE FALSE  TRUE FALSE FALSE
##  FALSE FALSE FALSE FALSE FALSE FALSE FALSE
##  FALSE FALSE FALSE  TRUE FALSE FALSE FALSE
##  FALSE FALSE FALSE FALSE FALSE FALSE FALSE
##  FALSE FALSE  TRUE

Puede usar sum para contar rápidamente el número de TRUE en el vector anterior. Recuerde que R convertirá los lógicos en numéricos cuando haga operaciones matemáticas con ellos. R convertirá TRUE en unos y FALSE en ceros. Como resultado, sum contará el número de TRUE:

sum(mazo2$cara == "as")
## 4

Puede usar este método para detectar y luego cambiar los ases en su mazo, incluso si ha barajado sus cartas. Primero, crea una prueba lógica que identifique los ases en tu baraja barajada:

mazo3$cara == "as"

Luego use la prueba para seleccionar los valores de puntos as. Dado que la prueba devuelve un vector lógico, puede usarlo como índice:

mazo3$valor[mazo3$cara == "as"]
##  1 1 1 1

Finalmente, usa la asignación para cambiar los valores de as en mazo3:

mazo3$valor[mazo3$cara == "as"] <- 14

head(mazo3)
##  cara      palo valor
## queen  treboles    12
##   rey  treboles    13
##    as     picas    14  # un as
## nueve  treboles     9
## siete     picas     7
## reina diamantes    12

Para resumir, puede usar una prueba lógica para seleccionar valores dentro de un objeto.

La creación de subconjuntos lógicos es una técnica poderosa porque le permite identificar, extraer y modificar rápidamente valores individuales en su conjunto de datos. Cuando trabaja con subconjuntos lógicos, no necesita saber dónde en su conjunto de datos existe un valor. Solo necesita saber cómo describir el valor con una prueba lógica.

El subconjunto lógico es una de las cosas que R hace mejor. De hecho, el subconjunto lógico es un componente clave de la programación vectorizada, un estilo de codificación que le permite escribir código R rápido y eficiente, que estudiaremos en Velocidad.

Usemos subconjuntos lógicos con un nuevo juego: corazones. En corazones, cada carta tiene un valor de cero:

mazo4 <- mazo
mazo4$valor <- 0

head(mazo4, 13)
##   cara  palo valor
##    rey picas     0
##  reina picas     0
##   jota picas     0
##   diez picas     0
##  nueve picas     0
##   ocho picas     0
##  siete picas     0
##   seis picas     0
##  cinco picas     0
## cuatro picas     0
##   tres picas     0
##    dos picas     0
##     as picas     0

excepto las cartas del palo de corazones y la reina de picas. Cada carta del palo de corazones tiene un valor de 1. ¿Puedes encontrar estas cartas y reemplazar sus valores? Intentalo.

Ejercicio 7.2 (Dar Valor al Mazo para el Juego Corazones) Asigne un valor de 1 a cada carta en mazo4 que tenga un palo de corazones.

Solución. Para hacer esto, primero escribe una prueba que identifique las cartas en el palo corazones:

mazo4$palo == "corazones"
##  FALSE FALSE FALSE FALSE FALSE FALSE FALSE
##  FALSE FALSE FALSE FALSE FALSE FALSE FALSE
##  FALSE FALSE FALSE FALSE FALSE FALSE FALSE
##  FALSE FALSE FALSE FALSE FALSE FALSE FALSE
##  FALSE FALSE FALSE FALSE FALSE FALSE FALSE
##  FALSE FALSE FALSE FALSE  TRUE  TRUE  TRUE
##   TRUE  TRUE  TRUE  TRUE  TRUE  TRUE  TRUE
##   TRUE  TRUE  TRUE

Luego usa tu prueba para seleccionar los valores de estas cartas:

mazo4$valor[mazo4$palo == "corazones"]
## 0 0 0 0 0 0 0 0 0 0 0 0 0

Finalmente, asigne un nuevo número a estos valores:

mazo4$valor[mazo4$palo == "corazones"] <- 1

Ahora todas sus cartas de corazones han sido actualizadas:

mazo4$valor[mazo4$palo == "corazones"]
## 1 1 1 1 1 1 1 1 1 1 1 1 1

En corazones, la reina de picas tiene el valor más inusual de todos: vale 13 puntos. Debería ser sencillo cambiar su valor, pero es sorprendentemente difícil de encontrar. Podrías encontrar todas las reinas:

mazo4[mazo4$cara == "reina", ]
##   cara      palo valor
##  reina     picas     0
##  reina  treboles     0
##  reina diamantes     0
##  reina corazones     1

Pero son tres cartas de más. Por otro lado, podrías encontrar todas las cartas en picas:

mazo4[mazo4$palo == "picas", ]
##   cara  palo valor
##    rey picas     0
##  reina picas     0
##   jota picas     0
##   diez picas     0
##  nueve picas     0
##   ocho picas     0
##  siete picas     0
##   seis picas     0
##  cinco picas     0
## cuatro picas     0
##   tres picas     0
##    dos picas     0
##     as picas     0

Pero son 12 cartas de más. Lo que realmente quiere encontrar es todas las cartas que tienen un valor de cara igual a la reina y un valor del palo igual a las picas. Puede hacerlo con un operador booleano. Los operadores booleanos combinan varias pruebas lógicas en una sola prueba.

5.0.2.2 Operadores Booleanos

Los operadores booleanos son cosas como y (&) y o (|). Colapsan los resultados de múltiples pruebas lógicas en un solo TRUE o FALSE. R tiene seis operadores booleanos, que se muestran en la tabla Tabla 5.2.

Tabla 5.2: Operadores Booleanos

Operador	Sintaxis	Pruebas
`&`	`cond1 & cond2`	¿Son verdaderas `cond1` y `cond2`?
`\|`	`cond1 \| cond2`	¿Es verdadera una o más de `cond1` y`cond2`?
`xor`	`xor(cond1, cond2)`	¿Es exactamente una de `cond1` y `cond2` verdadera?
`!`	`!cond1`	¿Es `cond1` falsa? (por ejemplo, `!` invierte los resultados de una prueba lógica)
`any`	`any(cond1, cond2, cond3, ...)`	¿Alguna de las condiciones es verdadera?
`all`	`all(cond1, cond2, cond3, ...)`	¿Son verdaderas todas las condiciones?

Para usar un operador booleano, colóquelo entre dos pruebas lógicas completas. R ejecutará cada prueba lógica y luego usará el operador booleano para combinar los resultados en un solo TRUE o FALSE, figura Figura 5.1.

El error más común con los operadores Booleanos

Es fácil olvidar poner una prueba completa a cada lado de un operador booleano. En español, es eficiente decir “¿Es x mayor que dos y menor que nueve?” Pero en R, necesitas escribir el equivalente de “¿Es x mayor que dos y es x menor que nueve?” Esto se muestra en la Figura Figura 5.1.

Figura 5.1: R evaluará las expresiones en cada lado de un operador booleano por separado y luego combinará los resultados en un solo TRUE o FALSE. Si no proporciona una prueba completa a cada lado del operador, R devolverá un error.

Cuando se usan con vectores, los operadores booleanos seguirán la misma ejecución de elementos que los operadores aritméticos y lógicos:

a <- c(1, 2, 3)
b <- c(1, 2, 3)
c <- c(1, 2, 4)

a == b
##  TRUE TRUE TRUE

b == c
##  TRUE  TRUE FALSE

a == b & b == c
##  TRUE  TRUE FALSE

¿Podría usar un operador booleano para ubicar la reina de picas en su mazo? Por supuesto que puede. Desea probar cada carta para ver si es tanto una reina como una pica. Puedes escribir esta prueba en R con:

mazo4$cara == "reina" & mazo4$palo == "picas"
##  FALSE  TRUE FALSE FALSE FALSE FALSE FALSE
##  FALSE FALSE FALSE FALSE FALSE FALSE FALSE
##  FALSE FALSE FALSE FALSE FALSE FALSE FALSE
##  FALSE FALSE FALSE FALSE FALSE FALSE FALSE
##  FALSE FALSE FALSE FALSE FALSE FALSE FALSE
##  FALSE FALSE FALSE FALSE FALSE FALSE FALSE
##  FALSE FALSE FALSE FALSE FALSE FALSE FALSE
##  FALSE FALSE FALSE

Guardaré los resultados de esta prueba en su propio objeto. Eso hará que sea más fácil trabajar con los resultados:

reinaDePicas <- mazo4$cara == "reina" & mazo4$palo == "picas"

A continuación, puede utilizar la prueba como índice para seleccionar el valor de la reina de picas. Asegúrese de que la prueba realmente seleccione el valor correcto:

mazo4[reinaDePicas, ]
##  cara  palo valor
## reina picas     0

mazo4$valor[reinaDePicas]
## 0

Ahora que encontraste la reina de picas, puedes actualizar su valor:

mazo4$valor[reinaDePicas] <- 13

mazo4[reinaDePicas, ]
##  cara  palo valor
## reina picas    13

Tu mazo está listo para jugar corazones.

Ejercicio 7.3 (Practica con Pruebas) Si cree que domina las pruebas lógicas, intente convertir estas oraciones en pruebas escritas con código R. Para ayudarte, he definido algunos objetos de R después de las oraciones que puedes usar para probar tus respuestas:

¿Es w positivo?
¿Es x mayor que 10 y menor que 20?
¿Es objeto y la palabra Febrero?
¿Son todos los valores de z un día de la semana?

w <- c(-1, 0, 1)
x <- c(5, 15)
y <- "Febrero"
z <- c("Lunes", "Martes", "Viernes")

Solución. Aquí hay algunas respuestas de ejemplo. Si se quedó atascado, asegúrese de volver a leer cómo R evalúa las pruebas lógicas que usan valores booleanos:

w > 0
10 < x & x < 20
y == "Febrero"
all(z %in% c("Lunes", "Martes", "Miercoles", "Jueves", "Viernes", 
  "Sabado", "Domingo"))

Consideremos un último juego, el blackjack. En el blackjack, cada carta numérica tiene un valor igual a su valor nominal. Cada figura (rey, reina o jota) tiene un valor de 10. Finalmente, cada as tiene un valor de 11 o 1, dependiendo de los resultados finales del juego.

Comencemos con una copia nueva de mazo; de esa manera, las cartas numéricas (dos a diez) comenzarán con el valor correcto:

mako5 <- mazo

head(mazo5, 13)
##    rey picas    13
##  reina picas    12
##   jota picas    11
##   diez picas    10
##  nueve picas     9
##   ocho picas     8
##  siete picas     7
##   seis picas     6
##  cinco picas     5
## cuatro picas     4
##   tres picas     3
##    dos picas     2
##     as picas     1

Puedes cambiar el valor de las figuras de una sola vez con %in%:

caracartas <- mazo5$cara %in% c("rey", "reina", "jota")

mazo5[caracartas, ]
##   cara      palo valor
##    rey     picas    13
##  reina     picas    12
##   jota     picas    11
##    rey  treboles    13
##  reina  treboles    12
##   jota  treboles    11
##    rey diamantes    13
##  reina diamantes    12
##   jota diamantes    11
##    rey corazones    13
##  reina corazones    12
##   jota corazones    11

mazo5$valor[caracartas] <- 10

head(mazo5, 13)
##   cara   palo valor
##    rey picas    10
##  reina picas    10
##   jota picas    10
##   diez picas    10
##  nueve picas     9
##   ocho picas     8
##  siete picas     7
##   seis picas     6
##  cinco picas     5
## cuatro picas     4
##   tres picas     3
##    dos picas     2
##     as picas     1

Ahora solo necesita corregir los valores de as, ¿o no? Es difícil decidir qué valor dar a los ases porque su valor exacto cambiará de una mano a otra. Al final de cada mano, un as será igual a 11 si la suma de las cartas del jugador no supera los 21. De lo contrario, el as será igual a 1. El valor real del as dependerá de las otras cartas en la mano del jugador. Este es un caso de falta de información. Por el momento, no tiene suficiente información para asignar un valor de puntos correcto a las cartas de as.

5.0.3 Información Faltante

Los problemas de falta de información ocurren con frecuencia en la ciencia de datos. Por lo general, son más sencillos: no conoce un valor porque la medida se perdió, se corrompió o nunca se tomó para empezar. R tiene una manera de ayudarlo a administrar estos valores faltantes.

El carácter NA es un símbolo especial en R. Significa “no disponible” y se puede utilizar como marcador de posición para la información que falta. R tratará a NA exactamente como usted debería querer que se trate la información faltante. Por ejemplo, ¿qué resultado esperaría si suma 1 a la información que falta?

1 + NA
## NA

R devolverá una segunda pieza de información faltante. No sería correcto decir que 1 + NA = 1 porque existe una buena posibilidad de que la cantidad que falta no sea cero. No tienes suficiente información para determinar el resultado.

¿Qué pasa si prueba si una parte de la información que falta es igual a 1?

NA == 1
## NA

Nuevamente, su respuesta sería algo como “No sé si esto es igual a uno”, es decir, NA. Generalmente, los NA se propagarán cada vez que los use en una operación o función de R. Esto puede evitar que cometa errores basados en datos faltantes.

5.0.3.1 na.rm

Los valores faltantes pueden ayudarlo a solucionar los agujeros en sus conjuntos de datos, pero también pueden crear algunos problemas frustrantes. Suponga, por ejemplo, que ha recopilado 1.000 pases:[observaciones] y desea tomar su promedio con la función mean de R. Si incluso uno de los valores es NA, su resultado será NA:

c(NA, 1:50)
## NA  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16
## 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
## 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

mean(c(NA, 1:50))
## NA

Es comprensible que prefieras un comportamiento diferente. La mayoría de las funciones de R vienen con el argumento opcional, na.rm, que significa remove los NA. R ignorará NAs cuando evalúa una función si agrega el argumento na.rm = TRUE:

mean(c(NA, 1:50), na.rm = TRUE)
## 25.5

5.0.3.2 is.na

En ocasiones, es posible que desee identificar las NA en su conjunto de datos con una prueba lógica, pero eso también crea un problema. ¿Cómo lo harías? Si algo es un valor faltante, cualquier prueba lógica que lo use devolverá un valor faltante, incluso esta prueba:

NA == NA
## NA

Lo que significa que pruebas como esta no te ayudarán a encontrar valores faltantes:

c(1, 2, 3, NA) == NA
## NA NA NA NA

Pero no te preocupes demasiado; R proporciona una función especial que puede probar si un valor es un NA. La función se llama sensatamente is.na:

is.na(NA)
## TRUE

vec <- c(1, 2, 3, NA)
is.na(vec)
## FALSE FALSE FALSE  TRUE

Establezcamos todos sus valores de as en NA. Esto logrará dos cosas. Primero, te recordará que no sabes el valor final de cada as. En segundo lugar, evitará que anotes accidentalmente una mano que tenga un as antes de determinar el valor final del as.

Puede establecer sus valores de as en NA de la misma manera que los establecería en un número:

mazo5$valor[mazo5$cara == "as"] <- NA

head(mazo5, 13)
##   cara   palo valor
##    rey picas    10
##  reina picas    10
##   jota picas    10
##   diez picas    10
##  nueve picas     9
##   ocho picas     8
##  siete picas     7
##   seis picas     6
##  cinco picas     5
## cuatro picas     4
##   tres picas     3
##    dos picas     2
##     as picas    NA

Felicidades. Su mazo ahora está listo para un juego de blackjack.

5.0.4 Resumen

Puede modificar valores en su lugar dentro de un objeto de R cuando combina la sintaxis de notación de R con el operador de asignación, <-. Esto le permite actualizar sus datos y limpiar sus conjuntos de datos.

Cuando trabaja con grandes conjuntos de datos, modificar y recuperar valores crea un problema logístico propio. ¿Cómo puede buscar en los datos para encontrar los valores que desea modificar o recuperar? Como usuario de R, puede hacer esto con subconjuntos lógicos. Cree una prueba lógica con operadores lógicos y booleanos y luego use la prueba como un índice en la notación de paréntesis de R. R devolverá los valores que está buscando, incluso si no sabe dónde están.

Recuperar valores individuales no será su única preocupación como programador de R. También deberá recuperar conjuntos de datos completos; por ejemplo, puede llamar a uno en una función. Entornos le enseñará cómo R busca y guarda conjuntos de datos y otros objetos R en su sistema de entorno. Luego usará este conocimiento para corregir las funciones repartir y barajar.