Pregunta

¿Cuál es el error en la enunciado ?

if(a=3){ print("Hola")}
?

Hola está mal escrito

a = 3

no es una condición, es una asignación

if debe llevar corchetes

Información General del Curso
Descripción del curso

Este curso te proporcionará las bases del lenguaje de programación estadística R, la

lengua franca de la estadística, el cual te permitirá escribir programas que lean,
manipulen y analicen datos cuantitativos. Te explicaremos la instalación del lenguaje;
también verás una introducción a los sistemas base de gráficos y al paquete para
graficar ggplot2, para visualizar estos datos. Además también abordarás la utilización de
uno de los IDEs más populares entre la comunidad de usuarios de R, llamado RStudio.

Objetivo

Al término del curso:

Utilizarás el lenguaje de programación R con el fin de manipular datos, generar análisis

estadísticos y representación gráfica, a través del procesamiento de datos cuantitativos.

Estructura temática

Módulo 1. Instalación de herramientas

Módulo 2. Introducción al lenguaje: objetos, clases, tipos de datos, importación y

exportación de datos

Módulo 3. Utilización del lenguaje: estructuras de control, funciones, reglas de alcance y

operaciones vectorizadas

Módulo 4. Acercamiento al sistema de gráficos de R

Módulo 5. Expresiones regulares, graficación con ggplot2 y simulación

Forma de trabajo

Este curso busca introducirte en el lenguaje de programación estadística R, un lenguaje

computacional diseñado para el análisis estadístico de datos. Este curso está dirigido a
estudiantes y profesionales que tienen interés en poder utilizar esta herramienta, para
leer, manipular, analizar y graficar datos.

Utilizarás un IDE (Ambiente de Desarrollo Integrado) muy popular para trabajar con el
lenguaje R, llamado RStudio, que se ha vuelto el IDE de facto para programar en R.

En cada módulo encontrarás videos que te guiarán en la instalación de las herramientas

a utilizar, así como explicaciones de las operaciones básicas y los elementos específicos
que ofrecen un manejo más profundo del lenguaje. También hallarás algunas
referencias bibliográficas para ahondar en el tema que sea de tu interés.

Para complementar las lecciones, realizarás prácticas con el lenguaje, las cuales
tendrán valor para la evaluación.

Criterios de aprobación

100 % prácticas

Estas prácticas conforman la parte interactiva de las lecciones. Son tareas de

programación que realizarás con el paquete Swirl.

Fuentes de información

Adler, J. (2012). R in a Nutshell (2.a ed.). EE. UU.: O'Reilly.

Chang, W. (2013). R Graphics Cookbook. EE. UU.: O'Reilly Media.

Dalgaard, P. (2008). Introductory Statistics with R (Statistics and Computing) (2.a ed.). EE.
UU.: Springer.

Matloff, N. (2011). The Art of R Programming: A Tour of Statistical Software Design (2.a
ed.). EE. UU.: No Starch Press.

Teetor, P. (2011). R Cookbook. EE. UU.: O'Reilly Media.

Historia e Introducción a R
[MUSIC]
Reproduce el video desde ::14 y sigue la transcripción0:14
La primera pregunta que se nos puede venir a la cabeza es, ¿qué es R? 
R en pocas palabras no es más que un dialecto del lenguaje S. 
S fue un lenguaje que fue desarrollado por John Chambers 
en los laboratorios Bell durante los 70s. 
Este fue pensado como un ambiente para el análisis 
estadístico dentro de la compañía. 
Es decir, que inicialmente se implementó como una serie de bibliotecas de Fortran. 
Un lenguaje muy utilizado durante los 70s. 
Y además las primeras versiones del lenguaje 
no contenían funciones para análisis estadístico. 
El sistema fue re escrito en los 80s en el lenguaje de programación C. 
Esto con el objetivo de que fuera portable. 
Y es entonces que también en estos años Chambers y Hastie documentan en el famoso 
libro, Statistical Models in S, la funcionalidad, 
del lenguaje para el análisis estadístico. 
Porque you estaba tomando completa forma. 
En los años 90s sale la versión 4, 
que es más o menos la versión que nosotros conocemos hoy en día. 
Y además aparece el libro Programming with Data de John Chambers. 
Y en este se detallan las minucias del lenguaje. 
Básicamente S fue pensado como un ambiente interactivo. 
Que no necesariamente se puede ver en un principio 
como un lenguaje de programación. 
Pero a medida que el usuario va utilizando más y más 
las particularidades del ambiente. 
Acá va utilizando prácticas de programación. 
El lenguaje S entonces you proveía un acceso relativamente simple a una gran 
variedad de técnicas estadísticas. 
Además, que para los usuarios avanzados, les permitía escribir 
funciones por medio de un lenguaje de programación you bien definido. 
Con el que podían añadir nuevas técnicas por medio de la definición de estas. 
[SOUND] Como podemos ver, 
el desarrollo de S y S-PLUS fue generado en este ambiente comercial. 
Quizá, motivados por esta razón, en 1991, 
Ross Ihaka y Robert Gentleman deciden implementar 
su propia versión de S, ellos la bautizaron como R. 
Tan bien lograron hacer esto que para 1993 ponen R al público general. 
Esto tuvo tanto éxito, que para 1995 liberaron el código bajo una licencia GNU. 
La liberación del lenguaje tuvo tanta popularidad, que para 1996, 
se formaron por primera vez las listas de correo 
o de distribución de información llamadas R-help y R-devel. 
En estas se discutían temas relacionados con ayuda hacia el lenguaje. 
Y por el otro lado, el desarrollo del propio lenguaje. 
En 1997, se funda el R Core Group, 
que es un grupo especializado de programadores. 
Que llevan el desarrollo del lenguaje a través de los años.
Reproduce el video desde :3:23 y sigue la transcripción3:23
Tan bien ha ido el lenguaje que para el año 2000, 
por primera vez se libera la versión 1.0 de este. 
Para este año la explosión del lenguaje you fue muy grande. 
Y es entonces que por primera vez aparece en el New York Times en el año 2006 
un artículo hablando de cómo los 
analistas de datos están cautivados por el poder de este lenguaje.
Reproduce el video desde :3:51 y sigue la transcripción3:51
Ahora estamos en el año 2015, y por fin tenemos una versión 
3.2.2, que es la que utilizaremos en este curso. 
Las características del lenguaje R son muchísimas, 
y la mayoría de estas son tomadas como ventajas del mismo lenguaje.
Reproduce el video desde :4:10 y sigue la transcripción4:10
La principal y que es la razón por la cual fue adoptada ampliamente, 
es que su sintaxis es muy similar al lenguaje S.
Reproduce el video desde :4:20 y sigue la transcripción4:20
La semántica también es muy parecida al lenguaje S. 
Corre prácticamente en cualquier plataforma, Windows, Mac, 
Linux y prácticamente cualquier Unix y tiene un cambio de versiones muy rápido. 
El lenguaje R en realidad es muy pequeño 
y todas las funcionalidades de él se van agregando con paquetes. 
La capacidad de graficación además es muy madura y está 
considerado uno de los mejores sistemas para graficar.
Reproduce el video desde :4:48 y sigue la transcripción4:48
Además recordemos que tenemos un modo interactivo que 
sirve más que nada para probar ideas. 
Pero una vez que hemos probado estas se pueden implementar en scripts 
o programas mucho más grandes para hacer nuevas herramientas. 
Otra de las grandes ventajas es que tenemos una comunidad 
muy grande y estimulante y muy activa. 
Esto en las listas R-help y R-devel y en el sitio web Stack Overflow. 
Además es gratis. 
Y es software libre. 
Es entonces que ahora quisiera hablarles qué significa 
que tenga las cuatro libertades básicas del software libre. 
Estas son, la libertad para ejecutar el programa, 
que eso prácticamente cualquier software nos lo da.
Reproduce el video desde :5:34 y sigue la transcripción5:34
Luego viene una de las más importantes que es la libertad de acceder al 
código fuente. 
¿Esto por qué es importante? 
Porque podemos obtener conocimiento de ese código. 
Finalmente, tenemos las dos últimas libertades que son las que hacen 
fuerte a la licencia GNU. 
Y esta es que podemos redistribuir nuestros cambios 
o el mismo software que obtenemos. 
Y finalmente los cambios que nosotros hacemos
Reproduce el video desde :6:4 y sigue la transcripción6:04
o mejoras pueden también ser distribuidas a la comunidad entera. 
Por supuesto R no es perfecto y podemos listar algunas de sus desventajas. 
Que es una tecnología relativamente vieja, tiene 40 años de edad.
Reproduce el video desde :6:19 y sigue la transcripción6:19
Y esto mismo se refleja en el sistema de gráficos en 3D, 
el cual no está completamente integrado en el sistema. 
La funcionalidad además, está basada en sus usuarios, ¿esto qué significa? 
Significa que si tú quieres un nuevo análisis, 
un nuevo modelo o algún tipo de tecnología nueva que quisieras probar. 
Dependes, you sea de la comunidad de usuarios para que se genere o 
tendrías que escribirlo tú mismo.
Reproduce el video desde :6:49 y sigue la transcripción6:49
Otro de los grandes problemas es que la mayoría de los objetos, 
o las variables que estamos usando en el sistema. 
Tienen que estar cargadas completamente en la memoria RAM. 
Por lo que las computadoras que tienen poca memoria 
pueden llegar a tener problemas.
Reproduce el video desde :7:6 y sigue la transcripción7:06
Además de que no es un sistema que es ideal para todo. 
No hay bala de plata tanto en los análisis
Reproduce el video desde :7:14 y sigue la transcripción7:14
estadísticos como en la programación en sí. 
Por lo cual R probablemente pertenece a un nicho muy pequeño todavía. 
Es también importante que hablemos del diseño del lenguaje. 
En principio hay un sistema base que contiene toda la funcionalidad 
del lenguaje y además ciertos paquetes. 
Que nos permiten poder manipular algunos datos 
y algunos métodos que nos van a servir. 
Encima de este sistema base tenemos paquetes que son recomendados. 
Generalmente son funciones que son muy utilizadas en 
general para casi cualquier tipo de de análisis estadístico.
Reproduce el video desde :7:58 y sigue la transcripción7:58
Y además, fuera de estos paquetes recomendados, existen más 
de 7000 paquetes que están contribuidos por la comunidad de usuarios de R. 
Y que suben todos los días algún paquete nuevo o mantienen estos en el sitio CRAN. 
Si quisiéramos convencer a alguien de por qué usarlo. 
Le podríamos decir que tiene muchas funciones estadísticas. 
Además de que podemos implementar de manera rápida procedimientos estadísticos 
y gráficos. 
Estos gráficos son muy buenos y están basados en el sistema base del lenguaje. 
Y los gráficos avanzados se pueden conseguir utilizando 
paquetes como ggplot2. 
Finalmente una cosa que a mí me parece maravillosa 
es que los autores de los paquetes pueden ser contactados directamente. 
Generalmente son personas que están dispuestas a ayudarte. 
Ustedes se preguntarán, ¿quién está detrás de R? 
Hay un grupo desde 1997, como you vimos en la historia, 
que mantiene el core del lenguaje que es conocido como el R Development Core Team. 
Este es financiado por la R Foundation que es una organización basada en Viena, 
sin fines de lucro. 
Podemos encontrar más información en el sitio de R que es www.r-project.org. 
Podemos ver en pantalla la interfaz básica de R y como you les conté, es muy simple. 
Las características de esta interfaz gráfica que es la oficial. 
Es que se tiene muy mala interacción. 
Te puedes olvidar muy fácilmente de qué variables y objetos están presentes en el 
sistema en un momento dado. 
Y las gráficas siempre aparecen en una ventana aparte. 
Es por eso que se creó el IDE o Integrated Development Environment, 
conocido como R Studio y es el que usaremos a lo largo del curso. 
Para los que están impacientes por comenzar. 
Pueden buscar algunos recursos de documentación en la página que you hemos 
nombrado antes www.r-project.org. 
Y estos son los cinco documentos básicos para poder tener, 
toda la documentación de R a la mano. 
Este es la introducción a R. 
Cómo escribir extensiones en R. 
Cómo importar y exportar datos en R. 
Cómo instalar y administrar un sistema donde más usuarios van a utilizar R. 
Y finalmente toda la implementación de los internos del lenguaje. 
[MUSIC]

Obteniendo Ayuda
[MUSIC]
Reproduce el video desde ::14 y sigue la transcripción0:14
En esta lección vamos a aprender a utilizar el sistema de ayuda de R, 
y también a aprender cómo podemos obtener ayuda. 
En R es muy fácil obtener ayuda, el lenguaje y la línea de comandos, 
viene con un sistema integrado de ayuda. 
Y podemos obtener ayuda en el sistema. 
En caso de que no podamos entender qué es lo que nos está explicando el sistema 
de ayuda. 
Podemos entonces generalmente preguntar con alguien que you sepa. 
O ir a las listas de distribución de correo donde podemos hacer 
nuestra pregunta y obtener alguna respuesta por ahí. 
Otra gran ayuda que podemos tener en el web es utilizando el sitio Stackoverflow. 
Donde podemos encontrar una gran cantidad de preguntas you hechas y respondidas. 
Incluso están rankeadas por
Reproduce el video desde :1:11 y sigue la transcripción1:11
la calidad de las preguntas y la calidad de las respuestas. 
El sistema de ayuda de R, como you observamos en la lección 
preliminar, está integrado al sistema. 
Hay cinco funciones que son muy útiles para obtener ayuda. 
Una de ellas es help() y su equivalente que es el signo de interrogación. 
La otra es example(). 
La siguiente es help.search(). 
Otra más es library con la opción help como parámetro. 
Y vignette(), 
que es un documento que se genera y puedes obtener ayuda por medio de un PDF.
Reproduce el video desde :1:55 y sigue la transcripción1:55
>> Aquí está la parte de RStudio, donde se ve la salida de read.table. 
La primera función que vamos a utilizar es help(). 
Help() recibe como parámetros 
entre comillas el nombre de la función a la cual queremos obtener ayuda. 
En este caso no observamos cual es toda la salida de help(). 
Porque cuando nosotros tecleamos en la consola hep( "read.table"). 
Esto lo que va a hacer es que la ayuda se despliegue en la 
ventana de ayuda de RStudio. 
Una vez que suceda eso, podemos entonces ver que la página 
del manual o de la ayuda de read.table al final siempre tiene ejemplos.
Reproduce el video desde :2:44 y sigue la transcripción2:44
Estos ejemplos, en caso de que tengamos una duda para poder resolver rápidamente. 
Podemos utilizar entonces solamente la función example, 
ponemos también el nombre de la función. 
Entonces en este caso haríamos example("read.table"). 
Y entonces esto lo que hace es que nos despliega todos los ejemplos que hay 
disponibles para la función "read.table". 
En esta otra captura de pantalla, lo que estamos viendo es la función library,
Reproduce el video desde :3:14 y sigue la transcripción3:14
poniendo como parámetro help. 
Si nosotros sabemos el tipo de ayuda que estamos buscando, podemos buscar 
esa ayuda directamente desde la biblioteca que estamos utilizando. 
Biblioteca o paquete. 
En este caso grDevices es un paquete del sistema base. 
Y entonces cuando llamamos al library help igual al nombre del paquete grDevices. 
Lo que hace es que nos manda igual esta 
documentación en una página aparte de RStudio. 
En R los desarrolladores de paquetes a veces 
generan un documento en PDF con viñetas. 
La función que utilizamos para obtener ayuda de viñetas es vignette(). 
Cuando ejecutamos vignette(all=TRUE), lo que hacemos es. 
Generamos una lista de todas las viñetas, 
si es que están disponibles, y el nombre de éstas. 
Por ejemplo, en el caso del paquete matrix, 
si buscamos la viñeta "Intro2Matrix", podemos generar el PDF. 
Y se nos desplegará en nuestra pantalla este PDF. 
En las viñetas generalmente es una especie de white paper. 
Que nos presenta toda la información del paquete, 
y también vienen algunos ejemplos. 
>> Si suponemos que no encontraste la respuesta a tu pregunta en 
el manual de R o el sistema de ayuda interna de R. 
Podemos utilizar alguna búsqueda en el Web usando Google. 
O verificar en el sitio donde se encuentran las listas de correos si la 
pregunta ha sido hecha antes, y además si you tuvo respuesta. 
O finalmente puedes leer alguna de las FAQ, 
que son listados de preguntas frecuentes que you se han hecho anteriormente. 
Una opción que tienes conforme vas avanzando en el aprendizaje del sistema y 
te vas volviendo un usuario más experimentado. 
Es, justamente experimentar un poco. 
Las páginas del manual te darán ejemplos. 
Y tú puedes modificar estos ejemplos para ver si
Reproduce el video desde :5:25 y sigue la transcripción5:25
las modificaciones que hacen te dan los resultados deseados. 
Otra opción que tienes es preguntar a alguien con más experiencia. 
O finalmente, cuando seas un usuario muy avanzado, leer el código 
fuente de las funciones y ver si hacen exactamente lo que estás buscando. 
Es importante que hagas una revisión del manual antes de hacer una pregunta.
Reproduce el video desde :5:51 y sigue la transcripción5:51
Porque si no estarás haciendo perder el tiempo a los usuarios que 
resuelven este tipo de problemas. 
Además, debes poner bien en contexto el tipo de pregunta que estás haciendo. 
Puedes incluir al hacer tu pregunta los pasos para resolver el problema. 
Qué salida estás esperando, qué salida está recibiendo, 
las versiones de R que estás usando del sistema operativo. 
O cualquier otra información adicional que pudiera poner en contexto 
a los demás usuarios. 
Por ejemplo, si vas a hacer preguntas en una lista de correo, 
crea un encabezado o subject en el correo que sea preciso. 
Por ejemplo, no hagas algún tipo de encabezado que no tenga mucho sentido. 
Por ejemplo, el primero que tenemos aquí en pantalla: "Auxilio!!!, 
no puedo ajustar un modelo". 
Eso no dice absolutamente nada, 
y cuando esto aparezca en la red y esté indexado, no se entenderá. 
Por ejemplo puedes hacer entonces una 
modificación al encabezado y hacerlo de manera más inteligente. 
En este caso puedes poner "R 3.2.2 función lm() produce un seg 
fault con un data frame muy grande". 
Esto, es mucho más preciso, aunque todavía es un poco ambiguo, 
porque hay otra información que no está presente. 
En este caso puedes ser un poco más inteligente y utilizar el siguiente 
encabezado. 
Que es "R 3.2.2 la función lm() en Mac OS versión 10.10.4, 
genera un seg fault con un data frame muy grande". 
Esto es completamente preciso y hará que incluso, 
cuando alguien tenga la misma duda pueda encontrarla rápidamente la respuesta. 
Cuando busques en las listas de correo, busca el objetivo, no los pasos. 
Porque muchas veces los pasos que pudieras estar haciendo pudieran ser incorrectos. 
Y podrías a veces también tener pasos diferentes para llegar al mismo punto. 
Además, también puedes hacer búsquedas explícitas de la pregunta. 
Ésto te puede ayudar si las personas que han hecho preguntas anteriormente, 
hicieron los encabezados de manera inteligente. 
Acuérdate siempre que, cuando posteés una pregunta, 
proveas un mínimo de información necesaria. 
Finalmente, si encuentras la respuesta, no olvides postearla. 
Para que cuando alguien más tenga una duda exactamente igual a la tuya, 
la pueda encontrar rápidamente. 
Cuando preguntas en una lista, 
no llegues diciendo primero que encontraste un error o un bug. 
Es raro, muy muy raro que en los programadores
Reproduce el video desde :8:33 y sigue la transcripción8:33
entreguen un producto o un paquete con errores. 
Ellos han testeado mucho tiempo sus paquetes tratando de que no 
aparezcan con errores. 
Por lo cual es muy difícil que tú pudieras encontrar uno. 
Otra cosa que es también importante es que. 
Como estas personas están ocupadas haciendo sus trabajos diarios, 
no deberías preguntar para que te resuelvan la tarea. 
No preguntes en las mismas listas al mismo tiempo. 
Porque esto lo que genera es duplicación de la información en el tráfico que se 
está generando en estas listas. 
Y entonces también podría molestar a algunos usuarios. 
Mis últimas recomendaciones para obtener ayuda es que te suscribas 
inmediatamente a la lista de distribución de R en español. 
Que se conoce como [email protected]. 
Una vez que estés subscrito, 
también puedes tener acceso al listado en la página web. 
Que es la que está apareciendo en pantalla. 
Y finalmente, recuerda leer el listado de tips 
sobre cómo hacer preguntas inteligentes. 
[MUSIC]

Operaciones Básicas y Números

[MUSIC]
Reproduce el video desde ::14 y sigue la transcripción0:14
En esta lección aprenderemos los tipos de datos que hay en el lenguaje. 
Además de las operaciones básicas que podemos hacer con estos tipos, 
hay varios tipos de objetos en R. 
Uno de los primeros son los objetos del lenguaje. 
Que estos pueden ser llamadas o funciones, 
expresiones o nombres de variables o de objetos.
Reproduce el video desde ::38 y sigue la transcripción0:38
También están las expresiones, que son un conjunto de expresiones correctas, 
que todavía no han sido evaluadas. 
Y finalmente están las funciones, 
que constan de una lista de argumentos y el código del cuerpo de ellas. 
Y el entorno en el que están siendo ejecutadas. 
R, cuando lo utilizas por primera vez. 
Puede parecer una calculadora común y corriente porque puedes llevar a cabo 
todas las operaciones aritméticas. 
Que puedes hacer con una calculadora, suma, resta, multiplicación, división. 
Y además de esto, 
también puedes hacer operaciones lógicas con los objetos que vas a trabajar. 
Generalmente, estos objetos pueden ser vectores o números. 
Las operaciones lógicas, es importante que sepas, se evalúan de izquierda a derecha. 
Y se llevan a cabo con el primer elemento de cada vector. 
Esto veremos qué siginifca un poquito más adelante. 
Como you te pudiste haber dado cuenta, el vector es el objeto más simple en R. 
Es por eso que las operaciones generalmente 
están basadas en ese objeto mínimo. 
Una de las primeras opciones que puedes querer hacer. 
Operaciones que puedes querer hacer con los elementos de un vector es 
seleccionar uno de esos elementos. 
Además, puedes manipular los valores que no están presentes 
o valores perdidos y podemos ordenar esos vectores.
Reproduce el video desde :2:15 y sigue la transcripción2:15
Para operaciones con conjuntos tenemos también 
operaciones que podemos llevar a cabo. 
También podemos tener operaciones para generar 
secuencias determinísticas o también pueden ser aleatorias. 
Y utilizando cierto número de funciones que tenemos en el lenguaje 
para poder llevar a cabo estas tareas. 
En R casi todo es un objeto, incluyendo las funciones y las estructuras de datos. 
Para ver qué objetos tenemos en un momento determinado, 
lo que podemos usar es la función ls( ). 
Al escribir el nombre de un objeto, 
lo que hace el sistema es regresarnos el contenido de ese objeto.
Reproduce el video desde :2:57 y sigue la transcripción2:57
Muchas veces podríamos tener objetos que you tenemos en la carpeta de trabajo. 
Es entonces que podemos usar la función attach para poder cargar esos objetos de 
nuevo en memoria. 
R tiene cinco tipos de objetos básicos o atómicos aunque en realidad son tres. 
Character, que son las cadenas de caracteres que podríamos 
tener como letras o incluso los propios números.
Reproduce el video desde :3:26 y sigue la transcripción3:26
Numeric, que es cualquier número que pudiera ser de tipo flotante, 
lo que se conoce como flotante en el lenguaje C, por ejemplo. 
Y además tenemos integer y complex, 
que también son numéricos pero son un tipo especial de numéricos. 
Integer ocupa menos locaciones de memoria y complex es una manera de 
representar a los números complejos. 
Y, finalmente, tenemos al tipo lógico, 
que lo que nos da es el valor lógico falso o verdadero. 
El objeto más básico que puede contener alguno de los tipos que 
vimos anteriormente es el vector. 
El vector tiene como limitante que todos los elementos de él 
tienen que ser del mismo tipo o la misma clase. 
La lista se puede ver, contrario al vector, 
como un vector que contiene distintos tipos o elementos en su contenido. 
Se pueden crear objetos de tipo vector con la función vector. 
Los números en R generalmente se tratan como elementos de tipo numérico. 
Si quisiéramos obtener números enteros y representados en el tipo de enteros. 
Entonces tenemos que hacerlo explícitamente 
poniendo una L después del número. 
Es importante conocer dos tipos de números. 
Que aparecen en la aritmética de R, uno es NaN y el otro es Inf. 
NaN significa Not a Number o no un número o que no es un número. 
Este valor aparece generalmente cuando llevamos a cabo alguna 
operación aritmética que es indeterminada como dividir 0 entre 0. 
Inf como pudieran tal vez predecir, significa infinito. 
Y generalmente aparece cuando dividimos un número muy pequeño entre algo que es 
relativamente muy grande, como 0 entre 1. 
[MUSIC]

