Aprenda programación en R (tutorial y ejemplos) | Introducción gratuita

¿Quieres aprender R , pero no sabes por dónde empezar? ¡Este es el tutorial que estabas buscando!🙂

Soy Alejandro Lugón, el fundador y autor principal de Estadisticool , y en esta página proporcionaré una introducción detallada al lenguaje de programación R para principiantes.

El tutorial consta de estos temas:

¿Qué es la programación R y para qué se utiliza?

R es un lenguaje de programación y software que se está volviendo cada vez más popular en las disciplinas de estadística y ciencia de datos.

R es un dialecto del lenguaje de programación S y fue desarrollado por Ross Ihaka y Robert Gentleman en el año 1995. Se lanzó una versión beta estable en el año 2000.

El software R es completamente gratuito y su comunidad lo desarrolla en colaboración ( software de código abierto ): cada usuario de R puede publicar nuevos paquetes complementarios.

La ideología de código abierto de la programación R refleja un gran contraste en comparación con la mayoría de los entornos de programación tradicionales (p. ej., SAS, SPSS, Stata, etc.), donde el desarrollo del software está en manos de un equipo de desarrollo pagado.

 

Por qué debería aprender el lenguaje de programación R (pros y contras)

¡Hay muchas razones por las que deberías, o no deberías, aprender R! La siguiente lista proporciona una descripción general de algunas de las ventajas y desventajas más importantes del lenguaje de programación R.

Los profesionales:

✅

✅

✅

✅

✅

✅

✅

✅

✅

✅

Los contras:

❌

❌

❌

❌

❌

Es posible que ya haya notado que soy un gran admirador de R, por lo que, en mi opinión, ¡definitivamente es uno de los mejores lenguajes de programación para dominar! Una vez que conozca los conceptos básicos, este lenguaje de programación será cada vez más fácil de usar.

Explicación de la interfaz R & RStudio

Es importante entender la diferencia entre R y RStudio :

  • R es el lenguaje de programación . Puede ejecutar sus programas R directamente a través del símbolo del sistema o terminal.
  • RStudio es un entorno de desarrollo integrado (IDE), es decir, una interfaz para el lenguaje de programación R que facilita la escritura y ejecución de scripts.

Si es un programador avanzado, o si está ejecutando R en un servidor, es posible que desee utilizar R sin la interfaz de RStudio. Sin embargo, hoy en día casi todo el mundo usa la interfaz de RStudio para programar en R, y te recomiendo que lo hagas también.

Descargar e instalar R y RStudio es bastante sencillo. Puede descargar el lenguaje de programación R aquí , y puede descargar RStudio aquí .

Asegúrese de instalar R antes de RStudio, porque de lo contrario, la instalación de RStudio mostrará un mensaje de advertencia.

Una vez que haya instalado R y RStudio, básicamente nunca tendrá que volver a abrir R. Todo el trabajo futuro se realizará directamente en RStudio.

Echemos un vistazo a los diferentes componentes de la interfaz de RStudio. A continuación, puede ver una captura de pantalla de una sesión típica de RStudio:

 

Explicación de la sesión de RStudio

Como puede ver, la interfaz de RStudio se divide básicamente en cuatro paneles diferentes :

primer panel

El panel superior izquierdo contiene el script R. Esta es la ventana donde normalmente se escribe y ejecuta todo el código de programación R. En este ejemplo específico, estamos creando dos objetos de datos llamados x e y, y dividimos x por y.

Segundo Panel

El panel superior derecho muestra el entorno global . En esta ventana encontrará todos los objetos de datos y funciones que ha creado en la sesión actual de R. En este ejemplo específico, hemos creado los objetos de datos x e y.

Tercer Panel

El panel inferior izquierdo es la consola RStudio y muestra el código R ejecutado, así como la salida correspondiente. En este ejemplo específico, hemos dividido x por y y, por lo tanto, la consola RStudio devolvió la salida 2.

Cuarto Panel

El panel inferior derecho muestra todos los paquetes complementarios de R que he instalado en el pasado. Este panel se puede cambiar a otros contenidos, como la documentación de ayuda de R y las salidas gráficas (más sobre esto más adelante).

En la parte restante de este tutorial, mostraré cómo usar estos diferentes paneles del IDE de RStudio en acción .

¡Vamos a sumergirnos en los ejemplos de programación R!

Manipulación de datos en R

Antes de saltar a los ejemplos de programación: he publicado un extenso tutorial de introducción al lenguaje de programación R como un suscriptor especial de 10K en el canal de YouTube de Statistics Globe .

Este tutorial ilustra los siguientes ejemplos de programación R en formato de video. En caso de que prefiera aprender viendo y escuchando en lugar de leyendo, puede consultar el curso de video gratuito a continuación:

Miniatura del botón de consentimiento de contenido de YouTube

El código R utilizado en este video se puede encontrar aquí .

Sin embargo, también encontrará todo el código de programación R, así como explicaciones detalladas sobre este código a continuación.

Entonces, pasemos a la primera sección: ¡ manipulación de datos en R !

La manipulación de datos suele ser el primer paso al crear un nuevo programa en R. Por lo general, es necesaria como preparación para la visualización y el análisis de los datos.

Para ello, primero tienes que saber que el lenguaje de programación R proporciona diferentes tipos de datos .

En la primera parte de este tutorial, mostraré cómo crear sus propios datos en R (más adelante, también aprenderá cómo importar datos externos a R).

¡Hagámoslo!

 

Creación de diferentes estructuras de datos

El siguiente código de programación R muestra cómo crear un objeto vectorial en R. Los vectores son secuencias de elementos de datos de la misma clase.

Para crear un objeto vectorial de este tipo, tenemos que aplicar la función c. Dentro de la función c, tenemos que especificar los elementos del vector que debe contener nuestro vector:

vec_1 <- c ( 1 , 1 , 5 , 3 , 1 , 5 )                                               # Crear objeto vectorial 
vec_1                                                                      # Imprimir objeto vectorial 
# [1] 1 1 5 3 1 5

Eche un vistazo al código R anterior y su salida. Como puede ver, hemos creado un nuevo objeto vectorial llamado vec_1. Este vector contiene seis elementos enteros, es decir, los números 1, 1, 5, 3, 1 y 5.

El siguiente tipo de datos que quiero mostrarles son los marcos de datos . Los marcos de datos son objetos bidimensionales con un cierto número de filas y columnas.

Vamos a crear un marco de datos de este tipo en R:

datos_1 < -datos . cuadro ( x1 = c ( 7 , 2 , 8 , 3 , 3 , 7 ) ,                             # Crear cuadro de datos 
                     x2 = c ( "x" , "y" , "x" , "x" , "x" , "y" ) ,
                     x3 =  11 : 16 ) 
data_1                                                                     # Imprimir marco de datos

 

tabla 1 lenguaje de programación de tramas de datos

 

En la Tabla 1 se muestra que hemos creado un nuevo data frame llamado data_1. Este marco de datos consta de seis filas y las tres columnas (o variables) x1, x2 y x3. Las columnas x1 y x3 contienen números; la columna x2 contiene caracteres.

El tercer tipo de objeto de datos que quiero explicar son las listas . Las listas contienen diferentes elementos de lista (o elementos), y cada uno de estos elementos de lista puede contener un tipo de datos diferente.

Por ejemplo, el siguiente código crea una lista con tres elementos de lista. El primer elemento de la lista contiene un rango de 1 a 5, el segundo elemento de la lista contiene nuestro objeto vectorial vec_1 y el tercer elemento de la lista contiene nuestro marco de datos data_1:

lista_1 <- lista ( 1 : 5 ,                                                        # Crear lista
               vec_1,
               data_1 ) 
