Contenido

Modulo 1: Introducción.....................................................................................................................2
Importancia de R............................................................................................................................2
¿Qué es R?................................................................................................................................2
Ventajas de R............................................................................................................................2
Instalación de R y RStudio..............................................................................................................3
Descarga e instalación de R........................................................................................................3
Descarga e instalación de RStudio.............................................................................................4
Panes..........................................................................................................................................5
Aspecto General.........................................................................................................................5
R Notebook................................................................................................................................5
Run.............................................................................................................................................5
Chunks.......................................................................................................................................5
Gráficas......................................................................................................................................6
Trabajando con chunks...............................................................................................................6
Obteniendo información de los data frames...............................................................................7
Pestaña Help...............................................................................................................................7
Modulo 2: Creación............................................................................................................................7
Tipos de datos en R........................................................................................................................7
Existen, principalmente, tres tipos de datos en R:......................................................................7
Tipos de datos................................................................................................................................8
Vectores.........................................................................................................................................9
Vectores en R.............................................................................................................................9
Indexación de vectores.............................................................................................................10
Matrices.......................................................................................................................................11
Matrices en R...........................................................................................................................11
Indexación de matrices.............................................................................................................12
Marcos de Datos(Data frame)......................................................................................................13
Marcos de datos en R...............................................................................................................13
Indexación de marcos de datos.................................................................................................14
Importación de bases de datos....................................................................................................15
Manejo de bases de datos.......................................................................................................15
Modulo 3: Visualización de datos.....................................................................................................16
 Paquete ggplot2...........................................................................................................................16
Instalación de ggplot2............................................................................................................16
Graficas de dispersión..................................................................................................................16
Gramática de gráficos...............................................................................................................16
Propiedades de la geometría.....................................................................................................19
Propiedades de la estética.........................................................................................................22
Gráficas de barra y pastel.............................................................................................................24
Gráficos de barras..................................................................................................................24
Gráficos de pastel.....................................................................................................................26
Histogramas.................................................................................................................................29
Histogramas de frecuencia.....................................................................................................29
Módulo 4: Programación en R..........................................................................................................31
Condicionales...............................................................................................................................31
Comandos if y else...................................................................................................................31
Ciclos............................................................................................................................................32
Comandos for y while..............................................................................................................32
Comandos next y break............................................................................................................34
Funciones.....................................................................................................................................35
Desarrollo y aplicación de funciones........................................................................................35
 Introducción a R.

Modulo 1: Introducción
Importancia de R

¿Qué es R?

1. Lenguaje de programación

2. Especializado en ciencia de datos

3. Comprende desde métodos estadísticos sencillos

Ejemplos:

 Pruebas de hipótesis

 Regresión lineal

 Series de tiempo

4. Hasta algoritmos más complejos de aprendizaje automático

Ejemplos:

 Árboles de decisión

 Clustering

 Redes neuronales

Ventajas de R

Sobre otros programas estadísticos, como:

 SAS

 Stata

 SPSS

1. Es un software libre y de código abierto.

 Acceso gratuito.

 Los usuarios pueden modificar y mejorar su diseño.

  Más de 15K paquetes estadísticos para su descarga.

 Más de 100K desarrolladores activos mantienen el programa.

2. R trabaja a través de un entorno de desarrollo integrado, el cual es una

herramienta que facilita el uso del software y maximiza la productividad del usuario.

Uno de los mejores entornos que existe para R es RStudio, el cual es también un software
libre. Por ello es que hemos decidido utilizarlo para este curso.

Una de las desventajas de R es que su sintaxis puede ser un poco complicada, por ello, en
este curso te guiaremos de forma fácil a entender la manera de programar en R. Aprenderás
desde cero a construir bases de datos para luego extraer la mayor información posible de
ellas; así mismo, presentaremos diversas formas y paqueterías con las que podemos
representar gráficamente estos datos. Finalmente, concluiremos enseñando los comandos
más comunes para que tú puedas programar tus propias funciones en R.

Instalación de R y RStudio

Descarga e instalación de R

Para descargar R:

 Acceder a www.r-project.org

 Darle click a "CRAN" en el apartado de descargas ("Download")

 Seleccionar el enlace correspondiente al país donde te encuentres

 Escoger el sistema operativo para el cual queremos descargar R (Linux, Windows o

MacOS)

De aquí se procede distinto según la opción que elijas.

Si eliges Windows:

Selecciona la opción de "instalar R por primera vez" ("install R for the first time") y luego
"Descargar R 4.0.0 para Windows".

Si eliges MacOS:
Selecciona "R-4.0.0.pkg" para la descarga. Cabe mencionar que este archivo funciona para
la versión High Sierra en adelante. Para versiones más antiguas como El Capitán o
Mavericks se descargan los archivos "R-3.6.3.nn.pkg" o "R-3.3.3.pkg", respectivamente.

Para instalar R en alguno de estos dos primeros casos, abre el archivo que se descargó en tu
computadora y sigue las instrucciones que aparecen ahí.

Si eliges Linux:

Elige el sistema operativo de Linux en el que estás trabajando (Debian, Red Hat, SUSE o
Ubuntu). En cada carpeta se encuentran las instrucciones de descarga e instalación; Sigue
las instrucciones y corre en la Terminal los códigos que aparecen ahí.

Descarga e instalación de RStudio

Para descargar RStudio:

 Acceder a www.rstudio.com y darle click a "Descargar" ("Download")

 Seleccionar la versión de RStudio que se quiere descargar, en nuestro caso "RStudio

Desktop - Free"

 Descargar la opción que nos recomienda RStudio o seleccionar manualmente el

archivo de descarga en la sección de "Todos los instaladores" ("All installers"),
según tu sistema operativo

Para instalar RStudio abre el archivo que se descargó en tu computadora y se instalará

automáticamente.

Panes

 Source: Código.

 Consola: Salida o resultado de código.

o Tener Consola a la derecha: Panes > Console on Right

  Environment: Información de variables y su contenido.

