R Graphics Cookbook, 2ª Edición

Capítulo 1. Conceptos básicos de R

Este trabajo se ha traducido utilizando IA. Agradecemos tus opiniones y comentarios: [e-mail]

Este capítulo cubre los aspectos básicos: instalación y uso de paquetes y carga de datos.

La mayoría de de las recetas de este libro requieren tener instalados en tu ordenador los paquetes ggplot2, dplyr y gcookbook. (El paquete gcookbook contiene los conjuntos de datos utilizados en algunos de los ejemplos, pero no es necesario para realizar tu trabajo real). Si quieres empezar rápidamente, ejecuta

install.packages("tidyverse")
install.packages("gcookbook")

Entonces, en cada sesión de R, antes de ejecutar los ejemplos de este libro, puedes cargarlos con:

library(tidyverse)
library(gcookbook)

Al ejecutar library(tidyverse) se cargarán ggplot2, dplyr y otros paquetes. Si quieres mantener tu sesión de R más racionalizada y cargar sólo los paquetes estrictamente necesarios, puedes cargar los paquetes ggplot2 y dplyr individualmente:

library(ggplot2)
library(dplyr)
library(gcookbook)

Nota

Si quieres comprender mejor cómo funciona ggplot2, consulta el Apéndice A, que explica los conceptos que hay detrás de ggplot2.

Paquetes en R son colecciones de funciones y/o datos que se agrupan para facilitar su distribución, e instalar un paquete ampliará la funcionalidad de R en tu ordenador. Si un usuario de R crea un paquete y cree que puede ser útil para otros, puede distribuirlo a través de un repositorio de paquetes. El principal repositorio para distribuir paquetes de R se llama CRAN (Comprehensive R Archive Network), pero hay otros, como Bioconductor, especializado en paquetes relacionados con datos genómicos.

Si has pasado mucho tiempo aprendiendo R, puede que hayas oído hablar deltidyverse, que es una colección de paquetes de R que comparten ideas comunes sobre cómo deben estructurarse y manipularse los datos. Esto contrasta conel R base, que es el conjunto de paquetes que se incluyen cuando simplemente descargas e instalas R. El tidyverse es un conjunto de complementos para R, que facilitan la realización de muchas operaciones relacionadas con la manipulación y visualización de datos. Este libro utiliza principalmente el tidyverse, ya que creo que proporciona una forma más rápida y sencilla (¡pero no por ello menos potente!) de trabajar con datos.

Si no has utilizado antes el tidyverse, hay una receta en particular que deberías leer y que te ayudará a entender un trozo de sintaxis de aspecto extraño, %>%, también conocido como operador de tubería. Se trata de la Receta 1.7 de este capítulo.

1.1 Instalar un paquete

Problema

En quieres instalar un paquete desde CRAN.

Solución

Utiliza install.packages() y dale el nombre del paquete que quieras instalar. Para instalar ggplot2, ejecuta

install.packages("ggplot2")

Llegados a este punto, puede que se te pida que selecciones una réplica de descarga. Normalmente es mejor utilizar la primera opción, https://cloud.r-project.org/, ya que es una réplica basada en la nube con puntos finales en todo el mundo.

Debate

Si quieres instalar varios paquetes a la vez, puedes pasarle un vector de nombres de paquetes. Por ejemplo, esto instalará la mayoría de los paquetes utilizados en este libro:

install.packages(c("tidyverse", "gcookbook"))

Cuando le digas a R que instale un paquete, instalará automáticamente cualquier otro paquete del que dependa el primero.

1.2 Cargar un paquete

Problema

En quieres cargar un paquete instalado.

Solución

Utiliza library() y dale el nombre del paquete que quieres instalar. Para cargar ggplot2, ejecuta:

library(ggplot2)

El paquete debe estar ya instalado en el ordenador.

Debate

La mayoría de las recetas de este libro requieren cargar un paquete antes de ejecutar el código, ya sea para las funciones gráficas (como en el paquete ggplot2) o para conjuntos de datos de ejemplo (como en los paquetes MASS y gcookbook).

Una de las peculiaridades de R es la terminología paquete/biblioteca. Aunque utilices la función library() para cargar un paquete, un paquete no es una biblioteca, y algunos usuarios veteranos de R se enfadarán si lo llamas así.

Una biblioteca es un directorio que contiene un conjunto de paquetes. Por ejemplo, puedes tener una biblioteca para todo el sistema y otra para cada usuario.

1.3 Actualizar paquetes

Problema

quieres actualizar un paquete que ya está instalado.

Solución

Ejecuta update.packages():

update.packages()

