Introducción a Data Science: Programación

Estadística con R

Week 1

Instalación de Herramientas.
Presentación del Curso

video: ​Bienvenida

https://d3c33hcgiwev3.cloudfront.net/2ae9bdAuEeWTMw4udNdVLQ.processed/full/36
0p/index.mp4?Expires=1567123200&Signature=Jvg2ToQ0rMnKSaHFYwXuf4CyfQeyJlz
IdGkwYoo5ViRHDkCi6tDErSyrcn1TMNJYM6PizsBazgfqjCKdRAHnvMk5lZACs-y~am0h
wvTnRRhsL~6EdDJDYHOXmcYCy~h7UUqq8-twv0IF2lPV4V1VDm75srn89L0jmhqvE0l
QN5M_&Key-Pair-Id=APKAJLTNE6QMUY6HBC5A

Bienvenidos al curso de ​introducción a la programación estadística con R.​ En este curso

aprenderemos a utilizar el lenguaje de programación R. El cual nos sirve para ​manipular,
limpiar, graficar y obtener información de datos cuantitativos.​ Además, aprenderemos
un poco de lo que trata la ​programación estadística​.

La ​programación estadística​ no es más que las t​ areas​ que se requiere llevar a cabo. Para
poder ​obtener información y llevar a cabo inferencias con los datos cuantitativos, por
medio de herramientas computacionales.

En este curso aprenderás a utilizar el lenguaje de programación R, el cual es considerado la

lengua franca de la estadística. Además aprenderemos a instalar las herramientas
necesarias y el lenguaje en tu computadora. Aprenderemos las ​bases necesarias​ para que
puedas ​analizar, manipular, limpiar y graficar datos cuantitativos​.

Además de que utilizaremos una herramienta conocida como R Studio, que es el ambiente
de desarrollo principalmente utilizado por los programadores estadísticos.

Este ​no es un curso de estadística​. Pero si tienes nociones de ella o si has tomado un
curso antes, será suficiente para que puedas seguir el paso del curso.
Te preguntarás cómo avanzaremos en este curso.
Nos enfocaremos primero en aprender los ​básicos del lenguaje de programación R.
Luego aprenderemos los distintos ​tipos de datos​ que hay en el lenguaje.
Y finalmente, comenzaremos a escribir nuestros primeros​ programas o scripts​ en él.

Después aprenderemos algunas ​estructuras de control​. Con esto, también aprenderemos

algunas​ operaciones básicas con datos​ y finalmente esto nos permitirá, que podamos
aprender a escribir ​funciones​. La forma básica de operaciones en el lenguaje.

Después haremos ​perfilado de tus programas​ y además con esto aprenderás a ​mejorar
el desempeño de ellos​. Notarás que no seremos demasiado minuciosos en los detalles del
lenguaje.

Pero al terminar el curso, tendrás la ​capacidad de poder atacar problemas más

complejos buscando tú mismo la información.

Un aspecto importante y que quiero que tengan en cuenta es que, ​aprender a programar
no es una tarea que puedes hacer en en un par de semanas, o en un mes o en un año. Es
una habilidad que se va adquiriendo ​a través de los años.

Les recomiendo mucho leer un artículo de Peter Norvig, que se llama Enséñate a programar
durante diez años ​ ​http://loro.sourceforge.net/notes/21-dias.html

Básicamente lo que indica es que la habilidad de la programación es algo que tienes que ir
cultivando. Y que cometiendo errores además, puedes ir aumentando tu habilidad para
lograrlo. Espero que lo disfrute.

Instalación de R en Windows XP

Instalación de R en Linux (Fuentes)

Instalación de R en Linux (Binarios)

Instalación de R en Mac OS X

Instalación de R Studio y Paquetes en Windows

Instalación de R Studio y Paquetes en Linux

Instalación de R Studio y Paquetes en Mac OS X