Atributos, Entrada y Coerción

[MUSIC]
Reproduce el video desde ::14 y sigue la transcripción0:14
Otra característica que pueden tener los objetos en R son los atributos. 
Estos pueden ser de diferentes tipos. 
Pueden ser nombres, dimensiones, clase, el tamaño, 
o incluso algunos atributos definidos por el usuario. 
Estos se pueden acceder, 
o puedes ver qué atributos tiene un objeto utilizando la función attributes(). 
Y poniendo entre paréntesis el nombre del objeto. 
Ahora vamos a hablar un poco de la entrada en R, en la línea de comandos de R. 
En esta podemos escribir expresiones como si fuera una calculadora, 
esto you lo hemos dicho. 
Pero es importante algo nuevo que vamos a ver, es que el 
símbolo <- es un símbolo de asignación. 
Aquí es justo como se pueden generar las variables u objetos 
de los que you hemos hablado. 
la gramática del lenguaje determina si una expresión está completa o no. 
Y solo podemos saber si esta fue correcta una vez que hemos presionado Enter. 
Finalmente, es importante que sepamos que con el 
símbolo de gato podemos hacer comentarios al código que estuviéramos escribiendo. 
you dijimos que cuando escribimos una expresión en la línea de comandos 
y presionamos Enter, esta se evalúa y el resultado no se regresaba. 
En este ejemplo que estamos viendo en pantalla, 
el [1] nos está indicando el tamaño del vector que estamos mandando a llamar. 
Es de tamaño 1, por lo que podemos ver que
Reproduce el video desde :1:49 y sigue la transcripción1:49
el 9 es el primer elemento de ese vector, que es el único que existe en él. 
En este caso por ejemplo, tenemos que x se le fue asignado un valor del 1 al 100. 
O sea, se genera un vector de tamaño 100, 
donde cada uno de ellos van incrementándose de uno en uno. 
El símbolo dos puntos, indica que lo que 
queremos es una secuencia del 1 al 100. 
Utilizamos la función c() para generar vectores. 
Lo que va haciendo c(), es ir concatenando todos los elementos que va 
encontrando dentro de los paréntesis.
Reproduce el video desde :2:34 y sigue la transcripción2:34
También podemos usar la función vector() para crear vectores. 
Esto lo habíamos dicho anteriormente, pero no habíamos visto cómo funciona. 
Podemos ver en la pantalla que podemos crear vectores numéricos, 
lógicos, de caracteres, enteros y complejos. 
En este caso, como podemos darnos cuenta, cada uno de los elementos 
cuando estamos creando estos vectores, son iguales, del mismo tipo. 
Cuando utilizamos la función vector(), tenemos que decir qué tipo de 
vector va a ser, el tipo de dato que va a contener y el tamaño. 
Si no especificamos explícitamente
Reproduce el video desde :3:15 y sigue la transcripción3:15
los elementos, lo que hará es rellenar de ceros ese vector. 
Te preguntarás probablemente qué pasa 
si combinas dos tipos distintos utilizando la función c(). 
Lo que sucede aquí es que no se genera un error, 
sino se lleva a cabo un tipo de operación conocida como coerción. 
En donde se busca un tipo común, 
y los elementos que no son de ese 
tipo son convertidos a él para poder generar un vector. 
Recordemos que el vector tiene elementos todos del mismo tipo. 
Por ejemplo, lo que estamos haciendo es utilizando la función c, 
asignar un par de valores o concatenarlos al vector y. 
El primer elemento que estamos tratando de concatenar es el valor numérico 1.7, 
el segundo es el caracter a. 
Como a en R no puede ser convertido a un valor numérico, entonces el 1.7, 
el valor numérico 1.7, es convertido al caracter 1.7. 
Que no es más que la representación en caracter del valor 1.7. 
La coerción tiene reglas muy particulares. 
Vamos a experimentar un poco en la práctica, para ver cómo son esas reglas. 
Una vez que llevemos a cabo, entendamos más bien esas reglas, 
vamos a ver que estas se hacen de manera explícita. 
Es decir, nosotros no decimos qué tipo estamos esperando.
Reproduce el video desde :4:50 y sigue la transcripción4:50
Hay una manera de hacerlo explícitamente, 
que se llama justamente coerción explícita. 
Donde utilizamos las funciones as, que nos convierten de un tipo a otro.
Reproduce el video desde :5:4 y sigue la transcripción5:04
El nombre de estas funciones son, as.numeric(), as.logical(), 
as.character(), as.integer(). 
Y como su nombre lo indica lo que hacen es convertir lo que le 
estás poniendo de entrada, a el tipo que tiene en la segunda parte de su nombre.
Reproduce el video desde :5:21 y sigue la transcripción5:21
En este ejemplo, el vector x es un vector que cuenta los valores del 0 al 10, 
con incrementos de uno en uno. 
Si observamos utilizando la función class, 
la clase a la que pertenece x, podemos ver que es de tipo entero. 
Ahora podemos crear cuatro vectores más, llamados a, b, c y d. 
Donde a cada uno vamos haciendo una coerción explícita como numérico, 
como lógico, como caracter y como entero. 
Entonces si ahora observamos el tipo de cada una de ellas, 
vamos a observar que justamente lo que queríamos. 
Uno es numérico, otro es lógico, otro es de caracter y el otro es entero. 
Pudiera suceder que quisiéramos intentar coaccionar un vector a un tipo 
donde puede resultar algo que no tiene sentido. 
Por ejemplo, ¿qué pasaría si intentamos coaccionar caracteres 
de letras a un vector de tipo lógico? 
Lo que nos va a suceder en este caso muy particular. 
Es que estos caracteres como no pueden ser interpretados como valores 
verdadero o falso, true or false.
Reproduce el video desde :6:34 y sigue la transcripción6:34
Lo que hará es generarnos valores NAs. 
NA es un tipo muy particular que significa Not Available. 
Es decir, es un valor faltante. 
[MUSIC]

Matrices

[MUSIC]
Reproduce el video desde ::14 y sigue la transcripción0:14
Nuestro siguiente tipo de objeto que vamos a aprender es las matrices. 
Las matrices son un tipo de vector particular. 
No son más que un vector con un atributo especial, llamado dimensión. 
La dimensión nos dice el número de renglones 
y el número de columnas que vamos a tener en una matriz. 
Si ustedes you han estudiado las matrices, recordaremos que una matriz no es más que 
un arreglo de números en renglones y columnas. 
Entonces este atributo es un vector de tamaño dos, 
que nos dice el número de renglones y el número de columnas. 
Las matrices son creadas explícitamente con la función matrix(). 
En ella podemos poner como primer argumento los elementos de la matriz. 
Y los siguientes dos argumentos son las dimensiones, 
que es el número de renglones y de columnas. 
Si utilizamos la función dim(m), podemos ver ese atributo, el de dimensión. 
Y si vemos la clase de la dimensión, 
podemos ver que es simplemente un vector de tamaño dos. 
Un hecho que es importante a tener en cuenta con las matrices nr, 
es que éstas se van rellenando columna a columna, de izquierda a derecha. 
Contrario a cómo se rellenan los arreglos por ejemplo en C. 
Que generalmente se rellenan de renglón en renglón de izquierda a derecha. 
Es importante saber esto porque cuando queramos convertir un vector a una matriz, 
tenemos que tener en cuenta cómo se va a ir rellenando 
los elementos de esta matriz. 
Las matrices pueden ser creadas también modificando o 
generando el atributo de dimensión para un vector. 
Como podemos ver en este ejemplo, que generamos un vector de tamaño 10. 
Con los números del uno al 10. 
Lo único que hacemos para convertirlo a una matriz, es utilizando la función 
dim(m), y asignándole a esta función el vector 2,5. 
Lo que hacemos es modificar ese atributo para que entonces se vuelva 
una matriz con dimensión dos renglones y cinco columnas. 
Otra manera de generar matrices en R es utilizando las funciones 
cbind() y rbind(). 
Quizá el nombre les de una pista de lo que se trata. 
Lo que hace cbind() es ir pegando vectores 
a manera de columnas para formar una matriz. 
Y rbind() es, toma esos vectores como si fueran renglones, 
y va generando la matriz. 
En el ejemplo, lo que pueden ver es que uno de los requerimientos para 
poder generar una matriz con dos vectores, 
renglones o columnas, es que éstos tengan el mismo número de elementos. 
Para que a la hora que los pegues, pueda generarse una matriz. 
Recuerden que una matriz no puede tener elementos faltantes. 
En el caso de que lo hiciéramos así con matrices que son de distinto tamaño, 
nos generaría un error. 
[MUSIC]

Precedencia Operaciones Vectoriales

[MUSIC]
Reproduce el video desde ::14 y sigue la transcripción0:14
En esta lección aprenderemos lo que son las reglas de precedencia 
y las operaciones vectoriales. 
Si retomamos el tema de las operaciones básicas al principio del curso. 
Podemos recordar que existen todas las que se puedan llevarse a cabo 
en una calculadora científica. 
Que éstas pueden ser binarias, como la suma o resta, multiplicación, división, 
la operación módulo, la exponenciación o la división entera. 
O también unarias, como el negativo o lógicas, como el and o "y lógico". 
Que se utiliza el operador ampersand. 
Y o el "o lógico", que es la barrita o doble barrita.
Reproduce el video desde :1: y sigue la transcripción1:00
También hay operadores de orden, que son mayor que, 
menor que, menor o igual, mayor o igual, o igual. 
Y de comparación, que es igual o distinto. 
Ahora, ¿qué pasaría si escribiéramos la siguiente operación en la línea de 
comandos? 
2 + 3 * 4 / 5, 
¿qué resultado creen que tendría llevar a cabo esta operación? 
Si vemos la ejecución del comando, podemos observar que es 4.4. 
Que es lo mismo que multiplicar primero 3 * 4, 
luego dividir eso entre 5, y luego sumárselo a 2. 
Ésto es más claro si nosotros utilizamos paréntesis. 
Cuando introducimos paréntesis, como you lo hicimos, 
es más fácil ver en qué orden se llevan a cabo las operaciones. 
En el caso que observamos en el ejemplo, 
la multiplicación es la primera operación que se lleva a cabo. 
Luego la división, y finalmente la suma. 
Cuando metemos operaciones sin paréntesis en R, 
algunas operaciones se llevan a cabo antes que otras. 
Éstas siempre se llevan a cabo en el mismo orden, 
que ésto es justo lo que nos define las reglas de precedencia. 
Las reglas de precedencia de orden de mayor importancia a menor. 
Son las llamadas a funciones y expresiones agrupadas. 
Las operaciones de indexado y búsqueda. 
Las aritméticas, las de comparación. 
Las fórmulas, las de asignación y finalmente, las de ayuda. 
Si utilizamos la ayuda de R para buscar base:Sintax, 
podemos encontrar la referencia completa de las reglas de precedencia. 
En este momento están apareciendo en pantalla los operadores completos de 
orden de mayor a menor precedencia. 
Como el vector es un elemento básico del lenguaje, 
es natural entonces pensar que se pueden definir operaciones sobre ellos. 
Que hagan la lectura del código más conciso, 
fácil de leer y además más eficiente. 
Éste tipo de operaciones se conoce como operaciones vectoriales. 
Estas operaciones se definen para hacernos a la idea de que 
las operaciones normales pueden llevarse a cabo de manera paralela. 
En este ejemplo tenemos dos vectores que tienen el mismo tamaño, 
o el mismo número de elementos. 
Si sumamos uno con el otro, la suma se va definiendo, es decir, 
la suma vectorial; se va definiendo operador elemento a elemento. 
Es decir, el vector 07, 08, 09, 10; se suma el 09,10, 11, 12; uno a uno. 
Es decir, que cuando nos regresa el resultado, nos da 16, 18, 20 y 22. 
Podemos llevar a cabo operaciones vectoriales 
por ejemplo de comparación de un vector con un valor único.
Reproduce el video desde :4: y sigue la transcripción4:00
Entonces este valor único se va comparando a cada uno de los elementos. 
En la pantalla podemos observar que si tomamos el vector "x" 
y lo comparamos si es mayor que a 8, 
entonces nos regresa un vector de valores lógicos. 
Lo mismo pasa si utilizamos los demás operadores. 
Como lo puede ser la comparación de igualdad, la multiplicación o la división. 
Éstas se hacen elemento a elemento. 
Si quisiéramos llevar a cabo la operación de suma del vector "x" con el vector "y", 
sin una operación vectorial. 
Entonces tendríamos que ir haciendo un bucle que veremos un poco más adelante. 
Que vaya tomando uno por uno de esos elementos de cada uno de los vectores 
y sumándolos a un tercer vector. 
Ésto es complicado, porque nos haría el código mucho más largo, 
y además mucho más lento. 
Porque iría haciendo la operación de suma paso por paso. 
En el caso de las operaciones vectoriales, podemos pensar que todas las 
sumas de todos los elementos están llevándose a cabo al mismo tiempo. 
Aunque internamente puede suceder que ésto no esté pasando. 
También podemos llevar a cabo operaciones vectoriales con matrices. 
¿Ésto que significa?, 
si tenemos dos matrices con el mismo atributo de dimensión. 
Entonces éstas pueden sumarse, multiplicarse, dividirse y restarse, 
elemento a elemento utilizando la operación que queramos. 
También podemos llevar a cabo la operación multiplicación 
matricial utilizando el operador %*%. 
Ésto está definido muy diferente a multiplicar elemento 
a elemento dos matrices con las mismas dimensiones. 
De hecho, las reglas de multiplicación de matrices son muy claras. 
Se pueden multiplicar dos matrices que tienen las mismas dimensiones cuadradas. 
O cuando las columnas de la primera matriz coinciden 
con los renglones de la segunda matriz. 
[MUSIC]

Manejo de Fechas Tiempos

[MUSIC]
Reproduce el video desde ::14 y sigue la transcripción0:14
Ahora, aprenderemos cómo manejar las fechas y los tiempos en R.
Reproduce el video desde ::19 y sigue la transcripción0:19
Estas tienen clases especiales dentro del sistema. 
Y nos permiten llevar a cabo operaciones numéricas o estadísticas con ellas. 
Manejar fechas y tiempos en R puede ser bastante sutil. 
Además de que hacer coerción explícita se puede hacer de distintas maneras. 
Es por eso que es importante saber que hay diferentes tipos tanto para datos 
de fechas como para datos de tiempos. 
Hay dos tipos de datos que vamos a estudiar para el tiempo en R. 
Uno de ellos es POSIXct.
Reproduce el video desde ::56 y sigue la transcripción0:56
En este, el tiempo es el número de segundos desde el 1ro de enero de 1970. 
Cualquier fecha posterior a este, se representará con un número positivo. 
Y cualquier fecha o tiempo anterior, será representada con un número negativo. 
Estos datos, que están enlistados y que están apareciendo en este momento, 
nos muestran el orden en el que aparecen los elementos de un vector. 
Que es de tipo POSIXlt, el otro tipo de datos para tiempo en R. 
Una de las grandes dificultades para los tipos de datos de tiempo en 
R es que la manera en que se representan internamente es muy 
diferente a cómo se imprimen en pantalla. 
Esto hace que las conversiones puedan llegar a ser un poco complejas. 
Por lo que hay que tener siempre cuidado en asegurarnos 
de que lo que estamos tratando de llevar a cabo sea lo que queremos. 
Para obtener el tiempo actual, por ejemplo, 
podemos utilizar la función Sys.time. 
Esta la podemos guardar en un objeto. 
Y podemos ver que el objeto, utilizando la función typeof(t), tiene tipo double.
Reproduce el video desde :2:18 y sigue la transcripción2:18
Pero cuando imprimimos el objeto tal cual, 
el objeto se imprime como una cadena de texto con la fecha y la hora actual. 
Utilizando las funciones as.POSIXct() y as.POSIXlt(), 
podemos convertir el valor de tiempo en los diferentes formatos. 
Por ejemplo, utilizando la función as.POSIXlt(t) del objeto que acabamos de 
crear con la función sys.time, 
podemos ver que al imprimirla nos da igual a la misma cadena. 
Pero si pedimos el tipeof, como es de tipo POSIXlt, es de tipo lista. 
Recordemos que POSIXlt es una lista. 
Podemos tratar de acceder a los nombres de la lista. 
Pero estos son nulos, 
porque en la definición de este formato no existen los nosmbres para esta. 
Pero podemos acceder a los elementos de la lista utilizando el operador ]]. 
Así podemos ver que l de 1 va a ser 47 y así sucesivamente. 
Si tuviéramos un tipo de dato de tiempo y quisiéramos convertirlo a cadena, 
de tal manera que pudieramos, entonces, 
guardar esa cadena en un archivo tenemos que utilizar la función strftime(). 
Esta recibe como primer parámetro un objeto de tipo tiempo, 
you sea POSIXct o POSIXlt. 
Y luego la descripción de la cadena que queremos generar. 
En el caso del ejemplo, se utiliza una anotación con % seguido de una letra. 
Que define you sea el año, el mes, el día, 
la hora, minutos o segundos incluso. 
¿Qué sucedería si nosotros queremos hacer lo contrario? 
Es decir, de una cadena de caracteres poder generar 
un objeto que tenga tipo POSIXct o POSIXlt. 
Esto lo podemos hacer utilizando la función strptime().
Reproduce el video desde :4:21 y sigue la transcripción4:21
Esta funciona similarmente a strftime(). 
Recibe un objeto que es el objeto que queremos convertir a tipo tiempo. 
Y como segundo parámetro, la definición de la cadena como está. 
Es decir, tenemos que observar primero cómo es que está 
definida la cadena de la fecha o tiempo. 
Y poner exactamente esa misma especificación para que sea 
convertida al tiempo correcto. 
Una vez que tengamos dos objetos de tipo tiempo, 
podemos llevar a cabo operaciones entre ellos. 
Por ejemplo, la diferencia en días o en segundos entre dos tiempos. 
Que es justo lo que estamos viendo en pantalla actualmente. 
Primero creamos una fecha a partir de una cadena. 
Y luego obtenemos el tiempo actual. 
Una vez que you tenemos a estos dos objetos, 
podemos llevar acabo la operación diferencia entre ellos. 
Y nos da como resultado la diferencia de días 
de manera decimal entre esos dos tiempos. 
Adicionalmente a los dos tipos de datos de tiempo que hemos observado, 
también tenemos el tipo de dato date, que se refiere a fechas. 
La única diferencia entre este y los de tiempo, 
es que en este se toman diferencias en días y no en segundos, 
como sucede con POSIXct o POSIXlt. 
En este caso, podemos convertir una cadena de caracteres 
a un tipo date utilizando la función as.Date. 
Podemos utilizar el parámetro origin pasándole a ese parámetro 
una cadena con una fecha para definir una fecha de origen. 
Y a partir de ahí, podemos llevar a cabo también operaciones 
entre objetos que son del mismo tipo Date. 
En este caso, lo que estamos haciendo en el ejemplo, 
es utilizar la función as.Date utilizando como origen una fecha. 
Y luego obtener la fecha actual utilizando la función Sys.Date. 
Y luego podemos llevar a cabo una operación de diferencia entre estos dos 
objetos. 
Y como resultado, nos da la diferencia en días entre esas dos fechas. 
Una función muy útil en R, para manejar las fechas, es la función format(). 
Esta recibe un objeto de tipo fecha o tiempo. 
Y nosotros como segundo parámetro podemos pasarle el formato en el que 
queremos que nos regrese la cadena que queremos formar. 
Es un poco parecido a las funciones que you hemos visto anteriormente. 
Solo que en este caso nos regresa exactamente solo el formato que nosotros 
queremos en tipo caracter. 
Finalmente, podemos llevar a cabo operaciones o 
comparaciones entre distintos objetos de tipo Date o fecha, 
una vez que estos están en el formato interno de R. 
Por ejemplo, 
la comparación mayor que o menor que tiene sentido cuando comparas dos fechas. 
Creamos un par de fechas, una posterior a otra, 
utilizando la fecha actual y sumándole un período más de tiempo. 
Utilizando la función as.difftime y una vez que creamos estas fechas 
podemos llevar a cabo la comparación. 
Decimos si la fecha actual es menor a una fecha posterior, 
esta nos da como valor verdadero o TRUE. 
Y esto es así porque la operación de comparación menor que tiene sentido. 
you que una fecha es menor a otra si está sucediendo 
antes que con la que se está comparando. 
[MUSIC]

Listas, Factores, Valores Faltantes y Dataframes

