Maneja dplyr/tidyverse con Manzanas

Qué es dplyr?

dplyr es un paquete que se encuentra dentro de la colección de paquetes de tidyverse.

dplyr es una gramática de manipulación de datos, que proporciona un conjunto consistente de verbos que lo ayudan a resolver los desafíos más comunes de manipulación de datos.

\(\underline{Funciones:}\)

1. select() : Selecciona las columnas que deseas, de acuerdo a sus nombres.
2. rename() : Renombra las columnas.
3. filter() : Filtrar registros en función de sus valores.
4. arrange() : Ordena una o varias columnas de formar ascendente (por defecto) o descendente.
5. mutate() : Crea nuevas variables en función de las existentes.
6. summarise() : Resume el Dataframe en uno o varios valores.
7. group_by() : Función que agrupa de acuerdo a algún campo y opera en conjunto con la función summarise(). (Similar al group by de SQL)

Nota: Se utilizarán las tuberias en cada ejercicio. ( %>% Tips: En windows Ctrol + Shift + M)

Instalación

install.packages("tidyverse", dependencies = TRUE)
library(tidyverse)

DataFrame de Ejemplo

#Tibble es un dataframe optimizado para tidyverse.
df = tibble("PAIS" = c("Chile","Brasil","Perú","Chile","Chile"),
           "CIUDAD" = c("Santiago","Antas","Lima","Santiago","Concepción"),
           "CODIGO" = c(1,2,NA,1,3),
           "VENTAS" = c(100,200,300,400,500))
df

# A tibble: 5 x 4
  PAIS   CIUDAD     CODIGO VENTAS
  <chr>  <chr>       <dbl>  <dbl>
1 Chile  Santiago        1    100
2 Brasil Antas           2    200
3 Perú   Lima           NA    300
4 Chile  Santiago        1    400
5 Chile  Concepción      3    500

Función select():

Ejercicio 1S: Seleccionar las columnas PAIS y VENTAS:

reg_sel_pais_ventas = df %>% select(PAIS,VENTAS)
reg_sel_pais_ventas

# A tibble: 5 x 2
  PAIS   VENTAS
  <chr>   <dbl>
1 Chile     100
2 Brasil    200
3 Perú      300
4 Chile     400
5 Chile     500

Ejercicio 2S: Seleccionar todas las columnas entre CUIDAD y VENTAS:
(Tips: Usar “:”)

reg_sel_cuidad_a_ventas = df %>% select(CIUDAD:VENTAS)
reg_sel_cuidad_a_ventas

# A tibble: 5 x 3
  CIUDAD     CODIGO VENTAS
  <chr>       <dbl>  <dbl>
1 Santiago        1    100
2 Antas           2    200
3 Lima           NA    300
4 Santiago        1    400
5 Concepción      3    500

Ejercicio 3S: Seleccionar todas las columnas, menos las columnas entre CODIGO y VENTAS:
(Tips: Usar “-”)

reg_sel_menos_codigo = df %>% select(-(CODIGO:VENTAS))
reg_sel_menos_codigo

# A tibble: 5 x 2
  PAIS   CIUDAD    
  <chr>  <chr>     
1 Chile  Santiago  
2 Brasil Antas     
3 Perú   Lima      
4 Chile  Santiago  
5 Chile  Concepción

Ejercicio 4S: Seleccionar todas las columnas, que comiencen con la letra C:
(Tips: Usar “start_with()”)

reg_sel_inician_c = df %>% select(starts_with("C"))
reg_sel_inician_c

# A tibble: 5 x 2
  CIUDAD     CODIGO
  <chr>       <dbl>
1 Santiago        1
2 Antas           2
3 Lima           NA
4 Santiago        1
5 Concepción      3

Ejercicio 5S: Seleccionar todas las columnas, que terminan con la letra S:
(Tips: Usar “ends_with()”)

reg_sel_terminan_s = df %>% select(ends_with("S"))
reg_sel_terminan_s

# A tibble: 5 x 2
  PAIS   VENTAS
  <chr>   <dbl>
1 Chile     100
2 Brasil    200
3 Perú      300
4 Chile     400
5 Chile     500

Ejercicio 6S: Seleccionar todas las columnas, que contienen la letra I:
(Tips: Usar “contains()”)