o Nombres de data frames y sus características.

o Historia: Registro de todos los comandos utilizados.

 Files: Archivos usados y generados (por ejemplo: gráficas exportadas).

Aspecto General

Tools > Global Options… > Appearance

Se recomienda usar un tema con fondo oscuro.

R Notebook

 El tipo de archivo utilizado en el curso.

 Es normal tener que actualizar librerías al abrir.

 Se recomienda guardar el archivo en cuanto se crea.

 Siempre utilizar extensión rmd.

 Se recomienda establecer el directorio donde se va a guardar el archivo y que sea el

mismo que el código o source.

o Session > Set Working Directory > To Source File Location

o Clic en la flecha

Run

Se puede correr todo el código completo o por "chunks".

Chunks

Son segmentos o bloques de código que funcionan como instrucciones.

 Nombrar el chunk: clic en el engranaje.

o Permite enlistar los chunks para navegarlos fácilmente.

 Correr el chunk: clic en la flecha verde.

o Ejecuta el chunk en esa sección directamente en el Markdown.

Gráficas

Mostrar gráficas en el panel Plot:

1. Clic en la Consola

2. Flecha arriba {use the keyboard styles to show the key} para cargar la última
instrucción

3. La gráfica aparece

Exportar una gráfica del panel Plot:

1. Clic en "Export"

2. Seleccionar el formato o copiar al Portapapeles

Visualizar gráficas con tamaño variable desde el código:

1. Clic en la flecha verde del chunk

2. Se muestra la gráfica en el Markdown

3. Clic en el primer botón sobre la gráfica para abrir en una nueva ventana

4. El gráfico en la nueva ventana se actualiza al cambiar el tamaño para mostrar el

mayor detalle posible.

Trabajando con chunks

Nuevo chunk

1. Insert > R

2. Se agrega el nuevo chunk

Escribiendo las primeras tres letras de una instrucción, R nos sugiere autocompletar con
una instrucción válida al usar la tecla tab {format tab as key}.

Obteniendo información de los data frames

Un data frame es una matriz de datos multivariados.

names(x)
Nos muestra el nombre de las variables donde x es el nombre del data frame.
str(x)
Nos muestra la estructura de x siendo ésta el nombre del data frame.

View(x)
Abre una nueva pestaña con el contenido de x siendo ésta el nombre del data frame.

Pestaña Help

Buscar información de un data frame:

 Escribir el nombre del data frame (busca entre los disponibles y autocompleta)

 Enter

Muestra la descripción, variables y comandos incluidos, los cuales se pueden copiar y pegar
en un nuevo chunk.

Modulo 2: Creación.

Tipos de datos en R

Existen, principalmente, tres tipos de datos en R:

1. Numéricos

2. Caracteres

3. Lógicos

Tipos de Definición Ejemplo Código de R

datos

Numéricos Son números Número de x <- 5, para un

enteros o empleados de una número decimal
decimales compañía (entero)
 Sueldo promedio de x <-5L, para un
dichos empleados número entero
(decimal)

Áreas de una x <-"produccion"

Son datos que empresa
Caracteres representan (producción, x <-"marketing"
categorías marketing, ventas,
etc.) x <-"ventas"

La empresa cumple
el mínimo de ventas
Son datos que sólo mensual
x <- TRUE
toman dos (verdadero)
Lógicos
valores: verdadero La empresa no
x <- FALSE
o falso. cumple el mínimo
de ventas mensual
(falso)

En ciertos casos, podemos convertir la variable "x" de un tipo de dato a otro, según
nuestra conveniencia:

 La función "as.numerical(x)" convierte a "x" en un dato numérico.

 La función "as.character(x)" convierte a "x" en un dato tipo caracter.

 La función "as.logical(x)" convierte a "x" en un dato lógico.

Es recomendable definir desde un principio el tipo de dato que va a representar cada

variable que forma parte del análisis.

Vectores

Vectores en R
En cualquier lenguaje de programación, los datos se almacenan a través de vectores.

Estos pueden ser vectores de tipo numérico, caracter y lógico, según los datos que
contengan. Para crear estos vectores en R, se utiliza el comando "c" que es una abreviación
de "concatenar".

Ejemplos:

 Para hacer un vector numérico v con los datos 1, 3, 5 y 7, utilizamos la instrucción v

<- c(1, 3, 5, 7).

 Para hacer un vector de caracteres v con los datos "uno", "tres"; y "cinco",
utilizamos la instrucción v <- c("uno", "tres", "cinco").

 Para hacer un vector lógico v con los datos TRUE y FALSE, utilizamos la
instrucción v <- c(TRUE, FALSE).

Cada vector tiene un tamaño, el cual es el número de elementos que contiene.

Para calcular el tamaño de un vector "v" se utiliza el comando "length(v)". En los ejemplos

anteriores el resultado será cuatro, tres y dos, respectivamente. Al igual que en el tema
pasado, podemos utilizar la función "class(v)" para saber el tipo de datos que almacena el
vector "v".

Finalmente, si tenemos el vector extra horas.extra <- c(1.5, 1, 0, 1, 0), podemos nombrar

cada elemento del mismo con la función names(horas.extra) <- c("Lunes", "Martes",
"Miercoles", "Jueves", "Viernes"). Es importante el uso de vectores en el análisis de datos
ya que mantiene la información organizada.

Indexación de vectores

Al momento de crear un vector, la pregunta natural que surge es: ¿cómo accedemos a
los datos contenidos en él?

Enlistaremos algunas formas de hacerlo. Para ello, consideremos el vector v <- c(10, 12,
14, 16, 18, 20).

Ejemplos:
  v[5] nos regresa el elemento de v en la posición cinco, es decir, 18.

 v[-5] nos regresa todos los elementos de v con excepción del quinto, es decir [10,
12, 14, 16, 18].

 v[2:5] nos regresa los elementos de v en las posiciones dos, tres, cuatro y cinco (de
la dos a la cinco), es decir, [12, 14, 16, 18].

 v[-(2:5)] nos regresa todos los elementos de v con excepción de los mencionados en