list_1                                                                     # Imprimir lista 
# [[1]] 
# [1] 1 2 3 4 5 
# 
# [[2]] 
# [1] 1 1 5 3 1 5 
# 
# [[3]] 
# x1 x2 x3 
# 1 7 x 11 
# 2 2 y 12 
# 3 8 x 13 
# 4 3 x 14 
# 5 3 x 15 
# 6 7 y 16

En resumen: el código anterior ha ilustrado tres de las estructuras de datos más comunes en R. El siguiente gráfico resume las principales diferencias entre estos tipos de datos:

diferentes estructuras de datos

Tenga en cuenta que el lenguaje de programación R proporciona muchos otros tipos de datos (por ejemplo, arreglos, matrices, tibbles, data.tables, etc.) que aún no he mostrado.

Sin embargo, los tres tipos de datos vector, marco de datos y lista ya le brindan una buena base para los siguientes ejemplos.

¡Pasemos a la siguiente sección de manipulación de datos!

Manejo de clases de datos

En la sección anterior, es posible que ya haya notado que hemos tratado con diferentes clases de datos (es decir, numéricos y de caracteres).

Las clases de datos son un tema crítico cuando se programa en R, ya que cada clase de datos se usa para diferentes tareas .

El siguiente código explica algunas de las clases de datos más importantes en R.

Primero verifiquemos la clase de datos del objeto vectorial que hemos creado al comienzo de la sección de manipulación de datos. Para verificar la clase, podemos usar la función de clase como se muestra a continuación:

class ( vec_1 )                                                               # Comprobar clase de elementos vectoriales 
# [1] "numeric"

Como puede ver, RStudio ha devuelto «numeric» a la consola, es decir, nuestro objeto vectorial vec_1 tiene la clase numeric. La clase numérica se utiliza para números.

Otra clase que ya hemos usado cuando creamos el marco de datos en la sección anterior es la clase de caracteres .

Vamos a crear un objeto vectorial que contenga elementos de caracteres:

vec_2 <- c ( "a" , "b" , "a" , "c" )                                             # Crear vector de caracteres 
vec_2                                                                      # Crear vector de caracteres 
# [1] "a" "b" "a" "c"

Como puede ver según la salida de la consola anterior, la clase de caracteres se usa para elementos de texto (también llamados cadenas de caracteres).

Según las comillas alrededor de las letras, ya puede ver que estamos tratando con personajes. Sin embargo, también podemos aplicar la función de clase a nuestro nuevo objeto vectorial para devolver su clase a la consola de RStudio:

clase ( vec_2 )                                                               # Comprobar clase de elementos vectoriales 
# [1] "carácter"

Nuestra suposición se confirmó: el objeto vectorial vec_2 tiene la clase de carácter.

Otra clase importante de programación en R son los factores . Al igual que los caracteres, el factor puede contener letras y números. Sin embargo, la diferencia con respecto a los caracteres es que cada elemento tiene un significado.

Ilustremos eso creando nuestro propio vector de factores:

vec_3 <- factor ( c ( "gr1" , "gr1" , "gr2" , "gr3" , "gr2" ) )                      # Crear factor vector 
vec_3                                                                      # Imprimir factor vector 
# [1] gr1 gr1 gr2 gr3 gr2 
# Niveles: gr1 gr2 gr3

La salida anterior muestra los valores en nuestro vector de factores, así como otra fila de salida llamada «Niveles». Los niveles de un objeto factor reflejan todos los valores posibles que puede tener un determinado factor.

En otras palabras: un factor tiene categorías nominales específicas y cada una de estas categorías tiene un significado particular.

Un ejemplo de una variable factorial serían los nombres de los países. Cada nombre de país corresponde a un área geográfica específica y, por lo tanto, podríamos agrupar cada observación en un conjunto de datos por país.

Para completar, apliquemos la función de clase a nuestro vector para devolver su clase a la consola de RStudio:

clase ( vec_3 )                                                               # Comprobar clase de elementos vectoriales 
# [1] "factor"

No hay noticias sorprendentes: nuestro objeto vectorial tiene la clase factor.

La siguiente figura resume las ideas de la parte anterior del tutorial:

diferentes clases de datos

Como se ilustra arriba, la clase de un objeto de datos es esencial para el manejo posterior de este objeto de datos. Por esa razón, a veces es posible que deseemos convertir ciertos objetos de datos o columnas de marcos de datos a una clase diferente.

La siguiente sintaxis de R muestra cómo realizar una transformación de clase de datos de este tipo en R. Más precisamente, usamos la función as.character para convertir el vector factor vec_3 en la clase de caracteres:

vec_4 <-  como . carácter ( vec_3 )                                               # Convertir factor a carácter 
vec_4                                                                      # Imprimir vector actualizado 
# [1] "gr1" "gr1" "gr2" "gr3" "gr2"

La salida anterior ha creado un nuevo objeto vector llamado vec_4, que contiene los mismos elementos que el vector vec_3, pero con una clase de datos diferente. Comprobemos esto:

clase ( vec_4 )                                                               # Verificar clase de elementos vectoriales actualizados 
# [1] "carácter"

Como puede ver, hemos cambiado la clase de factor a carácter.

Agregar y quitar columnas y filas de un conjunto de datos

Hasta ahora, hemos creado diferentes objetos de datos y hemos manipulado las clases de datos de estos objetos de datos.

La siguiente parte del tutorial muestra cómo agregar o eliminar ciertos valores hacia y desde un objeto de datos ya existente.

El primer fragmento de código demuestra cómo agregar una nueva columna a un conjunto de datos.

El código se divide en tres filas diferentes: primero, replicamos nuestro marco de datos data_1 que hemos creado al comienzo de la sección de manipulación de datos. Hacemos esto para mantener una versión original de nuestro marco de datos de entrada data_1.

En la segunda línea, usamos el operador $ para asignar los valores almacenados en el objeto vectorial vec_1 como una nueva columna llamada x4 a nuestro marco de datos. Tenga en cuenta que el objeto vectorial vec_1 debe tener la misma cantidad de elementos que la cantidad de filas en nuestro conjunto de datos.

Finalmente, imprimimos el marco de datos actualizado en la consola de RStudio ejecutando la tercera línea del siguiente código.

data_2 <- data_1                                                           # Crear un duplicado del marco de datos 
data_2$x4 <- vec_1                                                         # Agregar una nueva columna al marco de datos 
data_2                                                                     # Imprimir el marco de datos actualizado

tabla 2 lenguaje de programación de tramas de datos

 

La Tabla 2 muestra el resultado de la sintaxis de programación R anterior: hemos construido un nuevo marco de datos llamado data_2 que contiene las columnas del conjunto de datos data_1 más una columna adicional que contiene los valores del objeto vectorial vec_1.

También es posible utilizar el lenguaje de programación R para eliminar columnas de un marco de datos .

El siguiente código R usa la función colnames y una condición lógica para eliminar la variable x2 de nuestro conjunto de datos:

data_3 <- data_2 [ , colnames ( data_2 )  !=  "x2" ]                              # Eliminar columna del marco de datos 
data_3                                                                     # Imprimir marco de datos actualizado

 

tabla 3 lenguaje de programación de tramas de datos

En la Tabla 3 se muestra que hemos creado otro marco de datos llamado data_3 utilizando el código R mostrado anteriormente. Este marco de datos contiene solo las variables x1, x3 y x4. La variable x2 ha sido eliminada.

Al modificar las columnas de un marco de datos, a menudo tiene sentido cambiar el nombre de las columnas del conjunto de datos final.

Una vez más, podemos usar la función colnames:

data_4 <- data_3                                                           # Crear duplicados de los nombres de columna del marco de datos ( data_4 ) 
< -  c ( " col_A" , "col_B" , "col_C" )                           # Cambiar los nombres de las columnas 
data_4                                                                     # Imprimir el marco de datos actualizado

tabla 4 lenguaje de programación de tramas de datos

Después de ejecutar el código R anterior, se ha creado el marco de datos que se muestra en la Tabla 4. Como puedes ver, hemos cambiado los nombres de las columnas por los nuevos nombres “col_A”, “col_B” y “col_C”.

Hasta ahora, hemos ajustado la estructura de columnas de nuestro marco de datos. Sin embargo, también es posible modificar las filas de un marco de datos.

La siguiente sintaxis R ilustra cómo agregar una nueva fila en la parte inferior de un conjunto de datos. Para esta tarea, podemos aplicar la función rbind :

data_5 <- rbind ( data_3, 101 : 103 )                                           # Agrega una nueva fila al marco de datos 
data_5                                                                     # Imprime el marco de datos actualizado

tabla 5 lenguaje de programación de tramas de datos

Como se muestra en la Tabla 5, el código de programación R anterior ha creado un nuevo marco de datos llamado data_5 donde se ha agregado la secuencia de 101 a 103 como una fila adicional en la parte inferior.

También podemos eliminar ciertas filas de un marco de datos.

El siguiente ejemplo elimina filas en función de una condición lógica , es decir, solo queremos mantener las filas donde el valor en la columna x1 es mayor que 3:

data_6 <- data_5 [ data_5$x1 >  3 , ]                                          # Eliminar filas del marco de datos 
data_6                                                                     # Imprimir marco de datos actualizado

 

tabla 6 lenguaje de programación de tramas de datos

Al ejecutar el código de programación R anterior, hemos creado la Tabla 6, es decir, un subconjunto de las filas de nuestro marco de datos de entrada data_5.

Combinar múltiples marcos de datos

En la parte anterior de este tutorial, ya aprendió cómo agregar un objeto vectorial como una sola columna nueva horizontalmente a un marco de datos.

Sin embargo, a veces es posible que desee concatenar varios marcos de datos provenientes de diferentes fuentes de datos en un solo conjunto de datos.

Este es especialmente el caso cuando la información sobre ciertas observaciones se almacena en diferentes fuentes de datos.

El proceso de combinar estos datos a menudo se denomina «fusionar» o «unir» .

El siguiente ejemplo demuestra cómo realizar una combinación de este tipo en el lenguaje de programación R.

Para este ejemplo, primero tenemos que crear dos nuevos marcos de datos:

datos_7 < -datos . marco ( ID =  101 : 106 ,                                         # Crear primer marco de datos 
                     x1 = letras [ 1 : 6 ] ,
                     x2 = letras [ 6 : 1 ] ) 
data_7                                                                     # Imprime el primer cuadro de datos

 

tabla 7 lenguaje de programación de tramas de datos

 

datos_8 < -datos . marco ( ID =  104 : 108 ,                                         # Crear segundo marco de datos 
                     y1 =  1 : 5 ,
                     y2 =  5 : 1 ,
                     y3 =  5 ) 
data_8                                                                     # Imprime el segundo marco de datos

 

tabla 8 lenguaje de programación de tramas de datos

 

Nuestros dos marcos de datos de ejemplo se muestran en las Tablas 7 y 8. Como puede ver, ambos marcos de datos contienen una columna ID , pero otras variables diferentes (es decir, x1 y x2 en el primer marco de datos e y1, y2 e y3 en la segunda trama de datos).

Si queremos combinar estos datos en un solo conjunto de datos, podemos usar la función de combinación como se muestra a continuación:

data_9 <- fusionar ( x = data_7,                                                # Combinar dos marcos de datos 
                y = data_8,
                 by  =  "ID" ,
                all =  TRUE ) 
data_9                                                                     # Imprime el marco de datos fusionado

 

tabla 9 lenguaje de programación de tramas de datos

 

Como se muestra en la Tabla 9, la sintaxis R anterior ha creado una unión entre nuestros dos marcos de datos de entrada.

Tenga en cuenta que el código R anterior ha realizado una combinación externa completa , es decir, se han mantenido todas las filas de ambos marcos de datos, sin importar si la ID existía en ambos marcos de datos. Eche un vistazo aquí , en caso de que desee obtener más información sobre los diferentes tipos de uniones.

 

Reemplazar valores en vectores y marcos de datos

En los ejemplos anteriores, he demostrado cómo agregar o eliminar columnas y filas enteras. Esta sección, por el contrario, muestra cómo reemplazar solo celdas de datos específicas en un objeto de datos.

En el fragmento de código a continuación, ilustro cómo intercambiar un cierto valor en un objeto vectorial por un nuevo valor.

Para ser más específicos, el código R a continuación primero duplica nuestro vector de ejemplo vec_1 en un nuevo objeto vectorial llamado vec_5. Luego, usamos una condición lógica para reemplazar cada aparición del valor 1 por el valor 99. Finalmente, imprimimos el nuevo vector en la consola de RStudio:

vec_5 <- vec_1                                                             # Crear duplicado del vector 
vec_5 [ vec_5 ==  1 ]  <-  99                                                    # Reemplazar cierto valor en el vector 
vec_5                                                                      # Imprimir vector actualizado 
# [1] 99 99 5 3 99 5

Similar al fragmento de código anterior, también podemos reemplazar elementos particulares en un marco de datos .

La siguiente sintaxis de R muestra cómo sustituir cada aparición del carácter «y» por la cadena de caracteres «nuevo»:

data_10 <- data_1                                                          # Crear duplicado del marco de datos 
data_10$x2 [ data_10$x2 ==  "y" ]  <-  "new"                                     # Reemplazar valores en la columna 
data_10                                                                    # Imprimir marco de datos actualizado

 

tabla 10 lenguaje de programación de tramas de datos

 

El resultado de la sintaxis anterior se revela en la Tabla 10: un nuevo marco de datos donde «y» se estableció en «nuevo».

 

Exportar e importar conjuntos de datos

Hemos creado muchos marcos de datos diferentes en este tutorial. Para que estos marcos de datos sean accesibles fuera de R, es posible que queramos exportarlos a un archivo externo en nuestra computadora.

Este ejemplo específico explica cómo exportar un marco de datos a un archivo CSV. Sin embargo, podríamos usar una sintaxis similar para crear otros tipos de archivos, como archivos XLSX y TXT.

En cualquier caso, primero tenemos que especificar el directorio de trabajo donde se debe guardar nuestro archivo.

Para identificar el directorio de trabajo utilizado actualmente , podemos usar la función getwd:

getwd ( )                                                                    # Obtener el directorio de trabajo actual 
# [1] "C:/Users/Joach/Documents"

Como puede ver en base a la salida anterior de la consola de RStudio, nuestro directorio de trabajo actual es la carpeta Documentos en mi computadora.

Supongamos que tenemos una carpeta llamada my_directory en el escritorio de nuestra computadora:

 

carpeta vacía en el escritorio de la computadora

 

Luego, podemos configurar el directorio de trabajo de la sesión R actual en esta carpeta usando la función setwd como se muestra a continuación:

setwd ( "C:/Users/Joach/Desktop/my directory" )                               # Establecer nuevo directorio de trabajo

Verifiquemos el directorio de trabajo actual una vez más usando el comando getwd:

getwd ( )                                                                    # Obtener el directorio de trabajo actual 
# [1] "C:/Users/Joach/Desktop/my directory"

Como puede ver, hemos cambiado el directorio de trabajo a la carpeta en mi escritorio.

En el siguiente paso, podemos aplicar la función write.csv para exportar un determinado marco de datos como un archivo CSV a nuestro directorio de trabajo.

