Clase 4: Los verbos de la manipulación

En esta clase nos enfocaremos en agregar a nuestra caja de herramientas funciones para manipular dataframes (data rectangular) provenientes del paquete dplyr. Utilizaremos de ejemplo principalmente los datos que vienen en el objeto gapminder pertenecientes al paquete que lleva el mismo nombre.

Lo primero que haremos será cargar los paquetes que utilizaremos en nuestro análisis.

# Cargamos nuestras aplicaciones (paquetes).
library(dplyr)   # funciones (verbos) para manipular dataframes.
library(gapminder)  # paquete que tiene la data con que trabajaremos.

Algunos puntos antes de partir

Antes de comenzar, repasemos algunos puntos para asegurarnos de que todos nos encontramos hablando en los mismos t?rminos.

1. Estructura de datos: en el contexto de programación es como representamos la información. Hasta ahora solo hemos visto la estructura llamada data rectangular que la conocemos como dataframes o tibbles. Un ejemplo de este tipo de estructura de datos ser? el siguiente dataframe:

2. Dataframe: es el nombre formal de la estructura de datos que representa la data rectangular en el lenguaje de programación R. Por dataframe nos referimos simplemente a columnas que representan variables y filas que representan observaciones. En el ejemplo anterior, cada observación representa la nota de uno de mis ramos. Además hablamos de tibbles como término equivalente a dataframe, pero destacaremos una sola diferencia entre ambos, un tibble es más agradable de visualizar que un dataframe tradicional en la consola. En la clase pasada vimos las siguientes formas para crear data rectangular en R:

# Para crear un tibble por columnas.
notas <- tibble(
                ramo = c("Mate", "Lenguaje", "Danza"),
                notas = c(5.2,      3.9,         5.5)
                )


# Para crear un tibble por filas, ¡OJO! acá la función es tribble() con r.
# Vamos creando la data en orientación fila y especificamos los nombres de las
# columnas anteponiendo una cola de chancho ~ (alt + 126 en teclado 
# númerico)
notas <- tribble(
                  ~ramo,   ~ notas,
                  #---------------    # <- No es necesario escribir este comentario
                  "Mate",      5.2,   #    en el código, es para mostrar la
                  "Lenguaje",  3.9,   #    separaci?n del nombre de las columnas
                  "Danza",     5.5    #    con respecto a las observaciones.
)

# Fomra tradicional de crear un dataframe en R, la mécanica es equivalente
# a tibble() pero hay que forzar a que los caracteres sean tratados como
# tal y no como variable tipo "factor", especificando de esta forma el argumento 
# 'stringsAsFactors = FALSE'. En cambio, tibble() por defecto representan a los 
# caracteres como variable tipo "chr".
notas <- data.frame(
                ramo = c("Mate", "Lenguaje", "Danza"),
                notas = c(5.2,      3.9,         5.5),
                stringsAsFactors = FALSE
)

# Ahora en los tres casos anteriores, creamos una datarectangular y le asignamos
# al objeto que representa a esta, el nombre de "notas". Si queremos llamar
# o visualizar nuestra data en la consola, tenemos que llamar al objeto por
# su nombre de la siguiente manera: 
notas

3. Con respecto al código escrito arriba, destacar:

• El uso de # para escribir comentarios informativos en la región del código.
• El operador de asignación, <- (tecla rápida: alt + -), para darle un nombre a un objeto que creemos y así después poder utilizarlo en otra operación.
• Indentar el código, ¡Agregar espacio para que el código respire!, y para que visualmente sea más fácil de leer. No queremos escribir algo como lo siguiente que ejecuta lo mismo que la última forma de crear dataframes arriba pero es mucho más díficil de leer:

notas<-data.frame(ramo=c("Mate","Lenguaje","Danza"),notas=c(5.5,3.9,5.5),stringsAsFactors=FALSE)

• Respecto al estilo que adoptar para escribir código, darle nombre a las variables, archivos, etcétera, pueden leer más en este link

