Para que mantengas un buen orden en tu aprendizaje, es momento de crear un nuevo proyecto en el que irás anotando todo lo que aprendas en esta sesión. Cabe mencionar que todo lo que anotes deberás publicarlo al final en tu perfil de Rpubs.com

• Crear un nuevo proyecto en nuevo directorio: “02-ejercicios”

Puedes instalar la versión más reciente de ejerciciosT2 desde el r-universe de talleresdedatos con:

install.packages("ejerciciosT2", repos = 'https://talleresdedatos.r-universe.dev')

O desde el repositorio en Github con:

remotes::install_github("talleresdedatos/ejerciciosT2")

• Crear un nuevo archivo R Markdown a partir de la plantilla provista por el paquete ejerciciosT2:
  • Ve al menú File > New File > R Markdown
  • Elige “From template” y busca “R Básico” de ejerciciosT2
  • Guárdalo con el nombre “ejercicios.Rmd”

Los operadores, como dice su nombre, nos permiten realizar operaciones entre ciertos valores de manera similar a como lo haríamos con una calculadora. Los siguientes nos permiten realizar operaciones aritméticas básicas:

1994 + 27

## [1] 2021

28 / 365 * 100

## [1] 7.671233

2 ** 3

## [1] 8

(((1+2)*3)**2)/3

## [1] 27

Antes de explotar al máximo las capacidades de R, es necesario conocer otro operador fundamental: el de asignamiento. Está compuesto por el signo “menor que” (<) y el signo de resta (-), que al juntarse lucen como una flecha que apunta hacia la izquierda (<-).

Este operador sirve para asignar un nombre a cualquier objeto o valor, de tal modo podamos acceder a él con mayor facilidad. Por ejemplo, podemos asignarle el nombre “resultado” al resultado de la operación que realizamos anteriormente.

resultado <- (((1+2)*3)**2)/3

A simple vista, nada ha cambiado, pero cuando accedemos al objeto resultado ahora obtenemos inmediatamente la respuesta de nuestra operación.

resultado

## [1] 27

Si te diriges al panel Environment en RStudio, puedes ver que el objeto resultado está almacenado allí.

Es importante saber que el nombre asignado es arbitrario, es decir, no afectará el valor que está siendo asignado. Es buena práctica usar solo nombres que comiencen por letras y contengan solo letras, números y subguión. Por ejemplo: mi_valor, tabla1, mi_nueva_tabla, conjuntoDeDatos, etc.

Si por algún motivo necesitamos actualizar el valor asignado a nuestro objeto, basta con volver a asignar el mismo nombre a otro valor. Incluso se puede hacer referencia al valor anterior para modificarlo. No hay un límite de veces que el valor de un objeto puede ser modificado. En el siguiente ejemplo, sumaremos 3 a resultado para obtener 30.

resultado <- resultado + 3

Nuevamente, podemos ver el cambio al inspeccionar el elemento.

resultado

## [1] 30

Los siguientes objetos fundamentales para el manejo de R son los vectores. Estos pueden ser de dos tipos: atómicos y listas. La diferencia entre ellos radica en el tipo de información que pueden contener. Para efectos de estos tutoriales, consideraremos las listas como vectores “especiales” junto a otros que explicaremos más adelante.

Los cuatro principales tipos de vectores atómicos son: logical, double, integer y character.

• logical: pueden asumir dos valores: TRUE o FALSE(o en su forma abreviada T o F).
• integer puede asumir números enteros (1, 2, 3, -1, 1000, etc)
• double: pueden asumir números reales (1.0, 1.1, -1.999, 3.14159, etc)
• character: pueden asumir cualquier cadena de texto (“hola”, “buongiorno”, “$5.99”, etc)

Los de tipo double e integer también son conocidos como numéricos.

En el siguiente recuadro de código podemos ver un ejemplo de cada uno:

v_logical <- TRUE
v_double <- 3.1416
v_integer <- 5L
v_character <- "Hola mundo"

Si estamos atentos, vemos que el integer va acompañado de una “L” al final. Esto es necesario porque R interpreta por defecto cualquier número como double. Tanto los double como los integer pertenecen a la categoría de vectores numéricos. Los character siempre estarán rodeados de comillas ("").