Dentro de la función write.csv, tenemos que especificar el nombre del marco de datos que queremos guardar (es decir, data_10) y el nombre del archivo de salida (es decir, “data_10.csv”). Además, también especificamos que queremos evitar imprimir nombres de fila en el archivo CSV exportado.

escribir _ csv ( data_10,                                                         # Exportar marco de datos al archivo CSV 
          "data_10.csv" ,
          fila _ nombres  =  FALSO )

Después de ejecutar el código R anterior, nuestro directorio se actualiza:

 

Archivo CSV en carpeta en el escritorio de la computadora

 

Como puede ver, hemos escrito el marco de datos data_10 como un archivo CSV en nuestro directorio de trabajo.

En caso de que queramos importar este archivo a otra sesión de R, simplemente podemos usar la función read.csv como se muestra a continuación:

data_11 <- leer . csv ( "data_10.csv" )                                         # Importar marco de datos del archivo CSV 
data_11                                                                    # Imprimir marco de datos importado

 

tabla 11 lenguaje de programación de tramas de datos

 

El resultado de la sintaxis anterior se muestra en la Tabla 11: Importamos el archivo CSV «data_10.csv» y almacenamos este archivo como un nuevo objeto de marco de datos llamado data_11.

En este punto del tutorial, quiero dejar de hablar sobre la manipulación y disputa de datos en R.

En caso de que tenga alguna pregunta específica que aún no se haya cubierto, puede escribir su pregunta en la máscara de búsqueda en la parte superior derecha de la barra de menú de este sitio web. Ya he publicado varios cientos de artículos diferentes sobre manipulación de datos.

Sin embargo, pasemos a la visualización de nuestros datos en diferentes tipos de gráficos .

 

Creación de gráficos en R

La capacidad de dibujar y modificar gráficos es un requisito importante para un lenguaje de programación, especialmente cuando se trata de una herramienta de análisis estadístico como R.

Afortunadamente, la creación de diferentes tipos de gráficos es sencilla en el lenguaje de programación R y, al mismo tiempo, es una de las principales razones por las que R es tan poderoso.

En la siguiente sección, le mostraré cómo crear y ajustar gráficos para que se ajusten a sus propias necesidades.

¡Así que sigue leyendo!

 

Creación de gráficos usando Base R

La instalación básica del lenguaje de programación R ya proporciona características sorprendentes para la creación de gráficos en R.

En esta subsección, le mostraré cómo crear algunos de los tipos de gráficos más comunes usando Base R.

Los marcos de datos creados en la sección anterior de manipulación de datos son demasiado simples para mostrar todas las características gráficas bonitas de R, así que primero carguemos algunos datos más complejos en R.

El lenguaje de programación R proporciona algunos conjuntos de datos precargados, y uno de los más comunes es el conjunto de datos del iris que podemos cargar ejecutando el siguiente código:

data ( iris )                                                                 # Cargar conjunto de datos de iris 
cabezal ( iris )                                                                 # Cabezal de impresión del conjunto de datos de iris

 

tabla 12 lenguaje de programación de tramas de datos

 

Después de ejecutar la sintaxis R anterior, se ha cargado el marco de datos que se muestra en la Tabla 12. Como puede ver, el conjunto de datos del iris contiene información sobre diferentes especies de flores.

¡Basta de hablar sobre los datos, finalmente dibujemos algunas gráficas!

Uno de los tipos de gráficos más comunes son los llamados diagramas de dispersión (o diagramas xy), y podemos dibujar dicho diagrama de dispersión usando la función de diagrama.

Dentro de la función de trazado, tenemos que especificar los valores del eje x y del eje y . En la siguiente sintaxis, también especificamos que el argumento col sea igual a la columna Especie en nuestros datos para reflejar los puntos de datos de cada especie con un color diferente.

plot ( x = iris$Sepal . Longitud ,                                                # Draw Base R scatterplot 
     y = iris$Sepal . Width ,
     col = iris$Especies )

 

r gráfico figura 1 lenguaje de programación

 

Después de ejecutar la sintaxis de programación R anterior, se ha dibujado el diagrama de dispersión que se muestra en la Figura 1. Como puedes ver, cada especie se refleja con un color diferente .

Otro tipo popular de gráficos son los diagramas de densidad del núcleo .

Podemos dibujar una gráfica de densidad Base R usando la función de gráfica en combinación con la función de densidad .

El siguiente código de ejemplo creó un diagrama de densidad de la columna de iris Sepal.Length:

plot ( densidad ( x = iris$Sepal . Longitud ) )                                       # Draw Base R densidad plot

 

r gráfico figura 2 lenguaje de programación

 

De forma similar a los gráficos de densidad, también podemos dibujar un histograma de un determinado objeto vectorial o una columna de marco de datos.

Para lograr esto, debemos aplicar la función hist a una de las columnas de nuestro marco de datos:

hist ( x = iris$Sepal . Longitud )                                                # Dibujar histograma base R

 

r gráfico figura 3 lenguaje de programación

 

Otro tipo común de gráfico son los llamados diagramas de caja (o diagramas de caja y bigotes).

En el siguiente ejemplo, estamos creando un gráfico que contiene múltiples diagramas de caja para la variable Sepal.Length uno al lado del otro: uno para cada especie en nuestros datos:

diagrama de caja ( iris $ Sépalo . Longitud ~ iris $ Especie )                                  # Dibujar diagrama de caja Base R

 

r gráfico figura 4 lenguaje de programación

 

Como has visto en los ejemplos anteriores, la instalación básica del lenguaje de programación R ya proporciona muchas formas diferentes de visualizar tus datos ; Y aquí solo he mostrado la punta del iceberg.

Sin embargo, el lenguaje de programación R proporciona un paquete complementario muy potente que brinda soluciones aún más bonitas al crear gráficos en R.

Este paquete se llama ggplot2 , y en la siguiente parte del tutorial me enfocaré en la creación de gráficos utilizando el paquete ggplot2 en R.

¡Hagámoslo!

 

Creación de gráficos usando el paquete ggplot2

Para poder usar las funciones del paquete adicional ggplot2 , primero debemos instalar y cargar ggplot2.

En términos generales, la instalación y carga de paquetes complementarios es bastante sencilla en el lenguaje de programación R.

Para lograr esto, primero tenemos que instalar el paquete usando la función install.packages. Tenga en cuenta que esto debe hacerse solo una vez en cada computadora:

instalar _ paquetes ( "ggplot2" )                                                # Instalar el paquete ggplot2

En el siguiente paso, tenemos que cargar el paquete usando la función de biblioteca. Esto debe hacerse una vez por sesión de RStudio:

biblioteca ( "ggplot2" )                                                         # Cargar ggplot2

Luego de ejecutar el código anterior, podemos aplicar las funciones del paquete ggplot2 para dibujar diferentes tipos de gráficos.

Al usar el paquete ggplot2, debe saber que la sintaxis de los diagramas ggplot2 generalmente se estructura en diferentes partes:

  1. La primera parte define los datos y los nombres de las variables , así como la estética de nuestra trama (por ejemplo, los colores). Para ello, podemos utilizar las funciones ggplot y aes.
  2. La segunda parte especifica el tipo de gráfico que queremos crear. Cada tipo de gráfico puede ser creado por una función geom_ diferente, por ejemplo, los diagramas de densidad son creados por la función geom_density.
  3. La tercera parte es opcional y permite al usuario modificar ciertos componentes de un gráfico. Por ejemplo, puede cambiar los títulos principal y de los ejes, o puede cambiar el orden y la asignación de elementos particulares de la trama.