4. Cuando hablamos de herramientas que nos entrega un paquete, estamos hablando en el contexto de programación de funciones . La forma útil de pensar en una función es como una caja negra que le entregamos algo (input) y nos devuelve un resultado (output) en base a lo entregado. Si queremos saber que debemos entregarle a esta caja negra, podemos leer la documentación dentro de R que viene con información acerca de como usar y qué entregarle y/o especificarle a la función. Para esto debemos escribir ? inmediatamente seguido del nombre de la función en la consola como se muestra a continuación de este parrafo y se desplegará la documentación respectiva en uno de los cuadrantes. Lo importante con respecto a las funciones es que nos fuerzan a interactuar a traves de una interface para realizar una operación, evitando entrar en los detalles especificos de lo que ocurré por debajo, es por esto que la comparamos con una caja negra ya que no podemos observar lo que ocurré en su interior. Este concepto en programación se conoce como abstracción.

# Para consultar la documentación de la función tribble() dentro de R.
?data.frame

Los verbos de la manipulación

Nos referiremos por verbos de la manipulación a un conjunto de funciones pertenecientas al paquete dyplr que ejecutan una acción especifica sobre un dataframe y nos entregan un dataframe modificado como resultado.

Empezaremos explorando de forma individual cada uno de los verbos detallados a continuación y al final mostraremos como podemos componer operaciones más complejas sobre nuestros datos al juntar más de uno de estos verbos.

• filter: para filtrar observaciones basados en una o más condiciones.
• select: para seleccionar variables por nombre.
• mutate: para crear nuevas variables basadas en otras.
• summarise: para crear variables* que representan resumenes** de otras como el promedio.
• arrange: para ordenar las observaciones basado en una o más variable.
• group_by: para cambiar el dominio en que se aplican los verbos a nivel de grupos formados en base a variables dentro de un dataframe.

filter, para filtrar observaciones

Partamos con una operación a la que ya fuimos expuestos cuando realizamos el gráfico de burbujas. Estamos interesados solo en las observaciones de la data gapminder que tienen registros de paises pertenecientes al continente de America. Este tipo de tarea es ideal para la función filter(), podemos obtener subconjuntos de observaciones basados en los valores de estos.

filter(gapminder, continent == "Americas")

Reflexionemos un poco sobre la línea de código de arriba, el primer argumento de la función filter(), es decir, lo primero que especificamos dentro de la función es el nombre del objeto que representa nuestra data rectangular gapminder. Luego, encontramos la siguiente expresión continent == "Americas", que nos referiremos a este tipo de expresiones como condiciones lógicas.

Una condición lógica es una proposición que su resultado puede tener dos posibles valores: verdadero o falso.

Muchas de las condiciones lógicas se construyen con los operadores de relación, en las que se relaciona una variable con un valor. En el lenguaje de programación R los operadores de relación se especifican de la siguiente manera:

• ==: Igualdad.
• !=: No igualdad.
• >: Mayor que.
• <: Menor que.
• >=: Mayor o igual que.
• <=: Menor o igual que.

En el caso de nuestra condición lógica, queremos solo las observaciones de la data gapminder en que la relación continent == "Americas" sean evaluadas con valor verdadero. En otras palabras, no nos interesa el resto de las observaciones que pertencen a otros continentes para formar este subconjunto de datos.

filter(gapminder, continent = "Americas")

Error: `continent` (`continent = "Americas"`) must not be named, do you need `==`?

¡Ojo! un error común es utilizar = en vez de == para crear la relación de igualdad. Acá estaríamos tratando de asignar el valor "Americas" a la variable continent, cuando en realidad queremos generar una relación de igualdad, es decir utilizar el operador de relación ==.

Los operadores de relación >, <, >= y <= son utilizados para crear condiciones lógicas con variables númericas o con variables que no son númericas pero pueden ser representadas de alguna forma númerica.

# Ejemplo de una variable que no es n?merica pero puede
# tomar una representaci?n n?merica v?lida. TRUE = 1, FALSE = 0
c(TRUE, FALSE, TRUE, FALSE, FALSE) > 0