el punto anterior, es decir, [10, 20].

 v[c(2,3,6)] nos regresa los elementos de v en las posiciones dos, tres y seis, es decir,
[12, 14, 20].

 v[-c(2,3,6)] nos regresa todos los elementos de v con excepción de los mencionados

en el punto anterior, es decir, [10, 16, 18].

En los últimos dos puntos, se recomienda partir la instrucción en dos:

Primero, escribir la instrucción indice <- c(2,3,6) y después v[indice] (ó v[-indice]), para

mantener el código lo más ordenado posible.

Matrices

Matrices en R

Así como un conjunto de datos produce un vector, un conjunto de vectores produce

una matriz.

Consideremos los vectores v <- c(5, 10, 15, 20) y w <- c(3, 6, 9, 12). Hay dos formas de
formar una matriz:

Ejemplos:

 Usando el comando M <- rbind(v,w) si queremos que los vectores v y w sean las

filas de la matriz. Aquí resultará una matriz de dos filas por cuatro columnas.

 Usando el comando M <- cbind(v,w) si queremos que los vectores v y w sean las

columnas de la matriz. En este caso resultará una matriz de cuatro filas por dos
columnas.
Cabe recalcar que, para que las matricez se construyan como deseamos, los vectores
deben de tener la misma longitud y ser del mismo tipo (numérico, caracteres o
lógicos).

Los comandos rbind y cbind funcionan también para más de dos vectores. Si agregamos el

vector x <- c(1, 2, 3, 4), la instrucción "M <- rbind(v,w,x)" producirá una matriz de 3x4
y "M <- cbind(v,w,x,w,v)" construirá un arreglo de 4x5.

Finalmente, podemos nombrar las filas y columnas de nuestra matriz M.

Esto se logra con el comando rownames(M) <- c("F1", "F2", "F3", "F4") para las filas
y colnames(M) <- c("C1", "C2", "C3", "C4", "C5") para las columnas.

Indexación de matrices

Al igual que en el caso de los vectores, debemos aprender a acceder a los elementos de
una matriz.

Consideremos los vectores v <- c(10, 11, 12), w <- c(13, 14, 15) y x <- c(16, 17, 18), y la
matriz M <- cbind(v, w, x) formada por dichos vectores. Las siguientes instrucciones
producen diferentes arreglos de los elementos de M:

 M[2,3] devuelve el elemento que está en la segunda fila y tercer columna de la

matriz
M: 17.

 M[-2,3] devuelve todos los valores de la tercera columna, con excepción del

segundo:
[16, 18].

 M[2,-3] devuelve todos los valores de la segunda fila con excepción del tercero:
[11,14].

 M[-2,-3] elimina la segunda fila y la tercer columna de la matriz M: [10, 13; 12 15].

Considerando los índices filas <- c(1,3) y cols <- c(2,3):

  M[filas, cols] devuelve las filas uno y tres, y las columnas dos y tres, es decir, los
elementos (1,2), (1,3), (3,2) y (3,3) de la matriz M: [13, 16; 15, 18].

 M[-filas, cols] devuelve un arreglo que contiene la segunda fila con las columnas
dos y tres de la matriz: [14, 17].

 M[filas, -cols] devuelve en un arreglo que contiene las filas uno y tres con la primer
columna: [10, 12].

 M[-filas, -cols] devuelve un arreglo eliminando las filas uno y tres y las columnas
dos y tres, es decir, constaría de un sólo elemento: 11.

Finalmente:

 M[3,] devuelve la tercer fila completa.

 M[,2] devuelve la segunda columna completa.

Marcos de Datos (Data frame)

Marcos de datos en R

Una de las limitaciones de los vectores y matrices es que solo permiten datos de un
mismo tipo.

No podemos combinar datos numéricos con caracteres o con datos lógicos en un mismo
arreglo. Los marcos de datos (o data frames) proveen una solución a este problema y nos
permiten tener nuestros datos mejor organizados.

Comencemos creando tres vectores de tipos diferentes. Supongamos que contamos con la
información de los costos de producción de una empresa en el primer semestre del año:

 Vector de costos (en miles de pesos): Costo <- c(7.3, 9.5, 8.6, 11.3, 6.7, 7.7).

 Vector de meses: Mes <- c("Enero", "Febrero", "Marzo", "Abril", "Mayo", "Junio").

 Vector de excedentes (TRUE si el costo se pasó de nueve mil pesos y FALSE en

caso contrario): Excedente <- c(FALSE, TRUE, FALSE, TRUE, FALSE, FALSE).

Una vez creados los vectores que conformarán nuestro marco de datos, utilizamos el
comando df <- data.frame(Costo, Mes, Excedente) para combinarlos.

Esto nos permite incluirlos en el mismo arreglo aunque sean de diferente tipo.
Por último:

Podemos guardar nuestro marco de datos como archivo CSV utilizando la

instrucción write.csv(df, "CostosProduccion.csv", row.names = FALSE), especificando el
nombre del mismo.

Indexación de marcos de datos

Los marcos de datos son arreglos que pueden contener diferentes tipos de datos.

Al ser estos mismos una especie de matriz, se puede acceder a ellos con los mismos
comandos que cubrimos en la clase de indexación de matrices. Sin embargo, al tener una
estructura diferente, existen comandos especiales para acceder a ellos:

Consideraremos el marco de datos creado y guardado en la sesión anterior.

Accedemos a él con la instrucción df <- read.csv("CostosProduccion.csv"). Recordemos

que sus columnas son "Costo", "Mes" y "Excedente". Para acceder a una columna en
particular escribimos df$ seguido del nombre de la columna, por
ejemplo: "df$Costo", "df$Mes" o "df$Excedente". Cuando tratamos con vectores de
caracteres, adicional a la columna, se desplega el número de categorías diferentes que tiene
el vector.