reg_sel_contiene_i = df %>% select(contains("I"))
reg_sel_contiene_i

# A tibble: 5 x 3
  PAIS   CIUDAD     CODIGO
  <chr>  <chr>       <dbl>
1 Chile  Santiago        1
2 Brasil Antas           2
3 Perú   Lima           NA
4 Chile  Santiago        1
5 Chile  Concepción      3

Ejercicio 7S: Seleccionar en primera posición VENTAS y luego todo el resto de columnas siguientes:
(Tips: Usar “everything()”)

reg_sel_ventas_otras = df %>% select(VENTAS,everything())
reg_sel_ventas_otras

# A tibble: 5 x 4
  VENTAS PAIS   CIUDAD     CODIGO
   <dbl> <chr>  <chr>       <dbl>
1    100 Chile  Santiago        1
2    200 Brasil Antas           2
3    300 Perú   Lima           NA
4    400 Chile  Santiago        1
5    500 Chile  Concepción      3

Función rename():

Ejercicio 1R: Renombre las columnas PAIS como PAISES:

reg_ren_paises = df %>% rename(PAISES = PAIS)
reg_ren_paises

# A tibble: 5 x 4
  PAISES CIUDAD     CODIGO VENTAS
  <chr>  <chr>       <dbl>  <dbl>
1 Chile  Santiago        1    100
2 Brasil Antas           2    200
3 Perú   Lima           NA    300
4 Chile  Santiago        1    400
5 Chile  Concepción      3    500

Ejercicio 2R: Renombre las columnas a minúsculas:
(Tips: Usar rename_all())

reg_ren_tolower = df %>% rename_all(tolower)
reg_ren_tolower

# A tibble: 5 x 4
  pais   ciudad     codigo ventas
  <chr>  <chr>       <dbl>  <dbl>
1 Chile  Santiago        1    100
2 Brasil Antas           2    200
3 Perú   Lima           NA    300
4 Chile  Santiago        1    400
5 Chile  Concepción      3    500

Función filter():

Ejercicio 1F: Filtrar todos los registros de la columna PAIS que digan Chile:

registros_chile = df %>% filter(PAIS == "Chile")
registros_chile  

# A tibble: 3 x 4
  PAIS  CIUDAD     CODIGO VENTAS
  <chr> <chr>       <dbl>  <dbl>
1 Chile Santiago        1    100
2 Chile Santiago        1    400
3 Chile Concepción      3    500

Ejercicio 2F: Filtrar todos los registros de la columna PAIS que digan Chile y todos los registros de la columna CUIDAD que digan Santiago: (Tips: Usar & cuando es Y)

reg_chile_y_santiago = df %>% filter(PAIS == "Chile" & CIUDAD == "Santiago")
reg_chile_y_santiago  

# A tibble: 2 x 4
  PAIS  CIUDAD   CODIGO VENTAS
  <chr> <chr>     <dbl>  <dbl>
1 Chile Santiago      1    100
2 Chile Santiago      1    400

Ejercicio 3F: Filtrar todos los registros de la columna PAIS que digan Chile o todos los registros de la columna VENTAS que sean 200 o 300: (Tips: Usar | cuando es O, Usar %in% cuando son varios)

reg_chile_o_santiago = df %>% filter(PAIS == "Chile" | VENTAS %in% c(200,300))
reg_chile_o_santiago  

# A tibble: 5 x 4
  PAIS   CIUDAD     CODIGO VENTAS
  <chr>  <chr>       <dbl>  <dbl>
1 Chile  Santiago        1    100
2 Brasil Antas           2    200
3 Perú   Lima           NA    300
4 Chile  Santiago        1    400
5 Chile  Concepción      3    500

Ejercicio 4F: Filtrar todos los registros de la columna VENTAS entre 200 y 400 (Tips: between)

reg_ventas_entre_200_y_400 = df %>% filter(between(VENTAS, 200,400))
reg_ventas_entre_200_y_400  

# A tibble: 3 x 4
  PAIS   CIUDAD   CODIGO VENTAS
  <chr>  <chr>     <dbl>  <dbl>
1 Brasil Antas         2    200
2 Perú   Lima         NA    300
3 Chile  Santiago      1    400

Ejercicio 5F: Filtrar todos los registros de la columna CODIGO que sean NA : (Tips: Usar is.na())