Te preguntará por cada paquete que se pueda actualizar. Si quieres que actualice todos los paquetes sin preguntar, utiliza ask = FALSE:

update.packages(ask = FALSE)

Debate

Con el tiempo, los autores de los paquetes publicarán nuevas versiones de los mismos con correcciones de errores y nuevas funciones, y suele ser una buena idea mantenerse al día. Sin embargo, ten en cuenta que ocasionalmente las nuevas versiones de los paquetes introducirán errores o tendrán un comportamiento ligeramente modificado.

1.4 Cargar un archivo de datos de texto delimitado

Problema

En quieres cargar datos de un archivo de texto delimitado.

Solución

La forma más común de leer un archivo es utilizar datos separados por comas (CSV):

data <- read.csv("datafile.csv")

Como alternativa, puedes utilizar la función read_csv() (nótese el guión bajo en lugar del punto) del paquete readr. Esta función es significativamente más rápida que read.csv(), y tiene un mejor manejo de las cadenas y de la fecha y hora.

Debate

Como los ficheros de datos tienen muchos formatos diferentes, hay muchas opciones para cargarlos. Por ejemplo, si el fichero de datos no tiene cabeceras en la primera fila:

data <- read.csv("datafile.csv", header = FALSE)

El marco de datos resultante tendrá columnas llamadas V1, V2, etc., y probablemente querrás renombrarlas manualmente:

# Manually assign the header names
names(data) <- c("Column1", "Column2", "Column3")

Puedes establecer el delimitador con sep. Si está delimitado por espacios, utilizasep = " ". Si está delimitado por tabuladores, utiliza \t, como en:

data <- read.csv("datafile.csv", sep = "\t")

Por defecto, las cadenas de los datos se tratan como factores. Supongamos que éste es tu archivo de datos, y que lo lees utilizando read.csv():

"First","Last","Sex","Number"
"Currer","Bell","F",2
"Dr.","Seuss","M",49
"","Student",NA,21

El marco de datos resultante almacenará First y Last como factores, aunque en este caso tiene más sentido tratarlos como cadenas (ovectores de caracteres en la terminología de R). Para diferenciar esto, utilizastringsAsFactors = FALSE. Si hay columnas que deban tratarse como factores, puedes convertirlas individualmente:

data <- read.csv("datafile.csv", stringsAsFactors = FALSE)

# Convert to factor
data$Sex <- factor(data$Sex)
str(data)
#> 'data.frame': 3 obs. of 4 variables:
#> $ First : chr "Currer" "Dr." ""
#> $ Last : chr "Bell" "Seuss" "Student"
#> $ Sex : Factor w/ 2 levels "F","M": 1 2 NA
#> $ Number: int 2 49 21

Alternativamente, podrías cargar el archivo con cadenas como factores, y luego convertir las columnas individuales de factores a caracteres.

Ver también

read.csv() es una cómoda función que envuelve a read.table(). Si necesitas más control sobre la entrada, consulta ?read.table.

1.5 Cargar datos desde un archivo Excel

Problema

En quieres cargar datos de un archivo Excel.

Solución

El paquete readxl tiene la función read_excel() para leer archivos .xls y.xlsx de Excel. Esto leerá la primera hoja de una hoja de cálculo Excel:

# Only need to install once
install.packages("readxl")

library(readxl)
data <- read_excel("datafile.xlsx", 1)

Debate

Con read_excel(), puedes cargar desde otras hojas especificando un número o nombre para sheet:

data <- read_excel("datafile.xls", sheet = 2)

data <- read_excel("datafile.xls", sheet = "Revenues")

read_excel() utiliza la primera fila de la hoja de cálculo para los nombres de las columnas. Si no quieres utilizar esa fila para los nombres de las columnas, utilizacol_names = FALSE. En su lugar, las columnas se denominarán X1, X2, y así sucesivamente.

Por defecto, read_excel() deducirá el tipo de cada columna, pero si quieres especificar el tipo de cada columna, puedes utilizar el argumento col_types. También puedes eliminar columnas si especificas el tipo como"blank":

# Drop the first column, and specify the types of the next three columns
data <- read_excel("datafile.xls",
                   col_types = c("blank", "text", "date", "numeric"))

Ver también

Consulta ?read_excel para ver más opciones para controlar la lectura de estos archivos.

Existen otros paquetes para leer archivos Excel. El paquete gdata tiene una función read.xls() para leer archivos .xls, y el paquete xlsx tiene una función read.xlsx() para leer archivos .xlsx. Requieren la instalación de software externo en tu ordenador: read.xls() requiere Java, y read.xlsx() requiere Perl.