Tenga en cuenta que las pautas generales anteriores pueden variar según la trama que desee dibujar y según su complejidad. Sin embargo, especialmente para las tramas básicas, estas son buenas pautas a tener en cuenta.

El primer tipo de gráfico ggplot2 que quiero mostrarles es un diagrama de dispersión.

En la primera parte del código a continuación, especificamos que queremos usar el conjunto de datos del iris, así como las columnas Sepal.Length y Sepal.Width. Además, especificamos que queremos usar un color diferente para cada grupo en la columna Especie.

En la segunda parte del código especificamos que queremos dibujar un diagrama de dispersión. Para ello, podemos utilizar la función geom_point.

Dado que queremos usar la configuración predeterminada para los otros parámetros de este gráfico, no tenemos que especificar nada más.

Considere el siguiente código R:

ggplot ( iris,                                                               # Dibujar ggplot2 diagrama de dispersión 
       aes ( x = Sépalo . Longitud ,
           y = sépalo . ancho ,
           col = Especie ) )  + 
  geom_point ( )

 

r gráfico figura 5 lenguaje de programación

 

El resultado del código R anterior se muestra en la Figura 5. Hemos creado un diagrama de dispersión ggplot2 con diferentes colores para cada especie.

Podemos usar un código similar para crear otros tipos de diagramas ggplot2. El siguiente código R muestra cómo dibujar un diagrama de densidad ggplot2 de la variable Sepal.Length:

ggplot ( iris,                                                               # Draw ggplot2 diagrama de densidad 
       aes ( x = Sépalo . Longitud ) )  + 
  geom_density ( )

 

r gráfico figura 6 lenguaje de programación

 

Una característica muy útil del paquete ggplot2 es que podemos crear un gráfico que contiene varios gráficos dentro de la misma ventana gráfica simplemente especificando un determinado parámetro de agrupación dentro de la estética del gráfico ggplot2.

En el siguiente fragmento de código, configuramos el atributo de color dentro de la función aes para que sea igual a la columna Especie de nuestro marco de datos y, como se muestra en la figura a continuación, esto crea un gráfico con múltiples gráficos de densidad superpuestos :

ggplot ( iris,                                                               # Dibujar múltiples diagramas de densidad ggplot2 
       aes ( x = Sépalo . Longitud ,
           col = Especie ) )  + 
  geom_density ( )

 

r gráfico figura 7 lenguaje de programación

 

Además del color, también podemos especificar otros argumentos como el color de relleno de cada densidad:

ggplot ( iris,                                                               # Llenar ggplot2 gráficos de densidad 
       aes ( x = Sépalo . Longitud ,
           col = especie,
           relleno = Especie ) )  + 
  geom_density ( )

 

r gráfico figura 8 lenguaje de programación

 

El resultado de la sintaxis R anterior se muestra en la Figura 8: un gráfico ggplot2 que contiene varias densidades con un color de relleno.

En el gráfico anterior, algunas partes de algunas de las densidades están completamente superpuestas por otras densidades. Para evitar este problema, podemos establecer el argumento alfa dentro de la función geom_density en un valor más bajo para que nuestras densidades sean transparentes:

ggplot ( iris,                                                               # Opacidad de ggplot2 diagramas de densidad 
       aes ( x = Sépalo . Longitud ,
           col = especie,
           relleno = Especie ) )  + 
  geom_density ( alpha =  0.3 )

 

r gráfico figura 9 lenguaje de programación

 

Al ejecutar la sintaxis de programación R anterior, hemos creado la Figura 9, es decir, un gráfico ggplot2 con múltiples densidades transparentes .

También podemos usar el paquete ggplot2 para crear un histograma de una determinada variable usando la función geom_histogram en lugar de la función geom_density:

ggplot ( iris,                                                               # Dibujar ggplot2 histograma 
       aes ( x = Sépalo . Longitud ) )  + 
  geom_histogram ( )

 

r gráfico figura 10 lenguaje de programación

 

Además, podemos visualizar nuestros datos en diagramas de caja y bigotes:

ggplot ( iris,                                                               # Dibuja ggplot2 boxplot 
       aes ( x = Especie,
           y = sépalo . Longitud ) )  + 
  geom_boxplot ( )

 

r gráfico figura 11 lenguaje de programación

 

De forma similar al ejemplo en el que hemos dibujado varias densidades, también podemos dibujar varias gráficas de caja una al lado de la otra especificando un determinado atributo dentro de la estética de la gráfica ggplot2 (es decir, el argumento de relleno):

ggplot ( iris,                                                               # Agregar colores a ggplot2 boxplot 
       aes ( x = Especie,
           y = sépalo . Longitud ,
           relleno = Especie ) )  + 
  geom_boxplot ( )

 

r gráfico figura 12 lenguaje de programación

 

Como ha visto en los ejemplos anteriores, el paquete ggplot2 es bastante flexible y proporciona muchos tipos diferentes de gráficos. Sin embargo, hay un tipo de trama muy popular del que aún no hemos hablado: ¡las tramas de barras!

Para dibujar un gráfico de barras ggplot2, primero tenemos que agregar los valores en nuestros datos :

iris_groups <- iris                                                        # Crear duplicado del conjunto de datos de iris 
iris_groups$Sub <- letras [ 1 : 3 ]                                            # Agregar subgrupos a los datos 
iris_groups <- agregado ( fórmula = Sépalo . Longitud ~ Especie + Sub,           # Media por subgrupo de 
                         datos = iris_groups,
                         FUN = mean ) 
iris_groups                                                                # Imprimir conjunto de datos de iris agregados

 

tabla 13 lenguaje de programación de tramas de datos

 

Al ejecutar la sintaxis R anterior, hemos creado la Tabla 13, es decir, un nuevo marco de datos que contiene el valor medio de la columna Sepal.Length por cada subgrupo para cada especie.

Ahora podemos usar este nuevo conjunto de datos para dibujar un gráfico de barras ggplot2:

ggplot ( iris_groups,                                                        # Dibuja ggplot2 barplot 
       aes ( x = Especie,
           y = sépalo . Longitud ) )  + 
  geom_bar ( stat =  "identidad" )

 

r gráfico figura 13 lenguaje de programación

 

Como se muestra en la Figura 13, la sintaxis de programación R anterior ha creado un gráfico de barras que contiene una barra para la suma de todos los valores medios de cada especie.

Si además queremos tener en cuenta los subgrupos, podemos separar cada una de las barras en un denominado gráfico de barras apiladas . Para esto, tenemos que configurar el argumento de relleno para que sea igual a nuestra columna de subgrupo:

ggplot ( iris_groups,                                                        # Dibuja barplot ggplot2 apilado 
       aes ( x = Especie,
           y = sépalo . Longitud ,
           llenar = Sub ) )  + 
  geom_bar ( stat =  "identidad" )

 

r gráfico figura 14 lenguaje de programación

 

Como alternativa a esto, también podemos separar los subgrupos en cada especie dibujando un gráfico de barras agrupado . Para completar esto, tenemos que configurar el argumento de posición dentro de la función geom_bar para «esquivar»:

ggplot ( iris_groups,                                                        # Dibujar agrupados ggplot2 barplot 
       aes ( x = Especie,
           y = sépalo . Longitud ,
           llenar = Sub ) )  + 
  geom_bar ( stat =  "identidad" ,
           posición =  "esquivar" )

 

r gráfico figura 15 lenguaje de programación

 

Esta sección ha demostrado la fortaleza de R cuando se trata de la visualización de datos en diferentes tipos de gráficos.

Tenga en cuenta que esta sección solo ha ilustrado algunas de las formas más populares de visualizar datos en R. Sin embargo, el lenguaje de programación R proporciona básicamente formas ilimitadas de dibujar sus datos.