reg_na_codigo = df %>% filter(is.na(CODIGO))
reg_na_codigo

# A tibble: 1 x 4
  PAIS  CIUDAD CODIGO VENTAS
  <chr> <chr>   <dbl>  <dbl>
1 Perú  Lima       NA    300

Función arrange():

Ejercicio 1A: Ordenar la columana VENTAS de forma descendente: (Tips: Usar desc(VENTAS), es lo mismo que un signo menos antes de la columna -VENTAS)

reg_desc_ventas = df %>% arrange(-VENTAS)
reg_desc_ventas

# A tibble: 5 x 4
  PAIS   CIUDAD     CODIGO VENTAS
  <chr>  <chr>       <dbl>  <dbl>
1 Chile  Concepción      3    500
2 Chile  Santiago        1    400
3 Perú   Lima           NA    300
4 Brasil Antas           2    200
5 Chile  Santiago        1    100

Ejercicio 2A: Ordenar la columna PAIS de forma ascendente y CUIDAD de forma descendente: (Tips: Usar desc(CIUDAD) ya que -CIUDAD no opera cuando es chr el campo, con más de una columna)

reg_pais_desc_cuidad = df %>% arrange(PAIS,desc(CIUDAD))
reg_pais_desc_cuidad

# A tibble: 5 x 4
  PAIS   CIUDAD     CODIGO VENTAS
  <chr>  <chr>       <dbl>  <dbl>
1 Brasil Antas           2    200
2 Chile  Santiago        1    100
3 Chile  Santiago        1    400
4 Chile  Concepción      3    500
5 Perú   Lima           NA    300

Función mutate():

Ejercicio 1M: Generar una nueva columna llamada VENTASx1.5, que se genere de multiplicar la columna VENTAS por el valor 1.5.

reg_mut_ventas1.5 = df %>% mutate(VENTASx1.5 = VENTAS * 1.5)
reg_mut_ventas1.5

# A tibble: 5 x 5
  PAIS   CIUDAD     CODIGO VENTAS VENTASx1.5
  <chr>  <chr>       <dbl>  <dbl>      <dbl>
1 Chile  Santiago        1    100        150
2 Brasil Antas           2    200        300
3 Perú   Lima           NA    300        450
4 Chile  Santiago        1    400        600
5 Chile  Concepción      3    500        750

Ejercicio 2M: Reemplazar la columna CODIGO, por otra con el mismo nombre en donde los na sea reemplazado por 0: (Tips: Usar replace_na())

reg_codigo_sin_na = df %>% mutate(CODIGO = replace_na(CODIGO, 0))
reg_codigo_sin_na

# A tibble: 5 x 4
  PAIS   CIUDAD     CODIGO VENTAS
  <chr>  <chr>       <dbl>  <dbl>
1 Chile  Santiago        1    100
2 Brasil Antas           2    200
3 Perú   Lima            0    300
4 Chile  Santiago        1    400
5 Chile  Concepción      3    500

Ejercicio 3M: Crear nueva columna llamada DESC_CODIGO, de acuerdo a las siguientes reglas 0 => “PE” , 1 => “CL”, 2 => “BR”, 3 => “CL” en relación al campo CODIGO: (Tips: Usar case_when())

reg_desc_cod = reg_codigo_sin_na %>% mutate(DESC_CODIGO = case_when(
                                                    CODIGO == 0 ~ "PE",
                                                    CODIGO == 1 ~ "CL",
                                                    CODIGO == 2 ~ "BR",
                                                    CODIGO == 3 ~ "CL"
                                                    ))
reg_desc_cod

# A tibble: 5 x 5
  PAIS   CIUDAD     CODIGO VENTAS DESC_CODIGO
  <chr>  <chr>       <dbl>  <dbl> <chr>      
1 Chile  Santiago        1    100 CL         
2 Brasil Antas           2    200 BR         
3 Perú   Lima            0    300 PE         
4 Chile  Santiago        1    400 CL         
5 Chile  Concepción      3    500 CL         

Función summarise():

Ejercicio 1SU: Sumar las columnas de CODIGO y de VENTAS, eliminado los eventuales valores NA de cada una de ellas: (Tips: Usar na.rm = T)