[MUSIC]
Reproduce el video desde ::14 y sigue la transcripción0:14
Otro de los sujetos que son importantes en R son las listas. 
Las listas no son más que vectores, que ahora sí, 
pueden contener distintos tipos de datos en él. 
Este tipo de objeto es muy especial porque nos permite tener y llevar 
a cabo operaciones que podrían ser complicadas si no existiera.
Reproduce el video desde ::38 y sigue la transcripción0:38
Pueden observar que en la función lista recibe los elementos que van 
a formar parte de esta lista y lo asigna al objeto x. 
Los factores son un tipo especial de vectores, 
estos nos sirven para representar datos categóricos.
Reproduce el video desde ::56 y sigue la transcripción0:56
Puede haber de tipo ordenado o sin orden. 
Uno puede pensar en ellos como si fuera un vector de enteros, 
donde cada entero está asignado a una etiqueta en particular. 
Podemos generar un vector de factores utilizando la función factor(). 
En este ejemplo podemos ver que la función factor nos ayuda a generar 
un vector de factores. 
En este caso el vector x ahora tiene los valores yes yes y no y los niveles, 
como se le conoce a los factores, son no y yes. 
Como no pusimos explícitamente que tiene que ir en un orden. 
No aparece primero y yes aparece en segundo.
Reproduce el video desde :1:39 y sigue la transcripción1:39
Otra cosa muy bonita de este tipo de dato es que, si utilizamos la función table, 
lo que hace es nos tabula cada uno de los factores y la 
frecuencia con la que está apareciendo en el vector que estamos observando. 
Con la función unclass, en este caso, lo estamos usando solamente de manera 
ilustrativa para mostrar que a cada uno de los factores 
o de los niveles que estamos teniendo, va asociado un número entero. 
Es decir, nosotros podríamos tener entonces un vector de puros valores 
enteros que van asociados a una etiqueta, en este caso, las palabras yes Y no. 
El orden de los niveles se puede establecer dentro de la función factor, 
utilizando el parámetro level.
Reproduce el video desde :2:26 y sigue la transcripción2:26
Éste no es más que un vector indicando el orden en el que van a ir. 
En este ejemplo utilizamos ahora, en vez de las respuestas en inglés yes y no. 
Ahora utilizamos las palabras si y no, 
y establecemos que sí va primero, y no, va en segundo lugar.
Reproduce el video desde :2:45 y sigue la transcripción2:45
Al mandar a llamar el vector de factores, podemos observar que ahora sí, 
aparece en primer lugar, y no, aparece en el segundo lugar. 
Cuando hay un valor que está faltante, 
se utiliza un valor particular para rellenar ese valor faltante y, 
esto se indica con el carácter NA, 
o NaN, dependiendo del tipo de valor que esté faltando. 
NA significa not available y NaN es not a number, 
que you vimos como podemos también generar un valor de este tipo.
Reproduce el video desde :3:21 y sigue la transcripción3:21
Hay maneras de poder ver si un valor o un elemento de un vector es de tipo NA. 
Y también si es de tipo NaN.
Reproduce el video desde :3:35 y sigue la transcripción3:35
Es importante conocer que NA no necesariamente tiene que ser un NaN. 
O sea, ambos son valores faltantes, pero a veces pueden ser de tipo numérico, 
como NaN, que al mismo tiempo puede ser un NA. 
Los valores NA también tienen una clase, hay enteros NA, caracteres NA. 
Pero es importante acordarse que un valor NaN es al mismo tiempo un NA, 
pero no al contrario. 
Por ejemplo, el vector X tiene un valor NA. 
Si probamos con la función is.na, podemos ver que en el lugar número tres donde 
teníamos un NA dice TRUE, es decir, que ese valor sí es un NA. 
Pero si probamos si es un NaA, con la función is.nan, 
podemos ver que el valor tres no es un na, por eso le pone FALSE. 
En la segunda asignación del vector X, podemos ver que el elemento número tres es 
un NaN y el elemento número cuatro es un NA. 
Y si hacemos la pregunta de si es NA, ambos van a ser verdaderos. 
Por lo cual, justamente estamos comprobando lo que dijimos, 
que un valor NaN puede ser al mismo tiempo un NA, pero no al contrario. 
Los dataframes se representan en R como una lista muy particular, 
donde cada uno de los elementos de la lista tienen el mismo tamaño. 
Cada uno de estos elementos se puede ver como una columna, 
y la longitud de cada elemento es el número de renglones que se tiene. 
La forma tabular de los dataframes les puede recordar una matriz, 
pero recordemos que la matriz es un tipo particular de vector. 
Es decir, que tiene la limitante que todos los elementos de la matriz tienen que 
ser del mismo tipo o clase. 
Mientras que en un dataframe. 
Eso no es necesario, 
como es una especie de lista cada uno de los elementos de la lista, es decir, 
cada una de las columnas puede tener un tipo distinto o una clase distinta.
Reproduce el video desde :5:42 y sigue la transcripción5:42
Un atributo particular de los dataframes, es que cada una de las columnas 
puede tener un nombre, al igual que cada uno de los renglones.
Reproduce el video desde :5:53 y sigue la transcripción5:53
Y estos son conocidos como row.names y col.names. 
Ahora, ¿cómo generamos un dataframe? 
Es muy fácil, hay varias maneras, una es usando la función 
data.frame().Lla segunda es utilizando las funciones 
read.csv() o read.table() que lo que hacen es leer de un archivo o de una conexión. 
A un archivo los datos, y los va metiendo de manera tabular, 
y también podemos convertir una matriz a un dataframe 
utilizando la función data.matrix(). 
En este ejemplo podemos ver como formar un dataframe utilizado la función data.frame. 
La función recibe separado por comas. 
Primero el nombre de la columna que vamos a utilizar y luego un signo =, 
y seguido de los elementos que van a llenar esa columna. 
En este caso tenemos dos columnas, columna una que son los valores del uno, dos, 
tres y cuatro, y la columna dos que tiene los valores TRUE, TRUE, TRUE y FALSE. 
Podemos preguntar por los renglones, el número de renglones y el número de 
columnas, usando la funciones nrow(x) y ncol(x), al objeto que es ese dataframe. 
Que en este caso se llama X. 
Y finalmente una cosa que es importante recordar, 
es que el tamaño de cada una de las columnas tiene que ser el mismo. 
Por ejemplo, en el error que estamos viendo al final, 
estamos tratando de meter primero en la columna uno, cinco elementos. 
Y en la columna dos, que desde cuatro elementos, 
entonces cuando intentamos generar un dataframe con eso, 
nos dice que hay un error porque hay un número diferente de renglones. 
Podemos poner nombres a los objetos. 
Los nombres no son más que un tributo que nos permite describir 
de manera perfecta de qué trata un renglón o una columna. 
Podemos poner nombres a las listas, a las matrices y, también, a los dataframes. 
Podemos ver en este ejemplo que tenemos el vector x, 
que consta de los elementos 11, 12, 13, 14. 
Podemos ponerle nombre a cada uno de estos utilizando la función names 
y modificándola con una asignación de un vector que tiene cada uno de 
los nombres de cada elemento como un carácter. 
Si en el segundo ejemplo, lo que estamos generando es una lista donde cada uno 
de los elementos you tienen un nombre, si mandamos a imprimir la lista, nos aparece 
que ahora cada uno de los elementos tiene un símbolo de pesos y el nombre. 
Como you dije, las matrices también pueden tener nombres y podemos 
usar o asignar estos nombres utilizando la función dimnames, 
donde podemos ponerle nombres a cada una de las dimensiones. 
Ésto lo hacemos modificando ese atributo
Reproduce el video desde :9:6 y sigue la transcripción9:06
pasándole una lista o asignándole una lista a este atributo.
Reproduce el video desde :9:11 y sigue la transcripción9:11
Donde cada uno de los elementos van a ser vectores 
de los tamaños de cada dimensión de la matriz. 
[MUSIC]