Echa un vistazo a este tutorial para más detalles.

La visualización gráfica es solo un enfoque cuando se analizan datos. En la siguiente sección, mostraré algunas técnicas para analizar sus datos con base en métricas descriptivas y modelos estadísticos.

¡Vamos a sumergirnos en él!

 

Análisis de datos y estadística descriptiva en R

Esta sección demuestra diferentes métodos sobre cómo analizar datos en el lenguaje de programación R.

Comenzaremos con algunas métricas básicas y luego pasaremos a algunos modelos estadísticos más avanzados .

Entonces, sin hablar demasiado, ¡hagámoslo!

 

Calcular métricas estadísticas básicas

En la siguiente parte del tutorial, mostraré cómo calcular estadísticas descriptivas básicas en R.

Usaremos el objeto vectorial vec_1 que hemos creado al comienzo de este tutorial como base. Sin embargo, tenga en cuenta que podríamos aplicar la siguiente sintaxis R a columnas de marcos de datos o también a datos más complejos.

El lenguaje de programación R proporciona funciones para básicamente todas las métricas estadísticas importantes .

Por ejemplo, podemos calcular la media de un objeto vectorial utilizando la función media :

media ( vec_1 )                                              # Calcular la media 
# [1] 2.666667

Como puede ver en base a la salida anterior de la consola RStudio, la media de nuestro objeto vectorial es 2.666667.

Similar a esto, podemos aplicar otras funciones a nuestro objeto vectorial para calcular otras estadísticas de resumen.

Por ejemplo, podemos calcular la mediana usando la función mediana…

mediana ( vec_1 )                                            # Calcular mediana 
# [1] 2

…el valor mínimo usando la función min…

min ( vec_1 )                                               # Calcular mínimo 
# [1] 1

…el valor máximo aplicando la función max…

max ( vec_1 )                                               # Calcular máximo 
# [1] 5

…la suma usando la función de suma …

suma ( vec_1 )                                               # Calcular suma 
# [1] 16

…la varianza aplicando la función var…

var ( vec_1 )                                               # Calcular varianza 
# [1] 3.866667

y la desviación estándar usando la función sd:

sd ( vec_1 )                                                # Calcular desviación estándar 
# [1] 1.966384

Si queremos calcular múltiples estadísticas de resumen con una sola llamada de función, podemos aplicar la función de resumen como se muestra a continuación.

Como puede ver, la función de resumen devuelve el mínimo, el primer cuartil, la mediana, la media, el tercer cuartil y el valor máximo de un objeto de datos:

resumen ( vec_1 )                                           # Calcular múltiples estadísticas descriptivas 
# Min. 1er cuarto Mediana Media 3er Qu. máx. 
# 1.000 1.000 2.000 2.667 4.500 5.000

En caso de que queramos obtener los recuentos de frecuencia de ciertos valores en un objeto de datos, podemos aplicar la función de tabla .

El siguiente código R demuestra cómo calcular una tabla de frecuencias . Como puede ver, el valor 1 aparece tres veces en nuestro vector, el valor 3 aparece solo una vez y el valor 5 aparece dos veces:

tabla ( vec_1 )                                             # Crear tabla de frecuencias 
# vec_1 
# 1 3 5 
# 3 1 2

También podemos usar la función de tabla para obtener una tabla de contingencia en dos o varias columnas.

El siguiente código R imprime las contingencias para las combinaciones de dos columnas de marco de datos x1 y x2 de nuestro marco de datos data_1 que hemos creado en la sección de manipulación de datos.

Por ejemplo, la combinación del valor 2 en la variable x1 con el valor x en la variable x2 aparece 0 veces (es decir, nunca). La combinación del valor 3 en la variable x1 con el valor x en la variable x3 ocurre dos veces:

table ( data_1 [ , c ( "x1" , "x2" ) ] )                          # Crear tabla de contingencia 
# x2 
# x1 xy 
# 2 0 1 
# 3 2 0 
# 7 1 1 
# 8 1 0

El código R anterior ha demostrado cómo medir estadísticas descriptivas simples.

Sin embargo, el lenguaje de programación R también se puede usar para estimar modelos estadísticos más complejos , ¡y esto es lo que haremos en la siguiente sección!

 

Estimación de Modelos de Regresión

En la siguiente parte, usaremos una vez más el conjunto de datos de iris que ya hemos cargado en la sección de visualización de datos.

Probablemente el modelo estadístico más común es el llamado modelo de regresión lineal .

Podemos estimar dicho modelo de regresión con Sepal.Width como variable dependiente (o resultado; variable objetivo) y la variable Sepal.Length como variable independiente (o predictor) usando la función lm como se muestra a continuación:

mod_1 <- lm ( fórmula = Sépalo . Ancho ~ Sépalo . Longitud ,        # Estimación de 
            datos del modelo de regresión lineal = iris )

La sintaxis R anterior ha creado un nuevo objeto modelo llamado mod_1. Ahora podemos usar la función de resumen para imprimir ciertas estadísticas de resumen para este modelo en la consola de RStudio:

resumen ( mod_1 )                                           # Estadísticas resumidas del modelo 
# Llamada: 
# lm(formula = Sepal.Width ~ Sepal.Length, data = iris) 
# 
# Residuales: 
# Min 1Q Median 3Q Max 
# -1.1095 -0.2454 -0.0167 0.2763 1.3338 
# 
# Coeficientes: 
# Estimación Std. Error valor t Pr(>|t|)     
# (Intersección) 3.41895 0.25356 13.48 <2e-16 *** 
# Sepal.Length -0.06188 0.04297 -1.44 0.152     
# --- 
# Signif. códigos: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1 
# 
# Error estándar residual: 0.4343 en 148 grados de libertad 
# R-cuadrado múltiple: 0.01382, R-cuadrado ajustado: 0.007159
# Estadístico F: 2,074 en 1 y 148 DF, valor p: 0,1519

Como puede ver, la salida anterior es relativamente compleja. Además de muchas otras cosas, muestra ciertas métricas para los residuales de nuestro modelo, los coeficientes de regresión con estrellas de significación, el error estándar residual, el R-cuadrado múltiple y ajustado, el estadístico F, los grados de libertad y el p- valor.

La explicación de todas estas métricas iría más allá del alcance de este tutorial. Sin embargo, recomiendo echar un vistazo aquí para obtener instrucciones detalladas sobre cómo interpretar el resultado de los modelos de regresión.

Lo que es particularmente interesante sobre la salida del modelo es que el coeficiente de regresión para la variable Sepal.Length no es significativo .

Esto podría ser sorprendente, ya que uno podría suponer que la longitud de un pétalo estaría relacionada de alguna manera con el ancho del pétalo.

Usemos nuestras habilidades de visualización de datos que hemos reunido en la sección anterior para visualizar nuestros datos una vez más:

ggplot ( iris,                                             # Dibuja el diagrama de dispersión con la línea de regresión 
       aes ( x = Sépalo . Longitud ,
           y = sépalo . Ancho ) )  + 
  geom_point ( )  + 
  geom_smooth ( método =  "lm" )

 

r gráfico figura 16 lenguaje de programación

 

El código R anterior ha creado un diagrama de dispersión con una línea de regresión en la parte superior .

Como puede ver, la pendiente de regresión es relativamente plana , lo que parece confirmar el resultado no significativo de nuestro modelo de regresión lineal.

Sin embargo, en el gráfico también podemos ver que parece haber diferentes grupos (es decir, los grupos de especies) en nuestros datos. Por esa razón, podría tener sentido agregar otra variable predictora a nuestro modelo.

El siguiente código R estima un modelo de regresión lineal multivariable usando las variables Sepal.Length y Species como predictores para la variable objetivo Sepal.Width:

mod_2 <- lm ( fórmula = Sépalo . Ancho ~ Sépalo . Longitud  + Especie, # Modelo con 
            datos de predictores múltiples = iris )

A continuación, podemos devolver el resumen de este modelo:

resumen ( mod_2 )                                           # Estadísticas resumidas del modelo 
# Llamada: 
# lm(fórmula = Sepal.Width ~ Sepal.Length + Species, data = iris) 
# 
# Residuals: 
# Min 1Q Median 3Q Max 
# -0.95096 -0.16522 0.00171 0.18416 0.72918 
# 
# Coeficientes: 
# Estimación Std. Error valor t Pr(>|t|)     
# (Intersección) 1.67650 0.23536 7.123 4.46e-11 *** 
# Sepal.Length 0.34988 0.04630 7.557 4.19e-12 *** 
# Especieversicolor -0.98339 0.07207 -13.644 < 2e-16 * ** 
# Speciesvirginica -1.00751 0.09331 -10.798 < 2e-16 *** 
# ---
# signif. códigos: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0,1 ' ' 1 
# 
# Error estándar residual: 0,289 en 146 grados de libertad 
# R-cuadrado múltiple: 0,5693, R-cuadrado ajustado: 0,5604 
# Estadístico F: 64,32 en 3 y 146 DF, valor p: < 2,2e- dieciséis

Como puede ver, nuestro modelo multivariante muestra muchos coeficientes de regresión diferentes, y todos estos coeficientes son significativos. Incluso la variable Sepal.Length que se midió como no significativa en el modelo anterior ahora es altamente significativa.

La razón de esto es que la variable Especie es un factor de confusión que ha arruinado la medición de la relación entre Sepal.Width y Sepal.Length en el primer modelo.

Podemos ilustrar las relaciones entre las variables Sepal.Length y Sepal.Width dentro de cada grupo de especies dibujando un gráfico ggplot2 con una línea de regresión separada para cada grupo .

Tenga en cuenta que la siguiente gráfica no muestra la misma pendiente de regresión que nuestro modelo estimado anteriormente. Sin embargo, podemos usarlo para visualizar las diferencias por grupo.

Sin embargo, la siguiente gráfica muestra que las tres líneas de regresión claramente tienen una pendiente positiva .

ggplot ( iris,                                             # Dibujar líneas de regresión múltiple 
       aes ( x = Sépalo . Longitud ,
           y = sépalo . ancho ,
           col = Especie ) )  + 
  geom_point ( )  + 
  geom_smooth ( método =  "lm" )

 

r gráfico figura 17 lenguaje de programación

 

En esta sección, ha aprendido a analizar sus datos utilizando métricas estadísticas básicas, así como modelos de regresión estadística.

Tenga en cuenta que los métodos que se muestran en esta sección siguen siendo muy básicos y que el lenguaje de programación R proporciona técnicas de modelado mucho más avanzadas.

Puede echar un vistazo aquí para leer más sobre este tema.

En este punto, quiero pasar a la última sección del presente tutorial. En esta sección, demostraré algunas técnicas de programación más avanzadas para darle una idea de lo que es posible con el lenguaje de programación R una vez que se convierte en un programador de R más avanzado.

 

Técnicas Avanzadas en R

Esta sección demuestra algunas técnicas de programación más avanzadas en el lenguaje de programación R.

Primero explicaré cómo usar los bucles, luego pasaremos a las declaraciones if else y, por último, pero no menos importante, aprenderá cómo crear sus propias funciones.

 

Bucle sobre vectores y filas de marcos de datos

Los bucles son una técnica de uso frecuente en la mayoría de los lenguajes de programación.

En esta sección, demostraré cómo recorrer los elementos de un objeto vectorial y las filas de un marco de datos.

Comenzaremos creando un objeto vectorial numérico vacío de longitud cero:

vec_6 <- numeric ( )                                       # Crear vector numérico vacío 
vec_6                                                    # Imprimir vector numérico vacío # numeric 
(0)

Este vector se utilizará para almacenar las salidas del siguiente ciclo.

Los bucles en R normalmente se pueden dividir en dos partes diferentes:

  • El encabezado del ciclo define un índice de ejecución y los elementos a través de los cuales se debe iterar el ciclo.
  • El cuerpo del ciclo define qué tipo de operación debe aplicarse dentro de cada iteración del ciclo.

En las siguientes líneas de código, aplicaré un ciclo for a los elementos de nuestro objeto vectorial vec_1.

En el cuerpo del bucle, estoy especificando que quiero calcular la suma del i-ésimo elemento del bucle y el índice de ejecución i. Esta salida debe almacenarse en la i-ésima posición del objeto vectorial vacío vec_6.

for ( i en  1 : longitud ( vec_1 ) )  {                              # Aplicar bucle for al vector 
  vec_6 [ i ]  <- vec_1 [ i ]  + i
 }

Nuestro objeto vectorial previamente vacío vec_6 se actualiza después de ejecutar el bucle for anterior. Primero echemos un vistazo a nuestro vector de entrada vec_1:

vec_1                                                    # Imprime vec_1 para comparar 
# [1] 1 1 5 3 1 5

Y luego echemos un vistazo al vector de salida vec_6:

vec_6                                                    # Imprimir nuevo vector 
# [1] 2 3 8 7 6 11

Como puede ver, el vector de salida vec_6 contiene seis nuevos elementos. Esos elementos se han calculado dentro del bucle for como se muestra a continuación:

  • Iteración 1) 1 + 1 = 2
  • Iteración 2) 1 + 2 = 3
  • Iteración 3) 5 + 3 = 8
  • Iteración 4) 3 + 4 = 7
  • Iteración 5) 1 + 5 = 6
  • Iteración 6) 5 + 6 = 11

En el ejemplo anterior hemos recorrido los elementos de un vector. Sin embargo, podemos usar una sintaxis similar para recorrer las filas de un marco de datos .

Para esto, primero tenemos que construir un marco de datos a través del cual queremos recorrer:

data_12 <- data_1                                        # Crear un duplicado del marco de datos 
data_12$x4 <- NA                                         # Agregar una nueva columna que contenga solo NA 
data_12                                                  # Imprimir un nuevo marco de datos

 

tabla 14 lenguaje de programación de tramas de datos

 

Como puede ver en la tabla anterior, hemos creado un marco de datos llamado data_12 que contiene las tres columnas de nuestro marco de datos data_1 más una cuarta columna que contiene solo valores NA .

Ahora podemos usar un ciclo for para iterar sobre las filas de este marco de datos y almacenar nuevos valores en la columna vacía según este ciclo:

for ( i in  1 : nrow ( data_1 ) )  {                               # Bucle sobre las filas del marco de datos 
  data_12$x4 [ i ]  <- data_12$x1 [ i ]  + i * data_12$x3 [ i ] 
}

Echemos otro vistazo a nuestro marco de datos data_12:

data_12                                                  # Imprime el marco de datos actualizado

 

tabla 15 lenguaje de programación de tramas de datos

 

La tabla anterior muestra que hemos llenado los elementos NA de la variable x4 con nuevos valores. ¡Se ve bien!

En los ejemplos anteriores, hemos utilizado bucles for para iterar a través de elementos vectoriales y filas de marcos de datos. Tenga en cuenta que el lenguaje de programación R también proporciona otros tipos de bucles, como bucles while y bucles de repetición .

Además, tenga en cuenta que los bucles en R son un tema muy controvertido. Mucha gente argumenta que los bucles son lentos y no son la mejor práctica de programación. Por lo tanto, prefieren evitar los bucles for en absoluto.