[1]  TRUE FALSE  TRUE FALSE FALSE

Un aspecto práctico de la sintaxis de la función filter(), y el resto de los verbos que veremos, es que las variables de nuestro dataframe en que hacemos referencia dentro de los argumentos, no deben ser rodeados de comillas. Por ejemplo, el nombre de la variable en la condición lógica continent == "Americas" no lleva comillas. Sin embargo, el valor de las observaciones que deseamos filtrar de la variable continent si va entre comillas "Americas".

Podemos agregar más de un argumento expresando una condición lógica en la función filter(). Por ejemplo, queremos obtener solo información de los países del continente americano sobre el año 2000.

filter(gapminder, continent == "Americas", year > 2000)

Lo relevante cuando ocupamos más de un argumento con condiciones lógicas dentro de filter(), es que cada expresión que va separada por una coma, se une con el operador lógico conocido como & (AND). Esto significa que nos entregará las observaciones que cumplan las siguientes dos condiciones simultaneamente:

1. continent == "Americas"
2. year > 2000.

Como podemos observar del resultado que nos entrega el código, no hay observaciones que sean year > 2000 pero que no pertenezcan al continente americano, o viceversa, no hay observaciones que pertenezcan continent == "Americas" pero que daten igual o menor al año 2000.

Existen tambien los operadores lógicos:

• !: negación, se antepone en una condición lógica para invertir su valor.
• &: “y” lógico, equivalente agregar más de un argumento en filter.
• |: “?” lógico, sí se cumple alguna de las condiciones.

Si quisieramos obtener todas las observaciones que no sean del continente americano, podriamos negar la condición lógica continent == "Americas", invirtiendo el signo a FALSE cuando las observaciones pertenezcan al continente “Americas” y a TRUE cuando sean distintas de “Americas”, esto anteponiendo el operador lógico ! de la siguiente forma:

# Invertir el signo de la evaluación de la condición lógica con "!".
filter(gapminder, !(continent == "Americas"))

El operador & es equivalente cómo se mencionó anteriormente a enumerar más de una condición lógica en los argumentos de la función filter.

# Las dos formas de uso son equivalentes:
filter(gapminder, continent == "Americas", year > 2000)
filter(gapminder, continent == "Americas" & year > 2000)

En cambio, el operador lógico | (OR), no puede ser empleado enumerando condiciones lógicas en los argumentos de filter. Se debe hacer uso explicito de este operador, por ejemplo, si quisieramos las observaciones pertenecientes al continente americano o asiatico, es una buena oportunidad para ocupar | en uno de los argumentos de filter:

filter(gapminder, continent == "Americas" | continent == "Asia")

Observemos que la condición lógica continent == "Americas" | continent == "Asia" va en un solo argumento dentro de filter, no hay comas entremedio y además se debe especificar el nombre de la variable en cada uso del operador de igualdad ==. Los siguientes usos serían una forma incorrecta de aplicar el operador |:

# Mal uso del operador |.
filter(gapminder, continent == "Americas" | "Asia") 
# Esto equivale al operador & y no al operador |. De hecho, una observación
# no puede tener el valor "Americas" y "Asia" al mismo tiempo.
filter(gapminder, continent == "Americas", continent == "Asia")

Un último punto con respecto a la función filter y las condiciones lógicas es el uso del operador %in%. Para ilustrar las bondades de este nuevo operador, describamos el caso tedioso en que deseamos filtrar las observaciones que pertenezcan al continente americano o asiático o europeo. Según lo discutido anteriormente, esto equivaldría a emplear la condición lógica continent == "Americas" | continent == "Asia" | continent == "Europe" dentro de la función filter:

filter(gapminder, continent == "Americas" | continent == "Asia" | continent == "Europe")

El operador %in% nos permitira escribir la operación anterior de la siguiente forma:

filter(gapminder, continent %in% c("Americas", "Asia", "Europe"))

Este operador evalúa en cada observación de gapminder, se el valor de la variable continent se encuentra en alguno de los elementos del vector definido como c("Americas", "Asia", "Europe"). Por ahora, basta con entender que un vector es simplemente un conjunto de elementos del mismo tipo, en este caso, todos los elementos son un carácter.