Subjuntos de Datos
[MUSIC]
Reproduce el video desde ::14 y sigue la transcripción0:14
En esta lección lo que aprenderemos es a sacar un subconjunto 
de datos de algún objeto o variable que you tengamos en memoria. 
Y el cual probablemente sea muy grande como para poder utilizarlo completamente. 
Generalmente, este tipo de objetos será de la forma 
de matrices o de listas o de un DataFrame. 
Hay generalmente tres operadores básicos para hacer 
una extracción de un subconjunto de datos. 
Y estos son los corchetes que extraen elementos de 
la misma clase al objeto que estás extrayendo. 
Los dobles corchetes que extraen elementos de una lista o un dataframe. 
Y donde la clase que te va a regresar no necesariamente 
tiene que ser de tipo lista o dataframe. 
Y finalmente el símbolo de pesos que extrae elementos de un dataframe. 
En el ejemplo que estamos viendo en la imagen en pantalla. 
Podemos ver tres de las maneras que podemos usar corchetes. 
Una es pidiendo uno de los elementos, por el número del índice que estamos buscando.
Reproduce el video desde :1:34 y sigue la transcripción1:34
Una cosa que es importante no olvidar es que los índices en R comienzan desde 
el número uno, no desde el cero como en otros lenguajes. 
Luego también podemos pasar una secuencia de números. 
Y entonces esta secuencia de números, al pedirla por 
medio de corchetes nos va a regresar los elementos que están en esa secuencia. 
Y finalmente podemos pasar también un vector lógico.
Reproduce el video desde :2: y sigue la transcripción2:00
Donde nos va a regresar, al pedirlo por medio de corchetes, los lugares 
en donde el valor del vector lógico sea igual a verdadero o TRUE. 
Para hacer un subconjunto de datos de una matriz 
o lo que es lo mismo un subsetting de matrices. 
Podemos usar los operadores con corchetes, 
pero recordemos que la matriz tiene dos dimensiones. 
Que son los renglones y las columnas. 
Entonces podemos mandar a llamar utilizando corchetes, 
el valor de un renglón y una columna en específico, 
o el valor de una columna entera o de un renglón entero. 
Ésto lo hacemos, no poniendo ningún elemento en primer lugar en el corchete, 
luego una coma y luego el valor del renglón o la columna que queremos. 
Por supuesto también podemos pedir varias columnas poniendo igual secuencias. 
O incluso también vectores lógicos. 
Por ejemplo, en la imagen que estamos observando en pantalla, 
podemos pedir una matriz que you formamos. 
El elemento 1, 3 es decir, el renglón uno columna tres. 
Pero por ejemplo, si pedimos el elemento 3, 1 que es al revés, 
como no tenemos tres renglones, nos va a generar un error.
Reproduce el video desde :3:25 y sigue la transcripción3:25
Ésto porque el límite de los 
índices no está dentro del que nosotros pedimos. 
Los últimos dos ejemplos lo que estamos viendo es justamente eso. 
Pedimos el renglón uno y nos da todo el renglón uno. 
Y en el segundo, pedimos la columna cuatro y nos da exactamente la columna cuatro, 
que es el siete y el ocho. 
Una cosa que es importante recordar, 
es que cuando pedimos un elemento de una matriz.
Reproduce el video desde :3:56 y sigue la transcripción3:56
Ésta, este elemento regresado en forma de vector. 
Es decir, pierde su condición de matriz. 
Pero si nosotros utilizamos el parámetro Drop = FALSE. 
Lo que hace R es regresarnos también una matriz. 
Pedimos igual, el mismo elemento 3, 4 pero el valor que nos está 
regresando ese subsetting es una matriz que tiene un renglón y una columna, 
es decir, no ha perdido su condición de matriz. 
Sólo para reafirmar lo que he dicho, vemos el mismo subsetting. 
Los valores uno, seis, 11 y 16, 
de la misma matriz pero usando una el drop=FALSE. 
Y en el otro el valor por default del parámetro drop que es igual a TRUE. 
Podemos observar que cuando le pedimos la clase a uno de esos dos subsettings. 
Lo que estamos observando es que uno es de clase entera y otro es de clase matriz. 
Ahora, como extraemos elementos de una lista. 
O hacemos subsetting de listas. 
Podemos usar tres formas. 
Una es usando los corchetes, la otra es usar los dobles corchetes y la última es 
con el símbolo de pesos y el nombre que sólo puede utilizar nombres literales. 
Cuando hemos nombrado a los elementos de nuestra lista. 
Como podemos ver aquí en el ejemplo.
Reproduce el video desde :5:19 y sigue la transcripción5:19
Si mandamos a llamar, usando sólo corchetes podemos pasar de nuevo
Reproduce el video desde :5:24 y sigue la transcripción5:24
una secuencia o valores también lógicos. 
O como en este caso, muy simple, un número de índice. 
En este caso estamos pidiendo el índice número uno de la lista. 
Entonces lo único que nos regresará, 
es la lista o hola, el elemento de esa lista que es hola. 
Es decir, los números del uno al diez. 
Sólo para reafirmar, si pasamos un único índice, 
un único número a los corchetes nos va regresar el elemento con 
ese índice y su valor. 
Ésto en forma de lista, es lo que estamos observando en pantalla. 
Cuando usamos los dobles corchetes que es por ejemplo en el siguientes, 
que es x[[1]]. 
Nos regresa el primer elemento porque es el índice uno, 
de la lista que es ese vector. 
Ahora pueden observar que ese vector tiene de forma su clase, es vector.
Reproduce el video desde :6:31 y sigue la transcripción6:31
Y finalmente podemos observar también que si inferimos con el símbolo de 
pesos y el nombre de la variable literal, nos regresa exactamente el mismo valor. 
Ahora que pasa cunado utilizamos los dobles corchetes con el nombre literal. 
También nos puede dar ese valor y nos lo regresa en forma de vector. 
Y finalmente si pedimos la variable literal solamente con un corchete, 
nos va regresar ese elemento que pedimos, nombrado como hola2 en este caso, 
pero si se dan cuenta podemos observar que ahora es de tipo lista también.
Reproduce el video desde :7:15 y sigue la transcripción7:15
Por ejemplo podemos notar que en la anotación que estamos observando en 
pantalla, utilizando el operador corchete, podemos pasar un vector, 
este vector en este ejemplo, tiene los elementos uno y tres. 
Si se lo pasamos al operador corchetes, 
nos va a extraer el elemento uno y el tres de nuestra lista X. 
Que en este caso es dos, tres, cuatro, cinco, hasta el siete y la palabra puente. 
Ahora observemos que pasa con el operador de doble corchete. 
El operador doble corchete, 
uno podría pensar que es similar al operador del signo de pesos. 
Pero en realidad, en el fondo, no son tan similares. 
El operador de doble corchete puede utilizar índices computados. 
Es decir, que nosotros podemos calcular o generar un 
índice y meterlo al doble corchete y nos irá a extraer esos elementos que queremos. 
En este caso, en la lista X, calculamos o generamos una 
variable llamada name cuyo único elemento es una cadena llamada hola3 
y si se lo ponemos al operador doble corchete, nos regresa el elemento puente. 
En este caso si nosotros pasamos la variable 
name al operador de signo de pesos no va funcionar. 
Ahora veamos qué pasa, 
cuando queremos hacer subsetting de elementos anidados de una lista. 
Para empezar, lo elementos anidados de una lista, 
significa que dentro de la lista puede haber otra lista. 
Que es justamente la lista x que estamos observando en pantalla. 
Que contiene una lista que tiene los elementos 10, 11 y 12. 
Y un vector que tiene los elementos 9.8 y 2.33. 
Si quisiéramos tomar el valor 12, es decir, 
el tercer valor del primer elemento de la lista X. 
Entonces lo que hacemos es pasarle únicamente el vector 1,3 
entre corchetes dobles. 
Ahora si queremos utilizar otra notación que sea una notación equivalente. 
Es usar corchetes, corchetes, uno, que significa ve y extráeme el 
elemento uno de la lista, que es esa lista, 10, 11, 12. 
Y luego, otra vez dobles corchetes tres. 
Que lo que va a hacer es ir a extraer 
el elemento tres de esa lista que you se generó. 
El ejemplo de abajo no es más que solamente 
la misma notación del primer ejemplo. 
Para ir a acceder el segundo elemento de la lista, 
el primer elemento de ese vector que nos genera. 
supongamos que creamos una lista que tenga como elemento, 
un único elemento que se llame mmmddd223s, es un nombre arbitrario 
que se me ocurrió solamente para poder ejemplificar lo que vamos a observar. 
Y este tiene los valores del uno al 35. 
Es decir podríamos mandar a llamar o pedir usando la anotación de doble 
corchete o de nombres literales, usando la anotación del signo de pesos. 
Poniendo x$ el valor literal que es mmmddd223s 
en este caso, te lo podríamos poner así. 
Pero como es demasiado largo o demasiado complicado, 
podríamos hacer uso de lo que se conoce como emparejado parcial. 
El emparejado parcial, lo que hace es, si no encuentra un
Reproduce el video desde :10:51 y sigue la transcripción10:51
símbolo de alguno de los elementos que sea igual, idéntico al que estamos buscando. 
nos regrese el más cercano, en este caso, si sólo mandamos a llamar con la letra m, 
es decir, x[[¨m¨]] nos 
regresa justamente el elemento que 
estábamos diciendo en un principio, que es un nombre muy largo y muy complicado. 
Lo mismo pasa con el signo de pesos. 
Ahora.
Reproduce el video desde :11:21 y sigue la transcripción11:21
Este comportamiento se puede cambiar 
si utilizamos el parámetro exact y le ponemos igual a TRUE. 
Entonces, cuando hagamos uso de este, 
de intentar de hacer uso del emparejado parcial, no va a funcionar. 
Generalmente vamos a encontrar valores faltantes o NA, 
que you hemos observado qué significan estos valores. 
Cuando nos encontramos con este tipo de valores, algunas ocasiones 
vamos a querer eliminarlos y quedarnos sólo con los valores que 
sean diferentes a NA. 
El ejemplo que estamos observando, tenemos un vector que contiene NA. 
Lo que hacemos es generar un vector de valores lógicos, 
utilizando la función is.na. 
En éste nos regresará todo un vector que nos contenga los valores verdaderos, 
donde el elemento sea NA, entonces 
si lo que queremos es justo lo contrario, entonces tenemos que negar ese vector. 
Utilizando el operador signo de admiración. 
Entonces utilizando ese operador y el operador corchetes, 
podemos pasarle al vector x ese operador y entonces nos regresará 
sólo los elementos que son distintos de NA.
Reproduce el video desde :12:45 y sigue la transcripción12:45
Ahora, supongamos que tenemos un dataframe, 
y que este dataframe contiene NA en algunas columnas. 
Cómo le haríamos para eliminar 
los renglones que contienen NA sea de la columna que sea. 
Para eso utilizamos una función que es muy útil conocida como complete.cases(). 
Esta función lo único que tenemos que hacer es generar con ella 
un vector lógico, y luego mandar a llamar ese vector lógico, 
utilizando una operación de corchetes. 
El dataset airquality, is se lo pasamos a la función 
complete.cases nos genera un vector lógico, este vector lógico entonces 
se lo podemos pasar a airquality de nuevo, utilizando la operador corchetes 
para que nos de sólo los renglones donde los valores sean TRUE. 
Es decir, quitándonos todos los valores NA que no necesitamos. 
[MUSIC]
Leer y Escribir Datos
[MUSIC]
Reproduce el video desde ::14 y sigue la transcripción0:14
Es importante que sepas, antes de que comiences esta lección, 
que los datos a los que haremos referencia son tipos de datos tabulares, 
es decir, que están organizados en archivos por renglones y columnas. 
[SOUND] En esta lección lo que aprenderemos a hacer es a escribir y 
a leer datos, comenzaremos por leer datos. 
Esta es una de las operaciones más importantes porque generalmente nos dan 
datos en forma de archivos y si tenemos suerte estos serán archivos de texto. 
Por supuesto no todos los datos que nos proporcionan o que estemos generando, 
van a ser escritos en archivos de texto. 
Estos pueden venir como archivos en formato de excel, 
o algún otro formato de alguna hoja de cálculo. 
También pueden ser conexiones a base de datos o, incluso, 
podemos estar extrayendo información del web, 
you sea vía alguna interfaz de aplicación o páginas 
web directamente que tenemos, a las cuales tenemos que limpiarles estos datos. 
Hay algunas funciones dentro del sistema base de R que nos servirán 
para leer datos. 
Estas están enfocadas a datos que están escritos en archivos de texto, 
no los formatos, que hemos hablado como Excel 
o conexiones a base de datos o datos que provienen del web. 
Estas son las más importantes, las que están listadas en pantalla, pero además 
nos enfocaremos por este momento en read.table y read.csv. 
Así como hay funciones para leer datos en R, 
también hay funciones en el sistema base para escribirlos.
Reproduce el video desde :2:4 y sigue la transcripción2:04
Estas funciones aparecen ahorita en pantalla y, de nuevo, estaremos 
enfocando nuestros esfuerzos en aprender los detalles de la función write.table. 
Comenzaremos con la función read.table para aprender cómo leer datos en R. 
Read.table es una de las funciones más importantes para leer datos en el sistema.
Reproduce el video desde :2:28 y sigue la transcripción2:28
Es importante saber que, además, otras funciones
Reproduce el video desde :2:35 y sigue la transcripción2:35
para leer datos de archivos de texto, en realidad son funciones 
con parámetros you preestablecidos de la función read.table. 
Por ejemplo la función read.csv, read.csv2, 
read.fortran y read.socket 
son formas especializadas de read.table que you tienen parámetros preestablecidos. 
Volviendo con nuestra función read.table, podemos observar que los parámetros 
más importantes de esta función son: file, header, 
sep, colClasses, nrows, comment.char, 
skip y stringsAsFactors. 
La función read.table es muy eficiente con 
archivos pequeños porque al ser estos archivos pequeños, 
puede hacer toda la revisión del archivo, de manera rápida y eficiente. 
El problema comienza cuando los archivos son muy grandes, 
en ese caso tenemos que empezar a utilizar los parámetros para mejorar tal vez 
el rendimiento de la lectura. 
Por defecto, la función read.table 
ignorará todas las líneas que contengan este signo.
Reproduce el video desde :3:53 y sigue la transcripción3:53
Averiguará además, cuántos renglones tenemos. 
Y, finalmente, 
averiguará de qué tipo es cada columna de las variables que va encontrando, 
que es justo lo que sucede cuando mandamos a llamar la función de esta manera.
Reproduce el video desde :4:9 y sigue la transcripción4:09
Ahora, con los archivos grandes debemos ser cuidadosos, porque muchas veces 
una mala lectura o un mal parámetro pasado a la función read.table 
podría generar esperas muy largas, por ejemplo. 
Yo les sugiero no leer ningún archivo de datos si estos archivos 
son más grandes del tamaño de la memoria ram que tiene disponible o, también,
Reproduce el video desde :4:39 y sigue la transcripción4:39
recuerden utilizar el parámetro comment.char="", 
es decir, no hay ningún tipo de comentario, sí en el archivo no existe 
ningún comentario así ese chequeo no se hace en cada línea que se va leyendo. 
Es importante también que no olviden que aunque estamos tratando de revisar algunos 
de los parámetros más importantes de las funciones que vemos en el curso.
Reproduce el video desde :5:10 y sigue la transcripción5:10
También ustedes pueden ir a revisar el manual de la página de ayuda 
de cada una de las funciones, en este caso de read.table porque les dará una mejor 
visión de todos los parámetros que pueden ser controlados con esta función. 
Ahora vamos a ver algunos consejos para la función read.table uno de los primeros 
consejos que les daría es utilizar el parámetro col.Classes. 
Este parámetro lo que recibe es, en un vector, 
cada uno de los tipos que van a observar de cada una de las columnas, 
cuando estén leyendo esos valores con la función read.table. 
¿Esto por qué es de ayuda? 
Pues porque si tuviéramos digamos tres tipos diferentes en un
Reproduce el video desde :6:3 y sigue la transcripción6:03
archivo, lo que haríamos es ir leyendo cada uno. 
Más bien lo que hace el sistema es ir leyendo cada uno de ellos y al final 
decidir, de qué tipo es conforme a lo que ha observado en cada columna. 
Pero si nosotros le decimos a priori que lo que va a ver, por ejemplo, 
fuera una columna de puros nombres, otra de puras edades, 
y otra de puras categorías, entonces no tiene que hacer ese chequeo en cada 
una de las lecturas de los renglones, y podría hacerlo de manera más rápida. 
Podemos averiguar la clase de las columnas de manera fácil 
cuando tenemos archivos grandes. 
Lo que podemos hacer, como en este ejemplo que estamos observando en pantalla, 
es leer solamente los primeros cien renglones de nuestro archivo y
Reproduce el video desde :6:49 y sigue la transcripción6:49
utilizar la función sapply initial, o sea el nombre de nuestro objeto, y la clase. 
Lo que está haciendo es aplicar la función class 
a cada una de las columnas del objeto inicial. 
Entonces, este objeto lo guardamos en el vector clases, 
y luego leemos you entonces todo el archivo 
pero pasándole el parámetro col.classes. 
Otro consejo que les puedo dar es utilizar nrows desde el principio. 
Nrows le diría a la función read.table a priori cuantos renglones va a leer. 
Es por eso que nos ayudará a poder establecer el tamaño de 
memoria que vamos a utilizar desde el principio y no ir 
ampliando ese tamaño de memoria conforme vamos leyendo el archivo. 
Es claro, sólo de ver la función read.table y cómo 
puede llegar a complicarse leer un archivo de datos, 
que es importante saber qué tipo de sistema tienes. 
¿Esto que significa? 
Pues que debemos aprender antes de empezar a utilizar el sistema, 
qué tamaño es la memoria ram, qué aplicaciones se pueden estar usando al 
mismo tiempo en ella, si el sistema es multiusuario. 
Cuántos usuarios podría llegar a haber al mismo tiempo. 
Qué tipo de sistema operativo estamos utilizando. 
Y si es de 32 o 64 bits. 
Ahora supongamos que nos dicen que nos van a dar 
un millón de registros de usuarios del censo por ejemplo. 
Y que han recabado, 100 datos de cada uno de esos usuarios del censo.
Reproduce el video desde :8:29 y sigue la transcripción8:29
Cómo podríamos calcular el tamaño posible 
de ese archivo o de esos datos que van a ocupar en memoria. 
Pues es muy simple. 
Lo único que tenemos que hacer a sabiendas de que hay 1 millón 
de renglones en ese archivo, y hay 100 columnas. 
Tenemos que multiplicar esas columnas, 
también suponiendo que van a ser numéricas, por 8 bytes cada una, 
y eso nos daría el tamaño aproximado, Del archivo que vamos a tener, 
en este caso serían aproximadamente unos 700, 800 megabytes.
Reproduce el video desde :9:9 y sigue la transcripción9:09
Una recomendación que es empírica pero que funciona, 
es que generalmente es importante tener el doble de memoria RAM 
de los datos que vas a estar cargando en el sistema. 
[NOISE] La función write.table es muy parecida a la función read.table. 
Esta también tiene sus formas especializadas como read.csv, 
read.fortran, read.csv2, etcétera, etcétera. 
Estas van a ser utilizadas a más detalle en la práctica. 
Finalmente para terminar esta lección veremos las funciones para 
escribir objetos que you tenemos en el sistema en un momento dado 
utilizando las funciones dump y la función source para leerlos. 
En este ejemplo, podemos observar que tenemos dos objetos, X y Y. 
Utilizando la función dump, lo escribimos a un archivo llamado datos.r. 
Posteriormente, borramos esos dos objetos, pero si utilizamos la función 
source para leer de nuevo ese archivo que acabamos de crear, llamado datos.R, 
podemos observar que si volvemos a llamar a esos objetos, siguen estando en memoria. 
Bueno, haciendo un repaso final de esta lección, 
podemos recordar que las dos funciones más importantes para leer 
y escribir datos son read.table y write.table. 
Estas tienen muchos parámetros y es importante 
conocer nuestro sistema para poder saber qué parámetros debemos utilizar, 
para que cuando estemos leyendo datos de archivos muy grandes, 
nuestro rendimiento de esta lectura sea bastante bueno. 
Espero, puedan llevar a cabo estas lecturas y escrituras de 
sus datos en la práctica. 
[MUSIC]
Estructuras de Control
Bienvenidos al módulo tres, 
del curso de Introducción a la Programación Estadística con R, 
en este módulo aprenderemos a programar en R por primera vez. 
you que conocimos qué son los objetos, los tipos de datos que hay, 
las operaciones que podemos llevar a cabo con estos objetos.
Reproduce el video desde ::37 y sigue la transcripción0:37
Lo primero que aprenderemos en esta lección es aprender 
las diferentes estructuras de control que se pueden utilizar en R. 
Y primero comenzaremos por definir su uso.
Reproduce el video desde ::50 y sigue la transcripción0:50
Las estructuras de control nos permiten controlar el flujo de un programa
Reproduce el video desde ::55 y sigue la transcripción0:55
dependiendo si se cumplen las condiciones o no de esta estructura.
Reproduce el video desde :1:1 y sigue la transcripción1:01
También permiten llevar a cabo tareas de manera repetida o alguna operación. 
Hay varios tipos, éstas pueden ser condicionales, 
pueden haber bucles de repetición, bucles de condición, bucles infinitos. 
Y también podemos usar algunos operadores para romper un bucle 
o saltarse uno de ellos. 
La primera estructura de control que vamos a estudiar, es la estructura if. 
If, como su nombre indica en inglés, significa si.
Reproduce el video desde :1:32 y sigue la transcripción1:32
La manera en como la sintaxis de esta estructura es: if entre 
paréntesis ponemos la condición y luego abrimos y cerramos llaves. 
Y en éstas pondremos las operaciones que se van a llevar a cabo. 
Si la condición se cumple, 
el cuerpo de esta condición se lleva a cabo y si no, podemos incluso 
poner más condiciones utilizando la palabra else y abriendo otro if. 
En el ejemplo que están viendo en pantalla, lo que tenemos es 
una variable llamada r que tiene el valor número 4. 
Y probamos si sí esa condición se cumple, 
entonces lo que va a hacer es que el valor de un objeto llamado x, 
objeto o variable llamado x va a tener valor 1. 
En caso contrario, 
x va a ser igual a 3 y crea otra variable nueva llamada y que va a ser igual a 4. 
Entonces si ejecutamos esto podemos ver que como r en un principio 
sí era igual a 3, sólo se ejecuta la primera parte que es igual a 1. 
Si mandamos a llamar la variable y, 
podemos observar que nos dará un error porque ésta nunca fue creada. 
¿Por qué razón?, porque nunca entró a esa parte de la condición. 
¿Por qué?, porque r era igual a cuatro. 
Contrario a lo que pasa en este ejemplo. 
Si r vale igual a tres desde un principio, si ejecutamos nuestro if, 
podemos ver que ahora x es igual a tres, y y si existe, y es igual a cuatro. 
¿Por qué?, porque ahora si se ejecutó esa parte del código. 
Donde x toma ese valor, y y se crea. 
Sólo para revisar una vez más, podemos observar que la forma idiomática, 
o la forma más usada del if, es poniendo el if, 
poniendo entre paréntesis la condición, se abre llaves y se cierra llaves y dentro de 
estas llaves se ponen las operaciones que se van a llevar a cabo.
Reproduce el video desde :3:30 y sigue la transcripción3:30
Cuando se cierra la llave, podemos utilizar, 
si queremos probar otra condición o si queremos llevar a cabo 
alguna otra operación extra sin necesidad de probar condición. 
Un else sin un if, o un else con un if si es necesario. 
Otra forma que es muy común de usar en R, es hacer la asignación del if a un objeto. 
¿Eso qué significa? 
Que cualquier valor que te vaya a regresar ese if, o sea, si saliendo de 
ese bloque te regresa algún valor, porque tiene que salir algún valor. 
Ese valor se asigna directamente a una variable. 
Esto con el fin de que quede claro que el valor de esa variable depende 
justamente de ese bloque if. 
Por supuesto, también podemos prescindir de la palabra especial else, 
cuando estamos utilizando una estructura de control if. 
Lo único que cambiaría es que el if se vuelve un completamente simple. 
La condición, si se cumple o no, si no se cumple, 
no entra a nada y no hace nada de lo del cuerpo del if, y si sí, se lleva a cabo.
Reproduce el video desde :4:37 y sigue la transcripción4:37
Esto es muy común también utlizarlo.
Reproduce el video desde :4:40 y sigue la transcripción4:40
La siguiente estructura de control que vamos a aprender es el for. 
El for para lo que nos sirve es un bucle de repetición.
Reproduce el video desde :4:48 y sigue la transcripción4:48
Lo que se usa es utilizar la palabra especial for. 
Se abre un paréntesis con algo en medio 
y luego se abre y se cierran las llaves donde se lleva a cabo la operación. 
Que es justo lo que estamos viendo en pantalla. 
Es muy fácil ver lo que está haciendo este ejemplo. 
Porque lo que está haciendo es tomar cada uno de los valores de i. 
Cuando va iterando el vector del uno al diez y luego vamos a imprimir ese valor. 
Ahora tendríamos entonces que explicar qué es lo que está sucediendo. 
Lo que está sucediendo es la forma general del for. 
En el for tenemos la palabra especial for, 
luego entre paréntesis ahora sí lo que es conocido como un generador de rango. 
Y entre, en el cuerpo del for, 
las operaciones que estaríamos llevando a cabo. 
Un generador de rangos no es más que una estructura 
que podríamos ir recorriendo uno a uno. 
Entonces el valor del objeto que está 
tomando los valores del generador de rango. 
Va tomando justamente esos valores y los va utilizando o nos pueden servir 
dentro de la estructura for para llevar a cabo alguna tarea. 
A veces, muchas veces solamente es necesario poner el número, o sea el número 
de veces que queremos que se lleven a cabo esas repeticiones y con eso es suficiente. 
Muchas veces, también requeriríamos hacer otras cosas. 
Como pueden observar en este primer ejemplo. 
Podemos generar un vector llamado mis_letras que 
es un vector de caracteres donde son las letras a,b,c y d. 
Entonces podemos utilizar este como un generador de rangos. 
Para el objeto letras, es decir, en cada paso del for que vaya tomando, 
letras va a ir tomando, los valores de vector mis_letras. 
Es decir, que en cada uno de ellos de va a ir imprimiendo la letra primero a, 
luego b, luego c y luego d. 
Esto también se puede hacer de diferentes maneras. 
Es decir imprimir cada uno de los elementos del vector mis_letras. 
En este caso, en este segundo ejemplo que estamos viendo en pantalla, 
utilizamos entonces la función seq_along. 
Ésta lo que hace es, genera un vector donde los elementos van a ser
Reproduce el video desde :7:12 y sigue la transcripción7:12
los enteros que van apareciendo dentro del vector mis_letras. 
Prácticamente lo que hace es generar un vector del 1 al 4.
Reproduce el video desde :7:25 y sigue la transcripción7:25
Una vez que you tomó estos elementos del 1 al 4. 
Cuando vamos imprimiendo, en vez de imprimir letras, osea la función tal cual. 
Vamos imprimiendo el vector mis_letras, pero de manera indexada, 
como you lo hemos hecho antes con el operador de corchetes. 
En este último ejemplo, que es equivalente al anterior. 
Estamos también otra vez formando un generador de rangos, 
igualito al que teníamos en el ejemplo anterior.
Reproduce el video desde :7:57 y sigue la transcripción7:57
En este caso, en vez de utilizar sec along, 
que lo que genera es toda la secuencia del vector, o sea el vector 1, 2, 3, 4. 
Lo que hacemos es, decimos, el primer número de la secuencia va a ser 1, 
ponemos dos puntos, como cuando generamos secuencias. 
Y luego ponemos lenght, de mis_letras. 
Que lo que hace esta función, es encontrar el tamaño del vector mis_letras. 
Como es 4, entonces nos va a generar, del 1 al 4, un vector del 1 al 4. 
Y vamos a ir entonces imprimiendo el vector mis_letras, 
utilizando el operador corchetes. 
For, también funciona con las siguientes estructuras. 
Por ejemplo un vector de números. 
En este ejemplo que estamos observando en pantalla, 
lo que estamos haciendo es tomar un vector, del 1 al 100. 
Pero en vez de estar yendo entero por entero. 
Es decir, uno, dos, tres, cuatro, así hasta el cien, lo que estamos haciendo es 
caminando en incrementos de punto cinco por punto cinco, es decir, uno, uno 
punto cinco, dos, dos punto cinco, tres y así sucesivamente hasta llegar al cien. 
Por supuesto también podemos utilizar este vector para generar 
nuestro rango que tomará los valores de la variable i. 
Dentro de nuestro for.
Reproduce el video desde :9:17 y sigue la transcripción9:17
También podemos formar bucles anidados, 
es decir podemos poner un for anidado dentro de otro for. 
¿Esto para qué nos puede servir?. 
Generalmente lo necesitamos cuando queremos ir 
recorriendo todos los elementos de una matriz o de un data frame, por ejemplo.
Reproduce el video desde :9:35 y sigue la transcripción9:35
Como podemos ver en pantalla. 
Estamos generando una matriz del 1 al 18, de 3 por 
3 y lo que estamos observando es que estamos recorriendo la matriz una por una. 
Si ejecutan este código que están viendo en pantalla podrán ver que lo 
que estamos imprimiendo es uno por uno, los elementos de esa matriz. 
Recuerden como los elementos de nuestra matriz, se van llenando 
de izquierda a derecha y de arriba abajo, van a ir apareciendo en ese orden. 
Es importante que tomen en cuenta que no hay abusar del uso de los bucles anidados. 
¿Esto por qué? 
Porque genera mucha complejidad en el código. 
Y entre más bucles anidados vayan generando, más difícil de entenderlo será.
Reproduce el video desde :10:24 y sigue la transcripción10:24
Lo que les recomiendo es que vayan haciendo tal vez bucles anidados, 
de dos en dos, para que no se pierdan entre tanto código. 
La siguiente estructura que vamos a aprender es el while. 
Aunque antes de eso vamos a hacer un poquito 
de revisión de lo que significa el for. 
En el for, por ejemplo, sabemos a priori cuantos pasos se van a llevar a cabo. 
Es por eso que siempre sabemos el tamaño del vector 
donde se van generando los rangos. 
En el caso de un while no necesariamente sabemos ésto. 
Es por eso que, mientras, que es lo que significa la palabra while en inglés, 
se cumpla la condición, el cuerpo del while. 
Va a ser ejecutado. 
Por ejemplo, lo que estamos viendo en pantalla. 
Generamos primero una variable llamada contador, esta comienza en cero. 
La condición, es que este contador sea menor a diez estrictamente. 
Entonces si entramos en el while, 
lo primero que hace es imprimir el valor de contador. 
Y luego aumentarle en dos al valor que tiene actualmente. 
Una vez que haga eso, vuelve a entrar al while para probar la condición. 
Y así va a ir haciendo la impresión y la suma esta de dos en dos. 
Es decir, nos va a acabar imprimiendo 0, 2, 4, así hasta 8. 
Porque la condición es estrictamente menor a 10. 
While, también puede tener más de una condición y estas pueden ser 
conectadas dentro de los paréntesis por medio de operadores lógicos. 
En este caso estamos usando el operador lógico &. 
Que se escribe &&, como you hemos anteriormente. 
En este caso, 
lo que estamos pidiendo es que el valor de la variable a siempre esté entre 3 y 10. 
Mientras esté entre esos valores, 
lo que está dentro de nuestro cuerpo del while, se va a ejecutar.
Reproduce el video desde :12:28 y sigue la transcripción12:28
Este ejemplo que están viendo en pantalla, 
lo van a ejectuar en su computadora en la práctica. 
Y observarán que lo que genera es una caminata aleatoria. 
La siguiente estructura que vamos a aprender a utilizar es 
la combinación de repeat y break. 
Repeat lo que hace es entra directo al bucle, 
sin preguntar si se puede o no hacer. 
Y una vez adentro, nosotros podemos preguntar por medio de if, 
si la condición se cumple o no. 
Si la condición se cumple. 
Entonces puede llevar a cabo lo que queremos que lleve a cabo, 
las operaciones. 
O en caso contrario, también podemos utilizar un break para romper 
ese bucle y continuar con el camino del flujo del programa. 
Puede llegar a suceder que la condición para romper el repeat nuncla se cumpla. 
Entonces, ésto puede generarnos un bucle infinito. 
Debemos tener cuidado con ésto, 
al igual que cuando estemos utilizando un bucle while. 
Si la condición En el bucle while siempre se cumple. 
Entonces, puede llegar a pasar que también estemos dentro de un bucle infinito. 
Generalmente vamos a aprender a usar la palabra next, 
que se usa generalmente para saltarse los pasos de algún bucle.
Reproduce el video desde :13:51 y sigue la transcripción13:51
Por ejemplo, en una estructura de control for.
Reproduce el video desde :13:55 y sigue la transcripción13:55
Como la que tenemos en pantalla. 
Lo que podemos observar es que estamos iterando sobre 
un vector que va del 1 al 100. 
Si nos quisiéramos saltar los primeros 20 valores de ese vector. 
Lo único que hacemos es probar para i y si esta i es menor que 20, 
entonces nos la vamos saltando. 
Poniendo, por supuesto, una estructura if dentro de ese for 
para poder ir haciendo eso. 
Una vez que tenemos nuestro if, 
osea nuestra condición, ponemos en el cuerpo del if la palabra next. 
Y lo único que hará es saltar para volver a entrar al siguiente ciclo del for. 
you para finalizar esta lección, tenemos que recordar 3 cosas. 
If, while y for, son las estructuras de 
control que nos sirven para controlar el flujo de un programa en R. 
También debemos evitar el poder generar bucles infinitos. 
Esto nos puede ocasionar problemas. 
Y finalmente, utilizar estas estructuras de modo interactivo, 
puede ser un poco complicado. 
No lo dijimos de manera explícita, pero para evitarnos ésto, 
podemos utilizar la familia de funciones conocidas como apply. 
[MUSIC]
Funciones
En esta lección vamos a aprender cómo escribir funciones. 
Las funciones en R o prácticamente en cualquier lenguaje de programación 
son los bloques de construcción de análisis o programas más complejos. 
Las funciones se crean utilizando la función especial llamada function(). 
Y, una vez creadas, se guardan como un objeto de R con clase tipo "function". 
Estas se definen de la manera siguiente. 
Podemos ver en pantalla el esqueleto de una función de manera formal.
Reproduce el video desde ::48 y sigue la transcripción0:48
Primero ponemos el nombre de la función, 
luego el operador de asignación y luego la palabra especial function. 
Entre paréntesis van a ir los argumentos de la función. 
O también a veces son conocidos como parámetros. 
Y, finalmente, en el cuerpo de la función, 
abriendo y cerrando llaves, tendremos todas las operaciones que lleva a cabo. 
Algo que es importante recordar es que el valor que genera una función, 
o que regresa una función, 
es el último o la última sentencia que está en el cuerpo de la función. 
Hay dos particularidades que son importantes en las funciones. 
La primera es que éstas pueden ser pasadas también como argumentos a otras funciones. 
Y la segunda es que pueden ser anidadas, es decir, 
dentro de una función podemos definir a otra función más pequeña. 
Cuando creamos funciones, podemos crearlas con varios argumentos. 
Estos argumentos o parámetros pueden incluso tener valores por omisión. 
Los argumentos formales son aquellos que aparecen 
incluidos en la definición de la función. 
Estos pueden ser consultados utilizando la función formals() cuando you se encuentra 
la función dentro del ambiente de la línea de comandos de R. 
Si utilizamos formals() y el nombre de la función que vamos a consultar, formals 
nos va a regresar una lista de todos los parámetros que tiene esa función. 
Es importante que tomen en cuenta que en R no es necesario 
pasar toda la lista de parámetros formales que tengamos. 
Esto por dos razones. 
Una, puede ser que ese parámetro no se esté utilizando. 
Para un análisis en particular o para una operación en particular. 
Y dos, puede ser que ese parámetro you tenga un valor por omisión.
Reproduce el video desde :2:56 y sigue la transcripción2:56
En R, cuando mandamos a llamar a una función para que se ejecute, 
podemos ir poniendo los parámetros por nombre, uno por uno. 
Pero, si no lo hacemos, R tiene manera de coincidir estos valores 
que estamos pasándole a la función de dos maneras: de manera posicional 
o directamente por el nombre, pero no necesariamente a todos. 
¿Esto qué significa?, que los argumentos de R, siempre y cuando estén nombrados, 
le podemos cambiar el orden en el que están definidos.
Reproduce el video desde :3:32 y sigue la transcripción3:32
Esto puede ser un poco confuso por lo que no se lo recomiendo. 
Yo lo que generalmente hago es escribir los parámetros en el orden en 
el que deben de ir, o nombrar uno por uno para que haya absolutamente no confusión. 
Es importante recalcar que si decidimos cambiar el orden de los parámetros, 
no lo hagamos de manera seguida. 
Porque esto nos puede ocasionar mucha confusión en nuesto código. 
Es importante entonces recordar que hay tres tipos de argumentos coincidentes. 
El primero es una coincidencia exacta. 
El segundo es una coincidencia parcial, pues es decir, 
utilizando un nombre parcial de los nombres, así como you lo habíamos visto 
cuando la usamos con las listas o con los Data Frames. 
Y finalmente la coincidencia por posición. 
Por ejemplo, en el ejemplo que está apareciendo en pantalla, 
tenemos una variable llamada monedas. 
Ésta no es más que el valor del lanzamiento de una moneda.
Reproduce el video desde :4:37 y sigue la transcripción4:37
No tenemos que ver de qué trata la función rbinom, 
pero eso es justamente lo que está haciendo. 
Entonces, la variable monedas tiene 100 valores, 
y lo que queremos ver es el promedio de todos esos valores. 
Para eso utilizamos la función mean. 
Si mandamos a llamar mean(monedas), la función mean tiene como primer parámetro 
un vector X, que es sobre el cual vas a tomar ese valor promedio. 
En este caso como no mandamos a llamar a ningún otro parámetro, 
lo que hace es justamente sacarnos el valor promedio de ese vector. 
Ahora, también podemos mandar a llamar mean(x = monedas). 
Y nos va a hacer exactamente la misma operación 
que cuando mandamos a llamar solamente monedas sin nombrar a ese parámetro. 
¿Por qué?, porque x es el valor o el nombre de ese parámetro 
que necesita la función mean de manera obligatoria. 
Hay otro parámetro llamado na.rm, 
esto lo que hace es: nos elimina los valores faltantes. 
Normalmente, el comportamiento de mean 
nos indica que na.rm siempre va a ser igual a false. 
Es decir, si nosotros lo ponemos ahorita al llamar a la función na mean y x=monedas 
y na.rm=FALSE va a ser exactamente lo mismo que en los dos ejemplos anteriores. 
Esto mismo puede pasar si cambiamos el orden de los parámetros. 
Si están nombrados no hay ningún problema, R entenderá que uno es 
un vector lógico y el otro es el vector al que le va a sacar el promedio. 
Que es lo que no pasa en este último ejemplo, 
donde na.rm=FALSE, pero el segundo parámetro no está nombrado. 
R lo que hace es: si tú nombras a un parámetro nombrado, 
los demás tratan de hacer los coincidentes de acuerdo a la posición. 
Entonces, en este caso, supone que monedas 
es el primer parámetro sin nombre que vas a poner que es exactamente el vector x. 
La manera en que se evalúan los argumentos en una función en R 
es conocida como "evaluación floja" o "lazy evaluation". 
¿Esto qué significa? 
Esto significa que un argumento no es 
evaluado sino hasta el momento en que se necesita dentro de la función. 
Por ejemplo podemos observar en la función que tenemos definida en pantalla que pide 
dos parámetros: x y y, pero, dentro del cuerpo de la función, y nunca se utiliza.
Reproduce el video desde :7:28 y sigue la transcripción7:28
Es decir, si a la función cuando la llamamos, 
que es lo que podemos ver abajo, como argumento al valor 4. 
Lo único que hace es sumarle 1 a ese valor 4 y nos lo regresa. 
Y no nos genera ningún error. 
¿Ésto porqué? 
Por que en ningún momento llegó a necesitar evaluar 
el segundo parámetro que era y. 
Ahora vamos a hablar del argumento Este argumento se utiliza si no 
sabemos a priori el número de parámetros que le vamos a pasar a una función. 
O si un número variable de argumentos se le va a pasar a otras funciones 
que existan dentro del cuerpo de esa función que se está definiendo. 
Las funciones genéricas también hacen uso del argumento "···". 
Estas funciones son funciones que, justo como su nombre lo dice, 
son de tipo genérico. 
Esto significa que pueden llevar a cabo esa operación que se supone hacen, 
pero sobre diferentes tipos de objeto. 
Por ejemplo, la función mean. 
Puedes llevar a cabo encontrar el valor de un promedio, 
pero no sólo en un vector, sino puede ser en otro tipo de objeto. 
you sea un Data Frame o una matriz, por ejemplo. 
En éste momento estamos observando la función mi_graficador. 
Que es una función que he definido y en donde hago uso, 
dentro de ella, de la función plot. 
Como la función plot tiene que recibir además parámetros extra, 
es entonces que nosotros utilizamos el argumento "···". 
En este último ejemplo, podemos observar el uso de la función "···". 
Primero vamos a analizar los argumentos que requiere la función paste.
Reproduce el video desde :9:21 y sigue la transcripción9:21
Utilizando la función args. 
Podemos ver que como primer argumento tiene el parámetro "···". 
La función paste lo único que hace es concatena cadenas de parámetros.
Reproduce el video desde :9:35 y sigue la transcripción9:35
En este caso lo que estamos observando es que solamente concatenamos 
la cadena "hola" y la cadena "mundo". 
Pero podríamos poner muchas más o sólo una. 
Es decir, no sabemos a priori, el número de argumentos que vamos a pasar. 
Es por eso que En la definición, en la función paste, usa los "···" de argumento. 
Finalmente como última anotación, para el parámetro "···". 
Es importante hacer notar que una vez que utilizamos el parámetro "···", 
cualquier parámetro que continúe después de él, 
tiene que ir nombrado explícitamente y no puede ser emparejado parcialmente. 
[MUSIC]

Creando tu Primera Función en R