Para comprobar si nuestro vector es de un tipo determinado utilizamos una función de forma is.*() reemplazando el * por el tipo que queremos comprobar.

is.logical(v_logical)

## [1] TRUE

is.numeric(v_double)

## [1] TRUE

is.integer(v_double)

## [1] FALSE

Podemos ver que por cada consulta obtenemos un valor logical TRUE cuando se cumple la condición y FALSE cuando no se cumple. Es decir, es cierto que v_logical es logical, es cierto que v_double es numérico y es falso que v_double es integer. El valor logical obtenido con cada consulta es un vector en sí mismo.

Otra manera de verificar el tipo de vector que tenemos es con la función typeof(). Esta nos devuelve un character indicando el tipo de vector que tenemos.

typeof(v_character)

## [1] "character"

typeof(v_integer)

## [1] "integer"

En bloques de código, ejecuta el código necesario para identificar el tipo de los siguientes valores:

1. "3.1415"
2. FALSE
3. 1 + 10
4. 142365L

¿Cuáles de los siguientes vectores son de tipo double?

• 100
• 7.9
• "50.0 mm"
• 1024L

Hasta el momento hemos visto vectores que contienen un solo elemento. Sin embargo, es sumamente común encontrarse con vectores de mayor longitud. Por ejemplo, el vector letters contiene todas las letras minúsculas del alfabeto. Podemos consultar la longitud de un vector con la función length().

Esto es muy útil cuando sabemos que nuestro vector podría contener una gran cantidad de elementos y no queremos inspeccionarlos todos. El número que vemos rodeado entre corchetes ([]) en nuestro resultado nos indica el índice que el elemento siguiente tiene en el vector. Es por ello que hasta el momento en cada operación que realizábamos hemos obtenido un “[1]” antes de cada resultado.

length(v_logical)

## [1] 1

length(letters)

## [1] 26

letters

##  [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s"
## [20] "t" "u" "v" "w" "x" "y" "z"

Para formar vectores de longitud mayor a uno (1) se utiliza la función c() agregando como argumentos todos los elementos que queremos.

mi_vector_largo <- c("elemento1", 
                     "elemento2", 
                     "elemento3", 
                     "elemento4")

mi_vector_largo

## [1] "elemento1" "elemento2" "elemento3" "elemento4"

Para vectores numéricos, también es posible utilizar el signo dos puntos (:) como operador para crear una secuencia, que avanza de uno en uno, desde un número a otro. El vector resultado incluirá a los dos números utilizados en la operación.

mi_vector_numerico1 <- 1:6

mi_vector_numerico1

## [1] 1 2 3 4 5 6

Podemos hacer uso de c() nuevamente para seguir haciendo crecer nuestro vector. Incluso podemos usar una operación de secuencia como argumento.

mi_vector_numerico2 <- 11:16

mi_vector_muy_largo <- c(mi_vector_numerico1, 
                         mi_vector_numerico2, 
                         21:26)

mi_vector_muy_largo

##  [1]  1  2  3  4  5  6 11 12 13 14 15 16 21 22 23 24 25 26

Al consultar el tipo de vector que hemos creado, vemos que mantiene el mismo tipo que sus “ancestros”: integer.

typeof(mi_vector_muy_largo)

## [1] "integer"

En bloques de código, ejecuta código para obtener lo siguiente:

• Crea un secuencia que vaya del 100 al 200
• ¿Qué tipo de vector se formó con esa secuencia?

En bloques de código, ejecuta código para obtener lo siguiente:

• Crea un vector en el que cada elemento es una parte de tu nombre completo. Por ejemplo:

mi_nombre <- c("Barack", "Obama")

• ¿Qué tipo de vector se formó con esta operación?

Es posible realizar operaciones entre vectores. Cuando los vectores tienen la misma longitud, la operación se hará elemento a elemento de acuerdo a su índice. Es decir, el primer elemento del vector 1 con el primer elemento del vector 2, el segundo elemento del vector 1 con el segundo elemento del vector 2, y así sucesivamente.

mi_secuencia1 <- 1:10
mi_secuencia2 <- 11:20

mi_secuencia1 + mi_secuencia2

