Módulo 2: Objetos, operadores y funciones

Introducción

Ahora que sabemos cómo trabajar con RStudio y con scripts, podemos comenzar a entender cómo funciona realmente R.

R funciona esencialmente creando objetos y utilizando después operadores y funciones para hacer cosas con esos objetos.

En este módulo comenzaremos con algunos de los componentes más básicos del lenguaje R.

Comencemos

Lo primero que necesitamos hacer es abrir RStudio, abrir nuestro proyecto intro-r-course y crear un nuevo script de R.

Guarda el script dentro de la carpeta scripts con el nombre:

module-02.R

Utilizaremos este script durante todo el módulo.

Ejecutar comandos

R funciona básicamente dándole instrucciones escritas mediante comandos o expresiones.

Un comando muy sencillo en R puede ser:

2 + 2

[1] 4

Si escribimos esto en nuestro script, no ocurrirá nada hasta que le indiquemos a R que ejecute o evalúe el comando.

Para ejecutar una línea de código, coloca el cursor sobre esa línea y utiliza:

Windows: Ctrl + Enter

Mac: Command + Enter

También puedes hacer clic en el botón Run de RStudio.

Si quieres ejecutar varias líneas al mismo tiempo, selecciónalas y utiliza el mismo atajo.

Comencemos con algo sencillo:

2 + 2

[1] 4

R debería devolver:

[1] 4

Cuando ejecutamos esta línea, el resultado aparece en la Consola.

En este caso, R nos indica que al evaluar el comando se produjo un objeto que contiene el número 4.

Recuerda: R trabaja con objetos.

También podemos utilizar paréntesis para agrupar operaciones:

(50 + 9) / (2 * 3)

[1] 9.833333

R devuelve:

[1] 9.833333

Al igual que en las matemáticas tradicionales, las operaciones dentro de los paréntesis se evalúan primero.

Comentarios

A veces queremos escribir notas dentro de nuestro script para recordar qué hace el código.

Si simplemente escribimos texto normal dentro de un script e intentamos ejecutarlo, R probablemente devolverá un error porque intentará interpretar nuestras palabras como código.

Para evitarlo, utilizamos el símbolo #.

# R ignora esta línea porque comienza con #

# number <- 23
# R también ignora esta línea

2 # R evalúa el 2, pero ignora todo lo que aparece después de #

[1] 2

R devuelve:

[1] 2

Todo lo que aparece después de # en una línea se considera un comentario.

Tip

Utiliza comentarios frecuentemente en tus scripts.

Tu yo del futuro te lo agradecerá.

Crear objetos

Hasta ahora, los resultados de nuestras operaciones aparecen en la Consola, pero a medida que seguimos ejecutando comandos esos resultados desaparecen de nuestra vista.

La mayoría de las veces querremos asignar un resultado a un objeto para poder utilizarlo nuevamente más adelante.

En R, normalmente asignamos algo a un objeto utilizando:

<-

Por ejemplo:

number <- 2

big_number <- 56

Acabamos de crear dos objetos, cada uno de los cuales contiene un número.

Observa que R no imprimió nada en la Consola.

Los valores fueron almacenados dentro de los objetos.

Para ver qué contiene un objeto, simplemente ejecutamos su nombre:

big_number

[1] 56

R devuelve:

[1] 56

El atajo para escribir <- en RStudio es:

Windows: Alt + -

Mac: Option + -

¡Pruébalo!

Nombrar objetos

Puedes elegir casi cualquier nombre para un objeto, pero existen algunas reglas importantes.

R distingue entre mayúsculas y minúsculas.

Por ejemplo:

big_number

[1] 56

y:

Big_number

son dos nombres diferentes.

Si solamente existe big_number e intentas ejecutar:

Big_number

R devolverá un error.

También debemos evitar utilizar acentos o caracteres especiales en nombres de objetos, archivos, carpetas y columnas. Aunque pueden funcionar en muchos casos, las diferencias en la codificación de caracteres pueden generar problemas innecesarios.

Los nombres de objetos:

• no deberían comenzar con un número,
• no deberían contener espacios,
• deberían evitar operadores especiales como +, -, *, /, #, %, [ ], { }, ( ) o ~,
• y no deberían reutilizar nombres de funciones comunes de R, como mean.

Lo más importante es que el nombre del objeto nos dé alguna información sobre lo que contiene.

Compara:

x <- 25

con:

number_of_cameras <- 25

El segundo nombre es mucho más fácil de entender cuando regresamos al script más adelante.

Algunas formas comunes de escribir nombres de objetos largos son:

number_of_cameras

[1] 25

o:

number.of.cameras

A lo largo de este curso utilizaremos principalmente snake_case:

number_of_cameras

[1] 25

Importante

Ten cuidado al reutilizar el nombre de un objeto.

Asignar algo nuevo a un objeto que ya existe reemplazará su valor anterior.

Por ejemplo:

big_number

[1] 56

devuelve:

[1] 56

Pero ahora hagamos esto:

big_number <- "fifty six"

big_number

[1] "fifty six"

R ahora devuelve:

[1] "fifty six"