[MÚSICA] [MÚSICA] 
En esta lección vamos
Reproduce el video desde ::15 y sigue la transcripción0:15
a aprender cómo crear nuestra primera función en R,
Reproduce el video desde ::19 y sigue la transcripción0:19
además aprenderemos el proceso que se lleva para poder llevar a cabo esta tarea. 
Escribir funciones es uno de los pilares de la programación estadística 
o de la programación en general, you que esto nos ayuda a esconder complejidad que 
muchas veces tiene que ser incluso repetitiva. 
Es decir nos facilita mucho la 
organización de nuestro código y además de nuestros propios análisis. 
Podríamos tratar de escribir una función en R desde la consola o como you lo 
hemos dicho prompt o línea de comandos, esto va a ser un poco complicado, 
lo mejor es utilizar el editor que nos permitirá 
luego poder escribir esta función o funciones en 
un archivo de texto y que podemos después recuperar usando la función source. 
Es fácil una vez que hayas creado una función, guárdala en un archivo y 
además crear todo un paquete para esa función o funciones que hayas creado. 
Esto te ayudará a que puedas organizar todo ese ambiente 
en un solo lugar y además tener acceso a la documentación de estas funciones.
Reproduce el video desde :1:32 y sigue la transcripción1:32
Este curso no llegara tan lejos, 
pero es importante que sepas que a partir de que tu puedas escribir tus propias 
funciones puedes empezar a buscar e intentar crear tu propio paquete. 
El primer paso que vamos a llevar a cabo, una vez abierto R Studio, 
es ir al menú de archivo o File y pedir que nos cree 
un nuevo script dentro de la sección new file o nuevo archivo. 
El siguiente paso es definir qué es lo que va a hacer nuestra función, 
a esto se le conoce como la especificación de la función o especificar la función. 
Esto lo único que hace es definir formalmente 
las capacidades de la función y su interacción con el usuario. 
En nuestro caso vamos a crear una función que reciba 
2 números y lleve a cabo una operación con esos 2 números, 
estas operaciones van a ser la suma, la resta, la multiplicación y la división.
Reproduce el video desde :2:35 y sigue la transcripción2:35
El siguiente paso es entonces escribir nuestra función y 
una vez que hayamos visto que o pensemos que esté terminada, 
entonces lo que hacemos es seleccionarla con nuestro mouse 
y ejecutarla mandándola a ejecutar directamente con el mouse, 
en el botón de run o mandarla a ejecutar con command
Reproduce el video desde :3:2 y sigue la transcripción3:02
y enter o control y enter, si utilizas sistema Windows o Linux. 
Estamos viendo en pantalla la definición que yo he escrito, 
ustedes también podrían hacerlo, en este caso mi función se llama mi función y 
recibe como parámetros a x y y y un tercer parámetro llamado operación. 
La operación no es más que una cadena donde le indicamos qué operación va 
a llevar a cabo. 
Una vez en el cuerpo de la función utilizo una estructura de control if, 
para dependiendo del tipo de operación que vaya a llevar a cabo 
si en pareja con ese tipo se lleva a cabo esa operación. 
Ahora en pantalla estamos observando qué pasa si mando a llamar a mi función. 
Estoy llamando a mi función en una primera instancia utilizando los 
números 2 y 2, como no le paso el tercer parámetro entonces 
R supone que estoy mandando a llamar el valor por omisión, que es sumar. 
Es decir cuando pongo mi función 2, 2 me regresa el valor de 4. 
Ahora, ¿qué pasa si hago lo mismo, pero paso entre comillas la cadena suma? 
Hace exactamente lo mismo hace la suma y así sucesivamente con las 
demás operaciones. 
Ahora vamos a escribir una nueva función donde le pasemos un vector y
Reproduce el video desde :4:29 y sigue la transcripción4:29
una cota inferior y entonces esta función nos regresará todos los 
valores de ese vector que son mayores a la cota inferior que estamos especificando. 
Por ejemplo, yo definí la función de la siguiente manera,
Reproduce el video desde :4:44 y sigue la transcripción4:44
la función le llamo arriba de y recibe 2 parámetros el vector x 
y el limite inferior que vamos a utilizar. 
Entonces una vez en el cuerpo de la función genero un vector 
de valores lógicos, donde todos estos valores son 
todo los valores x que son mayores a limite. 
Una vez que tengo ese vector lógico utilizo una operación de subsetting 
utilizando corchetes y regreso el vector x utilizando ese vector lógico y eso 
me va a generar justamente lo que hemos pedido en la definición de la función. 
Una vez que nuestra función you esté dentro del ambiente de
Reproduce el video desde :5:32 y sigue la transcripción5:32
nuestra consola, podemos observar que al escribir la función, si intentamos
Reproduce el video desde :5:38 y sigue la transcripción5:38
utilizar la tecla tap dentro de los paréntesis, 
nos saldrá la lista de todos los parámetros que tenemos.
Reproduce el video desde :5:46 y sigue la transcripción5:46
Esto es muy bonito you que nos permite 
tener la lista completa de todos los parámetros podemos saber cuáles pueden 
ser usados y en el orden en el que deben ser usados. 
Podemos observar cómo al ejecutar nuestra función 
si solo la ejecutamos con un parámetro de entrada, esta nos mandará un error. 
Esto porque todos los parámetros necesitan estar presentes,
Reproduce el video desde :6:11 y sigue la transcripción6:11
porque ninguno de ellos está con valores por omisión. 
En el caso de que lo hagamos correctamente no tendremos ningún problema 
y nos regresará justamente lo que hemos pedido en la definición de ella. 
Regresando a la función que nombré mi función, 
podemos observar que podemos hacer algunas mejoras, ¿qué cambios haría? 
Una primera idea que se me ocurre es qué sucedería cuando paso como 
parámetro una operación que no esta definida en la lista DAVE que tengo.
Reproduce el video desde :6:41 y sigue la transcripción6:41
Sería bueno que si la operación que estamos introduciendo como parámetro no 
existe en esa lista, entonces mandemos un mensaje de error que sea claro 
para que el usuario pueda corregir esta. 
[MÚSICA]

Guía para el Estilo de Código

[MUSIC]
Reproduce el video desde ::14 y sigue la transcripción0:14
En esta lección aprenderemos una guía para el estilo de código. 
Este es importante you que puede ser que se tenga que revisar tu código 
tiempo después, por tí o por alguien más y entonces el seguir esta 
guía te permitirá tener un código más legible y por lo tanto perderás 
menos tiempo en tratar de re entender lo que tú you habías escrito. 
Es por ello que vamos a establecer una serie de estándares mínimos que la mayoría 
de la gente va a seguir y una vez que you estén utilizando esos estándares mínimos, 
adopten algún estilo particular o inventen el propio 
para algún proyecto en específico. 
Antes de continuar, no olvides que todos tus archivos de código en R deben estar 
guardados en modo texto y con una codificación ASCII. 
Si vas a utilizar acentos o algún carácter especial, es importante que guardes
Reproduce el video desde :1:9 y sigue la transcripción1:09
en el formato o codificación UTF-8. 
Esto se puede cambiar en el 
menú de file de R En la parte que dice "Save with Encoding". 
Una vez que le des clic ahí, te aparecerá una serie de codificaciones, y, te digo, 
utiliza el ASCII o UTF-8. 
La primera recomendación que te podemos dar en esta guía es 
que indentes tu código.
Reproduce el video desde :1:36 y sigue la transcripción1:36
Indentar no es más que colocar los espacios en blanco necesarios para hacer 
el código más legible. 
Esto lo que ocasionará es que tu código, o más bien, 
la idea que estás tratando de implementar con tu código, sea más clara.
Reproduce el video desde :1:52 y sigue la transcripción1:52
Indentando incluso podemos mejorar la manera en cómo se está moviendo el flujo 
de tu programa porque de buenas a primeras, en una primera vista, 
te permitirá ver hacia dónde está fluyendo la información de ella. 
Por ejemplo, ahorita el código que está apareciendo en la pantalla, 
es un código que está prácticamente sin indentar, es decir, 
pone los comentarios en la misma línea e incluso hay 
varias asignaciones que están también en una misma línea y el código se vuelve muy
Reproduce el video desde :2:27 y sigue la transcripción2:27
difícil, muy apretado, muy difícil de descifrar. 
Ahora si observamos esta segunda, esta misma función 
implementada con la indentación correcta, podemos observar que es mucho más clara. 
Cada comentario va en una línea aparte, al igual que las 
asignaciones y la llave que cierra está, también, en una línea aparte. 
Entonces puedes observar que este es mucho más claro sin necesidad 
de leer exhaustivamente esta función. 
Podemos cambiar la manera en como indentamos con la tecla tab o tabulador, 
es decir, cada vez que utilizamos o presionamos la tecla tab o tabulador, 
podemos ver que nos inserta cierto número de espacios en blanco. 
Podemos cambiar el comportamiento de la tecla tab en R Studio, es decir, 
cuántos espacios inserta, yendo a la configuración de R Studio en 
la sección de code y luego en editing hay una sección que dice
Reproduce el video desde :3:29 y sigue la transcripción3:29
ancho del tab o tab width y en esa parte por omisión tiene un valor de cuatro. 
Lo podemos cambiar a ocho que es el valor que yo recomiendo porque el código 
que es generado con éste; es mucho más claro. 
Una vez hecho esto, podemos entonces reinventar nuestro código, 
seleccionándolo completamente y luego presionando la combinación 
de teclas command I o control I, para reindentarlo. 
En el código que está apareciendo en pantalla en este momento, 
podemos observar que es muy legible. 
Los tabs o la indentación que tiene es de 8 caracteres 
y es muy claro dónde empieza y dónde termina la función. 
Además de que podemos observar que las asignaciones están bien definidas y, 
también, donde empiezan y termina los ciclos for. 
Otra recomendación importante es que limitemos 
nuestro código a 80 caracteres por cada línea de código que estemos escribiendo. 
Esto con el fin de que no vayamos alargando demasiado nuestra línea, 
que haga demasiado ilegible el código, 
porque pueden estar sucediendo demasiadas cosas en esa línea. 
Además de que evitamos que nuestro código vaya 
anidándose demasiado, lo que ocasiona también, más ilegibilidad. 
Si llegamos a escribir una función que resulta demasiado larga, y ahorita veremos 
a qué nos referimos con eso, será mejor reescribirla en funciones más pequeñas 
y luego conjuntarlas todas estas, para formar la función que queremos escribir. 
Idealmente, una función bien escrita, 
no debería de pasar más de 80 líneas de código o una página de tu editor.
Reproduce el video desde :5:17 y sigue la transcripción5:17
Estas funciones además, deben seguir la filosofía de UNIX. 
Donde cada comando hace una única cosa, pero lo hace muy bien. 
Una vez que dominemos esta guía, podemos entonces adoptar un estilo particular 
de programar, el cual incluye también modificar la manera en que se escriben 
las funciones, se nombran las variables y muchas otras recomendaciones. 
Uno de los estilos más populares es el que edita la Google's R Style Guide, 
que pueden consultarla en la página que está apareciendo en pantalla. 
De manera general lo que especifica es lo siguiente, el nombre de los archivos, 
que en este caso es con la extensión.R, los identificadores, 
que son las variables, cómo deben ir escritas las variables, 
el nombre de las funciones, el nombre de las constantes. 
También el tamaño de línea que, 
como you dijimos antes es un máximo de 80 caracteres, la forma de indentación 
que ellos recomiendan utilizar dos espacios y nunca tabulaciones. 
También los espacios entre operadores o antes de la coma o después de una. 
La forma en como se abren las llaves. 
Cómo abrir llaves y cerrarlas cuando utilzamos la palabra else. 
La forma en como debemos asignar, en este caso es usando el operador de asignación 
que you conocemos, nunca el signo igual, la forma en cómo o cuándo usar punto y 
coma, que ellos recomiendan nunca usarlo, la estructura general de un programa en R. 
Que es un poco larga de explicar pero, 
básicamente tienes que tener una descripción. 
Sentencias el source(), si estás cargando archivos de otro lado, y la
Reproduce el video desde :6:59 y sigue la transcripción6:59
función library(), luego la definición de funciones y las sentencias de ejecución. 
Además, también, cómo se deben escribir las pruebas unitarias que 
deben ir en un archivo aparte, 
los comentarios; con qué deben iniciar y en dónde se deben poner y las funciones. 
La forma en cómo debemos escribir los argumentos y dónde deben ir 
los argumentos que deben tener valores por omisión. 
También una sección de comentarios para cada función. 
Y finalmente las listas TO DO o de pendientes, 
en esta guía se establece cómo deben ser escritas de manera consistente y 
la descripción de las tareas que se deben hacer en ella. 
Pueden consultar más a fondo esta guía en la página que aparece en pantalla. 
[MUSIC]

Reglas de Alcance
[MUSIC]
Reproduce el video desde ::14 y sigue la transcripción0:14
En esta lección aprenderemos las reglas de alcance, 
que son la principal diferencia entre el lenguaje R y el lenguaje S. 
Las reglas de alcance determinan como se asocia un valor con una 
variable libre en una función en R. 
Las variables libres no son más que 
variables que no aparecen en la lista de argumentos formales de una función.
Reproduce el video desde ::37 y sigue la transcripción0:37
R, en particular, utiliza el alcance léxico. 
Por ejemplo en el código que está apareciendo en pantalla podemos observar 
que está definida la función funcion1. 
Y tiene como argumentos X y Y. 
Podemos observar que hay un valor dentro de la función, 
del cuerpo de la función donde se suma X, Y y otra variable Z. 
Esa Z es una variable libre. 
¿Como sabe R qué valor asignar a un símbolo? 
Por ejemplo, sabemos 
que existe una función llamada lm dentro del paquete stats. 
¿Qué pasaría entonces si definimos 
una función que le llamemos de la misma manera? 
lm. Si esta función con exáctamente 
el mismo nombre. 
¿Qué creen ustedes que pasaría? 
Por ejemplo, 
la función lm que estoy definiendo en el código que está apareciendo en pantalla, 
lo único que hace es, recibe un parámetro X y regresa el valor de esa X al cuadrado. 
Si mandamos a llamar inmediatamente en nuestra consola a la función 
lm con un valor, digamos cuatro, el resultado es 16. 
Es decir, está utilizando el valor de la función 
lm que nosotros acabamos de definir. 
Cuando R trata de ligar un valor a un símbolo lo que hace es hacer una búsqueda 
en una serie de ambientes para encontrar el valor apropiado. 
Cuando estamos trabajando en la línea de comandos 
y queremos traer el valor de un objeto, el orden en el que se busca es el siguiente. 
Primero busca en el ambiente global por un 
símbolo con el nombre que se está solicitando.
Reproduce el video desde :2:17 y sigue la transcripción2:17
Luego busca en los espacios de nombres, en la lista de búsqueda. 
La lista de búsqueda la podemos consultar utilizando la función search. 
El ambiente global siempre es el primero en la lista de búsqueda y el paquete base 
siempre es el último en la lista de búsqueda. 
El orden de los paquetes en la lista es el orden en el que se hará la búsqueda. 
Los usuarios pueden configurar los paquetes que se cargan al iniciar. 
Por lo que no podemos suponer que habrá una lista de paquetes disponibles siempre. 
Cuando cargamos un paquete con la función library, el espacio de nombres 
de este paquete quedará en segundo lugar en la lista de búsqueda. 
Y todos los demás paquetes se irán un lugar hacia abajo. 
Hay que notar que R tiene un espacio de nombres específico para 
funciones y para cualquier cosa que no sea una función. 
¿Esto que significa? 
Que por ejemplo podemos tener una función que you hemos utilizado llamada C, 
que nos puede ayudar a crear vectores. 
Y también un objeto llamado C que puede tener un valor. 
Como lo que estamos viendo en pantalla. 
Recuerdan este ejemplo que está apareciendo en pantalla. 
La función Z era una variable libre. 
¿Qué pasaría si ejecutáramos ese código? 
Si mandamos a llamar a la función1 con los argumentos uno y dos, y. 
Como la variable Z no está definida, 
nos mandará un error, que nos dice que la Z no se encuentra. 
Pero si definimos Z anteriormente, y luego volvemos a hacer una 
llamada a la función1, con los argumentos unidos, nos regresará ocho. 
Esto significa que el valor de Z dentro de la función es el valor que encuentra 
primero, es decir, en el ambiente global, que es donde se definió que Z vale cinco. 
Y ese es justamente de lo que trata el alcance léxico, que es que los valores 
de las variables se buscan en el ambiente en el que la función fue definida. 
Un ambiente no es más que una colección 
de parejas de símbolos y valores asociados a esos símbolos. 
Cada ambiente tiene un ambiente padre 
y es posible que un ambiente tenga múltiples ambientes hijos. 
El único ambiente que no tiene padre, es el ambiente vacío. 
SI el valor de un símbolo no se encuentra en el ambiente en el 
que la función fue definida, se busca en el padre, y así hacia arriba 
hasta el llegar al nivel más alto, es decir, generalmente el ambiente global. 
O el espacio de nombres de un paquete. 
Después de llegar al nivel más alto, se continúa hasta llegar al ambiente vacío. 
Si el valor de un símbolo no es encontrado en un ambiente 
antes de llegar al ambiente vacío, entonces se va a encontrar con un error, 
que es justo lo que pasó con el ejemplo que observamos al principio. 
Esto típicamente no tendría mucho sentido, 
pero en R, nosotros podemos definir funciones dentro de otras funciones. 
En este caso, el ambiente de una función es justamente el cuerpo de otra. 
Por ejemplo la función que estamos observando en pantalla en este momento, 
llamada elevar.potencia recibe un parámetro n. 
Y dentro de ella se define otra función que utiliza ese parámetro para 
generarnos una función. 
Es decir, que lo que regresa esa función es una función también. 
Vamos a ver cómo funciona. 
Por ejemplo, si mandamos a llamar la función elevar.potencia 
con diferentes parámetros. 
Y guardamos en diferentes objetos 
el resultado de esas ejecuciones de la función elevar.potencia, 
podemos observar que esos objetos que guardan el resultado de esas llamadas.
Reproduce el video desde :6:11 y sigue la transcripción6:11
También, a su vez, son funciones pero que hacen una función en específico, 
es decir, una eleva a la cuarta y la otra eleva al cuadrado. 
Podemos ver que estos objetos en realidad son funciones también. 
Podemos ver de manera más clara qué es lo que está sucediendo 
con los siguientes comandos. 
La función ambiente o enviroment nos permite analizar qué hay 
en el ambiente en donde está definida en la función que le pasamos a environment. 
Entonces, si usamos ls(environment(alacuarta)), 
que es uno de los objetos que definimos cuando hicimos la llamada. 
Podemos ver que hay dos objetos, m y pow, 
al igual que con el ambiente de alcuadrado. 
También existe "n" y "pow", pero si mandamos a llamar con la función get, 
el valor del nombre 
n podemos ver que en un ambiente tiene un valor 4 y en el otro tiene valor de 2. 
Es por eso que cuando se mandan a llamar los respectivos objetos con 
un argumento en uno elevará a la cuarta y en otro eleva al cuadrado. 
Es importante no olvidar la manera en que R lleva a cabo la evaluación 
y las reglas de alcance, esto nos servirá a escribir código más claro y conciso. 
Es importante y creo que en este momento you es un poco obvio. 
Que no se repitan los nombres de variables o de funciones, 
you que esto puede causar confusión si no estamos en el contexto correcto, 
o si no tenemos total conocimiento del código que estamos modificando. 
Finalmente, siempre es importante tomar en cuenta esto cuando 
vayamos a modificar el código de alguien mas. 
[MUSIC]

Funciones *apply: apply

[MUSIC]
Reproduce el video desde ::14 y sigue la transcripción0:14
En esta lección aprenderemos a utilizar la familia de funciones apply. 
Éstas son una familia de funciones vectorizadas, 
que nos ayudarán a aplicar, como el nombre lo indica, 
algún tipo de función sobre los vectores o sobre 
los objetos para las cuales están diseñadas. 
Como you hemos sugerido en algunas otras ocasiones, 
las funciones vectorizadas son funciones en donde 
implícitamente se piensa que la operación se hace en paralelo.
Reproduce el video desde ::50 y sigue la transcripción0:50
Una vez que hacemos ese tipo de operaciones en paralelo, 
podemos pensar entonces que tenemos una ganancia en el desempeño de la función. 
you que, si tuviéramos varios procesadores o varios "cores" en una sola máquina,
Reproduce el video desde :1:6 y sigue la transcripción1:06
este tipo de funciones toman ventaja de esa arquitectura. 
Éstas nos permiten cruzar los datos, 
de tal manera que no tengamos que utilizar bucles de manera explícita. 
Como son los For, los Whiles o los Repeats. 
Las funciones apply actúan sobre algún tipo de entrada. 
Éstas pueden ser listas, matrices o vectores.
Reproduce el video desde :1:31 y sigue la transcripción1:31
Además, que les aplican la función que entra también como un argumento opcional. 
La función más básica de las funciones apply es, justamente, la función apply. 
Ésta opera sobre rebanadas de los datos. 
Es decir, sobre subconjuntos de datos que nosotros you tenemos. 
Pueden ser rebanadas de un dataframe, 
o de una matriz, o incluso operar sobre vectores completos. 
Hay tres tipos de funciones que pueden entrar como argumento a la función apply. 
La primera, y es una de las más comunes, son las funciones de agregación.
Reproduce el video desde :2:12 y sigue la transcripción2:12
Estas pueden ser funciones que operan sobre un 
conjunto de datos y regresan un único valor. 
Por ejemplo, podemos decir la suma o la media. 
El segundo tipo puede ser una función 
de transformación o de extracción de subconjuntos. 
Como al alguno de los operadores que you hemos visto. 
you sea para acceder a índices de un vector o una matriz, 
o también de una lista. 
El tercer tipo son funciones vectorizadas que pueden regresar estructuras más 
complejas, como listas, vectores o matrices. 
Estas funciones, las funciones apply, pueden formar la base de funciones aún 
más complejas pero, lo que tienen de bonito es que 
pueden expresar complejidad muy grande en unas cuantas líneas de cógido. 
Las tres opciones más importantes de la familia apply son Apply, sapply y lapply. 
Además de que tenemos otras más que no son más que variantes de estas tres básicas. 
Comenzaremos con la función apply. 
Ésta opera sobre arreglos, como pueden ser las matrices. 
Los tres parámetros más importantes de la función apply son: X, 
que es un vector un arreglo donde se va a operar.
Reproduce el video desde :3:35 y sigue la transcripción3:35
Margin, que es una variable que nos define 
si vamos a operar sobre renglones o columnas, y la función. 
Cuando usamos margin=1, significa que estamos operando sobre los renglones, 
y cuando usamos margin=2, significa que estamos operando sobre las columnas. 
Pero también podemos pasar como parámetro a un vector c 1, 2, 
que nos indicaría que estamos operando sobre renglones y columnas. 
Antes de continuar, me gustaría hablarles de la función set.seed(). 
Ésta lo que hace es que si establecemos todos el mismo valor inicial de 
la semilla, como lo indica su nombre, todos los números aleatorios que generemos 
después de utilizar esta función, tendrán el mismo valor en todas las computadoras. 
Si no hiciéramos esto, estaríamos generando todos números aleatorios 
distintos, you que las semillas con las que se generan los números aleatorios, 
serían distintas en cada computadora que estuviéramos utilizando. 
En el ejemplo que está apareciendo en pantalla utilizamos la función set.seed 
con un parámetro igual a 100 para que, a partir de este momento, 
cuando utilicemos la función rnorm( ), que genera números aleatorios. 
Todos esos números, pseudoaleatorios en realidad, nos salgan iguales a todos 
al mismo tiempo, y pudieran reproducir este mismo ejemplo en sus computadoras. 
La función rnorm( ) lo que hace es nos regresa valores de una normal 0,1. 
Y como primer parámetro, 
es el número de valores de una normal 0,1 que queremos tener. 
En este caso, en nuestro ejemplo, 
estamos observando que estamos generando una matriz de valores pseudoaleatorios.
Reproduce el video desde :5:21 y sigue la transcripción5:21
De tamaño 5X6, es decir, cinco renglones, seis columnas. 
Ahora, supongamos que tenemos esa matriz, la llamamos x, entonces, 
si queremos encontrar la suma de cada columna, 
podemos utilizar la función apply, para encontrar esos valores de cada columna.
Reproduce el video desde :5:42 y sigue la transcripción5:42
La forma en como la aplicamos es utilizar la función apply(), 
el vector x como primer parámetro, el segundo es el parámetro margin, 
en este caso vamos a utlizar dos porque queremos operar la función suma sobre las 
columnas y, como tercer parámetro, la función suma. 
Así podemos observar que nos regresa a utilizar la función de esa manera,
Reproduce el video desde :6:7 y sigue la transcripción6:07
que es la suma de cada una de esas columnas. 
Sólo para comprobar, podemos utilizar la función sum 
sobre la primera columna del vector X.
Reproduce el video desde :6:19 y sigue la transcripción6:19
Usando los operadores de extracción de subconjuntos, y podemos ver que coincide 
con el valor del primer elemento del vector que nos regresó a la función apply. 
Lo cual nos está diciendo que la suma está siendo correcta. 
Una vez que tengamos nuestra matriz x, 
podemos encontrar la suma columna por columna de esta matriz. 
Si aplicamos la función apply. 
La podemos aplicar de la siguiente manera. 
Primero utilizamos apply, ponemos como primer parámetro la matriz X, 
como segundo parámetro margin sería igual a dos. 
Ésto significa que va a operar columna a columna. 
Y como tercer parámetro la función sum.
Reproduce el video desde :7:2 y sigue la transcripción7:02
Así nos regresaría a un vector donde cada uno de los valores 
o elementos de este vector va a ser la suma de cada una de las columnas. 
Este gráfico que estamos observando es sólo para recordarnos que, 
cuando utilizamos dos, quiere decir que estamos operando sobre las columnas,
Reproduce el video desde :7:22 y sigue la transcripción7:22
y, cuando utilizamos uno, estamos operando sobre los renglones. 
Si quisiéramos hacer esto paso por paso tendríamos que utilizar un ciclo for 
para ir iterando en cada una de las columnas y haciendo esta suma. 
Esto sería un poco complicado y alargaría mucho nuestro código. 
Es por eso que la función apply es muy útil en este caso. 
[MUSIC]