Instalación de prácticas
https://d3c33hcgiwev3.cloudfront.net/_a8e7db3920c3a71f6e9e3ef6265454d2_instalaci_n_pr
_cticas.pdf?Expires=1567123200&Signature=C5iVnCFKdJSyuCjRfb7M-enc~XMxiNux1TTO
Drj1txfM14RfoQ5P5jVyysLSvKp3hrLma0lPJGYyFmlD8p8fcaGYnANKS7CjH5eTfiz~-7lyQ8rc
XDQFHLNVl25ne~P1u5oi5MeWHFIe1~8sk6j-IA3NkUL4WCLDV8whC6q90cY_&Key-Pair-Id
=APKAJLTNE6QMUY6HBC5A

install.packages("curl", dependencies = TRUE)

install.packages("httr", dependencies = TRUE)
install.packages("swirl", dependencies = TRUE)
select_language()
#Elegir español (9: spanish).
install_course_github("ifunam", "programacion-estadistica-r")
#Después de la instalación en Mac OS:
#Una vez instalado el curso, cada vez que desees acceder a las prácticas debes ingresar:
Sys.setlocale("LC_ALL", "en_US.UTF-8")
swirl()
#después seguir las instrucciones y seleccionar el curso "programacion-estadistica-r".
#Sys.setlocale("LC_ALL", "en_US.UTF-8") te permitirá ver los acentos.
#Desinstalar el curso
#Si quieres desinstalar el curso, puedes usar uninstall_course("programacion-estadistica-r")
en cualquier momento.

#Cuando estés en el indicador de R (>):

# | -- Teclear skip() te permite saltar la pregunta actual.
#| -- Teclear play() swirl te deja experimentar con R; swirl no hará caso de lo que teclees...
#| -- HASTA que ingreses nxt(), vas a recuperar la atención de swirl.
#| -- Al teclear bye() swirl terminará. Tu progreso se guardará.
#| -- Al teclear main() te regresa al menú principal de swirl.
#| -- Teclear info() muestra estas opciones de nuevo.

Bibliografía
En este vídeo repasaremos un poco la ​bibliografía​ que nos podría ser útil, es importante
hacer notar que este curso no está basado en un libro en particular, pero hemos encontrado
que los siguientes títulos son de mucha utilidad.

En principio el libro de Peter Dalgaard, ​"Introductory Statistics with R"​, es muy bonito
porque nos da una introducción al lenguaje R, además de un acercamiento a muchísimos
conceptos de estadística.
Luego también tenemos el libro de Norman Matloff ​"El arte de la programación en R"​ o
"The Art of R Programming"​, es una referencia muy, muy importante.

Además también del libro de Joseph Adler, "​R in a Nutshell​", que prácticamente es la
biblia​. Donde se ve a muchísimo detalle cómo está creado el lenguaje R.

Y también tenemos el libro de Winston Chang, "​The R Graphics Cookbook​", que nos da
una visión general de las capacidades gráficas del lenguaje R. Y finalmente el libro de Paul
Teetor, llamado​ R Cookbook​, que nos enseña a hacer algunas tareas que son muy, muy
comunes en el manejo y la manipulación de los datos.
Introducción al Lenguaje

Carlos Ernesto López Natarén

En esta ​primera semana​, tendrás tus primeros pasos en el lenguaje, entenderás ​que son
los objetos, las clases, los tipos de datos​ y podrás​ leer y escribir datos ​a distintas
fuentes y tipos de archivos.

Video: Historia e Introducción a R

https://d3c33hcgiwev3.cloudfront.net/WXE20tXKEeWjTxJlqDdk5Q.processed/full/360p/index
.mp4?Expires=1567123200&Signature=Nk6OdzcGP2xp61uM8JH1dtfTqaRFt9~BAD7AKndd
k-lhpM0pWayD8IG6S0BR~KjHlX1YJgDL1Wl-58vWB0xu0zmi8EzB8GskOAyamiM9fJerwhxs
ve54CdxYmvdRlZHC6Vikhe2FKxM9AZLUDhmzVq2igPTisn0mU~~MKPkwlow_&Key-Pair-Id
=APKAJLTNE6QMUY6HBC5A

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 ya 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. Acaba utilizando prácticas de
programación.

El lenguaje ​S​ entonces ya 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 ya bien definido. Con el que podían
añadir nuevas técnicas por medio de la definición de estas. 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. 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 ya 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. 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.
3.4.3 (2017-11-30)