El número original 56 fue reemplazado.

Tipos de objetos

R puede almacenar diferentes tipos de información.

Por ahora nos enfocaremos en cuatro tipos básicos:

• numéricos (numeric),
• texto o caracteres (character),
• lógicos (logical),
• valores faltantes.

Más adelante combinaremos estos valores en estructuras de datos más complejas como vectores, matrices, listas y data frames.

Objetos numéricos

Los objetos numéricos contienen números.

Pueden contener números enteros o números con decimales.

number_1 <- 25

number_2 <- 27.5

Como estos objetos contienen números, podemos realizar operaciones matemáticas con ellos.

Por ejemplo:

sum_numbers <- number_1 + number_2

sum_numbers

[1] 52.5

Podemos seguir utilizando el objeto que acabamos de crear:

difference <- sum_numbers - number_2

difference

[1] 25

Y podemos continuar combinando objetos y operaciones:

product <- sum_numbers * difference

product

[1] 1312.5

O hacer algo un poco más complicado:

result <- ((product / sum_numbers) + difference)^2

result

[1] 2500

Operadores aritméticos

Operador	Operación
+	Suma
-	Resta
*	Multiplicación
/	División
^	Potencia

Inténtalo tú mismo

Crea dos objetos numéricos:

camera_days <- 30

number_of_cameras <- 12

Utilízalos para calcular el número total de días-cámara (camera-days) si todas las cámaras estuvieron activas durante los 30 días.

Guarda el resultado en un objeto llamado:

total_camera_days

Operadores relacionales

También podemos comparar valores utilizando operadores relacionales.

En lugar de devolver un número, estas comparaciones devuelven un valor lógico: TRUE o FALSE.

Por ejemplo:

7 < 3

[1] FALSE

Otro ejemplo:

30 >= 50

[1] FALSE

Y:

50 == 50

[1] TRUE

Observa que para comprobar si dos valores son iguales necesitamos utilizar dos signos de igual:

==

Operadores relacionales

Operador	Operación
<	Menor que
<=	Menor o igual que
>	Mayor que
>=	Mayor o igual que
==	Igual a
!=	Diferente de

Por ejemplo:

number_of_cameras > 10

[1] TRUE

Objetos de tipo character

Los objetos de tipo character contienen texto.

El texto en R normalmente debe colocarse entre comillas:

species <- "Raccoon"

o:

station <- "Camera_01"

Por ejemplo:

character_1 <- "a"

character_1

[1] "a"

También podemos almacenar frases completas:

character_2 <- "I like statistics"

character_2

[1] "I like statistics"

Ahora, ¿qué ocurre si hacemos esto?

fake_number <- "69"

Aunque 69 parece un número, las comillas le indican a R que debe tratarlo como texto.

Esto significa que no podemos utilizarlo directamente en operaciones aritméticas:

fake_number + 2

R devolverá un error.

Sin embargo, los operadores relacionales también pueden utilizarse con valores de tipo character.

Por ejemplo:

"a" < "b"

[1] TRUE

En este caso, R utiliza el orden alfabético.

También podemos comparar texto directamente:

"hello" == "Hello"

[1] FALSE

Recuerda que R distingue entre mayúsculas y minúsculas.

Otro ejemplo:

"23" != "twenty three"

[1] TRUE

Objetos lógicos

Los objetos lógicos contienen uno de dos valores:

TRUE
FALSE

Básicamente representan si una condición se cumple o no.

Podemos crear directamente un objeto lógico:

logical_object <- TRUE

logical_object

[1] TRUE

Los valores lógicos son especialmente útiles cuando utilizamos operadores relacionales.

Por ejemplo:

number_1 < number_2

[1] TRUE

También podemos combinar condiciones lógicas.

Por ejemplo, el operador | significa OR (o):

TRUE | FALSE

[1] TRUE

porque al menos una de las dos condiciones es verdadera.

Utilizaremos mucho más los valores lógicos cuando comencemos a filtrar y manipular bases de datos.

Valores faltantes

A veces una observación o un valor no existe o no fue registrado.

En R, los valores faltantes se representan mediante:

NA

Es muy importante entender que NA no es lo mismo que cero.

Imagina que estamos contando ranas en estanques.

Un valor de:

0

podría significar:

Visitamos el estanque y no observamos ninguna rana.

En cambio:

NA

podría significar:

Nunca visitamos ese estanque, por lo que no sabemos cuántas ranas había.

Son situaciones muy diferentes.

Podemos crear un objeto que contenga un valor faltante:

missing_value <- NA

missing_value

[1] NA

Los valores faltantes son extremadamente comunes en bases de datos reales y más adelante aprenderemos cómo identificarlos y trabajar con ellos.

Funciones

Las funciones son operaciones predefinidas diseñadas para realizar una tarea específica.

La mayoría de las funciones de R siguen una estructura general como esta:

function_name(object)

Por ejemplo, la función:

class()

nos indica con qué tipo de objeto estamos trabajando.

Prueba:

class(23)

[1] "numeric"

Ahora prueba con el objeto que creamos anteriormente:

class(fake_number)

[1] "character"