En mi opinión personal, los bucles son a menudo más intuitivos que sus alternativas y, por esa razón, uso bucles cuando trato con conjuntos de datos más pequeños donde la velocidad no importa demasiado. Cuando trato con conjuntos de datos más grandes, también prefiero usar técnicas más eficientes, como la familia de funciones de aplicación .

En caso de que desee leer más sobre esta discusión en bucle, puede consultar este artículo .

Sin embargo, pasemos a la siguiente técnica de programación avanzada: ¡declaraciones if else!

 

Declaraciones If Else

Si no, las declaraciones , como lo indica el nombre, generalmente se usan para crear dos salidas diferentes según una condición lógica.

Si esta condición es verdadera, se debe devolver la salida A; Si esta condición es falsa, se debe devolver la salida B.

El siguiente código R muestra cómo usar una instrucción if else dentro de un bucle for.

Para este ejemplo, primero tenemos que crear un vector de caracteres vacío:

vec_7 <- carácter ( )                                     # Crear vector de carácter vacío 
vec_7                                                    # Imprimir vector de carácter vacío 
# carácter(0)

A continuación, podemos ejecutar un ciclo for sobre los elementos de nuestro objeto vectorial vec_1, y dentro de este ciclo podemos aplicar una instrucción if else para crear una salida binaria.

En caso de que la condición lógica vec_1[i] > 3 sea VERDADERA, la cadena de caracteres “alto” debe asignarse al vector vacío vec_7; y en caso de que la condición lógica vec_1[i] > 3 sea FALSA, se debe asignar la cadena de caracteres “baja” al vector vacío vec_7.

for ( i in  1 : length ( vec_1 ) )  {                              # for loop & declaración if else anidada if 
  ( vec_1 [ i ] >  3  ) {  vec_7 
    [ i ] <  -  "high" 
  }  else  { 
    vec_7 [ i ]  <-  "low " 
  } 
}

Imprimamos el vector vec_7 una vez más:

vec_7                                                    # Imprimir vector actualizado 
# [1] "bajo" "bajo" "alto" "bajo" "bajo" "alto"

Como puede ver, hemos asignado las cadenas de caracteres «alto» y «bajo» a este vector, dependiendo de la condición lógica en la instrucción if.

Esto funcionó bien, pero el código anterior era un poco complicado. Afortunadamente, el lenguaje de programación R proporciona una alternativa conveniente: la función ifelse.

Dentro de la función ifelse, tenemos que especificar tres argumentos:

  • La condición de prueba lógica.
  • La salida en caso de esta condición es VERDADERO.
  • La salida en caso de esta condición es FALSO.

Considere el siguiente código de ejemplo:

vec_8 <- ifelse ( prueba = vec_1 >  3 ,                        # Aplicar la función ifelse 
                yes =  "alto" ,
                no =  "bajo" )

Después de ejecutar el código R anterior, se ha creado el nuevo objeto vectorial vec_8:

vec_8                                                    # Imprimir nuevo vector 
# [1] "bajo" "bajo" "alto" "bajo" "bajo" "alto"

Como puede ver, este objeto vectorial contiene exactamente los mismos elementos que el vector de salida vec_7 que hemos creado con la instrucción for-loop y if else anterior. Sin embargo, esta vez el código era mucho más simple.

 

Funciones definidas por el usuario

Otra técnica de programación muy útil es la creación de funciones definidas por el usuario.

Siempre que tenga que ejecutar un cierto tipo de código varias veces, puede guardar este código en su propia función y ejecutar esta función en lugar del código completo.

Esto puede ayudar a acortar enormemente su código y hacerlo más eficiente .

La siguiente sintaxis de R muestra un ejemplo simple sobre cómo crear una función definida por el usuario en R.

En este código, definimos una nueva función llamada fun_1. Esta función toma un valor de entrada x, y en el cuerpo de esta función se realizan algunos cálculos basados ​​en x. Al final de la función, se devuelve el resultado de este cálculo.

Creamos la función:

fun_1 <- function ( x )  {                                   # Crear una función sencilla definida por el usuario 
  out  <- x ^ 2  +  5  * x
   out 
}

Después de ejecutar la sintaxis anterior, podemos aplicar la función fun_1 como aplicaríamos cualquier otra función predefinida.

Por ejemplo, podemos aplicar nuestra función a los elementos del objeto vectorial vec_1:

fun_1 ( x = vec_1 )                                         # Aplicar función simple definida por el usuario 
# [1] 6 6 50 24 6 50

El código R anterior ha mostrado una función elemental definida por el usuario. Sin embargo, puede hacer que sus funciones sean tan complejas como desee.

El siguiente código R muestra cómo crear una función definida por el usuario que contiene una instrucción if else:

fun_2 <- function ( x, y )  {                                # Crear una función definida por el usuario compleja 
  if ( y >  3 )  { 
    out  <-  ( x ^ 2  +  5  * x )  / y
   }  else  { 
    out  <-  ( x ^ 2  +  5  * x )  /  ( 10  * y ) 
  } 
  fuera 
}

Ahora, podemos aplicar esta función definida por el usuario dentro de un bucle for:

for ( i en  1 : 5 )  {                                          # Función compleja definida por el usuario en bucle for 
  print ( paste0 ( "Este es el resultado de la iteración" ,
              i,
              ": " ,
              fun_2 ( x =  5 , y = i ) ) ) 
} 
# [1] "Este es el resultado de la iteración 1: 5" 
# [1] "Este es el resultado de la iteración 2: 2.5" 
# [1] "Este es el resultado de la iteración 3: 1.66666666666667" 
# [1] "Este es el resultado de la iteración 4: 12.5" 
# [1] "Este es el resultado de la iteración 5: 10"

Como puede ver, el código R anterior ha devuelto un resultado de nuestra función para cada iteración del ciclo for.

En este tutorial, he demostrado algunos de los métodos estadísticos y técnicas de programación más importantes proporcionados por el lenguaje de programación R.

Sin embargo, el lenguaje de programación R ofrece mucho más de lo que he mostrado en esta página.

En caso de que esté interesado en obtener más información sobre R , puede consultar la lista de tutoriales a continuación.

Muestra todos los tutoriales de programación R en Statistics Globe, y brindo instrucciones sobre una amplia variedad de temas.

Además, puede usar el botón de búsqueda en la parte superior derecha de la barra de menú para navegar a través de los tutoriales de programación R en este sitio web.

Déjame saber en los comentarios en caso de que tengas más preguntas o recomendaciones.

Te deseo mucho éxito y resistencia mientras aprendes R. ¡Definitivamente vale la pena!🙂

 

Todos los tutoriales de programación R en Statistics Globe

Puede encontrar una lista de todos los tutoriales de R en statisticsglobe.com a continuación. En los tutoriales, explico conceptos estadísticos y proporciono códigos de ejemplo reproducibles para principiantes y usuarios avanzados en R.

 

 

Alejandro Lugon Administrator

Alejandro Lugón es un economista y escritor especializado en Python y R, conocido por ser el creador del blog Estadisticool. Nacido enxico, Lugón se graduó de la Universidad Autónoma dexico con una Licenciatura en Economía. Desde entonces ha trabajado como economista en varias empresas. Lugón también ha escrito varios libros sobre temas relacionados con la economía, el análisis de datos y la programación. Su blog Estadisticool se ha convertido en un lugar de referencia para los programadores de Python y R. Alejandro Lugón es una inspiración para aquellos que buscan aprender programación y análisis de datos. Su trabajo ha ayudado a muchas personas a entender mejor el uso de la tecnología para hacer sus trabajos.

¿Quieres aprender R , pero no sabes por dónde empezar? ¡Este es el tutorial que estabas buscando! Soy Alejandro Lugón, el fundador y…