Muchas veces es útil combinar el operador de negación ! junto a la condición lógica compuesta por el operador %in% de la siguiente forma:

# Filtrar todas las observaciones que no esten en los siguientes continentes:
filter(gapminder, !(continent %in% c("Americas", "Asia", "Europe")))

select: seleccionar variables por su nombre

El verbo select es más simple de entender. La acción que ejecuta sobre un dataframe es la de seleccionar variables por su nombre. Al igual que filter, el nombre de las variables no debe ir rodeado por comillas.

Veamos el nombre de las variables contenidas en gapminder.

names(gapminder)

[1] "country"   "continent" "year"      "lifeExp"   "pop"      
[6] "gdpPercap"

Imaginemos que de la tabla gapminder solo nos interesan las variables country, year y lifeExp.

select(gapminder, country, year, lifeExp)

Esto que es una simple selección, muchas veces es la implementación de una simple técnica que es focalizar el análisis en una dimensión más reducida de los datos. Evidentemente el costo de disminuir la complejidad de nuestros datos descartando variables es el de la pérdida de información.

Podemos utilizar select para descartar variables, esto anteponiendo un signo - en el nombre de la variable a descartar.

# Todas las variables menos lifeExp.
select(gapminder, -lifeExp)

Una forma rápida para evitar tipear el nombre de muchas variables, es crear rangos de selección en variables que se quieren seleccionar y se encuentran de forma continua en la tabla. Por ejemplo, en gapminder sí quisiera escoger las variables year a gdpPercap podr?amos escribir esta selección por rango como year:gdpPercap.

# Seleccionar las variables que se encuentran entre year y gdpPercap inclusive.
select(gapminder, year:gdpPercap)

Otros uso de la función select es para reacomodar el orden de las variables. A veces, esto puede ser tedioso sí solo quisieramos mover la variable year a la primera columna y dejar el resto de las variables con el mismo orden. Esto implicaría escribir el siguiente código:

select(gapminder, year, country, continent, lifeExp, pop, gdpPercap)

La existencia de la función auxiliar everything para usar en conjunto con select facilita este tipo de tarea al realizar la misma operación de forma más concisa:

# Debemos incluir los parentesis para llamar a la funci?n everything()!
select(gapminder, year, everything())

Existen más funciones auxiliares que son convenientes de usar en conjunto con select como:

• starts_with("prefijo"): seleccionar variables que compartan igual prefijo.
• ends_with("sufijo"): seleccionar variables que compartan igual sufijo.
• contains("patron"): seleccionar variables que contengan un patrón común.

mutate: para crear nuevas variables

El verbo mutate nos permite crear una nueva variable en nuestro dataframe que se adjunta como columna al final de la tabla.

Ilustremos el uso de mutate creando la nueva variable popMillions en la tabla gapminder.

# Crear una variable con la poblaci?n en millones.
mutate(gapminder, popMillions = pop / 1e6) # 1e6 = 1000000

El ejemplo anterior es simplemente cambiar la unidad de medida de una variable ya existente. En caso de que conservar la variable original pop no nos interese, podemos sobreescribir esta directamente en la definición de mutate:

mutate(gapminder, pop = pop / 1e6)

Un ejemplo más interesante de mutate es el siguiente que involucra más de una variable de gapminder.

# Computar el PIB por cada observaci?n a partir del PIB per capita y la poblaci?n.
mutate(gapminder, gdp = pop * gdpPercap)

Otra caracteristica de mutate es que podemos crear más de una variable, incorporando cada creación en un nuevo argumento. Además, podemos utilizar variables nuevas que fueron creadas en algún argumento anterior en otro argumento dentro del mismo llamado de la función mutate.

mutate(gapminder, gdp = pop * gdpPercap,  # creo gdp primero
                  gdpMillion = round(gdp / 1e9, 2)) # ahora gdp en miles de millones

Podemos utilizar funciones en conjunto con mutate para crear las nuevas variables:

mutate(gapminder, pos_90 = ifelse(year > 1990, TRUE, FALSE))

Es importante entender que mutate esta diseñado para agregar nuevas variables a la tabla que se le entrega, por esto mismo, la variable creada debe ser del mismo tama?o que el resto de las variables. No se puede “descuadrar” la data rectangular, al tener una variable con más o menos observaciones que las variables restantes.

En línea con lo anterior, es importante tener presente lo qué pasa cuando hay una función involucrada en la creación de una nueva variable dentro de mutate, que devuelve menos valores de los que se le entregan. Es decir, le entrego una variable como gdpPercap que tiene 1704 observaciones y la función, que puede ser por ejemplo mean, me entrega un solo valor que es el promedio de estas 1704 observaciones que corresponde a 7215.327.

mutate(gapminder, avg_gdpPercap = mean(gdpPercap))

En el caso anterior, mutate recicla el valor 7215.327, repitiendo este tantas veces como número de filas tenga la tabla y así mantener la consistencia de la data rectangular.

summarise: para resumir valores

El verbo summarise funciona similar a mutate pero con el objetivo de crear variables resumenes. Estas se crean a partir de funciones que toman un grupo de valores y entregan un solo valor. Ejemplo de este tipo de funciones son:

• count
• sum
• mean
• median
• sd
• max
• min

Un caso aplicado de summarise sobre gapminder puede ser el cálculo promedio de expectativa de vida.

summarise(gapminder, avgLifeExp = mean(lifeExp))

La sintaxis de summarise es símil a la de mutate, primero y como todos los verbos, damos el nombre de nuestra data rectangular. Segundo, escribimos el nombre de la nueva variable resumen (avgLifeExp) seguido de = y la operación o acción sobre variables ya existente en la data entregada (lifeExp). Tambien se pueden crear más de una variable resumen en un mismo llamado de la función summarise.

summarise(gapminder, 
          avgLifeExp = mean(lifeExp),
          numObs = n())

La función n() cuenta el número de observaciones en la tabla. En general, summarise tiene mayor utilidad en conjunto de group_by, como veremos más adelante.

group_by: para cambiar el dominio de acción de los verbos

¿Qué pasa sí queremos el promedio de lifeExp pero ahora por continente? ¿o filtrar observaciones que cumplan cierta condición lógica pero para cada uno de los distintos años (year) de nuestra data gapminder?

group_by será la pieza que actuará cambiando el dominio en que se ejecuta cada verbo. Respondamos la primera interrogante, necesitamos agrupar (group_by) por continente (continent) para ejecutar el verbo summarise y crear la variable expectativa de vida promedio (avgLifeExp).

# cambiamos el dominio de ejecución (o análisis) de los verbos
por_continente <- group_by(gapminder, continent)
# en vez de aplicar los verbos sobre gapminder, lo hacemos sobre
# por_continente
summarise(por_continente, avgLifeExp = mean(lifeExp))

Abordemos ahora una interrogante como la segunda planteada, digamos que queremos encontrar el país (country) con mayor expectativa de vida (lifeExp) por año (year).

por_periodo <- group_by(gapminder, year)
filter(por_periodo, lifeExp == max(lifeExp))

El filter aplicado sobre la data agrupada por_periodo, arrojó 12 observaciones. Podemos corroborar que nuestra operación estuvo correcta sí analizamos cuantos años diferentes hay en gapminder y para esto podemos utilizar otra función de dplyr llamada distinct.

distinct(gapminder, year)

Efectivamente, el verbo filter nos entrego para cada uno de los años contenidos (por_periodo) en la base gapminder, la observación con mayor expectativa de vida lifeExp.

arrange: para ordenar observaciones

A veces queremos ordenar nuestra data rectangular en base a una o más variables. Esto es útil para saber que observación es la menor o mayor con respecto alguna variable. Para este tipo de tareas es útil el verbo arrange.

Nos gustaría ordenar gapminder por la variable year.

arrange(gapminder, year)