Las características del lenguaje R son muchísimas, y la mayoría de estas son tomadas
como ventajas del mismo lenguaje. La principal y que es la razón por la cual fue adoptada
ampliamente, es que su ​sintaxis​ es muy similar al lenguaje ​S​. La ​semántica​ también es
muy parecida al lenguaje ​S.​

¿Cuál es la diferencia entre sintaxis y

semántica?
Semántica ~ significado

Sintaxis ~ Representación simbólica

Entonces, dos programas escritos en diferentes idiomas podrían hacer lo mismo

(semántica) pero los símbolos utilizados para escribir el programa serían diferentes
(sintaxis).

Un compilador verificará su sintaxis por usted (​errores en tiempo de compilación​), y

derivará la semántica de las reglas del idioma (asigne la sintaxis a las instrucciones de la
máquina), pero no encontrará todos los errores semánticos (​errores en tiempo de
ejecución​, por ejemplo, calcular el resultado incorrecto porque el código dice agregar 1 en
lugar de agregar 2).

https://laingenieria.info/questions/395/cual-es-la-diferencia-entre-sintaxis-y-semantica

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.

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.

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 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. 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​, ya sea ​de la comunidad de usuarios​ para que se genere o
tendrías que ​escribirlo tú mismo.
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​. Además de que no es un sistema que es ideal para todo.

No hay bala de plata tanto en los análisis 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.​ 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 ya
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 ​http://www.r-project.org​.

Podemos ver en pantalla la interfaz básica de R ​(línea de comandos->R) ​y como ya 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 ya hemos
nombrado antes ​http://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.

Video: ​Obteniendo Ayuda

https://d3c33hcgiwev3.cloudfront.net/cRMsA9XKEeWbSgqxBCBhEw.processed/full/360p/in
dex.mp4?Expires=1567209600&Signature=HTIC6MEuHoHx0OFH~tZjUJQkVFr9lQknt5e1m
ANwtJbqoymj5bonQgal6TrrC5SFuinAovrTcdBVkI2bGn-PUASZJm5dGfNkQUg5epH1Ogcw0
qJz6i6TuOs-AmcWTidMXOUU5dRKedCw9jz6A0bza2A~puEPzX4fP1tmv6zeSlc_&Key-Pair-
Id=APKAJLTNE6QMUY6HBC5A

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 ya sepa. O ir a l​as
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 ya hechas y respondidas.
Incluso están rankeadas por la calidad de las preguntas y la calidad de las respuestas.

El sistema de ayuda de R,​ como ya 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​(help=”package”)​ 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.

>> Aquí está la parte de RStudio, donde se ve la salida de read.table. ​help(“read.table”)