##  [1] 12 14 16 18 20 22 24 26 28 30

mi_secuencia2 - mi_secuencia1

##  [1] 10 10 10 10 10 10 10 10 10 10

mi_secuencia1 * mi_secuencia2

##  [1]  11  24  39  56  75  96 119 144 171 200

Cuando un vector tienen longitud de uno (1), su valor se reciclará.

mi_secuencia1 + 1

##  [1]  2  3  4  5  6  7  8  9 10 11

mi_secuencia1 * 5

##  [1]  5 10 15 20 25 30 35 40 45 50

mi_secuencia1 ** 2

##  [1]   1   4   9  16  25  36  49  64  81 100

R incluye varias funciones que puedes usar para hacer tareas sofisticadas, por ejemplo, puedes puedes redondear un número con la función round() o calcular su raiz cuadrada con la función sqrt().

Usar una función es muy sencillo. solo escrite el nombre de la función y el valor con que quieres que opere esta función entre paréntesis:

round(3.14159)

## [1] 3

sqrt(81)

## [1] 9

El valor que le pasas a la función es llamado argumento. El argumento puede ser data sin procesar, un objeto de R, o incluso el resultado de otra función. en este último caso, R va a trabajar desde la función más profunda.

Por ejemplo, para redondear el promedio de los números del 1 al 6:

round(mean(1:6))

## [1] 4

En caso necesites ayuda para entender la manera en que se debe operar con una función, puedes consultar su página de ayuda especificando el nombre de la función dentro de la función help().

Por ejemplo, para buscar ayuda de la función sample()

help("sample")

Tomemos como ejemplo la documentación de la función sample(). Podemos ver que la función puede usar los siguientes argumentos:

• x: el vector del cual obtendremos una muestra
• size: el tamaño de la muestra que queremos obtener
• replace: lógico indicando si la muestra debe usar reemplazos
• prob: un vector de peso de probabilidades de los elementos del vector original

Podemos ver que en la documentación los valores de replace y prob tienen valores asignados de antemano. Esto significa que si no especificamos un valor distinto, se usará ese valor en el cálculo.

Hemos visto que podemos usar el operador ** para elevar un número a cualquier potencia, pero no tenemos un operador para obtener la raíz. Podemos solucionar esto haciendo uso de funciones.

Las funciones nos permiten aplicar transformaciones a los valores u objetos que ingresemos en ellas. Para crear una función, debemos asignarle un nombre, argumentos y código que será utilizado para la transformación. Su forma general en R es la siguiente:

nombredefuncion <- function(argumento_1, argumento_2, argumento_n){
  
cuerpo de código
  
}

Para que sea más entendible, haremos nuestra función para hallar la raíz cuadrada de cualquier número y la llamaremos raiz_cuadrada. Siempre es importante asignar un nombre significativo y que dé una buena idea del funcionamiento de la función.

Como vemos en el cuerpo de la función, esta obtiene un número “x” y calcula su raíz cuadrada. Probemos su funcionamiento.

raiz_cuadrada <- function(x){
  
  x**(1/2)
  
}

R ha calculado de manera correcta que la raíz cuadrada de 25 es 5. También podemos hacer una función para determinar la raíz cúbica de un número “x” de la misma manera.

raiz_cubica <- function(x){
  
  x**(1/3)
  
}

Al probar el funcionamiento de raiz_cubica() vemos que nos arroja el cálculo correcto. Podríamos hacer una función de raíz para cada número, pero como las funciones pueden tener más de un argumento, podemos usar eso para nuestra ventaja y hacer una función que aplique una raiz “n” a cualquier número “x”.

raiz_n <- function(x, n){
  
  x**(1/n)
  
}

Un truco muy útil al usar funciones es utilizar argumentos con valores por defecto. Vamos a reescribir nuestra función raiz_n() para utilizar un valor por defecto de n = 2, de tal modo que cuando no le proveamos explícitamente un valor para n, la función no deje de funcionar.

raiz_n <- function(x, n = 2){
  x ** (1/n)
}

Este es un truco muy utilizado por muchas funciones, porque permite no repetir trabajo innecesario y al mismo tiempo darle al usuario de la función una recomendación de cómo implementarla.