Podemos incorporar otra variable para ordenar dentro de cada año. Ordenemos luego de year por lifeExp tambien en orden ascedente, es decir, de menos a mas en caso de lifeExp, de lo pasado a lo más actual en caso de year.

arrange(gapminder, year, lifeExp)

Podemos observar que en el año 1952, el país con menor expectativa de vida fue Afghanistan. Si quisieramos ordenar de tal forma que las primeras observaciones de gapminder reflejen la situación de los países más cercano a la actualidad con respecto a que país tuvo menor expectativa de vida lifeExp. Para esta tarea, podemos utilizar la función auxiliar desc en conjunto con arrange.

arrange(gapminder, desc(year), lifeExp)

En el año 2007, la situación de Afghanistan mejoró aumentando aproximadamente 15 años la expectativa de vida. Sin embargo, esta mejora sigue siendo insuficiente sí consideramos que transcurrieron 55 años desde la primera medición.

Componer con los verbos y la historia de Pin Pon

En esta sección discutiremos acerca de como componer operaciones más complejas sobre dataframes que las ejercidas por un solo verbo.

Supongamos que tenemos en mente realizar las siguientes operaciones sobre la data gapminder para concluir con un gráfico.

1. Filtrar solo las observaciones correspondientes country igual Chile.
2. Seleccionar las variables year, pop y gdpPercap
3. Computar la variable gdpMillion en base a pop y gdpPercap.
4. Gráficar la evolución del PIB con respecto a la variable year (gráfico de línea).

Una forma de pasar lo que tenemos en mente a la consola, es enfocarse en el último paso y saber que para crear el gráfico necesitamos entregarle a la función ggplot una data con las caracteristicas deseadas. Luego, añadirle una capa con una línea como representación de las variables year y gdpMillion mapeadas al eje x e y respectivamente. Por lo tanto, el esqueleto simple de nuestro programa para ejecutar los pasos deseados es:

library(ggplot2)
ggplot(data = DATA_CARACTERISTICAS_DESEADAS)
  + geom_line(mapping = aes(x = year, y = gdpMillion))

En cuanto a la DATA_CARACTERISTICAS_DESEADAS, debemos pensar que cada verbo entrega un dataframe modificado. Luego, sí le entrego este output recibido de un verbo a otro, el nuevo verbo ejecutará su acción sobre una tabla ya modificada. Por lo tanto, si continuó esta cadena en algún punto obtendré una tabla con todas las caracteristicas deseadas.

                                           # IDENTIFICAR ARGUMENTOS
                                           # ----------------------             
mutate(                                    #                   | mutate
       select(                             #         | select  | data3
              filter(                      #| filter |  data2  | data3
                    gapminder,             #| data1  |  data2  | data3  
                    country == "Chile"     #| arg1   |  data2  | data3
                    ),                     #         |  data2  | data3
              year, pop, gdpPercap         #         |  arg2   | data3
              ),                           #                   | data3
      gdpMillion = (gdpPercap * pop) / 1e6 #                   | arg3
)                                          # ----------------------
                                           # Parentesis deben estar ()!

Integrando estos dos bloques de código en uno.

library(ggplot2) 
ggplot(data =
        mutate(
               select(
                      filter(
                             gapminder, 
                             country == "Chile"),
                      year,
                      pop,
                      gdpPercap
                      ),
               gdpMillion = (gdpPercap * pop) / 1e6
              )
      ) +
  geom_line(mapping = aes(x = year, y = gdpMillion))  

¿Podemos realizar la secuencia de operaciones sobre gapminder de otra forma?

La segunda alternativa es asignar el resultado de cada verbo a una variable y luego ir transmitiendo esta en representación de la operación.

chile <- filter(gapminder, country == "Chile")
chile2 <- select(chile, year, pop, gdpPercap)
chile3 <- mutate(chile2, gdpMillion = (gdpPercap * pop) / 1e6)
ggplot(data = chile3) +
  geom_line(mapping = aes(x = year, y = gdpMillion))

La tercera alternativa, es útilizar el operador %>% (ctrl + shift + m), llamado “pipe”, que Pin Pon nos contará un poco más.