También podemos revisar un valor lógico:

class(TRUE)

[1] "logical"

Y:

class(missing_value)

[1] "logical"

Un NA por sí solo se almacena de manera predeterminada como un valor lógico faltante. Más adelante, cuando trabajemos con bases de datos, veremos que también pueden existir valores faltantes dentro de variables numéricas, de texto y de otros tipos.

Argumentos de una función

Las funciones reciben información mediante argumentos.

Por ejemplo:

round(3.14159, digits = 2)

[1] 3.14

Aquí:

3.14159

es el valor que queremos que utilice la función, mientras que:

digits = 2

le indica a round() cuántos decimales queremos conservar.

Diferentes funciones aceptan diferentes argumentos.

No necesitas memorizarlos todos.

R proporciona documentación para sus funciones.

Por ejemplo:

help(round)

starting httpd help server ... done

o:

?round

abrirán la página de ayuda de round().

Tip

Aprender R no consiste en memorizar cada función y cada uno de sus argumentos.

Aprender a encontrar la documentación que necesitas es mucho más útil.

Funciones fuera de R base

Muchas funciones ya vienen incluidas cuando instalamos R. A estas funciones normalmente nos referimos como funciones de R base (base R).

Sin embargo, una gran parte de las capacidades de R proviene de funciones creadas por la comunidad y distribuidas mediante paquetes.

Para utilizar las funciones de un paquete, generalmente necesitamos:

1. Instalar el paquete.
2. Cargar el paquete.
3. Utilizar sus funciones.

Instalar un paquete

Vamos a instalar un pequeño paquete llamado beepr.

beepr permite que R reproduzca sonidos.

Ejecuta:

install.packages("beepr")

Recuerda que necesitas una conexión a Internet para instalar un paquete.

Normalmente solamente necesitas instalar un paquete una vez en tu computador.

Cargar un paquete

Una vez instalado el paquete, necesitamos cargarlo en nuestra sesión actual de R.

library(beepr)

A diferencia de install.packages(), normalmente ejecutamos library() cada vez que comenzamos una nueva sesión de R y queremos utilizar ese paquete.

Utilizar una función del paquete

Ahora podemos utilizar una de las funciones incluidas en beepr:

beep(sound = 8)

Si todo funcionó correctamente, tu computador debería reproducir un sonido.

Importante

Instalar y cargar un paquete son cosas diferentes.

install.packages("beepr")

instala el paquete en tu computador.

library(beepr)

hace que el paquete que ya está instalado esté disponible durante la sesión actual de R.

Existen miles de paquetes de R.

La mayoría están disponibles a través de un repositorio llamado CRAN, aunque los paquetes también pueden distribuirse de otras maneras.

Una de las formas más sencillas de encontrar un paquete es simplemente buscar lo que quieres hacer.

Por ejemplo:

paquete para calcular el índice de diversidad de Shannon en R

Una búsqueda de este tipo probablemente te llevará a paquetes como vegan.

El siguiente paso será aprender cómo funciona ese paquete leyendo su documentación, ejemplos o tutoriales.

Práctica en casa

Tip

Esta actividad debería tomar aproximadamente 15–20 minutos.

Abre tu proyecto intro-r-course y crea un nuevo script llamado:

practice-02.R

Guárdalo dentro de la carpeta scripts.

Completa las siguientes actividades:

1. Crea un objeto llamado species que contenga el nombre de una especie animal.
2. Crea un objeto llamado station que contenga el nombre de una estación de cámara, por ejemplo "CT01".
3. Crea un objeto llamado detections que contenga un número.
4. Utiliza un operador relacional para determinar si detections es mayor que 10.
5. Crea dos objetos numéricos y realiza al menos cuatro operaciones aritméticas diferentes con ellos.
6. Utiliza class() para revisar el tipo de cada uno de los siguientes valores:

25

[1] 25

"25"

[1] "25"

TRUE

[1] TRUE

NA

[1] NA

7. Utiliza el sistema de ayuda de R para abrir la documentación de la función round().
8. Agrega comentarios a lo largo de tu script explicando qué hace cada sección.

Solución sugerida

Tu script podría verse así:

# Práctica del Módulo 2

# Objetos character
species <- "Raccoon"
station <- "CT01"

# Objeto numérico
detections <- 15

# ¿El número de detecciones es mayor que 10?
detections > 10

[1] TRUE

# Operaciones aritméticas
number_1 <- 20
number_2 <- 5

number_1 + number_2

[1] 25

number_1 - number_2

[1] 15

number_1 * number_2

[1] 100

number_1 / number_2

[1] 4

# Revisar los tipos de objetos
class(25)

[1] "numeric"

class("25")

[1] "character"

class(TRUE)

[1] "logical"

class(NA)

[1] "logical"

# Abrir la página de ayuda de round()
?round

Los nombres y valores de tus objetos pueden ser diferentes.

Lo importante es que practiques:

• crear objetos,
• utilizar <-,
• trabajar con valores numéricos, de tipo character y lógicos,
• utilizar operadores aritméticos y relacionales,
• reconocer valores faltantes,
• y utilizar funciones sencillas.