totales = df %>% summarise(suma_codigos = sum(CODIGO, na.rm = T),suma_ventas = sum(VENTAS, na.rm = T))
totales

# A tibble: 1 x 2
  suma_codigos suma_ventas
         <dbl>       <dbl>
1            7        1500

Ejercicio 2SU: Contar la cantidad de valores de diferentes de la columna CODIGO y contar la cantidad de valores de la columna VENTAS: (Tips: Usar n_distinct() para contar los diferentes, y n() para contar todos)

cantidades = df %>% summarise(n_codigos_dif = n_distinct(CODIGO), n_ventas = n())
cantidades

# A tibble: 1 x 2
  n_codigos_dif n_ventas
          <int>    <int>
1             4        5

Función group_by():

Ejercicio 1G: Mostrar las ventas por PAIS: (Nota: Similar a función aggregate)
(Tips: Usar sum())

ventas_pais = df %>% group_by(PAIS) %>% summarise(TOTAL_VENTAS = sum(VENTAS))
ventas_pais

# A tibble: 3 x 2
  PAIS   TOTAL_VENTAS
  <chr>         <dbl>
1 Brasil          200
2 Chile          1000
3 Perú            300

Ejercicio 2G: Mostrar las ventas por PAIS y por CUIDAD: (Tips: Usar sum())

ventas_pais_cuidad = df %>% group_by(PAIS,CIUDAD) %>% summarise(TOTAL_VENTAS = sum(VENTAS))
ventas_pais_cuidad

# A tibble: 4 x 3
# Groups:   PAIS [3]
  PAIS   CIUDAD     TOTAL_VENTAS
  <chr>  <chr>             <dbl>
1 Brasil Antas               200
2 Chile  Concepción          500
3 Chile  Santiago            500
4 Perú   Lima                300

Ejercicio 3G: Mostrar promedio de ventas y la mediana por PAIS : (Tips: Usar mean(), median() y na.rm = T por si eventualmente existieran NA)

ventas_x_me_pais = df %>% group_by(PAIS) %>% summarise(PROMEDIO_VENTAS = mean(VENTAS, na.rm = T),
                                                      MEDIANA_VENTAS = median(VENTAS, na.rm = T))
ventas_x_me_pais

# A tibble: 3 x 3
  PAIS   PROMEDIO_VENTAS MEDIANA_VENTAS
  <chr>            <dbl>          <dbl>
1 Brasil            200             200
2 Chile             333.            400
3 Perú              300             300

Ejercicio 4G: Generar un ranking del campo PAIS , en relación a quién ha ventido más: (Tips: Usar min_rank() para encontrar el ranking y na.rm = T por si eventualmente existieran NA)

reg_rank_pais = df %>% 
                group_by(PAIS) %>% 
                summarise(SUMA_VENTAS = sum(VENTAS, na.rm = T)) %>% 
                mutate(RANKING = min_rank(SUMA_VENTAS))
reg_rank_pais

# A tibble: 3 x 3
  PAIS   SUMA_VENTAS RANKING
  <chr>        <dbl>   <int>
1 Brasil         200       1
2 Chile         1000       3
3 Perú           300       2

Ejercicio 5G: Sumar los CODIGO y las VENTAS agrupados por PAIS, usando y no usando na.rm = T:

reg_sum_cod_ven_sin_rm = df %>% 
                         group_by(PAIS) %>% 
                         summarise(SUMA_CODIGOS = sum(CODIGO),SUMA_VENTAS = sum(VENTAS)) 
reg_sum_cod_ven_sin_rm

# A tibble: 3 x 3
  PAIS   SUMA_CODIGOS SUMA_VENTAS
  <chr>         <dbl>       <dbl>
1 Brasil            2         200
2 Chile             5        1000
3 Perú             NA         300

reg_sum_cod_ven_con_rm = df %>% 
                         group_by(PAIS) %>% 
                         summarise(SUMA_CODIGOS = sum(CODIGO,na.rm = T),SUMA_VENTAS = sum(VENTAS,na.rm = T)) 
reg_sum_cod_ven_con_rm

# A tibble: 3 x 3
  PAIS   SUMA_CODIGOS SUMA_VENTAS
  <chr>         <dbl>       <dbl>
1 Brasil            2         200
2 Chile             5        1000
3 Perú              0         300