Analicemos el primer párrafo de la canción de Pin Pon:

Pin Pon es un muñeco
Muy guapo y de cartón, de cartón,
Se lava la carita
Con agua y con jabón, con jabón

Traduzcamos esto para el computador, queremos que Pin Pon, este muñeco guapo y de cartón, se lavé la carita con agua y con jabón.

Debemos crear primero al muñeco Pin Pon y las características que lo describen.

pin_pon <- muñeco(apariencia = guapo, material = carton)

Sí queremos ejecutar la acción lavar sobre el muñeco Pin Pon podemos utilizar esta como una función equivalente al verbo select, solo que en este caso el resultado modificará el estado higienico de Pin Pon y no un dataframe.

lavar(pin_pon, 
      que = carita, 
      como = con_agua_y_con_jabon)

El operador pipe %>%, toma el objeto que se encuentra a su izquierda como el primer argumento de la función que esta a la derecha. Es decir, obj_izq %>% accion_derecha() == accion_derecha(obj_izq). Por lo que aplicar la acción de lavar a Pin Pon quedaría escrito de la siguiente forma:

pin_pon %>% 
    lavar(que = carita,
          como = con_agua_y_con_jabon)

¿Qué gano con esto? El verdadero poder del operador %>% surge cuando estamos en una situación similar a la descrita al principio de esta sección. Nos encontramos con multiples acciones que ejecutar sobre un objeto como un dataframe.

Analicemos otro parrafo más de la canción de Pin Pon para encontrar una situación similar:

Pin Pon toma su sopa
Y no ensucia el delantal
Pues come con cuidado
Como un buen colegial

En este parrafo, a diferencia del anterior, Pin Pon ejecuta dos acciones principales tomar y comer. Podriamos escribir el código en la forma clásica como:

comer(
      tomar(
            pin_pon, 
            que = sopa),
      con = cuidado, 
      como = un_buen_colegial
      )

Sí utilizamos el operador %>% para escribir lo mismo:

pin_pon %>% 
        tomar(que = sopa) %>% 
        comer(con = cuidado,
              como = un_buen_colegial)

Cada operador %>% va tomando el objeto que tiene a su izquierda y lo ingresa como el primer argumento de la acción a ejecutarse por la función a la derecha del operador. Esto como resultado, tiene dos ventajas:

1. El código es más fácil de leer y entender, simplemente partimos con nuestro objeto inicial y vamos aplicando acciones que modifican a este objeto de arriba hacía abajo.

2. No necesitamos guardar variables intermedias con las modificaciones del objeto, simplemente guardamos cuando llegamos a la última modificación que nos interesa almacenar en una variable para ocupar después.

Ya dejando descansar a Pin Pon, ahora podemos ocupar esta forma de escribir código para crear nuestro gráfico:

gapminder %>% 
  filter(country == "Chile") %>% 
  select(year, pop, gdpPercap) %>% 
  mutate(gdpMillion = (gdpPercap * pop) / 1e6) %>% 
  ggplot() +
    geom_line(mapping = aes(x = year, y = gdpMillion))

El código anterior ilustra las ventajas del operador %>% sobre alternativas anteriores.

1. Sobre la primera alternativa, es evidente que es más fácil leer la ejecución de acciones de manera lineal, en el ejemplo, de arriba hacía abajo se van ejecutando cada uno de los verbos. En cambio, la primera alternativa que vimos, se va haciendo más compleja de leer al tener mayor número de acciones porque debemos iniciar una lectura de “adentro hacía afuera”

2. Sobre la segunda alternativa, la de almacenar el resultado de las acciones a variables para luego referirnos a estas por su nombre. Tiene a veces el problema de obligarnos a guardar resultados intermedios de los que por sí no tenemos mucho interes. El operador %>% nos propone la regla para crear objetos con nombres cuando estos realmente merecen tenerlos, y evitar crear objetos intermedios como chile1, chile2, chile3 que su único proposito es lograr un paso para otra acción de la cual tenemos interes en su resultado.