Funciones *apply: lapply / sappy

[MUSIC]
Reproduce el video desde ::14 y sigue la transcripción0:14
Ahora veremos la función lapply, esta función nos sirve para aplicarle una 
función a una lista, y además obtendríamos como resultado tambíen una lista. 
La sintaxis de la función lapply es muy parecida a la sintaxis 
de la función apply.
Reproduce el video desde ::32 y sigue la transcripción0:32
Las diferencias que hay entre ellas es que en vez de recibir un parámetro margin, 
aquí como tercer parámetro recibimos los parámetros de la función 
que estamos poniendo como argumento. 
Otra diferencia es que los objetos sobre los que puede operar 
pueden ser diferentes, 
no sólo un arreglo sino que puede también tener una lista o un dataframe. 
Y además la salida que regresa es una lista.
Reproduce el video desde :1:2 y sigue la transcripción1:02
En el ejemplo siguiente vamos a construir tres matrices. 
Y por ejemplo supongamos que queremos extraer 
la segunda columna de cada una de estas matrices que forma parte de una lista. 
Haremos la extracción de la siguiente manera, como primer parámetro 
de la función lappaly pondremos la lista mi lista. 
Como segundo parámetro el operador o función que queremos aplicar, 
es decir, el operador corchetes que es el de extracción. 
Y se tiene que pasar, en este caso en particular entre comillas. 
El tercer parámetro son los renglones y las columnas que son los parámetros 
del operador corchete.
Reproduce el video desde :1:48 y sigue la transcripción1:48
Como queremos todos los renglones, el primero va vacío y el segundo, 
como queremos la segunda columna ponemos el número dos. 
Aplicamos la función y nos regresa una lista donde cada uno de los elementos de 
esa lista es la segunda la columna de las matrices que habíamos creado al principio. 
Ahora, si quisiéramos extraer el primer renglón, 
en vez de la segunda columna, es muy claro. 
Lo único que tenemos que hacer es, en el lugar en que estaba vacío antes, 
ahora ponemos el número uno que es el primer renglón, y dejamos vacío 
el Donde debe ir la columna, porque queremos todas las columnas. 
Notemos que podríamos haber extraído un elemento de cada una de las matrices de 
esa lista, lo único que teníamos que hacer es no dejar
Reproduce el video desde :2:37 y sigue la transcripción2:37
espacios vacíos en la parte de los parámetros del operador corchete. 
Digamos que quisiéramos tomar el renglón uno columna dos, 
lo único que podríamos poner, en 1, 
2 hasta el final de la lista de parámetros del operador corchete y eso nos 
regresaría una lista de tres elementos, que es justo lo que estaríamos buscando. 
Vamos a hablar de la función sapply. 
Ésta trata de simplificar la salida de lapply. 
Es decir, lapply nos regresaba una lista, recordemos. 
Mientras que sapply trata de simplificar, 
y en vez de regresarnos una lista nos regresa un vector. 
Es decir, sapply es la función lapply pero con ciertos parámetros por omisión.
Reproduce el video desde :3:26 y sigue la transcripción3:26
Ésto es justo lo que habíamos hablado en el principio, que algunas funciones
Reproduce el video desde :3:31 y sigue la transcripción3:31
no son más que cierta variante de la función básica apply original. 
Como ejemplo vamos a comparar la salida de la función lapply con sapply. 
Digamos que queremos
Reproduce el video desde :3:44 y sigue la transcripción3:44
utilizar otra vez nuestra lista que teníamos desde el principio. 
Estas son tres matrices, digamos que quisiéramos obtener el elemento
Reproduce el video desde :3:55 y sigue la transcripción3:55
del renglón dos y la comuna uno. 
En este caso entonces el parámetro que vamos a pasar sería 2, 
1 al operador corchete.
Reproduce el video desde :4:7 y sigue la transcripción4:07
Como you hemos observado, utilizamos la función lapply de esta manera.
Reproduce el video desde :4:13 y sigue la transcripción4:13
Y lo que vemos es que la salida nos regresa una lista.
Reproduce el video desde :4:18 y sigue la transcripción4:18
Donde cada elemento de la lista, es un numerito.
Reproduce el video desde :4:22 y sigue la transcripción4:22
Pero si usamos la función sapply,
Reproduce el video desde :4:26 y sigue la transcripción4:26
simplemente cambiando el nombre de la función, con los mismo parámetros, 
podemos observar que lo que nos regresa, no es más que un véctor. 
Es decir está simplificando la salida de lapply. 
[MUSIC]
Funciones *apply: mapply / rep
[MUSIC]
Reproduce el video desde ::14 y sigue la transcripción0:14
Ahora hablaremos de la función mapply, 
como su nombre lo indica viene de multivariate apply. 
Su propósito es vectorizar argumentos para funciones que 
normalmente no reciben vectores como argumentos. 
Antes de continuar, hablaremos un poco de la función rep. 
Esta es muy utilizada en conjunto con las funciones de la familia Apply
Reproduce el video desde ::40 y sigue la transcripción0:40
el propósito de la función rep es generar un vector, 
con las repeticiones de un vector que nosotros le pasemos. 
Es decir, en pocas palabras, recibe dos vectores. 
El primer vector es el que vamos a repetir y el segundo vector nos 
dice cuántas veces se va a repetir cada uno de los elementos del primer vector. 
Por ejemplo el vector s minúscula 
no es más que un vector con los elementos uno, cuatro y ocho. 
Si utilizamos la función rep sobre el vector S, 
el segundo parámetro es un vector que tiene los elementos tres, uno y seis. 
Este nos está indicando que el elemento uno se repetirá tres veces, 
el elemento dos se repetirá una vez y el elemento tres 
se repetirá seis veces, que es justo lo que estamos observando en pantalla. 
Supongamos que queremos crear una matriz de cuatro renglones por cuatro columnas. 
Donde cada columna no sea más que la repetición 
del número de la columna en la que estamos posicionados. 
Es decir, uno, uno, uno, dos, dos, 
dos y así sucesivamente hasta llegar a la columna cuatro. 
Si queremos hacer esto con la función rep, podemos hacerlos de la siguiente manera. 
Como pueden ver, la matriz Q es creada utilizando la función rep cuatro veces, 
donde en cada una de las veces que la mandamos a llamar, 
va formando un vector que genera los elementos para la matriz Q. 
Y luego sólo pasamos las dimensiones. 
Una alternativa es usar la función mapply donde 
como primer parámetro va recibir a la función rep. 
El segundo parámetro es el número que vamos a repetir, 
pero en este caso vamos a ir iterando sobre los elementos uno, dos, 
tres y cuatro, y el siguiente parámetro es el número cuatro. 
El número de veces que queremos repetir cada uno de esos elementos del 
vector anterior. 
Es decir, va ir repitiendo el uno; cuatro veces, 
el dos; cuatro veces, y así sucesivamente hasta crear la matriz completa.
Reproduce el video desde :2:55 y sigue la transcripción2:55
Para clarificar un poco más esto, podemos ver que si ponemos un vector 
en el segundo parámetro de la función rep, dentro de la función mapply.
Reproduce el video desde :3:8 y sigue la transcripción3:08
Esto lo que va hacer, es ir iterando uno por uno, 
cada uno de los elementos de los vectores y aplicándoselo a la función rep. 
En este caso si utilizamos el vector 4:1, 
lo que hará es repetir el número uno, cuatro veces. 
Luego el número dos, tres veces. 
El número tres, dos veces. 
Y finalmente el número cuatro una única vez. 
Como esto no puede ordenarse en una matriz, nos regresa una lista. 
Como you les he dicho antes, en la práctica observaremos que las 
funciones vapply, rapply, y tapply, no son más que variaciones de 
estas tres funciones básicas de la familia apply que you hemos visto. 
[MUSIC]

Graficación con el Sistema de Base de Gráficos

[MUSIC]
Reproduce el video desde ::14 y sigue la transcripción0:14
En esta lección, cubriremos el sistema base de graficación en R. 
Este sistema cuenta con dos tipos de funciones.
Reproduce el video desde ::23 y sigue la transcripción0:23
Funciones que son de alto nivel, es decir, que generan gráficas preestablecidas. 
O funciones de bajo nivel, 
que nos permiten ir construyendo una gráfica elemento a elemento. 
Como primera función que vamos a ver, veremos la función plot.
Reproduce el video desde ::40 y sigue la transcripción0:40
Ésta es una función de alto nivel,
Reproduce el video desde ::43 y sigue la transcripción0:43
con ella podemos crear gráficas de diferentes tipos. 
Generalmente éstas son de dispersión, es decir, grafican puntos x contra y. 
Es importante que recuerden que las gráficas en el sistema base 
son en dos dimensiones. 
Esta función puede formar la base de una gráfica más compleja 
a partir de ahí podemos entonces poner encima de ella. 
Puntos, leyendas, texto o incluso otro tipo de gráficas. 
Plot, es una función genérica, es decir, 
graficará dependiendo del objeto que tenga como entrada. 
En este primer ejemplo, podemos observar cómo al llamar a la función plot, 
estamos introduciendo dos vectores de entrada.
Reproduce el video desde :1:31 y sigue la transcripción1:31
Cada uno de ellos tiene tres elementos. 
Es decir, podemos construir la gráfica tomando un elemento de un vector 
y un elemento de un segundo para construir tres puntos, y es justo lo que hace. 
Nos grafica los puntos que estamos poniendo de entrada. 
Plot además puede cambiar el tipo de caracter 
con el que va a graficar los puntos. 
En este caso se utiliza un parámetro llamado pch 
que lo que hace es cambiar el símbolo 
que voy a utilizar para graficar, justamente como lo hacemos en pantalla.
Reproduce el video desde :2:9 y sigue la transcripción2:09
Cambiamos solamente el caracter por una x, 
y en vez de ponernos un punto o un círculo, 
nos va graficando con x esos puntos que estamos pidiendo que nos grafique. 
También podemos utilizar plot para graficar por etapas. 
Es decir, podemos construir nuestra gráfica, vacía incluso, por fases. 
Y además ir agregando los elementos que necesitamos paso por paso. 
En este ejemplo vamos a generar una gráfica vacía, 
los dos vectores de entrada lo que nos definen es el tamaño de los ejes.
Reproduce el video desde :2:48 y sigue la transcripción2:48
Decimos además que el tipo de gráfica es n, esto 
le dice a plot que va ser una gráfica sin puntos, que no tiene que graficar puntos. 
Y además, ponemos un par de parámetros extras llamados xlab 
y ylab que son las etiquetas para los ejes X y Y. 
Ahora añadiremos algunos puntos 
y lo graficaremos encima de esta gráfica que generamos al principio. 
Primero generamos los vectores X y Y con tres elementos cada uno 
y luego utilizaremos la función point que lo que hace es tomar 
esos dos vectores de entrada y va graficando punto a punto. 
Una vez hecho ésto, pudiéramos querer tal vez generar una línea con 
el ajuste de una regresión lineal de esos tres puntos. 
Y ésto lo podemos hacer utilizando la función lm, ésta función lo que hace es 
recibe esos puntos y trata de ajustar un modelo de regresión lineal. 
Una vez que haga ésto, podemos guaradr ese modelo en un objeto 
y pasarle a la función abline ese modelo, para que grafique la línea que queremos. 
Si mandamos a llamar al objeto mi_linea, podemos observar que dentro de él 
se guarda la fórmula con la que se mandó a llamar con la función lm, 
y los coeficientes del modelo de regresión lineal que encontró.
Reproduce el video desde :4:21 y sigue la transcripción4:21
Éstos definen la recta que se está pintando con la función abline. 
Es importante que observemos cómo utilizamos las fórmulas, 
en funciones que generan modelos. 
En este caso la función lm. 
La fórmula nos dice cómo queremos que los puntos se expliquen 
para poder regresarnos en el modelo de regresión lineal. 
En este caso estamos pidiendo que la y, o sea los valores dependientes, 
sean explicados por medio de los valores x. 
En este caso se escribe entonces Y tilde X.
Reproduce el video desde :4:59 y sigue la transcripción4:59
Al ejecutarse lm, ésta regresa los coeficientes de la regresión, 
y se pueden guardar en un objeto. 
El objeto generalmente es de clase lm, y guarda justamente el modelo lineal. 
Regresando a la gráfica, digamos que quisiéramos graficar una línea más. 
Sólo por el puro gusto de hacerlo. 
En este caso podemos definir esta línea con la función lines, 
ésta recibe un punto inicial y un punto final 
y lo único que hacer es trazar la línea entre esos dos puntos. 
Le pasamos dos vectores, X y Y, donde tienes los valores de esos dos puntos. 
Podemos observar entonces que a llamar a líneas con dos vectores, 
tal cual definidos 1,3 y 2,3 nos genera la línea que va del punto 1,2 al punto 3,3. 
Si quisiéramos distinguir esta línea que estamos graficando con las anteriores, 
podemos entonces pintarla de un color particular. 
En este caso modificamos a la función lines, utilizando el parámetro col, 
que recibe una cadena y en la cadena a debe ir el nombre de un color en inglés. 
En este caso utilizamos la palabra green para pintarla de color verde y es justo 
el resultado que obtenemos. 
Como you dijimos, plot es una función genérica, ahora observemos qué sucede si 
en vez del punto por punto le introducimos un dataframe. 
En este caso ese dataframe es iris,
Reproduce el video desde :6:39 y sigue la transcripción6:39
que es un dataset viene internamente en R y que nos 
da varios valores de medición de las flores iris. 
Entonces si introducimos ese dataset, a plot, podemos observar 
que todos esos valores son graficados unos contra otros de manera conjunta. 
Por ejemplo, si pidiéramos los valores de sepal length y sepal width, podemos 
pasárselo a plot para que nos grafique únicamente esos dos conjuntos de puntos. 
Para guardar nuestras gráficas, podemos utilizar en R studio, la función export. 
Ésta nos permitirá, you sea guardar como una imagen, como un archivo pdf, 
o incluso guardarlo en la memoria temporalmente, 
para pegarlo en algún otro programa que quisiéramos utilizar. 
También podemos guardar nuestras gráficas utilizando la función pdf, png, 
jpeg y postcript. 
lo único que tenemos que poner como parámetro de entrada es una cadena con 
el nombre del archivo donde queremos guardar nuestro gráfico. 
Resumiendo, ahora tenemos you algunas funciones para graficar objetos en R, 
estas son la función plot, point, lines y abline.
Reproduce el video desde :8:2 y sigue la transcripción8:02
Además de que también tenemos funciones para guardar 
nuestras gráficas pdf, png, jpeg y postscript. 
[MUSIC]
Algunas Funciones Gráficas de Alto Nivel
[MUSIC]
Reproduce el video desde ::14 y sigue la transcripción0:14
A continuación revisaremos algunas funciones para hacer gráficas 
de alto nivel, es decir gráficas preestablecidas que nos dicen 
cierta información sobre los datos que estamos observando. 
Algunas que veremos serán gráficas de puntos, 
histogramas, densidades, barras o de caja. 
Hoy en las primeras funciones de alto nivel que veremos es las 
gráficas de histogramas.
Reproduce el video desde ::42 y sigue la transcripción0:42
Podemos crear histogramas utilizando la función hist, 
esta recibe un vector de valores numéricos y lo que hace es nos grafica 
el histograma tal como lo haríamos punto por punto. 
En caso de que no querramos que nos grafique frecuencias, 
lo que podemos utilizar es el parámetro freq = false 
para que nos grafique probabilidades en vez de frecuencias. 
Podemos cambiar el color de las barras de nuestro histograma utilizando un parámetro 
que you utilizamos antes, col donde le pasamos como cadena el nombre 
del color que queremos utilizar, en este caso estamos usando red, es decir rojo. 
Cuando lo utilizamos así nos grafica el histograma de color rojo. 
También es posible cambiar el número de cajas que queremos utilizar en nuestro 
histograma. 
Para eso utilizamos la función breaks, podemos observar que dependiendo de 
las cajas que utilicemos el gráfico podría ser de una forma u otra. 
Como el histograma no nos puede dar una visión mas o menos exacta de cómo se están 
comportando nuestros datos, podemos utilizar un truco para graficar 
una densidad encima del histograma y esto lo hacemos de la siguiente manera. 
En este código estamos utilizando el procedimiento por fases del que you 
hemos hablado. 
Primero pintamos un histograma y encima de él luego pintamos por medio de líneas 
los puntos que nos regresa la función de NOR que esta función 
nos regresa los valores de la densidad de los datos que estamos observando.
Reproduce el video desde :2:25 y sigue la transcripción2:25
Esta línea la podemos pintar de color azul para que sea distinguida. 
Una manera más efectiva de ver la densidad 
de unos datos es utilizando una gráfica de densidad por kernel. 
Para esto tenemos que utilizar la función density. 
A la función density lo único que tenemos que ponerle como parámetro de entrada 
es un vector numérico, como you lo hemos hecho antes. 
Una vez que introducimos ese vector numérico y mandamos a llamar a la función, 
esta nos regresará un ajuste a un kernel de manera no paramétrica.
Reproduce el video desde :3:4 y sigue la transcripción3:04
Este regreso de la función density puede ser utilizada, entonces, 
por la función plot para graficar justamente ese kernel. 
Un kernel no es más que una función que nos va describiendo 
la distribución de nuestros datos de manera no paramétrica. 
Por eso cuando mandamos a llamar a plot con la densidad de la 
función densidad, lo que observamos es que la gráfica puede tener ciertas curvas, 
no es totalmente suave. 
Las gráficas de puntos lo que nos grafican es un 
nombre y el valor que va teniendo, entonces lo único que necesita recibir son 
un vector de nombres y un vector de valores para cada uno de esos nombres. 
En este ejemplo vamos a utilizar el dataset conocido como mtcars. 
Y una columna de éste, que es mpg que nos dice el rendimiento 
por galón de gasolina en millas de los diferentes modelos de autos. 
Si mandamos a llamar esa columna y además los nombres de los coches, 
podemos utilizar la función Dotchart para generar una gráfica de puntos. 
Mandamos a llamar a dotchart primero con un argumento de 
un vector numérico con los valores de mpg y como 
segundo argumento las etiquetas para cada uno de esos valores numéricos.
Reproduce el video desde :4:31 y sigue la transcripción4:31
Finalmente veremos la función Boxplots 
que lo que hace es generarnos una gráfica de caja. 
Este tipo de gráficas lo que hace es, nos dice 
cómo se están comportando nuestros datos, unos respecto a otros. 
Boxplot recibe como parámetros un dataset o un dataframe. 
En este caso utilizaremos de nuevo mtcars, 
como las columnas de este dataset están nombradas, podemos utilizarlas 
en la fórmula que vamos a poner también como parámetro de entrada. 
En el caso que estamos observando, podemos ver que estamos tratando de explicar 
la columna mpg por el número de cilindros o llamada cyl.
Reproduce el video desde :5:21 y sigue la transcripción5:21
Entonces el boxplot que nos generará será por cada número de cilindro, 
los valores de dispersión de las millas por hora, dependiendo 
también de todos los modelos que estamos observando con ese número de cilindros. 
También como lo hemos hecho con otras funciones de alto nivel, podemos pasarle 
parámetros la función boxplot para cambiar títulos y etiquetas de los ejes. 
[MUSIC]
Parámetros en el Sistema de Gráficos
MUSIC]
Reproduce el video desde ::14 y sigue la transcripción0:14
En esta lección, veremos los parámetros del sistema de gráficos a más detalle. 
Por que you hemos observado antes que, 
cambiando algunos parámetros en las funciones de alto nivel. 
Podemos cambiar algunos aspectos de nuestros gráficos. 
Una manera de especificar las opciones de fuentes con colores, 
ejes y títulos es utilizando la función par. 
Si utilizamos la función par antes de iniciar una sesión de graficación,
Reproduce el video desde ::44 y sigue la transcripción0:44
estas opciones se guardarán durante toda la sesión. 
Este es el formato en el que podemos utilizar la función par. 
par(nombre_de_opcion = valor, nombre_de_opcion= valor, ..). 
Mandamos a llamar a par y vamos poniendo pares de
Reproduce el video desde ::56 y sigue la transcripción0:56
nombres de opciones y de valores asignados a esos nombres de opciones. 
Vamos a usar la función par con un ejemplo que you hemos hecho antes. 
Que es el histrograma de los valores mpg del dataset mtcars. 
Podemos ver que si llamamos a la función par() sin argumentos. 
Nos dará una lista de todos los parámetros que podemos modificar 
y los valores de éstos. 
Entonces, podemos guardar todos estos valores en un objeto. 
Una vez que hemos guardado los valores en un objeto, 
para quizá reutilizarlo después, podemos además cambiar estos parámetros. 
En este caso sólo cambiaremos uno, que se llama col.lab. 
Lo que hace éste es cambiar el color de las etiquetas del gráfico. 
También podemos haber cambiado el valor de col.lab a rojo 
utilizando ese parámetro dentro de la función hist. 
En particular para las funciones de alto nivel, 
podemos cambiar los parámetros directamente en las funciones. 
Estas opciones las podemos consultar 
revisando la página del manual de cada una de ellas. 
Digamos ahora que you hubiéramos hecho la gráfica como queríamos. 
¿Cómo regresamos a los parámetros por omisión que tenemos en 
nuestro sistema base?. 
Pues lo único que tenemos que hacer. 
Es mandar a llamar a la función par con el objeto en donde habíamos guardado 
todos los valores de el sistema base originalmente. 
Una opción muy importante que tenemos dentro de los 
parámetros de la función par. 
Es poder cambiar el tamaño del texto y los símbolos que van llenando nuestra gráfica.
Reproduce el video desde :2:51 y sigue la transcripción2:51
A continuación podemos observar las opciones 
y la descripción de cada una de ellas. 
Una de las más importantes quizás es cex.main. 
Ésta lo que hace es, cambia el tamaño del 
texto que va en los títulos principales de nuestras gráficas. 
Otro parámetro que es importante es 
el símbolo que se utiliza para graficar puntos. 
Estos se cambian utilizando el parámetro pch.
Reproduce el video desde :3:24 y sigue la transcripción3:24
Este parámetro puede recibir valores de dos maneras. 
Una, como un código numérico,
Reproduce el video desde :3:31 y sigue la transcripción3:31
y donde cada código numérico corresponde uno de los símbolos que están en la tabla. 
Y el otro es utilizando una cadena, como you lo hemos hecho anteriormente cuando 
cambiamos del símbolo de punto a una equis. 
Los códigos que podemos utilizar son del 1 al 25. 
En particular para los símbolos del 21 al 25 podemos cambiar, 
además, el color de la orilla y el de relleno. 
Esto se hace con los parámetros col y bg. 
Podemos cambiar también opciones para las líneas. 
Éstas pueden ser de diferentes tipos. 
Y se pueden referir a ellas por los códigos del 1 al 6. 
Además de que también podemos cambiar el grosor. 
Si ponemos dos, por ejemplo, como valor para el parámetro lwd, 
que es el referente al grosor, lo que hará es. 
Hacer el doble del grosor que normalmente se utiliza por omisión. 
Otra opción que tenemos son las fuentes. 
Para cambiar las fuentes es un poco complicado, pero podemos simplificarlo. 
Pensando en que tenemos una familia de fuentes que puede ser Sans, 
Serif, Mono y Symbol. 
Y el tipo de fuente que queremos usar que generalmente puede ser Normal, 
Bold o Italica. 
Si modificamos esos parámetros también podemos cambiar entonces
Reproduce el video desde :5:3 y sigue la transcripción5:03
la fuente que vamos a usar en los ejes, en el título principal o en las etiquetas.
Reproduce el video desde :5:9 y sigue la transcripción5:09
En este ejemplo, 
lo que haremos será probar los distintos tipos de fuentes que podemos generar. 
Para eso utilizamos la función text, donde lo único que especificamos es. 
Las coordenadas en donde queremos que nos ponga nuestro texto. 
El texto que vamos a utilizar. 
Y además le especificamos la familia de fuente que vamos a utilizar. 
En este caso utilizamos primero un valor por omisión. 
Luego sans, luego serif y luego mono. 
Podemos observar entonces en la gráfica. 
Que el valor por omisión el es de la familia Sans. 
Por último, la opción que veremos ahora será los márgenes y tamaños de la gráfica. 
Estos se pueden cambiar con las opciones mar, mai y pin. 
Dependiendo de qué opción estemos utilizando. 
Podemos usar un valor numérico como en el caso de mar 
para cambiar los márgenes o un valor en pulgadas. 
Como en mai o pin.
Reproduce el video desde :6:8 y sigue la transcripción6:08
Estos valores tienen que pasarse por medio de un vector. 
Que nos indica los márgenes de abajo, izquierda, arriba y derecha. 
[MUSIC]