Podemos filtrar los datos del marco con la función filter.

Primero instalamos el paquete correspondiente con la

instrucción install.packages("dplyr") y lo cargamos a R con library(dplyr). Una vez hecho
esto, filtrar datos es sencillo: escribimos el nombre de la columna que queremos y el
elemento a filtrar.

Ejemplos:

 filter(df, Costo > 8) devuelve las filas del marco de datos cuyo valor en la columna
"Costo" sea mayor a ocho.
  filter(df, Mes == "Abril") devuelve las filas del marco de datos cuyo valor en la
columna "Mes" sean igual a "Abril".

 filter(df, Excedente == TRUE) devuelve las filas del marco de datos cuyo valor en
la columna "Excedente" sean igual a TRUE.

Estas son algunas formas complementarias de acceder a la información de un marco de

datos.

Importación de bases de datos

Manejo de bases de datos

Apartir de ahora y hasta el final del curso, nos referiremos a los marcos como bases
de datos.

Hemos visto cómo crearlos, guardarlos y cargarlos en un archivo CSV desde la

computadora, ahora, veremos cómo aplicar algunas funciones a ellos.

El comando data nos desplega una lista de las bases disponibles en R. En la base datos <-
PlantGrowth se encuentra registrado el peso (weight) y el grupo de tratamiento (group) al
que pertenecieron 30 plantas en un experimento. La manera más fácil de obtener
información general sobre la base de datos es con la función summary(datos). Para la
columna numérica (weight) nos genera el resumen de cinco números (valor mínimo, primer
cuartil, mediana, media, tercer cuartil y valor máximo). Para la columna de caracteres nos
proporciona el número de niveles (categorías diferentes) y el número de veces que aparece
cada nivel.

Ahora, consideraremos la primer columa de la base: weight <- datos$weight. Algunas otras

formas de manipular los datos son las siguientes: mean(weight) calcula la media de la
columna, sd(weight) la desviación estándar e hist(weight) grafica un histograma para
visualizar mejor los datos. En el siguiente módulo veremos a detalle la forma de hacer este
tipo de gráficas.

Por último, podemos ordenar los datos de menor a mayor con la función order. Lo único
que tenemos que especificar es la columna numérica con respecto a la cual va a establecer
el orden, en este caso, weight. Así, escribimos "indice <- order(datos$weight)" y
luego "datos[indice, ]". Si queremos establecer el orden de mayor a menor, la instrucción
cambia a "indice <- order(datos$weight, decreasing = FALSE)" y "datos[indice, ]".

Con esto concluimos el módulo dos de este curso introductorio a R.

Modulo 3: Visualización de datos

Paquete ggplot2

Instalación de ggplot2

Uno de los paquetes más populares para la visualización de datos en R es ggplot2,

cuyas iniciales se refieren a "Gramática de Gráficos."

La particularidad de este paquete es que cada gráfica que construye se conforma de una
serie de capas y cada una de ellas, le aporta un atributo diferente a la misma.

Por ejemplo:

Hay una capa que especifica los datos, otra que determina las variables que van a ocupar
los ejes y una más que determina la forma de la gráfica (líneas, puntos, barras), entre otras.

En este módulo cubriremos a detalle las capas más importantes de cada gráfico, ya que es
importante saber cómo se comportan para tener una mayor libertad al momento de graficar
y así obtener los resultados deseados.

Instalamos ggplot2 escribiendo install.packages("ggplot2") en la terminal de R y cargamos

sus funciones con el comando library(ggplot2). Con esto el paquete está listo para su uso.

Graficas de dispersión

Gramática de gráficos

Cualquier lenguaje tiene reglas gramaticales y lo mismo ocurre con los gráficos en R.
Cada gráfico se compone, principalmente, de tres capas: datos, estética y geometría.
  Los datos se refieren a la base de datos que queremos graficar.

 La estética se refiere a cómo queremos asignar las variables de nuestra base en la

gráfica, por ejemplo, cuál variable estará en el eje x y cuál en el eje y.

 La geometría se refiere a la figura geométrica que queremos utilizar en el gráfico.

Por ejemplo, puntos para una gráfica de dispersión o barras para un histograma.

A este conjunto de capas se le conoce como la gramática de gráficos. Todas son igual de
importantes, si alguna falta no se producirá la gráfica deseada.

Por ejemplo:

Carguemos la base de datos Precios.csv y asignémosla a la variable datos con la

instrucción datos <- read.csv("Precios.csv"). La base contiene información sobre el precio
del barril de petróleo en dólares por litro (Petroleo), la tasa de cambio del dólar en pesos
mexicanos (Dolar), el día (Dia) y el mes (Mes) en donde se registraron esos precios. Los
datos se registraron entre el 18 de febrero y el 31 de marzo, es decir, en un periodo de 103
días. La primer columna (Indice) nos indica a cuál de esos 103 días pertenece cada
observación.

Construyamos un gráfico con esos datos. Veamos, gráficamente, cómo fluctúa el

precio del petróleo conforme transcurren los días.

Agregamos:

 La primera capa (datos): p <- ggplot(datos)

 La segunda capa (estética) a la capa anterior: p <- p + aes(x = Indice, y = Dolar)

 La tercer capa (geometría) a las dos capas anteriores: p <- p + geom_line()

Para que R nos muestre el gráfico agregamos p en una nueva línea y compilamos.
Podemos notar en la gráfica que, conforme avanzan los días, el precio del dolar va
aumentando hasta que, finalmente, decrece de nuevo.

En la gráfica anterior utilizamos líneas. Ahora veamos, con una gráfica de puntos,
cómo se relacionan el precio del dolar y del petróleo.

Agregamos:

 La primera capa (datos): p <- ggplot(datos)

 La segunda capa (estética): p <- p + aes(x = Petroleo, y = Dolar)

 La tercer capa (geometría): p <- p + geom_point()

Agregamos p en una nueva línea y compilamos.