1.6 Cargar datos de archivos SPSS/SAS/Stata

Problema

En querrás cargar datos de un archivo SPSS, o de otros programas como SAS o Stata.

Solución

El paquete haven tiene la función read_sav() para leer archivos SPSS. Para cargar datos de un archivo SPSS:

# Only need to install the first time
install.packages("haven")

library(haven)
data <- read_sav("datafile.sav")

Debate

El paquete haven también incluye funciones para leer desde otros formatos:

• read_sas(): SAS

• read_dta(): Stata

Una alternativa a haven en es el paquete foreign. También admite archivos SPSS y Stata, pero no está tan actualizado como las funciones de haven. Por ejemplo, sólo admite archivos Stata hasta la versión 12, mientras que haven admite hasta la versión 14 (la versión actual en el momento de escribir esto).

El paquete extranjero admite algunos otros formatos, entre ellos:

• read.octave(): Octave y MATLAB

• read.systat(): SYSTAT

• read.xport(): SAS XPORT

• read.dta(): Stata

• read.spss(): SPSS

Ver también

Ejecuta ls("package:foreign") para obtener una lista completa de las funciones del paquete extranjero.

1.7 Encadenar funciones con %>%, el operador tubería

Problema

En quieres llamar a una función, y luego pasar el resultado a otra función, y a otra, de forma que sea fácilmente legible.

Solución

Utiliza %>%, el operador de tuberías. Por ejemplo:

library(dplyr) # The pipe is provided by dplyr

morley # Look at the morley data set
#>     Expt Run Speed
#> 001    1   1   850
#> 002    1   2   740
#> 003    1   3   900
#>  ...<94 more rows>...
#> 098    5  18   800
#> 099    5  19   810
#> 100    5  20   870

morley %>%
  filter(Expt == 1) %>%
  summary()
#>       Expt        Run            Speed
#>  Min.   :1   Min.   : 1.00   Min.   : 650
#>  1st Qu.:1   1st Qu.: 5.75   1st Qu.: 850
#>  Median :1   Median :10.50   Median : 940
#>  Mean   :1   Mean   :10.50   Mean   : 909
#>  3rd Qu.:1   3rd Qu.:15.25   3rd Qu.: 980
#>  Max.   :1   Max.   :20.00   Max.   :1070

Toma el conjunto de datos morley y lo pasa a la función filter() de dplyr, manteniendo sólo las filas de los datos en las que Expt es igual a 1. A continuación, ese resultado se pasa a la función summary(), que calcula algunas estadísticas de resumen de los datos.

Sin el operador tubería, el código anterior se escribiría así:

summary(filter(morley, Expt == 1))

En este código, las llamadas a funciones se procesan de dentro hacia fuera. Desde un punto de vista matemático, esto tiene mucho sentido, pero desde el punto de vista de la legibilidad, puede resultar confuso y difícil de leer, sobre todo cuando hay muchas llamadas a funciones anidadas.

Debate

Este patrón, con el operador %>%, se utiliza mucho con los paquetes tidyverse, porque contienen muchas funciones que hacen cosas relativamente pequeñas. La idea es que estas funciones sean bloques de construcción que permitan a los usuarios componer las llamadas a las funciones para producir el resultado deseado.

Para ilustrar lo que ocurre, aquí tienes un ejemplo más sencillo de dos fragmentos de código equivalentes:

f(x)

# Equivalent to:
x %>% f()

En esencia, el operador tubería toma lo que está a la izquierda y lo coloca como primer argumento de la llamada a la función que está a la derecha.

Puede utilizarse para varias llamadas a funciones, en una cadena:

h(g(f(x)))

# Equivalent to:
x %>%
  f() %>%
  g() %>%
  h()

En una cadena de funciones, el orden léxico de las llamadas a funciones es el mismo que el orden en que se calculan.

Si quieres almacenar el resultado final, puedes utilizar el operador <- al principio. Por ejemplo, esto sustituirá el x original por el resultado de la cadena de funciones:

x <- x %>%
  f() %>%
  g() %>%
  h()

Si hay argumentos adicionales para las llamadas a la función, se desplazarán a la derecha cuando se utilice el operador tubería. Volviendo al código del primer ejemplo, estos dos son equivalentes:

filter(morley, Expt == 1)

morley %>% filter(Expt == 1)

En realidad, el operador de tuberías procede del paquete magrittr, pero dplyr lo importa y lo pone a tu disposición cuando llamas a library(dplyr).

Ver también

Para ver muchos más ejemplos de cómo utilizar %>% en la manipulación de datos, consultael Capítulo 15.