Colores en el Sistema de Gráficos

[MUSIC]
Reproduce el video desde ::14 y sigue la transcripción0:14
A continuación veremos cómo se manejan los colores en el sistema gráfico de R. 
you vimos anteriormente que podemos utilizar el parámetro 
col para especificar colores. 
Puede ser especificado de tres maneras, una utilizando un índice.
Reproduce el video desde ::32 y sigue la transcripción0:32
Dos, utilizando un nombre, como you lo hemos hecho anteriormente. 
Y tres, utilizando el valor hexadecimal del color. 
Una de las maneras más simples es mandar a llamar a un índice. 
En esta tabla podemos observar como a cada color le corresponde un índice diferente. 
Podemos utilizar algunas funciones que nos regresan colores continuos.
Reproduce el video desde ::59 y sigue la transcripción0:59
Es decir, colores que están uno al lado del otro.
Reproduce el video desde :1:3 y sigue la transcripción1:03
Una de las funciones más comunes es la función rainbow, donde le pasamos 
un valor n, que es un entero y este entero 
nos dice el tamaño del vector que queremos que nos regrese. 
Este vector que nos regresará será todo un vector donde cada uno de los elementos 
de este vector, tiene un valor hexadecimal diferente para cada color. 
Las otras funciones heat.colors, topo.colors, cm.colors, 
también reciben un valor entero como parámetro, y funcionan, mas o menos, 
de la misma manera que funciona rainbow. 
[MUSIC]

Graficación con Notación Matemática

[MUSIC]
Reproduce el video desde ::14 y sigue la transcripción0:14
Muchas veces vamos a necesitar utilizar etiquetas o títulos donde tengamos que 
utilizar notación matemática. 
Es decir, que tengamos que hacer uso de símbolos y expresiones matemáticas. 
En R, podemos utilizar la función expression() para generar símbolos 
matemáticos para un título o alguna etiqueta. 
Y además combinarlo con la función paste(). 
Para poder tener texto y símbolos en una misma sentencia. 
En este ejemplo, podemos observar que utilizamos la función expression 
para generar las etiquetas de eje x y el eje y. 
En este caso, los símbolos alfa, 
beta y mu que nos permiten etiquetar estos dos ejes. 
Y además combinando con la función paste, 
podemos generar además un texto para titular nuestra gráfica. 
Que combina texto con símbolos matemáticos. 
Finalmente, podemos utilizar la función substitute( ). 
Que nos servirá para obtener le valor de una variable u 
objeto en R que nos irá a servir dentro de una función paste. 
Para generar entonces un título de una gráfica. 
Esto es muy útil, por ejemplo, 
si queremos obtener gráficas donde alguno de los parámetros es diferente. 
Así podemos generar múltiples gráficas con distintos parámetros y las 
etiquetas de éstas o los títulos pueden ir cambiando acorde a ello. 
[MUSIC]

Creación de Gráficas en 3D
[MUSIC]
Reproduce el video desde ::14 y sigue la transcripción0:14
En esta lección veremos cómo crear gráficas en tres dimensiones. 
Para esto es importante que sepan que este tipo de gráficas, 
no están implementadas en el sistema base de R, 
sino que tenemos que utilizar un paquete conocido como rgl, 
por lo que tenemos que instalar antes de poder utilizarlo este paquete. 
Lo podemos instalar de la siguiente manera, con el comando install.packages 
y pasamos entre comillas el nombre del paquete que en este caso es rgl.
Reproduce el video desde ::48 y sigue la transcripción0:48
Una vez instalado el paquete rgl, podemos utilizar la función Plot3d, esta funciona 
de manera similar a la función Plot de dos dimensiones del sistema base de R. 
En este caso como es en tres dimensiones recibe una tripleta de valores, X, 
Y y Z y una vez que recibe esta tripleta, dibuja el punto que queremos visualizar.
Reproduce el video desde :1:12 y sigue la transcripción1:12
Por ejemplo, supongamos que tenemos una serie 
de valores guardadas en tres vectores, X, Y y Z. 
Cada uno de los puntos que va graficar va ser, 
uno proveniente del vector X, para la dimensión x. 
El siguiente para la dimensión y, será el del vector Y. 
Y el siguiente punto será el Z. 
En el ejemplo, lo que estamos haciendo es solamente crear los tres vectores, X, 
Y y Z, utilizando funciones aleatorias y una función trigonométrica. 
Una vez creados estos tres vectores podemos proceder a utilizar la 
función open3d, esto lo que hace es abre el sistema 
de opengl para poder entonces pintar los puntos que queremos obtener. 
Finalmente, podemos utilizar entonces, la función plot3d, 
que recibe los tres vectores numéricos, para pintar nuestros puntos. 
Podemos observar que utilicé el parámetro col, utilizando como valor
Reproduce el video desde :2:16 y sigue la transcripción2:16
rainbow, para poder generar puntos de distintos colores. 
Además que el tipo de gráfica será de puntos, pero esto también puede cambiar, 
podemos utilizar otros tipos como puede ser líneas o esferas. 
[MUSIC]
Expresiones Regulares
[MÚSICA] [MÚSICA] 
[MÚSICA] En esta 
lección vamos a hablar 
de una herramienta muy importante conocida como expresión de regulares. 
Hasta el momento hemos visto que en el lenguaje se nos ha presentado 
en muchísimas ocasiones vectores numéricos o matrices, 
pero también hemos visto en algunas ocasiones algunos vectores con 
cadenas de caracteres, estas son muy importantes, por ejemplo, 
anteriormente you hemos utilizado cadenas de caracteres cuando leemos archivos con 
fechas que estas vienen definidas en los archivos como una cadena de caracteres. 
Sin embargo también hay otros tipos de cadenas con las que nos podemos encontrar, 
para esto R nos provee con algunas 
funciones que nos sirven para manipular cadenas de caracteres. 
Ahora veremos algunas funciones para manipular cadenas 
y finalizaremos entonces con el uso 
de las expresiones regulares para aprender a utilizar mejor estas funciones. 
La primera función que vamos a aprender a utilizar es la función grep, 
esta función toma como parámetros primero un patrón y 
el segundo parámetro es un vector de caracteres. 
Donde x es un vector de cadenas, entonces grep lo que hace es regresarnos un 
vector numérico en donde los números de ese vector 
numérico son los índices donde se encontró el patrón que estamos buscando. 
En este ejemplo lo que vemos es que el patrón que estamos buscando es hola 
en minúsculas, es importante saber que este patrón 
es sensible a las mayúsculas o minúsculas, es decir si usáramos 
hola con una mayúscula el patrón puede o no ser encontrado. 
Como segundo parámetro le estamos pasando a grep en el ejemplo un
Reproduce el video desde :2:5 y sigue la transcripción2:05
vector de 4 cadenas, entre ellas una que tiene la palabra 
hola que va en el segundo lugar de ese vector. 
Ahora si llamamos esta función nos regresa un número 2, eso significa que en el lugar 
2 de ese vector de caracteres se encuentra la cadena o patrón que estábamos buscando. 
En este otro ejemplo utilizando una H mayúscula, este patrón no es encontrado en 
el vector de caracteres y por lo tanto nos regresa un vector de tamaño 0. 
Ahora la siguiente función que veremos es nchar, esta lo único que nos dice es el 
tamaño de el vector de caracteres que tengamos, si el 
vector tiene más de un elemento entonces nos regresa un vector numérico dándonos el 
tamaño de cada uno de los elementos, de las cadenas que conforman ese vector. 
La siguiente función paste concatena 
todas las cadenas que recibe como parámetros y nos regresa una única cadena. 
Por omisión estas cadenas son separadas con un espacio en blanco, 
pero podemos hacer cambiar el comportamiento de la función usando 
el parámetro sep, justamente como lo hacemos en el ejemplo. 
Sprintf es la siguiente función que veremos, esta ensambla una cadena y 
genera una nueva cadena formateada con los valores que vayamos pidiendo, 
por ejemplo, en este caso lo que tenemos es una variable llamada i que tiene un 
valor numérico que es 9, si quisiéramos conformar una cadena que nos
Reproduce el video desde :3:47 y sigue la transcripción3:47
diera la información sobre i, lo que podemos hacer es usar la función sprintf 
y pasarle en cada lugar donde vamos a utilizar el valor numérico, 
la cadena especial de %d, 
eso significa que es de una un valor decimal y luego cerramos esa cadena y 
utilizamos comas para poner los valores de las variables que queremos utilizar, 
en este caso es i y además su cuadrado por eso ponemos i, i cuadrada. 
La función substring lo que hace es extrae una subcadena de la cadena que 
le estemos pasando, los 2 parámetros que recibe después 
de la cadena a la cual vamos a extraer la subcadena es el 
índice de inicio y de término de donde queremos que extraiga esta subcadena. 
Entonces podemos tener una frase que en este caso es R es muy útil 
y dependiendo de los valores de los 2 índices de inicio y de final, 
la subcadena resultante será diferente en cada caso. 
Ahora la función strsplit lo que hace es subdivide una cadena 
en cadenas más pequeñas dependiendo de un caracter de separación. 
Lo que estamos viendo es que pasamos una cadena que dice esta es una cadena donde 
cada una de las palabras está separada por un guión y como segundo parámetro pasamos 
ese guión, entonces lo que nos va a regresar la función strsplit es 
cada uno de las palabras de esa cadena, pero quitándole el guión, 
porque you definimos que el guión es justamente la cadena divisoria. 
La siguiente función tiene su nombre regular expression, 
la cual es regexpr, esta función recibe un patrón o una expresión 
regular como primer parámetro y como segundo parámetro un texto o una cadena. 
Lo que hace esta función es nos regresa el índice en donde encuentra la primera 
instancia del patrón o expresión regular que estamos buscando. 
está función tiene un comportamiento similar a la función anterior, 
solamente que en este caso al utilizar esta nueva función nos 
regresa los índices donde son encontrados el patrón que estamos buscando. 
Es decir nos regresa los índices donde encuentra la instancia inicial 
y subsecuentes instancias que son encontradas.
Reproduce el video desde :6:31 y sigue la transcripción6:31
Ahora sí, tenemos que explicar qué es una expresión regular. 
Las expresiones regulares o patrones no son más que una especie de comodín o 
un atajo para podernos referir a una gran cantidad de cadenas, por ejemplo, esta 
expresión se refiere a cualquier cadena que contenga a la letra b o a la letra v. 
En términos más formales una expresión regular o una regexpr, 
como se conoce en la jerga computacional, 
es una secuencia de caracteres que define una búsqueda de un patrón, 
principalmente para hacer coincidencia de patrones con cadenas de caracteres. 
Las expresiones regulares pueden ser muy ricas e incluso muy complicadas. 
El objetivo del curso no define que veamos 
a profundidad de estas pero podemos ver en particular cómo las utiliza R, 
haciendo una llamada a la función help de la palabra regexp.
Reproduce el video desde :7:31 y sigue la transcripción7:31
Aquí podemos ver todas las expresiones que nos sirven para utilizar 
expresiones regulares dentro del lenguaje con las funciones que you hemos visto. 
Además hay libros completos que te enseñan 
únicamente a utilizar expresiones regulares. 
Ahora veremos un par de ejemplos que podrían ser muy útiles 
para hacer uso de estas. 
Como you vimos en el ejemplo de la b o la v podemos usar los corchetes para 
hacer búsquedas de esas letras dentro de una cadena. 
Por ejemplo en este momentos estamos observando cómo podemos buscar algunas de 
las vocales y la primera función nos regresa el índice en 
donde encuentra por primera vez una de esas vocales y la segunda función 
encuentra todos los índices donde son encontradas algunas de esas vocales. 
En una expresión regular en R un punto nos indica un caracter simple, 
entonces cuando lo utilizamos dentro de una expresión regular 
lo que estamos indicando es que no importa qué caracter este ahí, 
cualquiera que se ponga valida esa expresión regular. 
En el ejemplo lo que estamos viendo es hacemos una búsqueda de la expresión 
regular a.i, esto nos está indicando que queremos buscar 
una cadena que empiece con a, que siga un cualquier caracter y luego el caracter i. 
Entonces nos indicará en cuál cadena va a encontrar ese tipo de patrón. 
En esta segunda parte lo que hacemos es cambiar el orden de cómo estamos buscando 
los caracteres la i y la a, y como se encuentra 
más de una vez nos da los índices en donde esta cadena fue encontrada. 
Por ejemplo, 
¿ahora qué pasaría si quisiéramos buscar un punto dentro de una cadena? 
En este caso lo que tenemos que hacer es escapar ese caracter, como el 
punto dentro de una expresión regular tiene un significado muy particular, 
entonces tenemos que escapar ese caracter utilizando la diagonal invertida, 
pero en este caso como la diagonal invertida también es un carácter especial 
tenemos que escaparla también, 
por eso utilizamos una doble diagonal invertida y luego el punto. 
Con esto estamos indicándole a R que esa expresión regular 
se está refiriendo a la búsqueda de un punto exactamente.
Graficación con ggplot2
[MÚSICA] [MÚSICA] 
[MÚSICA] Ahora 
aprenderemos un poco del paquete ggplot2.
Reproduce el video desde ::18 y sigue la transcripción0:18
Este paquete para fines prácticos nos provee con gráficos 
de alto nivel donde el usuario no tiene que preocuparse por los detalles, 
como lo hacíamos en el sistema base de gráficos de R.
Reproduce el video desde ::33 y sigue la transcripción0:33
En este, las leyendas, los tipos de fuentes y todos los detalles que son
Reproduce el video desde ::39 y sigue la transcripción0:39
llevados a cabo hasta la última minucia con el paquete base, 
no tenemos que preocuparnos por ello, porque you trae valores por omisión.
Reproduce el video desde ::49 y sigue la transcripción0:49
Estos valores por omisión son de tan buena calidad, que incluso estos gráficos 
podemos utilizarlos inmediatamente en publicaciones. 
A diferencia del sistema base de gráficos de R, 
el sistema ggplot2 funciona con base en capas, 
donde cada una de las capas va añadiendo nueva información. 
Por ejemplo, en la primera capa se pueden ver los datos crudos, 
y luego se van añadiendo capas con anotaciones o de resúmenes estadísticos. 
Este modo de trabajo es la manera en cómo se estila hacer los análisis estadísticos. 
Así que en vez de pasar demasiado tiempo concentrado en 
los detalles de tu gráfico, lo que puedes hacer aquí es 
pensar de qué manera puedes ir ajustando tus datos y los mapeos hacia 
atributos estéticos de tal manera que puedas revelar más información de ellos. 
La única función que veremos en este curso del paquete de ggplot2 
es la función qplot. 
Esta función nos permitirá hacer una gran cantidad de gráficos 
y de modificar varios atributos estéticos de estos gráficos. 
you que incluso llevar a cabo o tratar de entender 
todas las minucias del paquete, nos tomaría todo un curso entero. 
Con esta función aprenderemos a hacer diferentes gráficos, 
y una vez que sepamos qué gráficos podemos hacer aprenderemos cómo mapear variables 
a diferentes atributos estéticos, como son los colores, los tamaños o las formas. 
También podemos usar condicionamientos para dividir subconjuntos de 
nuestros datos y así poder cambiar la apariencia de los gráficos que se generen. 
Para poder llevar a cabo los ejemplos utilizaremos un data set o conjunto de 
datos, que viene con el paquete ggplot2, este se llama diamonds. 
Este no es más que las medidas y la información de calidad y precios 
de más de 54.000 diamantes. 
Como podemos observar, las columnas x, y, z, 
depth y table no son más que las medidas de las dimensiones del diamante. 
Ahora, como los datos son demasiados, 
tomaremos una pequeña muestra para hacer algunos ejemplos y en algunos otros 
utilizaremos todos los datos para poder generarlos.
Reproduce el video desde :3:27 y sigue la transcripción3:27
Esta muestra se toma de la siguiente manera, utilizando la función sample y 
pasándola a el dataframe de diamonds y 
finalmente guardándolo en un nuevo, en una nueva variable que conocemos como dchico. 
Es solo un nombre que le puse para utilizar esta nueva subconjunto de datos. 
Ahora podemos crear algunas gráficas, qplot al igual que la función plot del 
sistema base, recibe 2 parámetros iniciales que es los valores en x, 
y los valores en y, y entonces grafica la gráfica de dispersión.
Reproduce el video desde :4:9 y sigue la transcripción4:09
La diferencia con plot es que en este caso no necesitamos pasarle 
los vectores directamente, sino los nombres de las columnas del dataframe, 
y luego utilizamos el parámetro data donde especificamos 
el nombre del dataset que estamos utilizando para graficar. 
Podemos ver que hay mucha saturación por la gran cantidad de datos que hay, 
you que estamos utilizando el dataset completo. 
Ahora, si utilizamos la muestra que le llamamos dchico, 
podemos observar entonces de una mejor manera la gráfica que se genera. 
Podemos observar en el gráfico inicial que hay cierta correlación, parece ser 
exponencial y además hay ciertos lugares en donde parece hacerse estrías.
Reproduce el video desde :4:59 y sigue la transcripción4:59
Esto, el primer problema podemos tratar de compensarlo haciendo una transformación de 
las variables, es decir en vez de utilizar los ejes lineales, podemos hacer una 
transformación logarítmica de las variables y entonces estaríamos graficando 
los valores logarítmicos contra los valores logarítmicos de x y de y. 
Se puede ver que hay un poco de sobregraficación todavía, 
por lo que no podemos llevar a cabo conclusiones tan prontas. 
Es decir, todavía podemos hacer algunas modificaciones 
a nuestra gráfica para poder entender mejor qué está pasando. 
También podemos utilizar los argumentos de la variable como combinaciones de otros, 
por ejemplo en este caso que estamos viendo, las variables x, y, 
y z las combinamos para formar una única variable y las comparamos con 
la variable o la columna cara del dataset diamonds. 
Ahora hablaremos de los atributos estéticos, comenzamos por el color. 
En ggplot2 podemos mapear algún 
atributo o categoría que tenga una variable a un atributo estético, 
en este caso el color que va a ser dibujado en la gráfica. 
Por ejemplo si utilizamos el dataset dchico, 
podemos mapear la columna color que nos indica el color del diamante 
a un color distinto en la gráfica, que es justo lo que estamos observando. 
Además del color, otro atributo estético que tenemos es shape, 
shape se refiere a la forma con la que va a pintar los puntos en la gráfica. 
Por ejemplo, shape también es muy bueno para poder mapear de características 
categóricas a una característica gráfica. 
En este caso utilizando nuestro subconjunto de datos dchico, 
podemos mapear cada uno de los cortes distintos del diamante, de los diamantes 
que tenemos a una figurita distinta cuando se pinta en la gráfica. 
Así podemos observar cómo cada tipo de corte va 
formando algún tipo de grupo en la gráfica. 
¿Recuerdan cuando en la primera gráfica, cuando pintamos todos los puntos 
de nuestro dataset diamonds, estaba demasiado saturado? 
Bueno, pues el tercer atributo que vamos a ver es alpha, este nos indica 
cuántos puntos se necesitan pintar o aparecer 
en un mismo lugar para que podemos pintar un punto completamente opaco. 
En el caso que estamos observando en este momento, podemos ver que le pide 
un alpha de un décimo, es decir cada vez que se pinte un punto en un lugar, 
se pintará solo un décimo de lo que sería un punto único opaco. 
Es decir, 
necesitaríamos 10 puntos en el mismo lugar para que se pinte un primer punto. 
Notemos ahora en esta segunda gráfica, como si cambiamos el alpha 
de un décimo a un centésimo, podemos encontrar nuevos patrones que 
no eran tan claros cuando utilizábamos un alpha más grande. 
El último atributo estético que vamos a aprender a utilizar es size, 
o como su nombre lo indica en inglés tamaño. 
Este atributo lo que hace es que en cada uno de los puntos que estamos dibujando, 
dependiendo de la medida o de la categoría que estemos mapeando a la variable, 
nos pintará un punto más grande o más pequeño. 
Podemos ver que mapeando la variable table podemos 
pintar puntos de distintos tamaños. 
El particular uso de este ejemplo, no es muy bueno y no nos da nueva información, 
por lo que quizá no sea conveniente utilizarlo.
Reproduce el video desde :9:3 y sigue la transcripción9:03
Antes de continuar tenemos que hacer algunas consideraciones estéticas 
para tratar de generar las mejores gráficas. 
Como you se habrán dado cuenta, algunas variables mapean mejor
Reproduce el video desde :9:16 y sigue la transcripción9:16
a ciertos atributos estéticos de mejor manera. 
Por ejemplo, color y la 
forma o shape se mapean muy bien a variables categóricas. 
Mientras que tamaño o size trabaja mejor con variables que son del tipo continuo. 
A veces la cantidad de datos puede hacer una gran diferencia y you 
vimos que podemos usar el alpha para poder cambiar 
la saturación mayor o menor, dependiendo del número de puntos que tengamos. 
Si esto no nos ayuda, 
entonces podemos tratar de subdividir los grupos de las variables 
que se forman en una sola variable con una técnica especial conocida como faceting. 
Este atributo nos permite crear una tabla, donde podemos subdividir en grupos. 
Por ejemplo, como lo estamos viendo en este momento,
Reproduce el video desde :10:15 y sigue la transcripción10:15
si queremos ver cómo se comporta la variable carat contra la variable price 
y le pedimos que nos haga el faceting por color, 
entonces por cada color de diamante nos va pintando el carat contra 
el price, o el peso del diamante contra el precio. 
Entonces, podemos observar cómo se va comportando 
para cada uno de los diferentes colores de diamantes. 
Esto nos permite la comparación visual inmediata. 
En una primera instancia, la función qplot nos sirvió para crear gráficas de 
dispersión, es decir valores x contra valores y. 
Este comportamiento puede ser modificado utilizando los geoms 
o geometric objects, que no son más 
que una descripción del tipo de objeto que queremos utilizar para graficar. 
Haremos una revisión de los geoms disponibles que tenemos con qplot. 
En principio, el primero y el que se utiliza 
por omisión es point, que es justo lo que utilizamos en un principio, 
valores x contra valores y, y los que nos dibuja es un puntito. 
También podemos utilizar otro geom conocido como smooth, 
este lo que hace es que ajusta una curva a los puntos que estamos pintando, 
además de que también nos dibuja el error estándar de esta curva. 
Una característica de smooth es que podemos especificar 
qué tipo de ajuste queremos para la curva, puede ser de regresión lineal, 
o incluso métodos más sofisticados como los splice. 
Otros geoms importantes que vamos a ver son el jitter y boxplot. 
Jitter nos permite analizar en cajas cómo se están dispersando 
nuestros puntos, dependiendo de las variables que queramos observar. 
Si usamos el geom boxplot, este nos graficará 
una gráfica de caja donde podemos observar la distribución de nuestros datos 
divididos por las categorías que nosotros querramos observar. 
Otros 2 geoms que son muy importantes y que están fuertemente ligados 
son line y path. 
Line nos dibuja una línea entre 2 puntos, como si fuera uno seguido del otro, 
y esta gráfica va generándose de izquierda a derecha. 
Mientras que path lo que va haciendo es puede tomar cualquier dirección, 
de izquierda a derecha, de derecha a izquierda. 
Es por eso que line se usa mucho para graficar series de tiempo, 
como la que estamos observando en pantalla. 
También es importante notar que en este ejemplo, 
el dataset que estamos utilizando es otro. 
En este, lo que estamos observando es el cambio de un precio en el tiempo. 
Finalmente podemos generar gráficas en una sola dimensión. 
Esto cuando por ejemplo queremos observar cómo se está comportando la distribución 
de cierta variable en nuestro conjunto de datos. 
Hay 3 muy importantes, la primera es histogram, 
que es justamente la que estamos observando en este ejemplo. 
En esta utilizamos el geom histogram para generar el 
histograma de la variable carat.
Reproduce el video desde :13:49 y sigue la transcripción13:49
Además de esta, también existen freqpoly que nos genera un polinomio de 
frecuencias, y finalmente density, que nos genera una gráfica de 
la densidad de nuestros datos, una gráfica suave de la densidad de nuestros datos. 
Funciones Matemáticas y Utilitarias
[MÚSICA] [MÚSICA] [MÚSICA] 
R provee una gran cantidad de funciones 
para hacer operaciones matemáticas, 
estadísticas, de álgebra lineal, 
de conjuntos, e incluso algunas operaciones utilitarias. 
En esta lección aprenderemos qué tipo de funciones podemos acceder 
y además cómo podemos utilizar estas para llevar a cabo simulaciones. 
Los primeros tipos de funciones que veremos son las funciones matemáticas. 
Por ejemplo, la función exponencial, que lo que hace es recibe un vector numérico 
o un valor numérico y nos regresa el número e elevado a ese valor numérico. 
También está la función logarítmica que hace exactamente lo mismo, 
recibe un vector o un valor numérico y nos regresa el logaritmo en base e 
y también la función en base 10 del logaritmo, que son muy parecidas. 
Además también tenemos la función raíz cuadrada que saca la raíz cuadrada 
del número que introduzcamos o de todo el vector completo, 
también la función abs o valor absoluto que nos encuentra el valor absoluto del 
vector o número que estemos observando, también las funciones trigonométricas, 
las 6 básicas, seno, coseno, tangente, secante, 
cosecante y cotangente, y también las funciones mínimo y máximo, 
que nos encuentran el mínimo en un vector y el máximo en un vector completo. 
También tenemos las funciones which.min y which.max que nos indican 
el índice en donde se encuentra el valor mínimo y el valor máximo.
Reproduce el video desde :1:55 y sigue la transcripción1:55
Además, de que también tenemos las funciones pmin y pmax 
que reciben varios vectores, y entonces va sacando renglón a renglón
Reproduce el video desde :2:7 y sigue la transcripción2:07
el valor mínimo o máximo de ese conjunto de vectores, es decir nos 
regresa un vector con los valores mínimos del conjunto de varios al mismo tiempo. 
También tenemos un par de funciones que you hemos usado antes, sum y prod, 
estas reciben como entrada un vector y lo único que hacen es 
regresan la suma o el producto de todos los elementos de ese vector. 
En esa misma línea cumsum y cumprod son 2 funciones que hacen más o menos lo mismo, 
la primera lo que hace recibe un vector y nos regresa un vector donde 
cada uno de los elementos va acumulando la suma 
elemento a elemento de todos los elementos del vector original, 
mientras que cumprod lo que va haciendo es ir acumulando pero la multiplicación 
de los elementos elemento a elemento en ese vector inicial. 
También tenemos las funciones round, ceiling y floor. 
Estas lo que hacen es redondean al entero más cercano, pero depende de cada una. 
Round lo hace dependiendo del elemento más cercano numéricamente, 
mientras que floor lo que hace es redondea pero 
al entero hacia abajo y ceiling redondea al entero hacia arriba. 
Por supuesto el vector o valor numérico que va a recibir 
es un número que puede ser decimal. 
Finalmente una última función que veremos es la función factorial, 
esta lo que hace es calcula el factorial de x. 
Por lo tanto, el vector que tiene que recibir es un vector de valores 
enteros o al menos numéricos que estén redondeados a 0. 
Ahora veremos algunas funciones para álgebra lineal. 
you nos hemos topado un poco con el álgebra lineal porque trabajamos en 
general con vectores o matrices, pero también hemos visto que 
podemos multiplicar un escalar, es decir un valor numérico por un vector completo 
y también que podemos llevar a cabo la operación de multiplicación entre matrices 
utilizando el operador %*%. 
Otra función importante es crossprod, 
esa lo que hace es recibe 2 vectores con la misma dimensión y nos regresa 
el producto punto de esos 2 vectores, es decir que el producto punto se 
define como la multiplicación elemento a elemento de 2 vectores, 
y al final sumas todos los elementos para tener un único valor numérico. 
Una función muy importante dentro de las funciones de álgebra lineal 
es la función solve, esta lo que hace es resuelve sistemas de ecuaciones lineales 
o incluso puede resolver matrices inversas. 
Por ejemplo supongamos que tenemos el siguiente sistema de ecuaciones lineales,
Reproduce el video desde :5:11 y sigue la transcripción5:11
x1 + x2 igual a 2 y menos x1 + x2 igual a 4. 
Esto lo podemos expresar de manera matricial de la siguiente forma, 
primero una matriz 1, menos 1, 1, 1, multiplicada por un vector columna x1, 
x2 y eso igual a un vector columna 2, 4. 
Ahora, si quisiéramos resolver este sistema 
en R lo haríamos de la siguiente manera. 
Creamos nuestra matriz por supuesto, y luego generamos también nuestro vector 
de salida, que es el vector y 2,4 y luego simplemente decimos solve 
la matriz x y el vector columna y. 
Esto nos regresará la solución de ese sistema, 
en ese caso x1 igual a menos 1 y x2 igual a 3. 
La segunda llamada solve donde solo recibe como entrada la matriz x, 
nos dará la matriz inversa de x, y podemos ver o comprobar que es correcto 
you que al multiplicar la matriz inversa de x, es decir solve x con
Reproduce el video desde :6:23 y sigue la transcripción6:23
la matriz original x entonces nos dará la matriz identidad. 
Otras funciones que son útiles dentro del álgebra lineal es la función t 
que lo que nos da es una transpuesta de una matriz, la función 
qr que nos encuentra la descomposición qr de álgebra lineal de una matriz, 
y finalmente la función chol que nos encuentra la descomposición de Cholesky. 
Estas funciones nos pueden servir mucho para agilizar algunos cálculos cuando 
queremos encontrar matrices inversas. 
Otras 2 funciones que son muy útiles son det, 
que nos encuentra el determinante de una matriz y eigen, 
que nos encuentra los eigenvectores y los eigenvalores de una matriz. 
Esas son muy útiles porque si tuviéramos que escribir el código para ellas 
haciéndolo serialmente sería 1, muy complicado y 2, 
también nos haría el código demasiado largo. 
Otra función muy importante dentro de las funciones de álgebra lineal es la función 
diag, que nos ayuda a extraer la diagonal de una matriz cuadrada. 
En este ejemplo podemos ver que podemos extraer la diagonal de la función, 
de la matriz x y una vez creada podemos crear una función 
con esa diagonal usando también la función diag de nuevo, 
solo que nos llenará de ceros todo lo que no sea la diagonal. 
Otra manera de utilizar la función diag es indicándole con un valor numérico las 
dimensiones que queremos, es decir si utilizamos diag2 o diag3, 
los que nos generará es una matrix de 2 por 2 o de 3 por 3 identidad donde 
solo la diagonal está llena de unos y lo demás completamente lleno de ceros. 
La última función que veremos en las funciones de álgebra lineal es la función 
sweep, lo que hace esta función es hacer operaciones de barrido sobre matrices. 
Esta funciona muy parecido a la función apply donde teníamos que indicar 
el modo, que iba a ser si va a ser por renglones o por columnas. 
En el ejemplo lo que estamos observando es que estamos haciendo una operación renglón 
a renglón, y como le estamos pasando un vector, el vector 1, 2, 3, y una matriz, 
la matriz b, lo que va a hacer es operar la operación que decimos al final, 
es decir la suma, renglón por renglón, es decir una vez que se lleva 
a cabo va a ir sumando el elemento de ese vector que estamos poniendo el 1, 2, 3, 
a cada uno de los renglones que estamos observando de nuestra matriz.
Reproduce el video desde :9:5 y sigue la transcripción9:05
Ahora veremos un par de funciones que son utilitarias. 
Una de ellas pues es la función sort. 
Esta recibe un vector como argumento y nos regresa el mismo vector pero ordenado, 
por omisión nos regresa el vector ordenado de forma creciente, 
pero podemos utilizar el parámetro decreasing 
igual a true para que nos lo haga de forma decreciente. 
Luego tenemos la función choose donde recibe 2 parámetros n y k, 
ambos enteros donde nos da el posible 
números de subconjuntos de tamaño k de un conjunto de tamaño n. 
Esto es muy común cuando se están tratando de encontrar combinaciones por ejemplo. 
También podemos llevar a cabo operaciones con conjuntos, 
donde nuestros conjuntos pueden ser vectores. 
Las 3 primeras funciones que vamos a ver son la unión, 
que lo que hace es une el conjunto x con el conjunto y, la función intersección 
que nos regresan los elementos que son comunes a ambos conjuntos y la función 
diferencia que nos da la diferencia de conjuntos de 2 vectores. 
Las últimas 2 operaciones de conjuntos que vamos a ver son setequal, 
que esta nos regresa un valor lógico, verdadero o falso, 
donde nos da verdadero si los 2 vectores son 
iguales y falso si estos tienen algún elemento o varios elementos diferentes. 
También está el operador que también es una función en realidad, 
%in% que nos dice si el elemento que estamos poniendo primero
Reproduce el video desde :10:51 y sigue la transcripción10:51
pertenece al vector que estamos teniendo del lado derecho. 
Ahora veremos las funciones de distribuciones estadísticas en R. 
R prácticamente tiene toda función de distribución estadísticas conocida. 
Principalmente, las que son base de un curso de probabilidad básico. 
La convención para nombrarlas es usar un prefijo y luego el nombre de la función. 
Hay 4 prefijos, r para designar aquellas funciones que están generando 
números aleatorios de esa distribución, p para designar aquellas funciones que están 
designando la acumulada de esa función de distribución, 
d para las funciones que nos están dando la densidad de masa 
de esa función, y q para designar aquellas funciones donde estamos 
queriendo encontrar un cuantil de esa función de distribución. 
En realidad hay una gran cantidad de ellas, 
como las que estamos observando en este momento. 
Pero, solo para ejemplificar una, 
utilizaremos por ejemplo la función rnorm donde antes
Reproduce el video desde :12:1 y sigue la transcripción12:01
ponemos la semilla de esta función set.seed que you habíamos hablado antes, 
y luego generamos un número, un gran número de funciones, 
de valores provenientes de una normal con parámetros 0 y 1, 
es decir la media 0 y la varianza 1. 
Y una vez que tengamos eso sacamos la media de ella 
y encontraremos que el promedio es muy cercano a 1. 
En este otro ejemplo, 
estamos también utilizando la función qnorm para encontrar los cuantiles. 
En el primero, buscamos un valor de un cuantil que nosotros 
you conocemos para una función normal con parámetros 0 y 1. 
Sabemos que el cuantil 0.5, 
es decir donde la probabilidad se ha acumulado a 0.5 nos va a dar 0. 
Solo para comprobarlo, utilizamos la función qnorm y podemos observar que sí, 
efectivamente el valor es 0. 
Para un valor donde la probabilidad se ha acumulado más, es muy cerca a 1, 
podemos ver que después del valor 1.64 esa 
probabilidad you se ha acumulado, al igual también por ejemplo cuando nosotros 
pedimos el valor de la función cuando ha acumulado la probabilidad 1, 
podemos ver que es infinito, y cuando es 0, es menos infinito. 
Es decir, la función qnorm nos está dando los cuantiles correctos. 
[MÚSICA] [MÚSICA]