Observamos que el precio del dólar disminuye cuando el precio del petróleo aumenta, es
decir, son inversamente proporcionales.

Existen otras capas que se pueden agregar al gráfico (facetas, estadísticas, coordenadas y
temas) pero no las veremos a detalle en este curso. Nos enfocaremos en entender las tres
capas principales (datos, estética y geometría) que son las bases de cualquier gráfica en R.

Propiedades de la geometría

En esta lección cubriremos los atributos de las funciones geom_line y geom_point que

pueden ser modificados.

Para la función geom_line:

 El tipo de línea se modifica con p <- p + geom_line(linetype = 6). Hay seis valores
posibles para la variable linetype; cada uno produce un estilo de línea diferente.

 El grosor de línea se modifica con p <- p + geom_line(size = 1)

 El color se modifica escribiendo el código del color en la instrcucción p <- p +

geom_line(colour = '#FA8072'). También se puede cambiar escribiendo entre
comillas el nombre del color: p <- p + geom_line(colour = "red").
  La intensidad del color (transparencia) se modifica con p <- p + geom_line(colour =
'#FA8072', alpha = 0.8). Alfa únicamente toma valores entre cero y uno.

Para hacer los cuatro cambios, modificamos los atributos dentro de la misma función: p <-
p + geom_line(linetype = 6, size = 1, colour = '#FA8072', alpha = 0.8), y la gráfica queda
como sigue:

Para la función geom_point:

La forma de los puntos se modifica con p <- p + geom_point(shape = 15). Hay 22

valores posibles para la variable shape; cada uno produce una figura diferente.

Se pueden modificar también los atributos size, colour y alpha de la misma forma que
en geom_line.

Por ejemplo: p <- p + geom_point(shape = 15, size = 1.8, colour = '#CD5C5C', alpha = 0.9)

Los tipos de líneas (linestyle) que existen son:

Los tipos de figuras (shape) que existen son:

Por último:

Podemos agregar etiquetas a nuestro gráfico.

Utilizamos:

 p <- p + xlab("Días transcurridos") para renombrar el eje x.

 p <- p + ylab("Tasa de cambio del dólar") para renombrar el eje y.

 p <- p + ggtitle("Fluctuación del dólar", subtitle = "18/feb - 31/may") para agregar

el título y subtítulo.

Finalmente, desplegamos p para ver el resultado. Así, nuestro gráfico está completo.

Propiedades de la estética
Hemos visto que el atributo shape permite cambiar la forma de la figura en la
función geom_point y el atributo colour cambia su color.

Ambos de esos atributos también pueden modificarse en la función de estética (aes) pero

producen resultados diferentes.

Si la segunda capa del gráfico la sustituimos por:

 p + aes(x = Petroleo, y = Dolar, colour = Mes), R le asignará un color diferente a

cada punto dependiendo del mes al que corresponda.

 p + aes(x = Petroleo, y = Dolar, shape = Mes), R le asignará una figura diferente a

cada punto dependiendo del mes al que corresponda.

 p + aes(x = Petroleo, y = Dolar, colour = Mes, shape = Mes), R le asignará un color

y una figura diferente a cada punto dependiendo del mes al que corresponda.

Con este ejemplo podemos entender la importancia de la gramática de los datos.

Si cambiamos colour y shape dentro de geom_point, R hará los ajustes generales y todos

los puntos tendrán el mismo color y la misma forma. Por el contrario, si
cambiamos colour y shape dentro de la estética aes, el ajuste de color y de forma se hará
con respecto a la variable que seleccionemos. En conclusión, gramáticas distintas producen
resultados distintos.

Podemos modificar manualmente las figuras que queremos que aparezcan en el gráfico con
la instrucción p <- p + scale_shape_manual(values=c(16, 17, 15, 18)). Para modificar
manualmente los colores se utiliza p <- p + scale_color_manual(values =
c("purple","brown", "orange", "gray48")). Además de la segmentación por color y forma,
se puede dividir la gráfica por tamaño. Esto no es tan común como los primeros dos pero es
posible. Para ello se escribe p + aes(x = Petroleo, y = Dolar, size = Mes) en la segunda capa
y scale_size_manual(values = c( 2, 1.5, 1.8, 1)) para modificarlos manualmente.

Finalmente:

Agregamos nombres personalizados a los ejes con las instrucciones: p <- p + xlab("Precio
del petróleo") y p <- p + ylab("Tasa de cambio \n del dólar"), y título y subtítulo con p <- p
+ ggtitle("Petróleo vs Dólar", subtitle = "18/feb - 31/may") para completar el gráfico.

Gráficas de barra y pastel

Gráficos de barras

Una vez estudiada la estética de los gráficos, es momento de profundizar en su

geometría.

En esta lección aprenderemos a hacer gráficos de barras. Utilizaremos la base de

datos COVID19MX.csv que contiene información sobre personas contagiadas con
coronavirus en dos entidades de la República Mexicana. Los datos que incluye son el sexo
del paciente, la entidad a la que pertenece, si fue hospitalizado o no, su edad, las
enfermedades que padece (obesidad, diabetes e hipertensión) y si falleció por la
enfermedad.

Construiremos ahora un gráfico que nos muestre el número que personas contagiadas
que hay en cada entidad.

Es importante recalcar que, en los gráficos de barras, la variable que se asigna al eje x (en
este caso, entidad) debe de ser categórica. Primero, asignamos la base de datos a la variable
datos con la instrucción datos <- read.csv("COVID19MX.csv") y cargamos la librería de
ggplo2 con library(ggplot2). Nuevamente, nuestro código tendrá tres capas: datos, estética
y geometría.

La primer capa se mantiene igual a los gráficos de dispersión, especificando la base de

datos que vamos a considerar: p <- ggplot(datos)

En la segunda capa, a diferencia de los gráficos de dispersión, sólo se especifica la variable

que está en el eje x. El eje y, será siempre un conteo de las veces que aparece la variable
que escribimos en x. Como queremos graficar el número de contagios por entidad,
escribimos p <- p + aes(x = ENTIDAD)

Para utilizar la geometría de barras en la última capa escribimos: p <- p + geom_bar()

Agregamos una p al final del código para desplegar el resultado y corremos los comandos
para obtener la gráfica.

Al igual que en las gráficas de dispersión, podemos cambiar el color de nuestra gráfica. El
atributo que cambia el color de las barras es fill. Recuerda que la gramática es importante al
momento de hacer estos cambios y produce resultados diferentes:

Si cambiamos el atributo fill desde la geometría, escribimos fill = "darkgreen" y se aplicará

un cambio de color general a nuestra gráfica, en este caso, verde oscuro.
Si cambiamos el atributo fill desde la estética, escribimos fill = ENTIDAD y el cambio se
hará con respecto a la variable que elijamos

Similarmente:

A la lección pasada, podemos cambiar manualmente el color de cada barra con la

instrucción p <- p + scale_fill_manual(values = c("#00BFC4", "#F8766D")), especificando
el nombre o código de los colores que deseamos. También, el ancho de cada barra puede
ser modificado con el atributo width en geom_bar(width = 0.5).

Dentro del número de infectados de nuestro gráfico podemos especificar, visualmente,

cuántos de ellos de ellos fallecieron.
Esto se logra cambiando a fill = DEFUNCION dentro de la capa de estética. Vemos que la
gráfica subdivide las barras que construimos previamente en secciones que marcan la
proporción de personas fallecidas y no fallecidas del total, teniendo así más información
que en nuestra primer gráfica. Es posible hacer algo similar con otras variables como sexo,
diabetes, obesidad, hipertensión, tipo (si fue hospitalizado o no), especificando la columna
deseada en el atributo fill. Por ejemplo, si queremos ver la proporción de diabéticos que hay
dentro de los infectados, escribimos fill = DIABETES.

Finalmente:

Agregamos las etiquetas de nuestra gráfica con p <- p + xlab("Entidad Federativa"), p <- p
+ ylab("Número de infectados") y p <- p + ggtitle("Datos COVID-19", subtitle = "Feb - Jun
2020") para completarlo.

Gráficos de pastel

Otro tipo de gráficas comunes en estadística son las de pastel. Estas consisten de un
círculo dividido en partes y que, generalmente, denotan un porcentaje.
La librería ggplot2 no tiene ninguna geometría específica para construir estos gráficos sin
embargo, es posible hacerlos a partir de un gráfico de barras.

Para ejemplificar esto, construyamos un gráfico de pastel con la gráfica de barras de

la lección pasada. Utilizaremos el mismo código pero le haremos unas modificaciones.

Primero, filtramos los datos cargando la librería dplyr con library(dplyr) y

escribiendo datos <- filter(datos, ENTIDAD == "CIUDAD DE MEXICO"). Con ello
estamos tomando únicamente una de las dos barras que aparecen en la gráfica, en este caso,
la correspondiente a la Ciudad de México. Para convertir esta barra en un gráfico de pastel,
añadimos al final del códgio la instrucción p <- p + coord_polar("y"). Al sólo tener una
entidad, no es necesario especificar la etiqueta del eje x, por lo tanto, la eliminamos con p
<- p + xlab("") para tener un gráfico más limpio.

Finalmente, corremos el código y desplegamos el resultado.

Otra forma de construir este tipo de gráficos es con la función pie. Al ser una función
que no pertenece a ggplot2, no es necesario especificar las tres capas que utilizamos
regularmente.
No obstante, su uso es menos automatizado. Como ejemplo de este caso, hagamos ahora
una gráfica de pastel con los porcentajes de las personas con coronavirus que padecen
diabetes. Utilizando los datos que filtramos en el ejemplo anterior,
escribimos summary(datos). La función nos indica en la columna de "DIABETES" que,
del total de personas infectadas, hay 10,161 que padecen diabetes y 76,619 que no.
Haciendo los cálculos manualmente, tenemos que los porcentajes son 15% y 85%,
respectivamente.

Con ellos construimos el gráfico como sigue:

Creamos los vectores Porcentajes <- c(15, 85) (numérico), Etiquetas <- c("15", "85%")
(categórico) y Colores <- c("#F8766D", "#00BFC4") con los colores que queremos que
tenga nuestra gráfica.

Combinamos estos vectores en la función:

pie(x = Porcentajes, labels = Etiquetas, col = Colores, main = "Casos de diabetes/COVID-

19 en la Ciudad de México"))

Por último, especificamos a qué categoría pertenece cada color con el vector Categorias <-
c("SI", "NO") y la instrucción legend("topright", legend = Categorias, fill = Colores)

Así, obtenemos la siguiente gráfica:

Como pudimos notar en estos dos ejemplos, hay pocos recursos básicos en R que nos
permitan hacer gráficos de pastel.

No obstante, no es algo que nos deba preocupar ya que, estadísticamente hablando, es más
útil representar un conjunto de datos utilzando gráficas de barras; esto se debe a que, al
manejar porcentajes, perdemos información sobre la cantidad total de datos con la que
estamos trabajando.

Histogramas

Histogramas de frecuencia

El último ejemplo de geometría que cubriremos en el curso son los histogramas de

frecuencia. Estos son similares a los gráficos de barras con la diferencia de que la
variable que se asigna al eje x debe de ser numérica.

Para ejemplificar esta gráfica haremos un histograma que nos de información de cómo
están distribuidas las edades de las personas infectadas. Dado que la edad es la única
variable numérica de nuestra base de datos, este es el único histograma que podremos
construir. Para este ejemplo necesitamos los datos completos (sin filtrar), entonces, los
cargamos de nuevo con datos <- read.csv("COVID19MX.csv").
El histograma se construye como sigue:

Empezamos la primer capa especificando los datos que vamos a utilizar: p <- ggplot(datos).
Al igual que los gráficos de barras, basta con especificar la variable que se asigna al eje x,
ya que el eje y será un conteo de los datos que caen en cada clase. Así, en la segunda capa
escribimos: p <- p + aes(x = EDAD).

Finalmente:

En la capa de la geometría especificamos que queremos hacer un histograma de frecuencias

con p <- p + geom_histogram().

Un atributo extra que tienen las gráficas compuestas por barras es que podemos
cambiar el color del contorno de las mismas.

Esto se hace con el atributo colour (mismo que utilizamos para cambiar el color de las
líneas). Dividimos nuestro histograma por color según el sexo de cada persona
escribiendo colour = SEXO dentro de la estética y cambiamos manualmente los colores
con p <- p + scale_color_manual(values = c('#00BFC4','#F8766D')).
Al igual que en el gráfico de barras, el color dentro de las mismas se modifica con el
atributo fill. Lo cambiamos a un gris más claro escribiendo fill = "gray40" dentro de la
geometría.

Al igual que en las gráficas de barras, podemos modificar el ancho de las mismas pero en
vez de la variable width utilizamos binwidth dentro de la geometría. Así, la
instrucción geom_histogram(fill = "gray40", binwidth = 2) reduce el ancho de las barras.

Finalmente:

Agregamos etiquetas personalizadas a los ejes con p <- p + xlab("Edad") y p <- p +

ylab("Número de infectados"), y un título con p <- p + ggtitle("Datos COVID-19", subtitle
= "Feb - Jun 2020"), para mejorar la presentación de nuestro gráfico.

Con esto concluimos el módulo de visualización de datos en R.

Módulo 4: Programación en R
Condicionales

Comandos if y else

A lo largo del curso hemos utilizado funciones programadas previamente en R pero

cabe la posibilidad de que necesitemos una función que haga una tarea tan particular
que no se encuentre disponible en ningún paquete existente.

Es por eso que en este módulo daremos las bases para poder crear funciones sencillas en R
y cómo utilizarlas para resolver problemas. Primero, cubriremos los
condicionales if y else que, como el nombre nos indica, nos permiten comparar dos o más
condiciones y actuar dependiendo del resultado de la comparación. Por ejemplo, cuando
estamos frente a un semáforo evaluamos una de dos condiciones: si el semáforo está en
verde seguimos nuestro camino y, en caso contrario (si está en amarillo o rojo), reducimos
nuestra velocidad hasta detenernos.

En esta lección programaremos un condicional que nos despliegue si un alumno aprobó o

reprobó el curso según su calificación final. Primero, comenzamos creando la
variable calificacion <- 89 que va a ser el valor que vamos a comparar en nuestras
condiciones.

Tomando en cuenta que la calificación aprobatoria es 70, tenemos las siguientes

condiciones:

 Si la calificación del alumno es mayor o igual a 70 está aprobado: if (calificacion >=

70) {print("aprobado")}

 En caso contrario, el alumno está reprobado: else {print ("reprobado")}

Al correr el código el resultado que nos despliega es aprobado. Si cambiamos calificacion

<- 55 el resultado es reprobado.

Más aún, podemos comparar más de dos condiciones agregando la instrucción else if.

Supongamos que dentro de las personas reprobadas queremos identificar a los estudiantes
que tienen calificaciones menores a 50 para darles asesorías personalizadas el siguente
semestre.

En este caso tenemos tres escenarios:

 Si la calificación es mayor o igual a 70 está aprobado: if (calificacion >= 70)

{print("aprobado")}

 Si la calificación está entre 50 y 70 está reprobado: else if (calificacion < 70 &&

calificacion > 50){print ("reprobado")}

 En caso de que no se cumplan las primeras dos condiciones, el alumno requiere

asesoría personalizada: else {print ("asesoría personalizada")}

Corroboramos nuestro código corriendo las calificaciones anteriores con: calificacion <-

89 obtenemos aprobado, con calificacion <- 55 obtenemos reprobado y con calificacion <-
40 obtenemos asesoría personalizada. Cabe mencionar que para la condición inicial siempre
se escribirá if, para las condiciones de en medio else if y para la final else.
 Ciclos

Comandos for y while

En esta lección aprenderemos el concepto de ciclos que, al igual que los condicionales,
nos servirán como herramienta para programar.

Los ciclos son conjuntos de instrucciones que se repiten cierto número de veces y son
utilizados para automatizar secciones de código.

Existen dos tipos: for y while.

Supongamos que tenemos una empresa que vende camisas a $120 cada una y nos llegan
cinco pedidos con el número de camisas que se requiere en cada uno: pedidos <- c(5, 3, 7,
2, 8). Haremos un programa que nos calcule el monto que debe de pagar cada cliente por su
pedido. Esto se hace multiplicando el número de camisas de cada pedido por el precio. Para
ello utilizaremos el ciclo for. Primero, determinamos el número de veces que repetiremos la
operación. Al ser cinco pedidos, escribirmos la instrucción for (k in 1:5). Con esto le
pedimos a R que nuestra variable k tome los valores de 1, 2, 3, 4 y 5; uno por cada pedido.
Después, dentro de llaves escribimos las instrucciones que se van a repetir por iteración:

 Tomar el número de camisas que corresponde al pedido: camisas <- pedidos[k]

 Calcular el costo de cada pedido: costo <- camisas*120

 Imprimir en la pantalla el costo calculado: print(costo)

Corriendo el código obtenemos que el costo de cada pedido es $600, $360, $840, $240 y
$960, respectivamente.

Ahora, supongamos que la empresa tiene solamente 15 camisas disponibles para vender; no
hay suficientes para abastecer los cinco pedidos, así que únicamente debemos de calcular
los costos de los pedidos que puedan cubrirse con esas camisas. En el ejemplo anterior era
necesario pasar por cada elemento del vector para calcular el costo pero ahora necesitamos
un ciclo que pare automaticamente cuando se acaben las camisas disponibles. Para ello,
utilizamos el ciclo while. Primero, especificamos nuestro número de camisas disponibles
con disponibles <- 15 y nuestro contador k <- 1 que va a ir aumentando por cada pedido
cubierto. Luego, escribimos while(disponibles != 0) lo cual le dice a R que repita este ciclo
hasta que el número de camisas disponibles sea cero; una vez que se acaben las camisas, el
ciclo automáticamente deja de repetirse. A continuación, escribimos dentro de llaves las
instrucciones que queremos que se lleven a cabo:

 Tomar el número de camisas que corresponde al pedido: camisas <- pedidos[k]

 Calcular el costo de cada pedido: costo <- camisas*120

 Imprimir en la pantalla el costo calculado: print(costo)

 Aumentar el contador para que cuando el programa ejecute nuevamente al ciclo

considere un pedido diferente: k <- k + 1

 Disminuir el número de camisas disponibles una vez que se cubra un

pedido: disponibles <- disponibles - camisas

Corriendo el código vemos que el programa nos imprime solamente los costos de los
primeros tres pedidos: $600, $360 y $840, que son los únicos que podemos cubrir con las
15 camisas disponibles. Podemos inclusive imprimir el número de camisas disponibles
escribiendo disponibles en la terminal, para verificar que, efectivamente, este número es
ahora cero.

En resumen, ambos ciclos hacen lo mismo:

Repiten automaticamente un fragmento de código determinado. La diferencia recae en que

el ciclo for repite el código un número de veces fijo, y el ciclo while lo repite hasta que se
cumpla el criterio de paro, una vez cumplido este criterio, el ciclo deja de ejecutarse.

Comandos next y break

Un par de comandos que nos ayudan a tener más control sobre los ciclos
son next y break.

Ambos nos permiten interrumpir parcial o totalmente un ciclo cuando no es necesario que
se ejecute completo.

Como ejemplo, construyamos un pequeño inventario de nuestra empresa.

Consideremos:

Cuatro tipos de prendas: Prenda <- c("Camisa", "Pantalon", "Saco", "Corbata") La cantidad

que se encuentra disponible de cada una de ellas: Cantidad <- c(15, 21, 9, 11) El marco de
datos: Inventario <- data.frame(Prenda, Cantidad)

Nuestro objetivo será consultar automáticamente el inventario para saber cuántos sacos
tenemos disponibles. Dado que necesitamos acceder uno de los cuatro elementos del vector
utilizaremos el ciclo for. Así, inicializamos el ciclo con for (k in 1:4). Después, debemos
verificar que la prenda a la que se está accediendo sea el saco; para ello utilizamos el
condicional if:

1. Si la prenda correspondiente no es el saco, le decimos al programa que no es

necesario que siga ejecutando esa iteración del ciclo ya que no es la prenda que
estamos buscando; para ello se utiliza el comando next: if (Prenda[k] != "Saco")
{next}

2. De lo contrario, le pedimos a R que nos imprima el inventario correspondiente a esa

línea: else {print(Inventario[k,])}

3. Ya que nuestra búsqueda está completa, no es necesario que el ciclo for siga activo,

por lo que agregamos la instrucción break dentro del else anterior para que finalice
el programa y no realice operaciones inecesarias.

Al ejecutar el código, obtenemos que la cantidad de sacos disponibles es nueve.

Así, vemos que todas las herramientas que hemos aprendido en este módulo no son
independientes sino que pueden combinarse entre sí. Podemos mezclar condicionales con
ciclos, los cuales, a su vez, podemos interrumpir según nuestra conveniencia. Con todas
estas herramientas ya estamos listos para construir nuestras propias funciones en R.

Funciones

Desarrollo y aplicación de funciones

Concluiremos el curso aprendiendo a crear funciones en R y como aplicarlas.

Es común que requiramos un programa que haga una tarea tan específica que no exista una
función previamente creada que la resuelva, por lo es importante saber crear este tipo de
funciones. Recordemos que una función es una regla de asigación que evalúa un grupo de
variables dependientes y nos arroja un resultado.

Ejemplo:

Haremos una función sencilla que determine si un número es primo o no, para números
mayores a dos. Primeramente, necesitamos especificar dos cosas: el nombre de la función y
las variables que requiere. La función se llamará "primos" y su única variable dependiente
será el número a evaluar. Así, escribimos primos <- function(numero) y abrimos llaves;
todo lo que se encuentre dentro de ellas será lo que realice nuestra función. Para saber si un
número es primo el programa debe de hacer lo siguiente:

1. Evaluar todos los números anteriores a él, empezando por dos, para saber si alguno
de ellos lo divide. Así, inicializamos el ciclo: for (k in 2:(numero-1))

2. Aplicar un condicional: si el valor k divide al número, concluimos que no es

primo: if (numero %% k == 0) {return("No es primo")}. Con el comando return le
pedimos a R que imprima lo que se encuentra dentro del paréntesis y que de por
terminada la función

3. De lo contrario, si k no divide al número, pasamos al siguiente valor para continuar

con la búsqueda de divisores: else {next}

4. Finalmente, si el ciclo termina y ningún valor de k dividió al número, concluimos

que es primo: return("Sí es primo")

Una vez corrido el código, aplicar la función es muy sencillo: debemos escribir en la
terminal el nombre seguido del número que queremos evaluar.

Ejemplo:

Si escribimos primos(121) obtenemos "No es primo" y con primos(727) obtenemos "Sí es

primo". Cuando la función tenga más de una variable dependiente, se tiene que especificar
los valores de cada una de ellas. Cabe recalcar que esta forma de hallar primos no es la
óptima y puede ser mejorada.
Con esto damos por terminado nuestro curso introductorio a R. Hemos logrado obtener
bases sólidas que nos servirán para futuros cursos de ciencia de datos. Este fue solo el
inicio, aún queda mucho por aprender en el campo de la estadística aplicada pero, las
herramientas con las que ya contamos, serán de gran ayuda para entender mejor las
referencias que nos vengan en un futuro.