La primera función que vamos a utilizar es ​help()​. ​Help() ​r​ecibe 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 ​help("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​. 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()​, poniendo
como parámetro help, ​library(help="grDevices"), library(help="e1071")

Si nosotros sabemos el tipo de ayuda que estamos buscando, podemos buscar esa ayuda
directamente desde la biblioteca que estamos utilizando. 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 está 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. ​vignette("svmdoc")

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 ya tuvo respuesta. O finalmente puedes leer alguna de las
FAQ​, que son listados de preguntas frecuentes que ya 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
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 a​ vanzado​, ​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. 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. C​uando 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 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​ r-help-es@r-project.org​.
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.

LEER y ESCRIBIR DATOS

Introducción de datos desde terminal y fichero

Para introducir datos desde la propia ventana de comandos se utiliza la función scan():

> scan()

1: 1

2: 2

3: 3

4:

Read 3 items

[1] 1 2 3

Como vemos, cuando queremos dejar de introducir datos, pulsamos un ENTER de más.

Si queremos guardar el resultado en una variable, escribiríamos algo como:

> datos = scan()

La funcion scan toma la siguiente forma:

scan(file=" ", what = numeric(), n, sep, ...)

Veamos algunos ejemplos:

 datos = Recuperaría un hipotético fichero de datos, denominado datos.txt
scan("c:\\datos\\datos.txt" situado en el directorio C:\DATOS, y lo almacenaría en la variable
) datos

> nombres = Crea un vector de 3 cadenas de caracteres.

scan(,what=character(),3)

1: pepe

2: paco

3: pipo

Read 3 items

> nombres

[1] "pepe" "paco" "pipo"

Supongamos que tenemos un fichero denominado ​pocosdatos.txt ​ y que lo queremos leer y

convertir en matriz:

> datos = scan("c:\\cursoada\\pocosdatos.txt",sep=",")

Read 9 items

> datos

[1] 1 2 3 0 1 2 4 5 6

Observemos que hemos puesto sep="," para indicar que los datos vienen separados por comas.

Para darle forma de matriz:

> datos = matrix(datos,ncol=3,byrow=T)

> datos

[,1] [,2] [,3]

[1,] 1 2 3

[2,] 0 1 2

[3,] 4 5 6
Lectura de tablas desde ficheros

A veces nos será de utilidad la función read.table().

Supongamos que tenemos un fichero llamado ​edadaltura.txt​, y que queremos leerlo con una

sola función.

> datos = read.table("c:\\cursoada\\edadaltura.txt")

> datos

edad altura

paco 20 174

pepe 22 180

kiko 19 170

> colnames(datos)

[1] "edad" "altura"

> rownames(datos)

[1] "paco" "pepe" "kiko"

Como vemos, el sistema automáticamente asigna nombres a filas y columnas.

La estructura general de la orden es:

read.table(file, header = F, sep = "", ...)

Si deseamos especificar que la primera fila contiene los nombres de las variables

pondremos header=T.

La orden análoga para escribir una tabla en disco es:

write.table(x, file = "", append = FALSE, quote = TRUE, sep = " ", row.names = TRUE, col.names =
TRUE)

Escritura de ficheros de texto

Aparte de utilizar la función write.table() , podemos utilizar la función write().

Supongamos que queremos guardar en un fichero el contenido de un vector:

> x<-c(1,2,3,4,5)

> write(x,"c:\\cursoada\\x.txt")

El contenido del fichero x.txt será el vector 1 2 3 4 5

Si lo que queremos es escribir una matriz con este procedimiento, hay que ser más cuidadosos.

Creamos una matriz para probar:

> x<-matrix(1:9,ncol=3,byrow=T)

>x

[,1] [,2] [,3]

[1,] 1 2 3

[2,] 4 5 6

[3,] 7 8 9

La escribimos en el fichero x.txt:

> write(t(x),"c:\\cursoada\\x.txt",ncol=ncol(x))

La función write() actúa escribiendo una columna de la matriz cada vez, por lo que

primero deberemos trasponer. El número de columnas en este caso es 3, pero

indicando ncol(x) nos aseguramos de acertar siempre.

Tareas de programación: Lección de swirl: 1. Obtener

Ayuda

Una vez instaladas las prácticas, completa la ​lección 1 (Obtener ayuda).

Los detalles sobre la instalación los encuentras en la semana 1 en la lectura "Instalación de

prácticas"

Para enviar los resultados de tu práctica, al final de ésta deberás utilizar ​tu correo
electrónico de registro en Coursera y generar el código (token)​. Para más información
consulta el apartado ​"Cómo enviar"​ que encontrarás en esta misma página
OBJETOS Y TIPOS DE DATOS.

Video: ​Operaciones Básicas y Números

https://d3c33hcgiwev3.cloudfront.net/HBkaydAmEeWcuAr30b9I0w.processed/full/360
p/index.mp4?Expires=1567123200&Signature=gyqOrbBfo4TCrAS373y0nIWwSFvOydU
WY7MF5eEAJg8qZ2Bf3HEdJeWWkXo9reKDVLw7hhnM~3xH7uUv-GkzPZwc-wC8TW3
MV0UJ3H-qSO8xiXN3jQjOolZ-uDvT5zCb8DybzYgBsXFWogptNkzcfdDDnWjPU3ndrhV
WnUzYB5Y_&Key-Pair-Id=APKAJLTNE6QMUY6HBC5A

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 a funciones, expresiones, o nombres de llamadas o de
objetos​.

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 ​código del cuerpo​ de ellas y el ​entorno​ en que están siendo ejecutadas.

R cuándo 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. Y además de esto también puedes hacer operaciones lógicas.
El ​vector​ es el objeto mas simple en R, es por eso que las operaciones generalmente están
basadas en ese objeto mínimo, una de las primeras 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.

Tenemos operaciones que podemos llevar a cabo con conjuntos, también podemos tener
operaciones para llevar a cabo secuencias determinísticas o aleatorias.

En R ​casi todo es un objeto​ incluyendo las ​funciones y las estructuras de datos​, para
ver que objetos tenemos en un momento determinado lo que podemos usar es la función
ls().

Al escribir el nombre de un objeto en R​, esté ​regresa su contenido​. Muchas veces

podríamos tener objetos que ya tenemos en la ​carpeta de trabajo​ es entonces que
podemos utilizar la función ​attach()​ para poder volver a cargar esos objetos de nuevo en
memoria.

R tiene 5 tipos de objetos básicos o atómicos aunque en realidad son 3:

-character​. caracteres y cadenas.
-numeric​. Cualquier número, incluso flotante
-integer​. Ocupa menos memoria.
-complex​. Números complejos.
-logical​. FALSO y VERDADERO.
El objeto mas básico que puede contener algunos de los tipos anteriores 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 cómo un vector de objetos de diferentes clases. Puedes crear objetos
de tipo vector, con la función ​vector()​.

Los números en R generalmente se tratan como objetos numéricos ​(tipo numeric)​. Si

queremos explícitamente un ​entero ​(integer)​ necesitamos usar el sufijo ​L​.

valores NA=Not Available, NaN=not a number(0/0), inf=infinito (1/0).

video: Atributos, Entrada y Coerción

https://d3c33hcgiwev3.cloudfront.net/jYYxA9XKEeWjTxJlqDdk5Q.processed/full/360p/index.
mp4?Expires=1567123200&Signature=d1FBkQnoAV77YJLAbUJAiF~dejVmw4EL-YfatNtloH
Ix8MudgncmPwsscPefLvlG7cbrtV-tJsyWpnAXEURL9gWNxxsUcXmO3FNWSGC7gj2TS6e7
RqsQZMof3PgEtvJcqin-MdzHXowTmxEIdwUOYfDmQqIlh0xSvCtH3J1pu~0_&Key-Pair-Id=
APKAJLTNE6QMUY6HBC5A

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 ya 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 ya 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. ya 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 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. 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 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.
y<-c(1.7, “a”)
El primer elemento que estamos tratando de concatenar es el valor numérico 1.7, el
segundo es el carácter “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 carácter “1.7”. Que no es más que la
representación en carácter 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 ​(implícita)​. Es decir, nosotros
no decimos qué tipo estamos esperando.
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. 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. En este ejemplo, el vector x es un
vector que cuenta los valores del 0 al 10, con incrementos de uno en uno.
x<-0:10.
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
carácter y como entero.
a<-as.numeric(x)
b<-as.logical(x)
c<-as.character(x)
d<-as.integer(x)
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 carácter 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. Lo que hará es generarnos valores NAs. NA es un tipo muy
particular que significa Not Available. Es decir, es un valor faltante.
video:​Matrices

https://d3c33hcgiwev3.cloudfront.net/nkryVNXKEeWjTxJlqDdk5Q.processed/full/360p/index.
mp4?Expires=1567123200&Signature=kbdPAioGni9II8lqz5~Mg-33LwP3UZUEGyBCKGy6lH
o2wfV49IACnHOLqV~yCJZkCJw2DmlFbRiqbMkBzz1FxEiIdYXwKmDoD0t~zPfKkxY8-Qjhah
lNoJGfRwNLYgnzSh1g1Tcyy6KmWK5DB87LnVC2QrybDWFB-cheHsm5XfA_&Key-Pair-Id=
APKAJLTNE6QMUY6HBC5A

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 ya 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 en R, 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 convertir en una
matriz, es utilizando la función ​dim( )​, 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 estos 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. ​(En realidad te genera una
advertencia de que los vectores no son del mismo tamaño y el mas chico comienza a
repetirse hasta completar el mismo tamaño del mas grande)

video: ​Precedencia Operaciones Vectoriales

https://d3c33hcgiwev3.cloudfront.net/CJIPutAnEeWcuAr30b9I0w.processed/full/360p/i
ndex.mp4?Expires=1567123200&Signature=WyOyPDVJrIP-Ap9SXf7aMRKZq8G~sTpp
WMF3htCupj13jjNq3wBOAPooIaAksEObm0WGzQg-GvL2bbbAzqc4l1S~c4iav6eaCb23
a2VM27lD2h271RGTh246yTtjkY4Usd-DT6dFHnyfjsNHyupw8eYMIdhVCK0~RueXoXrLF
4E_&Key-Pair-Id=APKAJLTNE6QMUY6HBC5A

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 barra.
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
ya 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. 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.
>​x>8
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.
video: ​Manejo de Fechas Tiempos

https://d3c33hcgiwev3.cloudfront.net/05huSNmIEeWaQgoI1qH58w.processed/full/360p/inde
x.mp4?Expires=1567123200&Signature=emYu4ZOLK1JahVJdoyTF~I2mCE~icgMtEX1TOT
dHOPFNSj71dBV4mdb9K6aBKA2UGJZA78sQoaF7x9~98HM0kHfrLNkYmkW5VPXoNUmc
u7luXhxbPlJO9jtpM95YiOK3Kn709Gp0heoD~vc0SSqEkO-LcIxe04trLdc7iBDpUbA_&Key-P
air-Id=APKAJLTNE6QMUY6HBC5A

Ahora aprenderemos cómo manejar las ​fechas y los tiempos​ en R, estas tienen ​clases
especiales dentro del sistema y nos permiten llevar a cabo operaciones numéricas y
estadísticas con ellas. Manejar fechas y tiempos en R puede ser bastante sutil, además de
que la ​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
tiempo​.
Hay dos ​tipos​ de datos que vamos a estudiar para el tiempo en R, uno de ellos es
POSIXct,​ en esté el tiempo es el ​número de segundos​ desde el ​1ero de Enero de 1970​,
cualquier fecha ​posterior​ a está se representara con un numero ​positivo​ y cualquier fecha
o tiempo ​anterior​, será representada con un numero ​negativo​.

Estos datos nos muestran el orden en que aparecen los elementos de un ​vector (lista​) que
es de tipo ​POSIXlt​, el otro ​tipo​ de dato 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 representa internamente es muy diferente a cómo se imprimen en pantalla, esto
puede hacer que las conversiones puedan llegar a ser complejas.

Para obtener el tiempo actual podemos usar la función ​Sys.time()​, está la podemos guardar
en un objeto y podemos ver que el objeto usando la función ​typeof(), ​es de tipo ​double​,
pero cuándo imprimimos el objeto tal cual, el objeto se imprime cómo una cadena de texto
con la fecha y la hora actual.
Usando las funciones as.POSIXct() y as.POSIXlt() se puede convertir el valor de tiempo en
diferentes formatos.

Por ejemplo utilizando la función ​as.POSIXlt()​ del objeto que acabamos de crear con la
función ​Sys.time()​ podemos ver que al imprimirla nos da igual la misma cadena, pero si
pedimos el typeof() cómo es de tipo ​POSIXlt​, es de tipo lista, podemos tratar de acceder a
los nombres de la lista con la función ​names()​, pero estos son nulos porque en la definición
de esté formato no existen no existen los nombres para está, pero podemos acceder a los
elementos de la lista usando el operador [ [ ] ].
Si tuviéramos un tipo de dato de tiempo y quisieramos convertirlo a cadena de tal manera
que pudiéramos guardar esa cadena en un archivo, tenemos que utilizar la función
strftime() ​esta recibe como primer parámetro un objeto de tipo tiempo ya sea POSIXct o
POSIXlt y luego la descripción de la cadena que queremos generar, en el ejemplo se usa
una notación con % seguido de una letra que define ya sea: el año, mes, día, hora, minutos
y segundos.

Qué sucedería si quisiéramos hacer lo contrario? Es decir de una cadena de caracteres

poder generar un objeto que tenga tipo POSIXct o POSIXlt, esto lo podemos hacer usando
la función ​strptime()​ está funcióna similarmente a strftime(), recibe un objeto que es el
objeto que queremos convertir a tipo tiempo y cómo segundo parámetro la definición de la
cadena cómo 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 dias o segundos entre dos tiempos.

Adicionalmente a los dos tipos de datos observados, también tenemos el tipo de dato ​Date
que se refiere a fechas, la unica diferencia entre esté y los de tiempo, es que en esté se
toman diferencias en dias y no en segundos, cómo sucede con POSIXct o POSIXlt, es esté
caso podriamos convertir una ​cadena de caracteres​ a un tipo ​Date​, usando la función
as.Date().

Podemos utlilizar el parámetro ​origin​ pasandole a ese parámetro una ​cadena​ con una
fecha para ​definir una fecha de origen​ y a partir de ahi podemos llevar a cabo operaciones
entre objetos que son del mismo tipo ​Date​.

Una función muy útil en R para manejar las fechas es la función ​format()​ está recibe un
objeto de tipo fecha o tiempo y cómo segundo parámetro podemos pasarle el formato en
que queremos que nos regrese la cadena que queremos formar.
Finalmente podemos llevar a cabo operaciones o comparaciones entre distintos objetos de
tipo Date, una vez que estos están en el formato interno de R, por ejemplo la comparacion >
y <, tiene sentido cuándo comparas un par de fechas.
video: ​Listas, Factores, Valores Faltantes y Dataframes

https://d3c33hcgiwev3.cloudfront.net/lvcA-tAnEeWGUwp-0F6aaQ.processed/full/360p/index.
mp4?Expires=1567123200&Signature=bSWC399ZWtK~U5UouarFNy6SY46-L6Yd9UX2-aZ
FhjbLZh41ehxNNyG8c5alLfbyyIPnlDUY0DAqMeVuKvfF089c4w4uIZYOnuvGeT7gDuyk4Tou
eqN0nfODxbxFPz4hGqRwWffYBglu80g9rE~WDsEUc0z0w6Yq~mox1lqibLw_&Key-Pair-Id=
APKAJLTNE6QMUY6HBC5A

Otro de los objetos 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.

Imagen

Pueden observar que en la función lista ​list()​ 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​.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 y
​ es
aparece en segundo.

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​. É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. 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 N
​ aN​ es ​not a number,​ que ya vimos como podemos
también generar un valor de este tipo.

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​. 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 i​s.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.

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. 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()​. La 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 ya 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 ya 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 pasándole una lista o asignándole una lista a este
atributo. Donde cada uno de los elementos van a ser vectores de los tamaños de cada
dimensión de la matriz.

Tareas de programación: Lección de swirl: 2. Objetos

Tipos de Datos y Operaciones Básicas
video: Subjuntos de Datos
https://d3c33hcgiwev3.cloudfront.net/6xb8zNmIEeWW0gqmcN3p3w.processed/full/360p/ind
ex.mp4?Expires=1567123200&Signature=QhX4zd-~oDNiuw79jJSPxf-sA1NJqTSpHC8xKkm
B011DyVOHORFl9XohI6YvewQYIHkGQh51u295fuUWG-xQg28~h4VmEoXBWPU9ZXhVlq
NwcHUtglmHZIs3WjloUEs2kWLv84LChSBHU1Q9i3gZa2I-XQ5gRij8o4ZadRDIjys_&Key-Pai
r-Id=APKAJLTNE6QMUY6HBC5A

En esta lección lo que aprenderemos es a ​sacar (obtener) un subconjunto de datos de

algún objeto o variable que ya tengamos en memoria. Y el cual probablemente sea muy
grande como para poder utilizarlo completamente. (O la solución del problema solo
requiere una parte de los datos)

Generalmente, este ​tipo de objetos (los subconjuntos obtenidos) 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 (del)
que estás extrayendo.

Los ​dobles corchetes [ [ ] ] que ​extraen elementos de una lista o un dataframe (o de

una matriz) . Y donde la clase (tipo) que te va a regresar no necesariamente tiene que
ser de tipo lista o dataframe o (matriz).

Y finalmente el ​símbolo de pesos $​ que ​extrae elementos de un dataframe.

Imagen

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. 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​. 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 ya 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. É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.
É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, cómo 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. Si mandamos a llamar, usando sólo corchetes podemos pasar de nuevo 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. 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 cuando 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.

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 ya 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 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. 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 ya 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.

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 cómo
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, esté
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.
Tareas de programación: Lección de swirl: 3.
Subconjuntos de Datos
Escribir funciones es una de las bases de la programación y del análisis de datos,
esto es útil para esconder complejidad que muchas veces tiene que ser repetitiva,
es decir, nos facilita la elaboración de programas y el análisis.Para poder crear una
función necesitamos abrir RStudio, crear un nuevo script de R:

Después tenemos que definir qué hará la función, teóricamente se le conoce como:
Especificación de la función que es la descripción formal de las capacidades de la función y
la interacción con el usuario.
Guia para el estilo de código
Reyes de Jesús Luis rodolfo

Aprenderemos una guía para el estilo de código. Este es importante 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 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 inventes tu código.
Indentar no es más que colocar los espacios en blanco necesarios para hacer el código más
legible.
Puede incluso mostrar al lector el flujo del programa, sin necesidad de otra cosa.
un ejemplo sin indentar seria:

pone los comentario en la misma línea, más de una asignación en la misma línea, esto lo
vuelve más apretado y difícil de entender, pero si vemos este otro ejemplo, el código es más
entendible

cada comentario va en una línea, las asignaciones en diferentes, para saber que se asigna
a que y que datos recibe cada variable y la llave en otra parte.
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 en tab width le damos el ancho que

queramos tener de preferencia 8

En la imagen con el
código podemos ver que los espacios están bien dados, haciendo más entendible y legible el
código para los demás.

otra recomendación muy importante es limitar el código a 80 caracteres

si una función resulta demasiado larga es mejor simplificar para un mejor entendimiento a los
próximos programadores que la deseen ver, siguiendo con la filosofía unix, Donde cada
comando hace una única cosa, pero lo hace muy bien.

Conociendo bien esto podremos adoptar una manera de programar, incluyendo la manera en la
que nombras las funciones y modifcas las variables
un stilo muy utilizado es el google style

https://google.github.io/styleguide/Rguide.xml
https://docs.google.com/document/d/1C_iqJkBSed5KlNpC4m3Jh29tUiC6TsIxXm-Zn
XF3PuM/edit#heading=h.km843nkdz5jm

https://www.coursera.org/learn/intro-data-science-programacion-estadistica-r/lecture/
c3Qkv/funciones-apply-mapply-rep

FUNCIÓN MAPPLY.

Viene de multivariate apply.

Su propósito es vectorizar argumentos para funciones que

normalmente no reciben vectores como argumentos.

Esta es muy utilizada en conjunto con las funciones de la familia Apply

El propósito de la función ​rep()​ es generar un vector,

con las repeticiones de un vector que nosotros le pasemos.

Es decir, 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.

Si 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.

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.

función ​mapply()
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.

Si ponemos un vector en el segundo parámetro de la función ​rep()​, dentro de la
función ​mapply()​.

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​.
 Parámetros en el Sistema de Gráficos
Presentación del curso
https://docs.google.com/document/d/1C_iqJkBSed5KlNpC4m3Jh29tUiC6TsIxXm
-ZnXF3PuM/edit?usp=sharing

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.

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 queramos 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.

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.

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.

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.

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.
Desarrollo del módulo, paso a paso.
Estructuras de control
Dejan controlar el flujo de un programa dependiendo si se ejecutan las condiciones o no de
esta estructura.

También permiten llevar a cabo tareas de manera repetida o alguna operación.

Tipos:

-Condicionales (IF,else)

-Bucles de repeticion(for)

-Bucles de condición(while)

-Bucles infinitos(repet)

-Romper un blucle (break)

-Saltarse un bucle (next)

IF, ELSE

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.

FOR

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.

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.

for funciona también con números:

BUCLES FOR ANIDADOS

WHILE

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.

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.

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.

BREAK

Podemos utilizar un break para romper ese bucle y continuar con el camino del flujo del
programa.

NEXT

Para saltarse los pasos de algún bucle.

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.

FUNCIONES

Las funciones son los bloques de construcción de análisis más complejos , estás se crean
utilizando la función especial llamada ​function(), ​y cuando se crean se guardan como un
objeto de R con clase tipo “fuction”