Simulación
[MÚSICA] [MÚSICA] [MÚSICA] 
[MÚSICA] Ahora veremos cómo todas 
estas funciones, o algunas de ellas 
nos pueden servir para llevar a cabo la resolución de un problema de simulación. 
Supongamos por ejemplo que quisiéramos encontrar la probabilidad de que 
pudiéramos tener al menos 5 caras al lanzar 7 veces una moneda. 
Sólo para recordar, podemos ver que el lanzamiento de una moneda 
puede ser modelado con una variable aleatoria, Bernoulli. 
Es decir, donde tiene como parámetro p, que es la probabilidad de éxito. 
En este caso, la probabilidad de éxito para nosotros va a ser que caiga una cara. 
Y el 1 menos p, la probabilidad de fracaso, que es que salga el otro, o cruz. 
En este caso entonces, una vez que you recordamos la variable aleatoria 
Bernoulli, podemos entonces utilizar la variable aleatoria binomial, que 
lo que nos dice es, el número de éxito en n repeticiones de experimentos Bernoulli. 
Esta variable aleatoria la podemos modelar con 
una función que you tenemos en r, que se llama rbinom. 
No olviden que cuando n es igual a 1, en la función rbinom 
o cualquiera de la familia binom, el experimento que estaríamos observando 
es el lanzamiento de una moneda, es el caso más simple. 
Pero, también podemos utilizar para nuestro caso, n igual a 7, 
que son los 7 lanzamientos de la moneda. 
Ahora vamos a generar esos números aleatorios utilizando la función rbinom. 
Observemos que si lleváramos a cabo ese experimento una única vez, 
tendríamos que llamar a rbinom de la siguiente manera. 
El primer parámetro es el número de veces que se va a llevar a cabo ese experimento. 
Luego, 7 nos dice el número de lanzamientos de 
monedas que se va a llevar a cabo y el tercer parámetro que es 0.5, 
en este caso, un medio es, la probabilidad de éxito. 
Como estamos hablando del lanzamiento de una moneda y como la moneda 
estamos suponiendo además que es una moneda justa. 
Es decir, la probabilidad de éxito o de fracaso es un medio, 
entonces por eso ponemos 0.5 en ese parámetro.
Reproduce el video desde :2:36 y sigue la transcripción2:36
El resultado de esa llamada rbinom 
es como si hubiéramos hecho una única vez ese experimento. 
Ahora si quisiéramos sacar la proporción de éxitos que tendríamos, 
tendríamos que llevar a cabo ese experimento una gran cantidad de veces. 
Esto se puede justificar de manera matemática, con la ley de los grandes 
números, pero en este caso lo podemos hacer de manera intuitiva, 
aplicando ese mismo experimento muchas veces. 
En este caso muchas veces va a significar hacerlo 100 mil veces. 
Una vez teniendo los resultados de esas 100 mil veces del experimento, 
lo que podemos hacer es encontrar ahora, cuántos de esos 
experimentos tuvieron 5 veces o más éxito. 
Es decir, donde el vector de resultado sea mayor o igual a 5. 
Una vez que tengamos este vector que va a ser un vector de lógicos, podemos entonces 
encontrar la proporción de verdaderos contra falsos, sacando la media.
Reproduce el video desde :3:44 y sigue la transcripción3:44
Esto es posible you que, recordemos, 
los valores lógicos falsos se pueden tomar como 0 
y los valores verdaderos se pueden tomar como 1 cuando hay coacción. 
Al final, al haber encontrado este promedio, 
lo que estamos encontrando entonces en realidad es la probabilidad de que al 
llevar a cabo el lanzamiento de una moneda 7 veces, ¿cuántas veces nos caería cara?
Reproduce el video desde :4:14 y sigue la transcripción4:14
Al menos 5 veces o más. 
[MÚSICA]
Depuración
[MÚSICA] 
[MÚSICA] 
[MÚSICA] Es muy común que quizá nos aparezcan errores en nuestro código.
Reproduce el video desde ::19 y sigue la transcripción0:19
A veces podemos intentar resolver esto 
utilizando funciones como print para encontrar dónde pudiera estar el error. 
En R tenemos un conjunto de herramientas que nos pueden ayudar a poder 
localizar mucho más rápido un error y, además, también hay algunas técnicas que 
nos pueden ayudar a depurar cuando you hay un error de manera más rápida.
Reproduce el video desde ::44 y sigue la transcripción0:44
Es justo eso lo que veremos en esta lección. 
Este es el flujo que se debe llevar a cabo para hacer una depuración. 
En primer lugar tenemos que darnos cuenta que hay un error, 
muchas veces ni siquiera sabemos eso. 
Esto va a depender de los tipos de mensajes de error que nosotros 
enviemos, por ejemplo, 
cuando no estemos introduciendo los parámetros correctos a una función. 
Una vez que sepamos que hay un error tenemos que saber bien cómo reproducirlo.
Reproduce el video desde :1:13 y sigue la transcripción1:13
Esto es un poco complicado a veces porque, como you hemos visto, 
muchas ocasiones, las funciones que estamos utilizando no son completamente 
terminísticas sino pueden ser aleatorias. 
Entonces, puede ser complicado encontrar un error en ese tipo de funciones. 
Para eso es recomendable utilizar 
funciones como set seed para llevar siempre a cabo el mismo, 
los mismos números aleatorios que pueden llevarnos a reproducir el problema. 
Una vez que you encontramos el problema y lo pudimos reproducir, 
entonces, debemos encontrar en qué parte del código 
está llevándose a cabo ese error y, una vez habiéndolo encontrado, 
tenemos que arreglarlo y volver a probar para ver que se haya resuelto. 
Una consideración importante cuando estemos escribiendo código en R y que you 
hemos hecho énfasis anteriormente es que las funciones tengan un tamaño adecuado, 
que no sean demasiado largas porque esto lo que provocan 
es que cuando haya algún tipo de problema sea difícil encontrarlo.
Reproduce el video desde :2:17 y sigue la transcripción2:17
Por ejemplo, 
hemos visto que es muy bueno que las funciones no pasen de una página, y si 
pasan más de una página podemos entonces repartirla en funciones más pequeñas donde 
así nos será más fácil encontrar errores o problemas cuando estos se presenten. 
En R Studio tenemos 3 herramientas que nos pueden servir 
muchísimo para llevar a cabo la depuración de nuestro código. 
La primera es Traceback, que nos ayuda a regresar los pasos que 
se han llevado a cabo hasta que encuentra el que nos está ocasionando el problema.
Reproduce el video desde :2:56 y sigue la transcripción2:56
Luego, también dentro de R studio hay otro que se conoce como Rerun and Debug, 
que lo que hace es que vuelve a correr el código de tal manera que cuando se empiece 
a ejecutar, uno puede ir llevando a cabo, paso por paso, las líneas del código 
de tal manera que pudiéramos probar línea por línea, y Breakpoints, 
que lo podemos mandar a llamar utilizando la función Breakpoints dentro de R Studio. 
Por ejemplo, en esta definición de las funciones f, g, h e i, 
podemos ver que no son más que las llamadas de una detrás de otra y, 
cuando llamamos a la función f con el parámetro 10, nos genera un error. 
En R Studio se genera entonces un error en color rojo y nos da 2 opciones. 
La primera es Show traceback, que es justamente el uso de la herramienta 
traceback, y la otra es Rerun and debug, que es justamente este modo interactivo 
donde nosotros podemos llevar a cabo la corrida paso por paso de nuestro código. 
Si damos clic en la opción Show traceback, lo que podemos ver es que nos 
aparece toda la pila de las llamadas de las funciones que se han llevado a cabo. 
Esta se debe leer de abajo hacia arriba. 
Si la leemos así, podemos llegar al 
punto donde se rompe el programa o donde se encuentra el error. 
En este caso, justamente, cuando se llama la función i. 
En el caso de que el error hubiera sido provocado en alguna función que hubiera 
sido cargada con la función source, este modo de R Studio nos permitiría darle 
clic al archivo donde están definidas las funciones que nos están dando el error. 
A veces esto es suficiente para poder encontrar el error y arreglarlo, 
pero otras esto no es posible. 
Para eso, necesitamos entonces, 
tal vez un modo más interactivo, que nos permita entonces 
poder llevar a cabo una depuración más fina de lo que está pasando. 
A este modo o herramienta para llevar a cabo este tipo de trabajo 
se el conoce como un debugger o depurador. 
Este nos permite correr el programa o la parte donde estamos teniendo el error 
paso a paso, para que así podamos nosotros hacer 
pruebas dentro de este modo para tratar de poder localizar el error también. 
Si nosotros queremos entrar en ese modo, entonces tenemos que darle clic a la 
opción de Rerun and Debug. 
En este modo nosotros tenemos 5 comandos básicos, 
que pueden ser utilizados con las teclas. 
El primero es n, que nos permite ejecutar el siguiente comando; s, 
que da paso a la siguiente función para ejecutarse; f, 
que termina el bucle actual o la función que se estuviera ejecutando; c, 
que continúa ejecutándose normalmente y q para salirse de esa consola. 
El uso de esta consola y sus comandos podrán manipularlos en la práctica. 
Para finalizar este tema de depuración hablaremos de la programación defensiva. 
Esta es una aproximación a la escritura del código de tal manera 
que los errores se generen pronto, para así, una vez que tenemos un error, 
se genere un mensaje que nos indique de manera clara que algo está fallando. 
Esto se puede hacer de 3 manera. 
La primera es checar que los parámetros de entrada sean los correctos. 
Es muy común, por ejemplo, que cuando tenemos funciones que no sean 
vectorizadas, estar utilizando dentro de estas funciones funciones que sí lo son. 
Entonces tenemos que checar los valores de entrada que sean de manera correcta, 
utilizando ifs o la función stop para parar cuando haya un error de este tipo. 
La segunda es evitar la evaluación no estándar. 
Esto es muy común cuando utilizamos funciones como subset, transform o with, 
que son funciones muy útiles cuando estamos utilizándolas de 
manera interactiva porque hacen suposiciones sobre los tipos pero 
que no mandan muchos mensajes informativos cuando pudiera haber una falla. 
Es por eso que debemos evitarlas cuando estemos escribiendo código 
que va a ser utilizado por alguien más. 
La tercera es evitar funciones que nos regresen diferentes tipos de salida. 
En este caso, es muy común que nos suceda cuando utilizamos el operador corchete 
o la función sapply. 
Para evitar esto, cuando utilicemos el operador corchete, podemos utilizar el 
parámetro Drop igual a False para que no nos haga un tipo de cambio de clase. 
Por ejemplo, cuando hacemos una extracción de una matriz y nos regrese un vector. 
De la misma manera podemos utilizar la función vapply, 
que es más estricta que sapply cuando se haga uso de ella dentro de una función. 
Una última recomendación es que tomemos en cuenta que cuando estamos 
escribiendo código en modo interactivo, 
lo que queremos son resultados rápidos, de tal manera que podamos corregir también, 
algún error o algún detalle al vuelo, pero, cuando estemos escribiendo código 
debemos evitar hacer suposiciones sobre lo que nuestro usuario quiere hacer. 
Es decir, debemos enviar mensajes de error o advertencia 
tan pronto nos percatemos de que pudiera haber un error de este tipo.
Reproduce el video desde :8:38 y sigue la transcripción8:38
Este es el último video en nuestro curso, 
por lo que quisiera agradecer a ustedes la atención y el tiempo invertido en este. 
Espero que una vez que hayan tenido los objetivos cumplidos puedan llevar a cabo 
análisis de datos más sofisticados. 
También a todo el equipo de producción 
y de diseño instruccional para poder lleva a buen puerto este curso. 
Y finalmente, quisiera agradecer a Coursera por haberme daplado esta oportunidad 
de poder compartir con ustedes un poco el conocimiento en esta área. 
Muchísimas gracias. 
[MÚSICA] [MÚSICA]