index.Rmd

---
title: Manual básico de R
author: "Bastián Olea Herrera"
site: bookdown::bookdown_site
documentclass: book
# output:
#   bookdown::gitbook: default
##     highlight: tango

  #bookdown::pdf_book: default
---

# Introducción 

Este “manual” es una colección de fragmentos de código, ejemplos e instrucciones que he ido recolectando, poco a poco, para recordar cómo realizar operaciones que comúnmente realizo en mi trabajo como analista de datos. En este sentido, no es un manual exhaustivo, sino una mera referencia. Su objetivo es que futuros usuarios de R puedan encontrar pistas y soluciones que les ayuden en su flujo de trabajo.



# (PART\*) Datos {-}

# Manejo de datos con R

## Importación de datos

Esta sección contiene instrucciones y ejemplos para importar datos a R, ya sea desde Excel, creando tus propias tablas de datos, importar desde PDF en R, u otros.

### Importar archivos desde internet

```
library(readxl)
library(gdata)
```

Archivo Excel:
```
url_xls <- "http://s3.amazonaws.com/assets.datacamp.com/production/course_1478/datasets/latitude.xls"

## Import the .xls file with gdata: excel_gdata
excel_gdata <- read.xls(url_xls)

## Download file behind URL, name it local_latitude.xls
download.file(url_xls, destfile = "local_latitude.xls")

## Import the local .xls file with readxl: excel_readxl
excel_readxl <- read_excel("local_latitude.xls")
```

Cualquier archivo:
```
## https URL to the wine RData file.
url_rdata <- "https://s3.amazonaws.com/assets.datacamp.com/production/course_1478/datasets/wine.RData"

## Download the wine file to your working directory
download.file(url_rdata, destfile = "wine_local.RData")

## Load the wine data into your workspace using load()
load("wine_local.RData")

## Print out the summary of the wine data
summary(wine)
```
### Importar archivos csv
```
read.csv(”myfile”, sep = ";")
```
- Por defecto importa la primera fila como nombres de variables, y usa coma como separador.
- Para importar variables como caracteres y no factores:
	```
	read.csv('csvsoundsystem.com/soundsystem.csv', stringsAsFactors = FALSE)
	```
- Para importar datos donde los decimales sean _comas_ y no puntos, y los separadores sean `;`, usar `read.csv2`.

Importar csv: `read_csv`
```
bakeoff <- read_csv("bakeoff.csv")
```
Agregar `skip=TRUE` para saltarse la primera fila.
Para definir datos missing, agregar argumento: `na = c("", "NA", "UNKNOWN", "0")'`

Importar archivos separados por tabulación: `read_tsv`

Importar archivos con formato de tabla: `read_delim`
```
potatoes<-read_delim("potatoes.txt", delim="\t", col_names=properties)
```

Determinar colectores para importar los datos con los tipos y categorías correctos:
```
fac <- col_factor(levels = c("Beef", "Meat", "Poultry"))
int <- col_integer()

## Edit the col_types argument to import the data correctly: hotdogs_factor
hotdogs_factor <- read_tsv("hotdogs.txt",
                           col_names = c("type", "calories", "sodium"),
                           col_types = list(fac, int, int))
```


#### Importar csv con `fread`
Importa tablas en formato `data.table` y `data.frame`. 

```
library(data.table)
potatoes <- fread("potatoes.csv")
```

Argumentos para botar o seleccionar variables:
```
fread("path/to/file.txt", drop = 2:4) ##botar variables 2 a 4
fread("path/to/file.txt", select = c(1, 5)) ##importar variables 1  y 5
fread("path/to/file.txt", drop = c("b", "c", "d"))
fread("path/to/file.txt", select = c("a", "e"))
```



#### Importar archivos separados por tabulación:
```
hotdogs<-read.delim("hotdogs.txt", header=T)
```
- Por defecto importa la primera fila como nombres de variables, y usa tabulación `\t` como separador.
- `header` indica que al primera fila son los nombres de variables. 
- Para importar datos donde los decimales sean _comas_ y no puntos, y los separadores sean `;`, usar `read.csv2`.

### Importar datos desde Excel 
Usando `readxl`
```
library(readxl)
```

```
encuesta <- readxl::read_excel("clase_25-6/Encuesta.xlsx")
```

Importar una hoja específica:
```
diccionario <- readxl::read_excel("clase_25-6/Encuesta.xlsx",
                                  sheet="Diccionario")
```


Nombres de hojas:
```
excel_sheets("urbanpop.xlsx")
```

Importar hojas de Excel: `sheet= 1`

Definir nombres de columnas manualmente:
```
cols <- c("country", paste0("year_", 1960:1966))
pop_b<- read_excel("urbanpop_nonames.xlsx", col_names=cols)
```

Saltarse casos: `skip=4`

Ver las hojas del documento:
```
readxl::excel_sheets()
```

Para importar todas las hojas en un archivo:
```
archivo <- "clase_25-6/Encuesta.xlsx"

lista <- lapply(readxl::excel_sheets(archivo), readxl::read_excel, path = archivo)

lista[[1]]
lista[[2]]
```


#### Importar y editar datos desde Excel con `XLConnect `

```
library(XLConnect)
```

```
my_book<-loadWorkbook("urbanpop.xlsx")
```

```
## List the sheets in my_book
getSheets(my_book)

## Import the second sheet in my_book
readWorksheet(my_book, sheet = 2)
```

```
## Import columns 3, 4, and 5 from second sheet in my_book: urbanpop_sel
urbanpop_sel <- readWorksheet(my_book, sheet = 2, startCol = 3, endCol = 5)

## Import first column from second sheet in my_book: countries
countries <- readWorksheet(my_book, sheet = 2, startCol = 1, endCol = 1)

## cbind() urbanpop_sel and countries together: selection
selection <- cbind(countries, urbanpop_sel)
```

```
## Build connection to urbanpop.xlsx
my_book <- loadWorkbook("urbanpop.xlsx")

## Add a worksheet to my_book, named "data_summary"
createSheet(my_book, "data_summary")

## Use getSheets() on my_book
getSheets(my_book)
```

```

## Rename "data_summary" sheet to "summary"
renameSheet(my_book, "data_summary", "summary")

## Print out sheets of my_book
getSheets(my_book)

## Save workbook to "renamed.xlsx"
saveWorkbook(my_book, "renamed.xlsx")
```

```
## Remove the fourth sheet
removeSheet(my_book, "summary")

## Save workbook to "clean.xlsx"
saveWorkbook(my_book, "clean.xlsx")
```
### Importar tabla pivotada de Excel

Cuando las tablas no vienen en formato tidy, sino con varios headers e incluso headers al lado izquierdo, se usan los paquetes `tidyxl` y `unpivotr`

Importar usando `readxl`
```
alojo <- readxl::read_xlsx("Datos/3 Establecimientos de alojamiento turístico 2017-2019.xlsx",
                           sheet=2+1,
                           skip=4)
```

Luego se transforma para que cada _celda_ de Excel corresponda a una fila en R:
```
alojo2 <- unpivotr::as_cells(alojo)
```

Luego se aplica `unpivotr::behead()` para indicar dónde están los headers y en qué dirección:
```
library(unpivotr)

alojo3 <- alojo2 %>%
  behead("up-left", "fecha") %>%
  behead("up", "nivel") %>%
  behead("left", "region")
```

[https://github.com/nacnudus/tidyxl](https://github.com/nacnudus/tidyxl)
[https://github.com/nacnudus/unpivotr](https://github.com/nacnudus/unpivotr)

#### Importar archivos de Stata
```
foreign::read.dta()
```


```
casen <- readstata13::read.dta13("~/Casen/Casen 2017.dta") %>% as_tibble()
```
#### Importar archivos de SPSS
```
library(foreign)
read.spss
```
Reads SPSS data file	read.spss(“myfile”)

#### Importar datos con `readr`
Importa datos creando objetos de clase `tbl_df`, `tbl` y `data.frame`.

- Saltarse casos, y especificar la muestra: `skip = 6, n_max = 5`
- Para definir los nombres de columnas: `col_names=c("area", "temp", "size", "storage", "method","texture", "flavor", "moistness")`
- Para definir manualmente los tipos de cada columna: `col_types="cdil"` (character, double, integer, logical).
	```
	potatoes_char <- read_tsv("potatoes.txt", col_types = "iiiiiddd", col_names = properties)
	```
- El delimitador es `delim=""`

### Importar otros archivos con formato de tabla
```
path <- file.path("data", "hotdogs.txt") ## directorio

hotdogs <- read.table(path, 
                      sep = "/t", ##tabulación
                      head=FALSE, ##sin nombres de columna
                      col.names = c("type", "calories", "sodium"))
```
- `header` indica que al primera fila son los nombres de variables. En `read.table`, `FALSE` va por defecto. El separador se indica con `sep`.
- Para especificar los tipos de variables, agregar el argumento `colClasses = c("factor", "NULL", "numeric"))`


### Importar tablas desde PDF

Usando Tabulizer:
```
library(tabulizer)

out <- extract_tables("/Users/bastianolea/Documents/RStudio/Tarapacá\ R/Servel/Participación\ Municipales\ 2016\ comuna\ género.pdf",
                      output = "data.frame")

out2 <- as_tibble(out, .name_repair = "minimal")

View(out2)
```


```
library(tabulizer)
##Convertir PDF a data.frame
##Sirvió recoratar el PDF para que no tuviera logo en al página 1
mesas_2016 <- extract_tables("~/Servel/Mesas Primarias 2016.pdf",
                             pages = c(55:63), ##páginas 1 a 7
                             output = "data.frame")

mesas_2016b <- bind_rows(mesas_2016, .id = NULL) ##%>% ##Combinar lista de dataframes en un solo dataframe

```

Instalación en Mac: [https://gist.github.com/tomsing1/1da54d3f720ed96fbbb5a3f075bd2a56](https://gist.github.com/tomsing1/1da54d3f720ed96fbbb5a3f075bd2a56)
Tutorial: [https://datascienceplus.com/extracting-tables-from-pdfs-in-r-using-the-tabulizer-package/](https://datascienceplus.com/extracting-tables-from-pdfs-in-r-using-the-tabulizer-package/)

### Combinar bases de datos
  
Para combinar bases donde las columnas son las mismas (es decir, agregar casos)
```
bind_rows(datos1, datos2)
```

Par añadir columnas a una base
```
bind_cols
```

Unir a partir de una columna que coincida:
```
datos1 %>% ##Unir datos con mapa
    left_join(datos2)
```

Combinar en base a variables compartidas dentro de dos datasets:
```
## Print the votes_processed dataset
votes_processed

## Print the descriptions dataset
descriptions

## Join them together based on the "rcid" and "session" columns
votes_joined <- votes_processed %>%
  inner_join(descriptions, by = c("rcid", "session"))
```

Ejemplo:
```
ilo_data <- ilo_hourly_compensation %>%
  inner_join(ilo_working_hours, by = c("country", "year"))
```
### Conectar a base de datos

```
library(DBI)
```


```
## Connect to the MySQL database: con
con <- dbConnect(RMySQL::MySQL(), 
                 dbname = "tweater", 
                 host = "courses.csrrinzqubik.us-east-1.rds.amazonaws.com", 
                 port = 3306,
                 user = "student",
                 password = "datacamp")

## Build a vector of table names: tables
tables <- dbListTables(con)
```

Importar una tabla en específico:
```
## Import the users table from tweater: users
users<- dbReadTable(con, "users")
```

Importar todas las tablas:
```
## Get table names
table_names <- dbListTables(con)
table_names
## Import all tables
tables <- lapply(table_names, dbReadTable, conn = con)
```
### Aplicar factor de expansión
Cuando los datos provienen de fuentes estadísticas que requieren expansión:

```
library(mefa)
casen_w <- rep(casen, times = casen$expc)
```


O con tidyr:
```
casen %>% 
    select(expr, sexo, pco1, oficio4) %>%
    slice(1:100) %>%
    tidyr::uncount(expr, .remove = F) %>%
    print(n=Inf)
```
## Codificación

En esta sección encontrarás comandos para producir estructuras de dato de forma “manual”; es decir, imputando los datos caso por caso, o bien trabajando con ellos de forma personalizada.

### Importar datos desde vectores
```
Año = c(1997,1998,1999,2000,2001,2002,2003,2004,2005,2006,2007,2008)
Nacimientos= c(4571,4782,4834,4701,4787,4467,4571,4583,4776,4761,5017,5287)
Defunciones= c(889,946,946,916,991,1026,1040,1127,1092,1070,1156,1199)
TasaNatalidad= c(20.8, 21.0, 20.4, 19.1, 19.0, 17.2, 17.2, 16.8, 17.1, 16.6, 17.1, 17.6)
TasaMortalidad= c(4.0, 4.1, 4.0, 3.7, 3.9, 3.9, 3.9, 4.1, 3.9, 3.7, 3.9, 4.0)
TasaFecundidad= c(2.61, 2.63, 2.58, 2.43, 2.42, 2.21, 2.22, 2.18, 2.23, 2.17, 2.23, 2.29)
Tarapaca <- data.frame(Año,Nacimientos,Defunciones,TasaFecundidad,TasaMortalidad,TasaNatalidad)
```
### Escribir dataframe
Crear un dataframe escribiendo las columnas

```
sales <- tibble::tribble(
  ~quarter, ~year, ~sales,
  "Q1",    2000,    66013,
  "Q2",      NA,    69182,
  "Q3",      NA,    53175,
  "Q4",      NA,    21001,
  "Q1",    2001,    46036,
  "Q2",      NA,    58842,
  "Q3",      NA,    44568,
  "Q4",      NA,    50197,
  "Q1",    2002,    39113,
  "Q2",      NA,    41668,
  "Q3",      NA,    30144,
  "Q4",      NA,    52897,
  "Q1",    2004,    32129,
  "Q2",      NA,    67686,
  "Q3",      NA,    31768,
  "Q4",      NA,    49094
)
```
### Crear vector y matriz de datos
```
linkedin <- c(16, 9, 13, 5, 2, 17, 14)
facebook <- c(17, 7, 5, 16, 8, 13, 14)
views <- matrix(c(linkedin, facebook), nrow = 2, byrow = TRUE)
```
### Repetir un valor

Repetir un 5 10 veces:
```
rep(5, times=10)
```

Repetir dos valores, uno cada x veces:
```
rep(c("a", "b"), each = 100)
```
### Crear sequencia de números

Generar del 1 al 10 de uno en uno
```
seq(from=1, to=10, by=1)
```

Generar 10 valores desde 1 a 100
```
seq(from=1, to=100, length.out=10)
```
### Crear data frame a partir de vectores

```
data <- data.frame(llamados_ventas,
                   planes_contratados)
```
### Crear listas

```
my_list <- list(my_vector, my_matrix, my_df)
```

```
pop_list<-list(pop_1, pop_2, pop_3)
```

Listas con nombres:
```
my_list <- list(vec=my_vector, mat=my_matrix, df=my_df)
shining_list <- list(moviename = mov, actors=act, reviews=rev)
```

Seleccionar desde listas:
```
shining_list[["reviews"]]
shining_list$reviews

## Print out the vector representing the actors
shining_list[[2]]

## Print the second element of the vector representing the actors
shining_list[[2]][2]
```

Expandir una lista:
```
## We forgot something; add the year to shining_list
shining_list_full <- c(shining_list, year = 1980)

## Have a look at shining_list_full
str(shining_list_full)
```
### Añadir casos manualmente

```
datos %>%
	add_row(x = 4, y = 0, Nombre = "Mapache")
```
### Crear vector de nombres

Útil para selectores Shiny donde las alternativas son largas.
El segundo argumento son los nombres. En el ejemplo, se crea un vector de números donde los nombres son el vector, cosa que en Shiny aparezcan las alternativas con el contenido del vector pero internamente se retorne un número.

```
vector_nombrado <- setNames(c(1:33), vector)
```
### Añadir vector a una matriz

```
all_wars_matrix <- cbind(star_wars_matrix, worldwide_vector)
```
### Contar hacia abajo

Hacer una columna o variable que contenga números del 1 hasta el máximo de filas de la base:

```
mutate(fila = 1:n())
```

```
e %>%
    mutate(fila = 1:nrow(e))
```
### Usar output como texto de vector
Retorna el output como el texto necesario para reproducir un vector

```
dput()
```
## Limpieza de datos
Esta sección contiene instrucciones y ejemplos para limpiar datos en R, con operaciones que cambian los nombres de las variables, eliminan observaciones, tratan los datos perdidos de distintas maneras, etc.

### Seleccionar variables
El verbo `select` permite mantener, botar, y reordenar variables.

Seleccionar variables que contengan un término:
```
datos %>%
select(contains("término"))
```

Filtrar datos para dejar o eliminar ciertas variables en la base de datos.
```
select(datos, var1, var2, var3)
select(datos, var1:var9)
```
Se puede usar `-var4` para ignorar una columna y `-(var1:var5)` para ignorar varias seguidas.

Ejemplo:
```
ratings %>% 
  select(series, channel, bbc, viewer_growth)
```
Acá no es necesario poner la base de datos como primer argumento.

Poner una variable antes que todas:
```
datos %>% 
  select(var1, everything())
```
El argumento `everything()` pone el resto de las variables al final.

#### Des-seleccionar variables
El signo menos sirve para indicar que se seleccionan todas menos lo especificado:
```
ratings %>% 
  select(-ends_with("day"))
```


Combinar comandos de selección:
```
ratings %>% 
  select(channel, everything(), -ends_with("day"))
```
La variable especificada al frente, luego todas las demás, menos las que terminan con "day".

### Reordenar columnas

```
library(dplyr)
weather5 <- select(weather4, date, Events, CloudCover:WindDirDegrees)
```
### Ordenar datos

```
arrange(cran2, ip_id) ## ascendente
arrange(cran2, desc(ip_id)) ## descendente
```

Ordenar por una variable, y luego por la otra:
```
arrange(datos, var1, var2)
```

Ejemplos:
```
arrange(top_counts, desc(count))
```

```
arrange(series, episode) %>% 
```

```
bakers_mini %>% 
  arrange(age) %>% 
  glimpse()
```

#### Ordenar datos con base

```
sort(datos$var1)
order(datos$var1)
```

```
## Use order() to create positions
positions <-  order(planets_df$diameter)

## Use positions to sort planets_df
planets_df[positions, ]
```
### Cambiar tipo de datos

Convertir a carácter:
```
students$Grades <- as.character(students$Grades)

```

Convertir a factor:
```
mutate(var1 = as.factor(skill))
```

```
students$Fedu <- as.factor(students$Fedu)
```

```
weather6 <- mutate_at(weather5, vars(CloudCover:WindDirDegrees), funs(as.numeric))
```
### Filtrar datos

```
filter(datos, var1=="Peq")
filter(pack_sum, count>679)
```

Filtrar datos de acuerdo a ciertas condiciones de los casos.
```
filter(datos, var2=="categoría")
filter(datos, var2=="categoría", var3=="mapache")
filter(cran, r_version <= "3.0.2", country == "IN")
filter(cran, country=="US" | country == "IN")
```


```
filter(episode == 1 | episode == max(episode))
```

```
filter(star_baker==0 & technical_winner == 0)
```

#### Con subset
```
nombredefiltro<-subset(datos,var1=="categoria")
```
Ejemplo:
```
west<-subset(pollution,region=="west")

## Select planets with diameter < 1
subset(planets_df, diameter <1 )
```

#### Con base

Otra forma:
```
nuevodataframe <- datos[datos$var1=="categoria",]
```

```
nuevodataframe <- datos[datos$var1=="categoria" & datos$var2=="categoria",]
```

Filtrar datos específicos de una variable:
```
common_cyl <- filter(cars, ncyl %in% c(4, 6, 8))
```

```
## Select the non-US revenue for first two movies
non_us_some <- all_wars_matrix[1:2,2]
```
### Convertir datos a tibble
Convertir una tabla de datos a el formato tibble, más moderno, ordenado, y usado en el _tidyverse._
```
datos_tibble <- tibble::as_tibble(datos)
```
### Cortar datos o eliminar filas

Permite recortar un dataframe por las filas, para separar por ejemplo las primeras 200 filas:
```
datos %>%
	slice(1:200)
```

Si se necesita eliminar algunas filas:
```
datos %>%
	slice(-1, -2, -3)
```
### Eliminar más de una palabra a la vez

```
datos %>%
mutate(ambito = stringr::str_remove_all(ambito, "\\r|\\n"))
```
### Reemplazar más de una palabra a la vez

```
datos %>%
mutate(ambito = stringi::stri_replace_all_fixed(ambito, 
                                                  c("gnero", "indicgena", "plotica", "oiriginarios"), 
                                                  c("genero", "indigena", "politica", "originarios"),
                                                  vectorize_all = FALSE))
```
### Eliminar caracteres especiales de un texto

Para eliminar acentos y eñes de los textos:
```
iconv(tolower(comuna), from = 'UTF-8', to = 'ASCII//TRANSLIT')
```
### Filtrar columnas en base a condición
```
datos %>%
	select(which(nlevels(.) == 0))
```
### Limpiar números

Elimina cualquier texto y deja sólo el número
```
library(readr)
parse_number(datos)
```

Cuando un número viene en formato caracter pero también con símbolos, espacios o letras. También sirve para eliminar los caracteres y dejar sólo números:
```
mutate(var1 = readr::parse_number(var1))
```
### Reemplazar datos perdidos
Reemplazar casos missing o NA con 0
```
mutate(filtro_calculado = tidyr::replace_na(filtro_calculado, 0))
```

Convertir los missing en un valor:
```
mutate(cantidad3 = ifelse(is.na(cantidad3), 0, cantidad3)) %>%
```

Para convertir un texto o símbolo en missing:
```
mutate(variable = na_if(variable, "símbolo"))
```

```
na_if() to replace specified values with a NA.
```

```
coalesce() to replace missing values with a specified value.
```

```
tidyr::replace_na() to replace NA with a value
```
### Convertir texto vacío a missing

```
mutate(nombres = replace(nombres, !str_detect(nombres, ""), NA))
```
### Recodificar a missing

Usando `na_if()`
```
datos %>% mutate(d11 = na_if(d11, "No sabe")) 
```

Usando `replace()` 
```
datos %>% mutate(d11 = replace(d11,"No sabe", NA)) 
```


na_if() to replace specified values with a NA.

coalesce() to replace missing values with a specified value.

tidyrreplace_na() to replace NA with a value

### Datos perdidos

```
sum(is.na(datos))
```
Retorna cantidad de datos missing. También se logra con `summary(datos)` o con `datos %>% filter(is.na(variable))`

```
which(is.na(datos))
```
Entrega la ubicación de los datos missing.

```
## Replace all empty strings in status with NA
social_df$status[social_df$status == ""] <- NA

## Print social_df to the console
social_df

## Use complete.cases() to see which rows have no missing values
complete.cases(social_df)

## Use na.omit() to remove all rows with any missing values
social_df<-na.omit(social_df)
```
  
Definir valores missing al importar un archivo:
```

## Edit to add list of missing values
bakeoff <- read_csv("bakeoff.csv", skip = 1,
                    na = c("", "NA", "UNKNOWN"))
```
### Filtrar datos perdidos
```
datos %>%
  filter(!is.na(var1) & !is.na(var2)) 
```

```
datos %>%
select(User_Score, Critic_Score) %>%
   na.omit() %>%
```
### Filtrar datos perdidos en varias columnas
Filtrar observaciones donde sean missing en varias columnas

```
datos %>%
filter_at(vars(eval_act_pol_1_a:eval_act_pol_1_ad), any_vars(!is.na(.)))
```
### Limpiar nombres de variables

Elimina símbolos de las variables y las estandariza:
```
library(janitor)
ratings <- messy_ratings %>%  
  clean_names("lower_camel")
```

En el argumento de  `clean_names` determina el tipo de nombre:
```
"snake" produces snake_case

"lower_camel" or "small_camel" produces lowerCamel

"upper_camel" or "big_camel" produces UpperCamel

"screaming_snake" or "all_caps" produces ALL_CAPS

"lower_upper" produces lowerUPPER

"upper_lower" produces UPPERlower
```

Para convertir los nombres de las categorías de una variable factor:
```
library(stringr)
levels(eme2$nacionalidad) <- str_to_title(eme2$nacionalidad)
```
### Ordenar columnas alfabéticamente

```
datos %>%
select(sort(names(.)))
```
### Renombrar todas las columnas

Reemplazar un texto en lo nombres de variables
```
datos %>%
  rename_all(funs(str_replace(., "pregunta", "p")))
```

Renombrar columnas específicas
```
rename_at(vars(starts_with("b")), funs(str_replace(., "b", "agua")))
```
### Renombrar columnas con base

```
nombres <- gsub("Pregunta ", "p", names(encuesta))
```
### Renombrar variables o columnas


```
rename(nombrenuevo = nombreviejo) %>%
```

Cambiar nombre de variables:
```
view(datos)
col(datos)
names(datos)[1]<-"Campo"
names(datos)[2]<-"Ciudad"
```
El número 1 significa que es el primer elemento o primera columna. Entre comillas va el nombre.

### Añadir sufijo a nombres de columnas

```
rename_at(vars(c(30:53)),function(x) paste0(x,"_x"))
```
### Eliminar un término en el título de variables

Seleccionar variables que contengan un término:
```
datos %>%
select(contains("término")) %>%
gather(variable, frequency) %>%
mutate(variable = str_remove(variable, "término"))
```

Eliminar todas las palabras anteriores a un término, incluyendo al término:
```
gathered_data %>%
    mutate(response_var = str_remove(response_var, '.*rude to '))
```

Ejemplo:
```
learning_platform_usefulness <- multiple_choice_responses %>%
  ## select columns with LearningPlatformUsefulness in title
  select(contains("LearningPlatformUsefulness")) %>%
  ## change data from wide to long
  gather(learning_platform, usefulness) %>%
  ## remove rows where usefulness is NA
  filter(!is.na(usefulness)) %>%
  ## remove "LearningPlatformUsefulness" from each string in learning_platform 
  mutate(learning_platform = str_remove(learning_platform, "LearningPlatformUsefulness"))
```
### Rellenar casos

Cuando una columna sólo tiene valores cuando éstos cambian, y lo que se quiere es llenar de repeticiones entre cada cambio de los valores,
cosa que `1 NA NA 2 NA NA 3 NA NA` se vuelva `1 1 1 2 2 2 3 3 3`

```
datos %>%
fill(columna)
```
### Convertir fechas de Excel

```
as.Date(42736, origin = "1899-12-30")
```


```
library(tibble)
library(janitor)

excel_numeric_to_date(as.numeric(as.character(42736)), date_system = "modern")
```
### Eliminar una categoría

```
comics_filtered <- comics %>%
  filter(align != "Reformed Criminals") %>%
  droplevels()
```
### Añadir identificadores o folio

```
iris$Flower <- 1:nrow(iris)
```
### Remover texto de una categoría

```
mutate(tipo = str_remove(tipo, "texto a borrar"))
```
### Borrar espacios antes y después
```
stringr::desaparecidos$Región <- str_trim(desaparecidos$Región)
```
### Agregar caracteres antes o después
```
stringr::str_pad(c("23485W", "8823453Q", "994Z"), width=9, side="left", pad="0")
```
### Detectar patrones en texto
```
stringr::str_detect(students3$dob, "1997")
```
### Buscar y reemplazar valores
```
stringr::str_replace(students3$sex, "M", "Male")
weather3$day <- stringr::str_replace(weather3$day, "X", "")
```
También sirve para eliminar caracteres o patrones.

Ejemplo:
```
bakers <- bakers %>% 
  mutate(position_reached = stringr::str_replace(position_reached, "-", " "),
         position_reached = stringr::str_replace(position_reached, "THIRD PLACE", "RUNNER UP"))
```


```
mutate(tipo = stringr::str_replace(tipo, "mal escrito", "bien escrito"))
```
### Filtrar outliers

Se crea una variable que especifique si son o no outliers, y luego se filtra la base según esa variable.


```
## Filter for Asia, add column indicating outliers
gap2007 <- gap2007 %>%
  mutate(is_outlier = lifeExp < 50)

## Remove outliers, create box plot of lifeExp
gap2007 %>%
  filter(!is_outlier) %>%
  ggplot(aes(x = 1, y = lifeExp)) +
  geom_boxplot()
```
### Convertir valores a mayúsculas o minúsculas:
Convertir a minúsculas:
```
tolower("AAAA")
```

Convertir a mayúsculas:
```
toupper("aaaa")
states_upper <- toupper(states)
```

Ejemplo:
```
bakers <- bakers %>% 
  mutate(position_reached = str_to_upper(position_reached))
```
### Borrar prefijo de variables

Borra el prefijo de los años, dejando solo caracteres entre ubicaciones 2 y 5
```
names(datos) <- substring(names(datos),2,5)
```
### Rellenar las fechas en una serie de tiempo

```
##inicio y final de la serie parcial
min(conceptos$date)
max(conceptos$date)

##crear serie completa
ts <- seq.POSIXt(as.POSIXct(min(conceptos$date),
as.POSIXct(max(conceptos$date)), 
by="day")

df <- data.frame(date=ts)

left_join(df, conceptos)
##unir la serie completa con la serie parcial
```
### Ejemplos de Regex en R

`"."` equivale a cualquier dato.
`"ha."` retorna `TRUE` para `"happy"`

`".*"` cualquier carácter antes o después del texto
`.` cualquier carácter
`$` final de palabra


`\\d` es cualquier dígito único
`\\d+ ` es cualquier cantidad de dígitos

`\\w+` es cualquier palabra

`\\.` es un punto

Ejemplo:
```
"\\d\\d\\. \\w+ - "
```
...va a hacer match a "06. VI - "

Dejar sólo el último caracter:
```
^(.*)(?=.$)
```

Borrar todo hasta un caracter:
```
^[^\\)]*\\) ##hasta ")"
```

Borrar todo dentro de paréntesis
```
([^()]*)
```

Borrar todo desde "POB."
```
POB\\..*$
```

Borrar todo después de una palabra pero mantener la palabra:
```
(?<=caleta).*
```

[https://help.relativity.com/9.3/Content/Relativity/Regular\_expressions/Regular\_expression\_metacharacters.htm](https://help.relativity.com/9.3/Content/Relativity/Regular_expressions/Regular_expression_metacharacters.htm)

### Fechas

```
library(lubridate)
```

La fecha se pone como argumento entre comillas, y se utiliza la función correspondiente:
```
dmy("17 August 2010")
mdy("August 17 2010")
ymd("2010 August 17")
```

Luego de definir las fechas con `lubridate`, se pueden realizar operaciones, por ejemplo, con `mutate`.

- `interval`: intervalo temporal entre dos fechas.
- `duration`: número de segundos en un intervalo.
- `period`: cambio de tiempo en un intervalo.

Crear variables a partir de fechas:
```
datos %>%
mutate(fecha= dmy(variableoriginal))
```

Calcular diferencias entre fechas:
```
datos %>%
mutate(intervalo = interval(var1, var2)
```

Luego se pueden convertir estos intervalos a otras unidades de tiempo:
```
datos %>%
mutate(años_decimal = intervalo / years(1),
	años_enteros = intervalo %/% years(1))
```
En vez de `years` pueden usarse `months`, `hours`, etc.

Obtener el mes de una fecha:
```
mutate(month(last_date_appeared_us, label = TRUE))
```

Ejemplos:
```
baker_time <- baker_time  %>% 
  mutate(time_on_air = interval(first_date_appeared_uk, last_date_appeared_uk),
         weeks_on_air = time_on_air / weeks(1),
         months_on_air = time_on_air %/% months(1))
```
### Agrupar datos
Permite que los cálculos posteriores se apliquen a todas las categorías de una variable por separado.

```
grupodedatos<-group_by(datos, var1)
```

Ejemplos:
```
grupodedatos<-group_by(datos, var1)
summarize(grupodedatos, mean(var2))
```
Retorna el promedio de la variable dos para cada categoría de la variable 1.

```
bakeoff %>% 
  filter(!is.na(us_season)) %>% 
  group_by(us_season)  %>% 
  skim()
```

 Para desagrupar: `ungroup()`

### Crear variables

```
mutate(cran3, size_mb = size / 2^20)
mutate(cran3, correct_size = size + 1000)
```

Crear una nueva variable que indique el promedio de una variable:
```
summarize(cran, avg_bytes = mean(size))
```
Esto se puede usar para obtener puntos promedios de una variable para una serie temporal:
```
datos2 <- datos %>%
group_by(year) %>%
summarize(var_promedio
= mean(var1))
```
Y luego usar la nueva variable `var_promedio` como eje y de un gráfico.

Este código crea nuevas variables  a partir de operaciones realizadas sobre un conjunto de datos agrupados (con `group_by`):
```
pack_sum <- summarize(by_package,
                      count = n(),
                      unique = n_distinct(ip_id),
                      countries = n_distinct(country),
                      avg_bytes = mean(size))
## The 'count' column, created with n(), contains the total number of rows (i.e. downloads) for each package. The 'unique' column, created with n_distinct(ip_id), gives the total number of unique downloads for each package, as measured by the number of distinct ip_id's. The 'countries' column, created with n_distinct(country), provides the number of countries in which each package was downloaded. And finally, the 'avg_bytes' column, created with mean(size), contains the mean download size (in bytes) for each package.
```

Crear variable para todo el data frame:
```
mutate(datos, var9="si")
```
### Crear variable categórica

Variable nominal:
```
## Sex vector
sex_vector <- c("Male", "Female", "Female", "Male", "Male")

## Convert sex_vector to a factor
factor_sex_vector <- factor(sex_vector)

## Print out factor_sex_vector
factor_sex_vector
```

Variable ordinal:
```
temperature_vector <- c("High", "Low", "High","Low", "Medium")
factor_temperature_vector <- factor(temperature_vector, order = TRUE, levels = c("Low", "Medium", "High"))
factor_temperature_vector
```

```
## Create speed_vector
speed_vector <- c("medium", "slow", "slow", "medium", "fast")

## Convert speed_vector to ordered factor vector
factor_speed_vector <- factor(speed_vector, ordered=TRUE, levels=c("slow", "medium", "fast"))
```

Cambiar nombre de niveles:
```
## Specify the levels of factor_survey_vector
levels(factor_survey_vector) <- c("Female","Male")
```

Desagregar variable categórica:
```
## Male
male <- factor_survey_vector[1]

## Female
female <- factor_survey_vector[2]
```


## Recodificación de datos
Esta sección cubre instrucciones y ejemplos sobre recodificación de datos; es decir, operaciones que alteran el contenido de las variables o crean nuevas variables en base a condiciones o instrucciones.

### Recodificar variables

Recodificar variables:
```
gapminder %>%
mutate(gdp = gdpPercap*pop)
```
El primer argumento de `mutate` es el nombre de la nueva variable.

```
datos2 <- datos %>% 
  mutate(categorianueva = recode(categoria, "var_antigua" = "var_nueva", 
    "missing" = NA_character_))
```
Si la variable missing es numérica, `NA_integer_`

Para recodificar todos los demás valores en una sola variable, usar `.default`:
```
mutate(tech_win = recode(technical, `1` = 1,
	.default = 0))
```

```
email %>%
  mutate(has_image = recode(image, `0` = FALSE, .default = TRUE))
```

Si la variable a crear es un factor (por ejemplo, dummy), usar `recode_factor` en vez de `recode`.

```
mutate(episode = recode(episode, `1` = "first", .default = "last"))
```

Ejemplos:
```
ratings <- ratings %>% 
  mutate(bbc = recode_factor(channel, 
	"Channel 4" = 0,
	.default = 1))
```

```
mutate(bump = (last - first) / first)
```
### Crear una variable a partir de operaciones
```
mutate(cran3, size_mb = size / 2^20)
mutate(cran3, correct_size = size + 1000)
```

```
summarize(cran, avg_bytes = mean(size))
```

```
datos %>% mutate(variable = recode(
student, `0` ) NA_character_,

```
Con `.default` cualquier valor que no es 0 es recodificado por esta variable.

Este código crea nuevas variables  a partir de operaciones realizadas sobre un conjunto de datos agrupados (con `group_by`):
```
pack_sum <- summarize(by_package,
                      count = n(),
                      unique = n_distinct(ip_id),
                      countries = n_distinct(country),
                      avg_bytes = mean(size))
```
### Recodificar con base
```
library(car)
datos$nuevavariable<-recode(datos$variableoriginal,"
			25:34.9='Pequeño';
			35:54.9='Mediano';
			55:65='Grande'",as.factor=TRUE)
```
Se rectifica en "datos" la variable titulada `nuevavariable`, basada en `variableoriginal`, y luego se especifican sus categorías.

```
datos$nuevavariable<-recode(datos$variableoriginal, "
	'hombre'=0;
	'mujer'=1,
				as.integer=TRUE)
```

Cortar el rango de los datos de una variable:
```
adult <- adult[adult$SRAGE_P <= 84, ]
```
### Crear variable desde condicional

```
datos %>%
mutate(has_image = image > 0)
```

```
datos %>%
mutate(zero = variable == 0)
```

Revisar niveles: `levels(datos$variable)`
Convertir los niveles a factor:
```
datos$variable <- factor(datos$variable, levels=c("TRUE", "FALSE"))
```
### Recodificación según condiciones
Funciona como un _if true, then._

#### Condicional simple
```
datos %>%
mutate(gen = if_else(
	between(birth_year, 1981, 1996), "millenial", "not_millenial"))
```
La segunda categoría es para los casos que no cumplen la condición.

```
mutate(Valor = ifelse(Delito=="Otras causas", Valor/4, Valor)) %>% ##Si el delito es "otros", dividir por la cantidad de categorías colapsadas por fct_lump (22-n) para sacar el promedio
```


```
 mutate(pobreza2 = case_when(pobreza == "Pobres extremos" ~ "Condición de pobreza",
                                 pobreza == "Pobres no extremos" ~ "Condición de pobreza",
                                 pobreza == "No pobres" ~ "Fuera de condición de pobreza"))

```

#### Múltiples condiciones
```
datos %>%
mutate(gen = case_when(
	between(birth_year, 1965, 1980) ~ "gen_x",
	between(birth_year, 1981, 1996) ~ "millenial"))
```


```
case_when(x %% 15 ==0 ~ "fizz buzz",
		  x %% 3 == 0 ~ "fizz",
		  x %% 5 == 0 ~ "buzz",
		  TRUE ~as.character(x) )
```

Agregar `TRUE ~ "asdas"` para crear una variable para los casos que no cumplen. De lo contrario, serán missing.

Ejemplos:
```
bakers_skill <- bakers %>% 
  mutate(skill = case_when(
    star_baker > technical_winner ~ "super_star",
    star_baker < technical_winner ~ "high_tech",
    TRUE ~ "well_rounded"
  ))
```

```
bakers_skill <- bakers %>% 
  mutate(skill = case_when(
    star_baker > technical_winner ~ "super_star",
    star_baker < technical_winner ~ "high_tech",
    star_baker == 0 & technical_winner == 0 ~ NA_character_,
    star_baker == technical_winner  ~ "well_rounded"
  ))
```

Ojo que para recodificar a missing, `NA_character_` va sin comillas.

### Convertir caracter a factor

```
is.character(datos$variable)
datos %>%
mutate_if(is.character, as.factor)
```
### Etiquetar variables
Utilizando base
```
Etiqueta <- c("Año","Nacimientos","Defunciones","Tasa de fecundidad","Tasa de mortalidad","Tasa de natalidad")

library(sjlabelled)
Datos <- set_label(Datos, label = Etiqueta)
```

```
adult$RBMI <- factor(adult$RBMI, labels = c("Under-weight", "Normal-weight", "Over-weight", "Obese"))
```
### Manipulación de objetos con base

Buscar el atributo en cierto objeto, reportando las filas donde se puede encontrar
```
grep(atributo, objeto)
posicion_valpo <-  grep("Valparaíso", encuesta$`Pregunta 3`)
```

Reemplazar un valor inicial por uno final en cierto objeto.
```
gsub(inicial, final, objeto)
df$region <- gsub("Región", "R.", encuesta$`Pregunta 3`)
```

Substraer de un objeto un carácter entre la posiciones inicial y final.
```
substr(objeto, inicial, final)
```

Permite unir uno o más objetos, en formato carácter.
```
paste(objeto1,..., sep=“ ”)
```
### Crear variable de interacción

Crea una nueva variable que tiene por categorías a las combinaciones de todos los factores de dos variables.

```
mutate(interacción = fct_cross(var1, var2, sep = " + "))
```
### Recodificar meses a texto
Para pasar desde el número del mes a el mes con nombre:

```
data %>%
    mutate(Month = lubridate::month(Month, label = T, abbr= F, locale = "es_ES"))
```
### Calcular promedio móvil

Rolling average, media móvil

```
mutate(hits_rm = zoo::rollmean(hits, k = 7, 
                                        fill = 0, align="left")) %>%
```

Donde `k` representa las filas para atrás que va a promediar

### Aplicar mutate a varias columnas

```
datos %>%
mutate(across(c(col1, col2), ~ round(.x*100, 1)))
```

Otros ejemplos:
```
mutate(across(g2_1:g2_6, as.numeric)) %>% ##convertir a numéricos
```

```
mutate(across(g2_1:g2_6, ~replace(.x, is.na(.x), 0))) %>% ##poner ceros en vez de NA
```


```
cep_r %>%
  mutate(across(c(percepcion_2, percepcion_3), 
         ~forcats::fct_relevel(.x, "No sabe + No contesta", after=0))) %>%
  count(percepcion_2)
```

O también:
```
mutate_at(vars(4:length(notas)), list(as.character))
```
### Convertir a logaritmos

Convertir variable a logaritmo:
```
gap2007 <- gap2007 %>%
  mutate(log_pop = log(pop))
```
### Crear categoría "otros"

Agrupar automáticamente los factores menos comunes en una categoría "Otras":
```
datos %>%
mutate(variable = fct_lump(variable, prop = .08, other_level = "Otras"))
```
Las variables que sean menores al 8% se agrupan en "otras".

Mantener sólo las de mayor frecuencia:
```
datos %>%
mutate(variable = fct_lump(variable, n = 3, other_level = "Otras"))
```
El `n` especifica la cantidad de variables superiores que se mantienen.

Para nombrar categorías como "otros", se seleccionan las que se desean mantener:
```
datos %>%
mutate(variable = fct_other(variable, keep = c("antigua1", "antigua2"), other_level = "Otras"))
```
El resto de las variables no elegidas se vuelven "otras".

El argumento `other_level = "other method"` determina el nombre de la categoría "otros".

Seleccionar las que se desean transformar en "otros":
```
datos %>%
mutate(variable = fct_other(variable, drop = c("antigua1", "antigua2")))
```
De este modo, las variables especificadas pasan a formar parte de una variable "otras".


### Combinar categorías
Combinar o agrupar múltiples categorías de una variable categórica en una cantidad menor.

```
datos %>%
mutate(variable = fct_collapse(variable,
nueva = c("antigua1", "antigua2"),
nueva 2 = c("antigua3", "antigua4")))
```
### Dicotomizar la variable de respuesta:

Hacer variable dummy:
```
datos %>%
filter(!is.na(variable)) %>%
	mutate(variable = if_else(
		variable %in% c("categoria", "otra categoria"),
		1,
		0))
```
### Recodificar categoría si coincide con texto
Sirve, por ejemplo, para corregir errores ortográficos

```
mutate(variable = stringr::str_replace(variable, "texto incorrecto", "Nuevo nombre de la categoría que contiene ese texto")) %>%
```


Para coincidir texto ignorando mayúsculas o minúsculas:
```
mutate(variable = stringr::str_replace(variable, regex('texto', ignore_case = T), "Nuevo nombre de la categoría que contiene ese texto")) %>%
```
### Reemplazar un valor por otro

Sirve para cambiar algún valor que esté malo por otro, o recodificar un valor a missing (NA)

```
mutate(Casos = replace(Casos, Fecha == ymd("2020-04-15"), valornuevo))
```

Reemplazar para imputar un valor missing:
```
mutate(Casos = replace(Casos, Casos == 0, NA))
```

Reemplazar un missing por otro valor:
```
mutate(nacionalidad = replace(nacionalidad, is.na(nacionalidad), "missing"))
```
### Crear columna que sea la diferencia entre los valores de otra

Para calcular brechas en columnas con categorías en formato long:
```
mutate(diferencia = porcentaje[sexo == "Mujer"] - porcentaje) %>%
```
### Renombrar categorías

```
mutate(variable = recode(variable, "antigua" = "nueva"))
```
### Añadir columna con porcentaje

```
library(janitor)
```

Agregar fila con suma de totales:
```
adorn_totals("row") %>%
```

Agregar columna con suma de totales:
```
adorn_totals("col") %>%
```


```
perc_useful_platform <- learning_platform_usefulness %>%
  ## change dataset to one row per learning_platform usefulness pair with number of entries for each
  count(learning_platform, usefulness) %>%
  ## use add_count to create column with total number of answers for that learning_platform
  add_count(learning_platform, wt = n) %>%
  ## create a new column, perc, that is the percentage of people giving that response for that learning_platform
  mutate(perc = n / nn)
```
### Añadir columna con promedio
```
usefulness_by_platform <- learning_platform_usefulness %>%
    ## If usefulness is "Not Useful", make 0, else 1 
    mutate(usefulness = if_else(usefulness == "Not Useful", 0, 1)) %>%
    ## Group by learning platform 
    group_by(learning_platform) %>%
    ## Summarize the mean usefulness for each platform
    summarize(avg_usefulness = mean(usefulness))
```
### Calcular tasa

```
  mutate(Tasa = (Casos/Poblacion)*100000) %>%
```
### Dicotomizar variables
Crear variable dicotómica:
```
learning_platform_usefulness %>%
    ## If usefulness is "Not Useful", make 0, else 1 
    mutate(usefulness = if_else(usefulness == "Not Useful", 0, 1))
```

```
## Dichotomize the value variable to make a new variable, rude
    mutate(rude = if_else(value %in% c('No, not rude at all', 'No, not at all rude'), 0, 1))
```

Ejemplo:
```
mutate(extranjeros = case_when(nacionalidad == "Chile" ~ "Chilena", TRUE ~ "Extranjera")) %>%
```
### Cortar una variable continua a factores

Para cortar la variable en intervalos discretos con el límite izquierdo abierto y el límite derecho cerrado (de 0 a 5, de 6 a 10):
```
cut(datos$variable, c(0,5,10,15,20,25,30))
```

Cortar datos en una secuencia fija:
```
cut(datos$variable, seq(0, 30, 5))
```
Indica que empieza en 0 y termina en 30 en intervalos de 5 en 5.

### Reordenar factores

```
mutate(ocupación_CIUO = forcats::fct_relevel(ocupación_CIUO, c("Estudiantes", "Sin empleo", "Sin información", "Jubilados/as", "Otras"), after = Inf)) %>%
```

```
datos <- datos %>%
mutate(variable = forcats::fct_relevel(variable, "categoria1", "categoria2", "categoria3"))
```
#### Reordenar factor según otra variable
Por ejemplo, reordenar una variable categórica a partir de los valores de una variable numérica:
```
ggplot(datos, aes(x = forcats::fct_reorder(variable, referencia), y=...
```
Según otra pero en descendiente:
```
mutate(Genre = forcats::fct_reorder(Genre, n, .desc = TRUE))
```


#### Invertir el orden de un factor
```
iris$Species <- factor(iris$Species, levels = rev(levels(iris$Species)))
```

```
datos %>%
	mutate(variable = forcats::fct_rev(variable))
```
#### Especificar un orden a un facyor
Obtener los niveles primero: `levels(var)`

```
datos1 <- datos %>%
    mutate(variable1 = forcats::fct_relevel(variable1,
                 "Entirely internal", 
                 "More internal than external",
                 "Approximately half internal",
                 "More external than internal", 
                 "Entirely external"))
```

```
eme2<- eme2 %>%
	mutate(tramo_ingresos = forcats::fct_relevel(tramo_ingresos, "Entre 0 y $193.000","Entre $193.001 y $ 375.000","Entre $ 375.001 y $600.000","Entre $600.001 y $1.125.000","Entre $1.125.001 y $2.500.000","Entre $ 2.500.001 y $ 4.500.000","Entre $4.500.001 y $10.000.000","Entre $10.000.001 y $20.000.000","Entre $20.000.001 y $50.000.000","Entre $50.000.001 y $200.000.000"))
```

Mover un nivel al final:
```
multiple_choice_responses %>%
    mutate(FormalEducation = forcats::fct_relevel(FormalEducation, "I prefer not to answer", after = Inf)) %>%

```

Mover un nivel a una posición:
```
multiple_choice_responses %>%
    mutate(FormalEducation = forcats::fct_relevel(FormalEducation, "Doctoral degree", after = 5))
```
### Crear columna que tenga los valores de una categoría de una columna en formato long

Para repetir en una columna un dato específico a una categoría de agrupación (por ejemplo, el género en una variable “género”:
```
mutate(mujer = porcentaje[sexo == "Mujer"]) %>%
```

Por ejemplo, para añadir barras de brecha:
```
casen %>%
    filter(region=="Región de Tarapacá") %>%
    rename(trabajan=o1) %>%
    group_by(sexo, comuna, trabajan) %>%
    summarise(cantidad=n()) %>%
    mutate(porcentaje = cantidad/sum(cantidad)) %>%
    group_by(comuna) %>%
    mutate(diferencia = porcentaje[sexo == "Mujer"] - porcentaje) %>%
    group_by(comuna, trabajan) %>%
    mutate(mujer = porcentaje[sexo == "Mujer"]) %>%
    mutate(hombre = porcentaje[sexo == "Hombre"]) %>%
    filter(trabajan=="Sí") %>%
    ##filter(!is.na(trabajan)) %>%
    ##graficar
    ggplot(aes(fct_reorder(str_wrap(comuna, 4), diferencia), porcentaje, fill=sexo)) +
    ##facet_wrap(~comuna, strip.position = "bottom") +
    geom_col(position="dodge", width=0.8) +
    geom_text(aes(label = percent(porcentaje)), position = position_dodge2(width=0.8), 
              hjust = 1.2, vjust=0.5, size=3.5, angle=90, color="white") +
    geom_linerange(aes(ymin = mujer, ymax = hombre, linetype="Brecha\nde género"), size=3, col="##DF1A57")
```
## Estructura de datos
Instrucciones y ejemplos para realizar transformaciones de la estructura de los datos.

### Desordenar una base
```
datos %>%
    mutate(desorden = sample(1:nrow(datos))) %>%
    arrange(desorden)
```
### Convertir a tidy
Los datos _tidy_ cumplen lo siguiente:
- Las observaciones son filas
- Las variables son columnas
- Existe una sola unidad observacional por tabla
- La primera fila corresponde a nombres de variables, no valores
Para convertis a tidy se usa `gather`:
```
datos_untidy %>%
gather(key="columna_key", value="valores", columna_1:columna_3)
```
![](DraggedImage.jpeg)
![](DraggedImage-1.jpeg)
![](DraggedImage-2.jpeg)

```
datos_long <- gather(datos, key, value, -year)
```
   - `data: data set
	`- `key`: nueva columna que contiene folios o valores
- `value`: nueva columna que expresa el valor
- `-…`: nombre de las columnas a ignorar (que se va a mantener)
- `na.rm=TRUE` eliminar casos missing.

Ejemplos:
```
weather2 <- gather(weather, day, value, X1:X31, na.rm = TRUE)
```

```
tidy_ratings <- ratings %>%
    ## Gather and convert episode to factor
	gather(key = "episode", value = "viewers_7day", -series, 
           factor_key = TRUE, na.rm = TRUE)
```

```
## Add column with unique ids (don't need to change)
iris$Flower <- 1:nrow(iris)

## Fill in the ___ to produce to the correct iris.wide dataset
iris.wide <- iris %>%
  gather(key, value, -Species, -Flower) %>%
  separate(key, c("Part", "Measure"), "\\.") %>%
  spread("Measure", value)
```

Use `gather()` to move from `fish.species` to a tidy data frame, `fish.tidy`. This data frame should have three columns: Year (int), Species (factor) and Capture (int).
`gather()` takes four arguments: the _original data frame_ (fish.species), the name of the _key column_ (Species), the name of the _value column_ (Capture) and the name of the _grouping variable,_ with a minus in front (-Year). They can all be specified as object names (i.e. no " "):
```
fish.tidy <- gather(fish.species, Species, Capture, -Year)
```


### Tidyr 1.0

Los siguientes son equivalentes:
```
gather(key="título", value="cantidad", ingresos_2016:gastos_2017) %>%

pivot_longer(ingresos_2016:gastos_2017, names_to = "título", values_to = "cantidad")
```

Otro ejemplo:
```
  pivot_longer(cols = starts_with("total"), names_to = "tipo", values_to = "cantidad") %>%
```
### Trasponer data frame

Transponer, para que las fila sean columnas y las columnas filas
```
library(reshape)
matricula2 <- t(matricula)
```


```
indicadores %>%
gather(key = indicador, value = value, 2:ncol(indicadores)) %>% 
    spread_(key = names(indicadores)[1],value = 'value')
```
### Unir dos columnas

```
unite(datos, nuevacolumna, col1, col2)
```
Agregar el argumento `, sep = ", "` para determinar el separador para la nueva columna, que por defecto es guión bajo.
El argumento `remove = TRUE` elimina las columnas originales luego de unirlas.

Sirve para cuando una base de datos viene con una misma variable con cada categoría de respuestas en texto pero en columnas distintas. Así se unen las columnas en una sola.

### Separar dos columnas
Separar una columna que contiene dos variables en dos columnas.
```
require(tidyr)
separate(datos, variable_pegada, into=c("variable", "pegada"))
```
Separa automáticamente en símbolos, de lo contrario hay que especificarle.

Se puede agregar un `sep` para determinar el separador.

```
separate(census_long3, yr_month, c("year", "month"))
```

```
datos_untidy %>%
separate(col=spice, into=c("spice","order"))
```

Agregar `convert=TRUE`...

Se pueden botar el resto de las columnas:
```
separate(episode, into = "episode", extra = "drop"
```



Separar celdas que contengan varios casos en filas distintas:
```
separate_rows(MESAS, sep = "-", convert = FALSE)
```
### Convertir a wide
```
spread(datos, var1, var2)
```
En caso de que hayan dos valores de una variable que se correspondan con un solo valor de otra variable (por ejemplo, dos pruebas en un solo curso).

Although it may not be immediately obvious, if we treat the values in the type column as variables and create a separate column for each of them, we can set things straight. To do this, we use the spread() function. Run the following code to see for yourself:

```
spread(pets, type, num)
```
The result shows the exact same information in a much clearer way! Notice that the spread() function took in three arguments. The first argument takes the name of your messy dataset (pets), the second argument takes the name of the column to spread into new columns (type), and the third argument takes the column that contains the value with which to fill in the newly spread out columns (num).

### Anidar datos
Cambia el data frame a una sola columna, produciendo una lista que contiene un data frame para cada caso.

```
datos %>%
	nest(-country)
```
La variable indicada es la que va a quedar en el data frame, mientras que el resto se anidan.

Obtener un dato de la lista:
```
## All countries are nested besides country
nested <- by_year_country %>%
  nest(-country)

## Print the nested data for Brazil
nested$data[[7]]
```

Para desanidar:
```
## All countries are nested besides country
nested <- by_year_country %>%
  nest(-country)

## Unnest the data column to return it to its original form
nested %>%
unnest(data)
```


#### Aplicar una función a todos los elementos de una lista
```
map()
```
Se usa `.` para representar cada uno de los ítems en la columna data.

## Exportación de datos
Exportar datos

### Exportar tablas

```
library(htmlTable)

tabla <- comunas %>%
  mutate(n_pueblos_originarios = pueblos_originarios * poblacion) %>%
  mutate(n_pueblos_originarios = round(n_pueblos_originarios, digits= 0)) %>%
  group_by(comuna) %>%
  select(poblacion, pueblos_originarios, n_pueblos_originarios)

htmlTable(tabla)
```
Luego copiar y pegar en Pages y formatearlo

### Exportar a Excel

```
writexl::write_xl(datos, file = "ruta/archivo.xlsx")
```
### Exportar data frame

```
save(objeto, file="objeto.Rdata")
```

----

# (PART\*) Visualización {-}

# Visualización de datos con R y ggplot2

Se basa en siete componentes principales:
- DATA FRAME which contains the data you're trying to plot. 
- AESTHETIC MAPPINGS determine how data are mapped to color, size, etc. 
- The GEOMS (geometric objects) are what you see in the plot (points, lines, shapes) 
- FACETS are the panels used in conditional plots. 
- STATS are statistical transformations such as binning, quantiles, and smoothing which ggplot2 applies to the data. 
- SCALES show what coding an aesthetic map uses (for example, male = red, female = blue). 
- plots are depicted on a COORDINATE SYSTEM. When you use qplot these were taken care of for you.

```
g+geom_point()+geom_smooth(method="lm")+facet_grid(.~drv)
```
Donde `g` es un "objeto gráfico" de ggplot guardado como variable:
```
g<-ggplot(mpg,aes(displ,hwy))
```
El primer valor `mpg` es el conjunto de datos, y luego, dentro de la función "estética" `aes`, van como argumento las dos variables que queremos graficar.
`geom_point()` es una capa que al estar vacía grafica un gráfico de dispersión.
`geom_smooth()` con su argumento vacío grafica el intervalo de confianza. Pero al llevar `lm` como argumento, grafica una línea de regresión.
`facet_grid(.~drv)` desagrega los datos en facetas según la variable indicada.
Otros elementos, como títulos `ggtitle` y etiquetas `ylab` `xlab` se añaden como suma.

Ejemplos:
```
g+geom_point(aes(color=drv))+labs(title="Swirl Rules!")+labs(x="Displacement",y="Hwy Mileage")
```

```
g+geom_point(aes(color=drv), size=2,alpha=1/2)+geom_smooth(size=4,linetype=3,method="lm",se=FALSE)
```
`alpha` grafica los puntos del plot transparentes.
`linetype` vuelve la línea en intermitente.
`se` elimina el intervalo de confianza.

```
g+geom_point(aes(color=drv))+theme_bw(base_family="Times")
```


Graficar variable como factor (para que sólo aparezcan en el eje los valores presentes): `factor(variable)`

#### Gráfico con múltiples instancias según variable
Se usa la capa `facet`:
```
ggplot(iris.tidy, aes(x = Species, y = Value, col = Part)) +
  geom_jitter() +
  facet_grid(. ~ Measure)
```
## Tipos de gráfico
Ejemplos de los distintos tipos de gráficos que se pueden hacer en R

### Barras
```
geom_bar
```

```
ggplot(Tarapaca, aes(y=Nacimientos, x=Año)) + geom_bar(stat="identity")
```

```
ggplot(df2, aes(measurements, value)) + 
  geom_line(aes(colour = samples, group = samples))
```

Barras una sobre otra:
```
cyl.am <- ggplot(mtcars, aes(x = factor(cyl), fill = factor(am)))

## Add geom (position = "stack" by default)
cyl.am + 
geom_bar(position = "stack")
```

Barras encima de otras pero llenando el eje vertical:
```
## Fill - show proportion
cyl.am + 
  geom_bar(position = "fill")  
```

Barras lado a lado:
```
## Dodging - principles of similarity and proximity
cyl.am +
  geom_bar(position = "dodge") 
```

Barras lado a lado pero superpuestas:
```
ggplot(mtcars, aes(x = cyl, fill = am)) +
  geom_bar(position = "dodge")

## 2 - Define posn_d with position_dodge()
posn_d <- position_dodge(width=0.2)

## 3 - Change the position argument to posn_d
ggplot(mtcars, aes(x = cyl, fill = am)) +
  geom_bar(position = posn_d)


## 4 - Use posn_d as position and adjust alpha to 0.6
ggplot(mtcars, aes(x = cyl, fill = am)) +
  geom_bar(position = posn_d, alpha=0.6)
```

Para definir el color de las barras, hay que cambiar `col` y `fill`:
```
m <- ggplot(mtcars, aes(x = cyl,y = wt, col = am, fill = am))
```

De barras con porcentaje para variables categóricas o factores:
```
ggplot(eme2, aes(x = sexo)) + 
  geom_bar(aes(y = (..count..)/sum(..count..), fill=sexo)) +
  scale_y_continuous(labels=scales::percent) +
  geom_text(aes(y = ((..count..)/sum(..count..)), 
                label = scales::percent((..count..)/sum(..count..))), 
                stat = "count", 
                vjust = 4,
                color="white")
```

#### Barra "dinamita" (con marcas de error)
```
## Base layers
m <- ggplot(mtcars, aes(x = cyl, y = wt))

## Draw dynamite plot
m +
  stat_summary(fun.y = mean, geom = "bar", fill = "skyblue") +
  stat_summary(fun.data = mean_sdl, fun.args = list(mult = 1), geom = "errorbar", width = 0.1)
```

```
## Base layers
m <- ggplot(mtcars, aes(x = cyl, y = wt))

## Set your dodge posn manually
posn.d <- position_dodge(0.9)

## Plot 3: Redraw dynamite plot
m +
  stat_summary(fun.y = mean, geom = "bar", position = posn.d) +
  stat_summary(fun.data = mean_sdl, fun.args = list(mult = 1), geom = "errorbar", width = 0.1, position = posn.d)
```

Gráfico de barras con faceta:
```
ggplot(email, aes(x= number)) +
  geom_bar() +
  facet_wrap(.~spam)
```
### Dispersión
Útil para agregar sobre boxplots.

```
+ geom_jitter(color="steelblue", alpha=0.3) +
    geom_boxplot(alpha=0)
```
### Torta
Representa la distribución de categorías dentro de un todo.

Gráfico de torta:
```
## Create a stacked bar plot: wide.bar
wide.bar <- ggplot(mtcars, aes(x = 1, fill = cyl)) +
              geom_bar()

## Convert wide.bar to pie chart
wide.bar +
  coord_polar(theta = "y")
```

Gráfico de anillo:
```
## Create stacked bar plot: thin.bar
thin.bar <- ggplot(mtcars, aes(x = 1, fill = cyl)) +
              geom_bar(width = 0.1) +
              scale_x_continuous(limits = c(0.5,1.5))

## Convert thin.bar to "ring" type pie chart
thin.bar + 
  coord_polar(theta = "y")
```

Definir los colores:
```
scale_fill_manual(values=c("##320D70", "##DF1A58"))
```

Torta de variable categórica o factores con porcentajes:
```
eme_genero2_gg <- eme2 %>%
  ggplot(aes(x=1, fill=sexo)) + 
  geom_bar(position="stack",width = 0.5, aes(y = (..count..)/sum(..count..))) +
  scale_y_continuous(labels=scales::percent) +
  scale_x_continuous(limits = c(0.5,1.3)) +
  scale_fill_manual(values=c("##320D70", "##DF1A58")) +
  geom_text(aes(y = ((..count..)/sum(..count..)), 
              label = scales::percent((..count..)/sum(..count..))), 
              stat = "count", 
              vjust = -9,
              color="white") +
    theme(axis.title = element_blank(),
      axis.text = element_blank(),
      axis.ticks = element_blank(),
      rect = element_blank(),
      panel.grid = element_blank(),
      legend.title = element_blank(),
      legend.direction = "horizontal",
      legend.position = "bottom") +
    labs(title="Microemprendedores según género") +
  coord_polar(theta = "y")
```

Ejemplo:
```
eme_genero_gg <- eme2 %>%
    ggplot(aes(x = 1, sexo, fill = sexo)) +
   geom_col() +
    scale_fill_manual(values=c("##320D70", "##DF1A58")) +
    coord_polar(theta = "y") +
    theme(axis.title = element_blank(),
        axis.text = element_blank(),
        axis.ticks = element_blank(),
        rect = element_blank(),
        panel.grid = element_blank(),
        legend.title = element_blank(),
  legend.direction = "horizontal",
legend.position = "bottom") +
  labs(title="Microemprendedores según género")

eme_genero_gg

```


Ejemplo:
```
extranjeros_verano <- turismo %>%
    filter(periodo=="Verano") %>%
    mutate(extranjeros = case_when(nacionalidad == "Chile" ~ "Chilena",
                                   TRUE ~ "Extranjera")) %>%
    group_by(extranjeros) %>%
    summarize(cantidad = n()) %>%
    ggplot(aes(x=1, y=cantidad, fill=extranjeros)) +
    geom_col() +
    coord_polar(theta = "y", start=0, direction = -1) +
    scale_fill_discrete(name = "Nacionalidad") +
    theme(axis.text = element_blank(), axis.title = element_blank()) +
    ##geom_text(aes(x=1, y = cumsum(cantidad) - cantidad/3, label = percent(cantidad/sum(cantidad)))) +
    geom_text(aes(label = percent(cantidad/sum(cantidad), accuracy=1)), position = position_stack(vjust = 0.5)) +
    labs(subtitle="Verano")
```
### Densidad

```
geom_density
```

El gráfico de densidad  es una línea curva de la silueta del histograma:
```
ggplot(common_cyl, aes(x = city_mpg, fill = as.factor(ncyl))) +
  geom_density(alpha = .3)
```

La desviación estándar `bw` suaviza el histograma.

```
ggplot(truck_speeding, aes(x = hour_of_day)) +
    ## switch to density with bin width of 1.5, keep fill 
    geom_density(fill = 'steelblue', bw=1.5) +
    ## add a subtitle stating binwidth
    labs(title = 'Citations by hour', subtitle= "Gaussian kernel SD= 1.5")
```


Parámetros:
- `bw` - the smoothing bandwidth to be used, see ?density for details
- `adjust` - adjustment of the bandwidth, see density for details
- `kernel` - kernel used for density estimation, defined as
	- "g" = gaussian
	- "r" = rectangular
	- "t" = triangular
	- "e" = epanechnikov
	- "b" = biweight
	- "c" = cosine
	- "o" = optcosine

### Boxplot

```
ggplot(aes(x = 1, y = city_mpg)) +
  geom_boxplot()
```

Se puede poner 1 en el eje x para mostrar solo un boxplot.

El ancho de cada caja puede depender de la cantidad de casos:
```
geom_boxplot(varwidth=TRUE)
```
### Curvas y modelos lineales
Agregar líneas de regresión al gráfico

```
geom_smooth
```

Curva Loess:
```
ggplot(mtcars, aes(x = wt, y = mpg)) +
  geom_point() +
  geom_smooth()
```
Cambiar

Línea de regresión:
```
ggplot(mtcars, aes(x = wt, y = mpg)) +
  geom_point() +
  geom_smooth(method="lm", se=FALSE) ## línea de regresión
```


Ejemplo:
```
ggplot(mtcars, aes(x = wt, y = mpg, col = factor(cyl))) +
  geom_point() +
  stat_smooth(method = "lm", se = FALSE) +
  stat_smooth(method = "lm", se = FALSE, aes(group=1))
```

```
myColors <- c(brewer.pal(3, "Dark2"), "black")

ggplot(mtcars, aes(x = wt, y = mpg, col = factor(cyl))) +
  geom_point() +
  stat_smooth(method = "lm", se = FALSE, span = 0.7) +
  stat_smooth(method = "loess", 
              aes(group = 1, col="All"), 
              se = FALSE, span = 0.7) +
  scale_color_manual("Cylinders", values=myColors)
```
### Barras redondeadas


```
library(ggchicklet)

ggplot(count(mtcars, cyl), aes(x = cyl, y = n)) +
  geom_chicklet(radius = grid::unit(15, 'mm'), fill = 'skyblue') +
  theme_minimal()
```
### Nubes de palabras

[https://medium.com/@rohitnair\_94843/analysis-of-twitter-data-using-r-part-2-word-cloud-dd423af1b2c6](https://medium.com/@rohitnair_94843/analysis-of-twitter-data-using-r-part-2-word-cloud-dd423af1b2c6)

[https://www.r-bloggers.com/awesome-twitter-word-clouds-in-r/](https://www.r-bloggers.com/awesome-twitter-word-clouds-in-r/)

### Convertir a 3D

[https://www.rayshader.com](https://www.rayshader.com)

### Estadísticas en gráficos

Curva normal:
```
+ stat_function
```


```
## Plot 2: Mean and SD - the easy way
wt.cyl.am +
stat_summary(fun.data=mean_sdl, fun.args=list(mult=1), position=posn.d)


## Plot 3: Mean and 95% CI - the easy way
wt.cyl.am +
stat_summary(fun.data=mean_cl_normal, position=posn.d)


## Plot 4: Mean and SD - with T-tipped error bars - fill in ___
wt.cyl.am +
  stat_summary(geom = "point", fun.y = mean,
               position = posn.d) +
  stat_summary(geom = "errorbar", fun.data = mean_sdl,
               position = posn.d, fun.args = list(mult = 1), width = 0.1)
```
### Crestas
```
library(ggridges)
p + geom_density_ridges()
```

```
md_speeding %>% 
    mutate(day_of_week = factor(day_of_week, levels = c("Mon","Tues","Wed","Thu","Fri","Sat","Sun") )) %>% 
    ggplot(aes( x = percentage_over_limit, y = day_of_week)) + 
    ## make ridgeline densities a bit see-through with alpha = 0.7
    geom_density_ridges(bandwidth = 3.5, alpha=0.7) +
    ## set expand values to c(0,0)
    scale_x_continuous(limits = c(0,150), expand=c(0,0)) +
    labs(subtitle = 'Guassian kernel SD = 3.5') +
    ## remove y axis ticks
    theme(axis.ticks.y=element_blank())
```
### Enjambre
Alternativa al boxplot. Agrega dispersión de forma inteligente, con los puntos lo más cercanos al eje. 

```
library(ggbeeswarm)
p + geom_beeswarm()
```

Muestra todos los puntos de datos y la forma de la distribución.
Funciona mal con demasiados datos.

Cambiar el tamaño de los puntos:
```
geom_beeswarm(cex=0.5) +
```
### Violín
Alternativa al boxplot. Muestra la distirbución de forma simétrica. 

```
geom_violin()
```


Funciona bien con muchos datos, pero no muestra cada dato individualmente.

```
geom_violin(bw = 2.5) +
```
### Líneas
```
geom_line
```

```
ggplot(economics, aes(x = date, y = unemploy/pop)) +
geom_line()
```

```
ggplot(fish.tidy, aes(x = Year, y = Capture, color=Species)) + geom_line()
```

```
ggplot(ChickWeight, aes(x = Time, y = weight, col=Diet)) +
  geom_line(aes(group = Chick), alpha=0.3) +
  geom_smooth(lwd=2, se=FALSE)
```

Seis mapas de líneas horizontalmente:
```
ggplot(barley, aes(x=year, y=yield, col=variety, group=variety)) +
geom_line() +
facet_wrap( ~ site, nrow= 1)
```

Planos de líneas de promedios con desviación estándar como barritas transparentes:
```
## Create overlapping ribbon plot from scratch
ggplot(barley, aes(year, yield, col= site, group=site, fill=site)) +
stat_summary(fun.y=mean, geom="line") +
stat_summary(fun.data=mean_sdl, fun.args=list(mult=1), geom="ribbon", col=NA, alpha=0.1)
```
### Histograma

```
geom_histogram
```

A mayor `binwidth`, más gruesas las líneas. 
`bins` es el número de barras.
`center` hace que la barra central esté en un punto determinado.

```
ggplot(mtcars, aes(x = mpg)) +
  geom_histogram(aes(y=..density..), binwidth=1, bins=40, fill="##377EB8")
```

```
ggplot(adult, aes(SRAGE_P, fill=factor(RBMI))) + geom_histogram(binwidth=1)
```

```
qplot(var1,data=datos,fill=var2)
```
Con color

```
qplot(var1,var2,data=datos,facets=.~var3)
```
Tres histogramas horizontalmente, divididos por variable 3.

```
qplot(var1,data=datos,facets=var2~.,binwidth=2)
```
Tres histogramas, uno encima del otro.

Polígono de frecuencias:
```
ggplot(mtcars, aes(mpg, color=cyl)) +
  geom_freqpoly(binwidth=1)
```

Alfombra de casos:
```
+ geom_rug
```
### Dumbell

```
ggplot(first_last, aes(x = series, y = viewers, color = episode)) +
  geom_point() + ## keep
  geom_line(aes(group = series)) + ## keep
  coord_flip() ## keep
```
### Mapas de calor

```
geom_tile
```

```
## Create color palette
myColors <- brewer.pal(9, "Reds")

## Build the heat map from scratch
ggplot(barley, aes(x = year, y = variety, fill = yield)) +
  geom_tile() + ## Geom layer
  facet_wrap( ~ site, ncol = 1) + ## Facet layer
  scale_fill_gradientn(colors = myColors) ## Adjust colors
```
### Splom (scatterplot matrix)
```
pairs(datos)
```

```
library(PerformanceAnalytics)
chart.Correlation(iris[1:4])
```

```
library(GGAlly)
ggpairs(datos[1:9])
```

### Matriz de correlación

### Coordenadas paralelas
```
ggparcoord(datos, columns =1:4, groupColumn=5, scale="globalminmax", order="anyClass", alphaLines=0.4)
```
### Mapas

Mapoteca congreso nacional:
[https://www.bcn.cl/siit/mapas\_vectoriales/index\_html](https://www.bcn.cl/siit/mapas_vectoriales/index_html)

[http://guillermoacuna.blogspot.com/2017/02/como-hacer-un-mapa-de-chile-en-r.html](http://guillermoacuna.blogspot.com/2017/02/como-hacer-un-mapa-de-chile-en-r.html)

[https://geocompr.robinlovelace.net/adv-map.html](https://geocompr.robinlovelace.net/adv-map.html)

```
  tm_fill() +
  tm_borders() 
```


[https://eriqande.github.io/rep-res-web/lectures/making-maps-with-R.html](https://eriqande.github.io/rep-res-web/lectures/making-maps-with-R.html)

### Mapa de densidad
Mapa lineal de densidad, como un mapa topográfico:
```
geom_density_2d()
```

Mapa con degradado de calor:
```
geom_density_2d(geom="tile", aes(fill=..density..), contour=FALSE)
```

Mapa de círculos:
```
geom_density_2d(geom="point", aes(fill=..density..), n=20, contour=FALSE) + 
scale_size(range=c(0,9))
```


Agregar línea de medianas:
```
p+geom_vline(data=mu, aes(xintercept=grp.mean, color=sex),
             linetype="dashed")
```
### Scatter
Permiten explorar preguntas e hipótesis iniciales, sugerir estrategias para siguientes pasos, y resumir los datos gráficamente para destacar características generales.

```
geom_point
```
Requiere especificar x e y.

```
ggplot(df, aes(x = wt, y = mpg)) + geom_point()
```

Cambiar color y forma:
```
b + geom_point(color = "##00AFBB", size = 2, shape = 23)
```

Cambiar forma de los puntos según otra variable:
```
b + geom_point(aes(shape = cyl))
```

Cambiar forma y color de los puntos según otras variables:  
```
b + geom_point(aes(shape = cyl, color = cyl))	
```
Para colores personalizados: `+ scale_color_manual(values = c("##00AFBB", "##E7B800", "##FC4E07")`

Texto del eje x: rotar y mostrar todos los valores:
```
+ scale_x_continuous("Año", labels = as.character(Año), breaks = Año)
```

Definir mínimos y máximos:
```
+ coord_cartesian(ylim = c(800, 5500)) ## especificar mínimos y máximos del eje y
```

Añadir dispersión a los puntos:
```
jitter can be 1) an argument in geom_point(position = 'jitter'), 2) a geom itself, geom_jitter(), or 3) a position function, position_jitter(0.1)
```

---- 

Ejemplo de scatter:
```
ggplot(Vocab, aes(x=education, y=vocabulary)) + geom_jitter(alpha=0.2, shape=1)
```

Ejemplo:
```
gD<- ggplot(Tarapaca, aes(x = Año, y = Defunciones))

gD+ geom_smooth(se=FALSE, alpha=10, size=0.5, color="##C19BDE") + ##línea de tendencia, falso para no mostrar intervalos
    geom_point(aes(size = TasaMortalidad), alpha = 0.7, color = "##8A1CDD") + ##variable graficada como "size", con color y transparencia
    scale_size(range = c(0.5, 10)) + ##rango del tamaño de círculos
    theme(axis.text.x = element_text(angle = 45, vjust = 0.5)) + ##ángulo del texto del eje x
    scale_x_continuous("Año", labels = as.character(Año), breaks = Año) + ##etiquetas del eje x
    theme(panel.grid.major = element_line(Año, color = "white"), ## líneas del fondo
          panel.grid.minor = element_blank(), ## borrar líneas menores
          panel.background = element_rect(fill = "##EDE6F2"), ## color de fondo
          legend.key = element_rect(fill = "##EDE6F2")) + ## color de fondo de leyenda
    labs(size="Tasa de mortalidad") + ##título del elemento "size"
    coord_cartesian(ylim = c(800, 5500)) ## especificar mínimos y máximos del eje y
```

Ejemplo de scatter con dos variables:
```
gX <- ggplot(Tarapaca)
gX + geom_point(aes(y=Nacimientos , x=Año, size=TasaNatalidad, colour=TasaFecundidad), alpha = 0.7, color = "##DD4814") + 
    geom_point(aes(y = Defunciones, x=Año, size=TasaMortalidad), alpha = 0.7, color = "##8A1CDD") + 
    ##geom_point(aes(y = , x=Año, size=Nacimientos), alpha = 0.7, color = "##DD4814")
    scale_size(range = c(2, 15)) + ##rango del tamaño de círculos
    theme(axis.text.x = element_text(angle = 45, vjust = 0.5)) + ##ángulo del texto del eje x
    scale_x_continuous("Año", labels = as.character(Año), breaks = Año) + ##etiquetas del eje x
    theme(panel.grid.major = element_line(Año, color = "white"), ## líneas del fondo
          panel.grid.minor = element_blank(), ## borrar líneas menores
          panel.background = element_rect(fill = "##EDE6F2"), ## color de fondo
          legend.key = element_rect(fill = "##EDE6F2")) + ## color de fondo de leyenda
    labs(size="Tasa de mortalidad") ##título del elemento "size"
```

Ejemplo de qplot:
```
qplot(wt, mpg, data = mtcars)
```
### Gráficos con iconos o logotipos

Instalar iconos de símbolos como FontAwesome o IonIcons

Luego graficar con `geom_text` usando el código del glifo a utilizar:
```
geom_text(label="\uF236", size = 14, family = 'FontAwesome', col="##1C2366") +
```
### Waffle

```
disease_counts <- who_disease %>%
	group_by(disease) %>%
	summarise(total_cases = sum(cases)) %>% 
	mutate(percent = round(total_cases/sum(total_cases)*100))

## Create an array of rounded percentages for diseases.
case_counts <- disease_counts$percent
## Name the percentage array
names(case_counts) <- disease_counts$disease

## Pass case_counts vector to the waffle function to plot
waffle(case_counts)
```


```
parts <- c(80, 30, 20, 10)
chart <- waffle(parts, rows=8)
## print(chart)

## library(extrafont)
## waffle(parts, rows=8, use_glyph="shield")

parts <- c(One=80, Two=30, Three=20, Four=10)
chart <- waffle(parts, rows=8)
## print(chart)

```

```
library(waffle)

parts <- c('TRUE' = 3, 'FALSE' = 77)
p <- waffle(parts, rows = 8, colors = c("black", "grey70"))
p
```

Ejemplo:
```
originarios_total <- read_excel("/Users/rndzvs/RStudio/Tarapacá\ R/Indígenas.xlsx",
                                sheet="Región")

originarios_total

originarios_total_tidy <- originarios_total %>%
  gather(`Pueblo originario`, Porcentaje, Aimara:`Sin pertenencia`) %>%
  mutate_if(is.character, as.factor)

originarios_total_tidy

## Explorar porcentajes de cada pueblo en total
originarios_total_tidy %>%
  group_by(`Pueblo originario`) %>%
  ##filter(`Pueblo originario`=="Aimara") %>%
  summarize(percent(Porcentaje/10))

originarios_desagregado_tidy

pueblos_originarios_vector <- c(Aimara=29.1, Diaguita=1.44, Mapuche=2.18, Quechua=3.24, `Otra etnia`=3.24, `Sin pertenencia`=62.5)

pueblos_originarios_waffle <- waffle(pueblos_originarios_vector, 
                                     rows=9, 
                                     size=2)

pueblos_originarios_waffle_gg <- pueblos_originarios_waffle + 
  labs(title="Pertenencia a pueblos originarios", 
       subtitle="Cada cuadro representa a 1 de cada 100 tarapaqueños") +
  scale_fill_manual(values=c("##1A9D75", ##aymara
                             "##69A500", ##diaguita
                             "##7370B5", ##mapuche
                             "##DB6200", ##quechua
                             "##E8348B", ##otros
                             "##AFAFAF", ##sin
                             "##FFFFFF" ##fondo
                             )) +
  tema_comparaciones2 +
  theme(legend.title = element_blank(),
        legend.position = "bottom")

pueblos_originarios_waffle_gg
```
### Voronoi

[https://rspatial\_es.gitlab.io/blog/2020-08-02-diagrama-voronoi-r-ggplot/](https://rspatial_es.gitlab.io/blog/2020-08-02-diagrama-voronoi-r-ggplot/)

### Densidad 2D

Densidad con líneas concéntricas:
```
## Base layers
p <- ggplot(faithful, aes(x = waiting, y = eruptions)) +
  scale_y_continuous(limits = c(1, 5.5), expand = c(0, 0)) +
  scale_x_continuous(limits = c(40, 100), expand = c(0, 0)) +
  coord_fixed(60 / 4.5)

## 1 - Use geom_density_2d()
p + geom_density_2d()

## 2 - Use stat_density_2d() with arguments
p + stat_density_2d(aes(col = ..level..), h = c(5, 0.5))
```

Densidad con gradiente:
```
## Load in the viridis package
library(viridis)

## Add viridis color scale
ggplot(faithful, aes(x = waiting, y = eruptions)) +
  scale_y_continuous(limits = c(1, 5.5), expand = c(0,0)) +
  scale_x_continuous(limits = c(40, 100), expand = c(0,0)) +
  coord_fixed(60/4.5) +
  stat_density_2d(geom = "tile", aes(fill = ..density..), h=c(5,.5), contour = FALSE) +
  scale_fill_viridis()

```
### Gráficos animados

```
library(gganimate)
library(tween)
library(ggplot2)
```

#### Animar según otra variable
```
p<- ggplot(iris, aes(x = Petal.Width, y = Petal.Length)) +
	geom_point() + ##Gráfico de dispersión común
	transition_states(Species, ##Anima los puntos según variable
                    transition_length = 2,
                    state_length = 1) + 
	ease_aes('cubic-in-out') + ##suavizar animación
	ggtitle('Now showing {closest_state}',
          subtitle = 'Frame {frame} of {nframes}') ##Título con estados de la animación
```
`transition_states()` splits up plot data by a discrete variable and animates between the different states.
`ease_aes()` defines the velocity with which aesthetics change during an animation.

#### Animar transiciones de entrada y salida:
```
anim <- ggplot(iris, aes(x = Petal.Width, y = Petal.Length)) + 
  geom_point(aes(colour = Species), size = 2) + 
  transition_states(Species,
                    transition_length = 2,
                    state_length = 1)
anim + 
  enter_fade() + 
  exit_shrink()
```
`enter` and `exit` functions are used to modify the aesthetics of appearing and disappearing data so that their entrance or exit may be animated.

#### Agregar título
Si es `transition_reveal`:
```
labs(x = "Años", y = "Nacimientos", title="Año {as.integer(frame_along)}") +
```

Si es `transition_states`:
```
labs(x = "Años", y = "Nacimientos", title="Año {closest_state}") +
```

```
ggtitle('Año {closest_state}') ##título de años
```

#### Exportar:
```
animate(gA_anim, nframes=300, fps=24, width=750, height=675, res=150, end_pause = 30)
anim_save("Animación2.gif", animation = last_animation())
```
`nframes` es la cantidad total de cuadros de la animación
`fps` son los cuadros por segundo de la animación
`end_pause` son cuadros de pausa al final de la animación
`rewind=TRUE` para rebobinar.

Ejemplo:
```
library(ggplot2)
library(gganimate)

p<- ggplot(iris, aes(x = Petal.Width, y = Petal.Length)) +
    geom_point() + ##Gráfico de dispersión común
    transition_states(Species, transition_length = 2, state_length = 1) + ##Anima los puntos según variable
    ease_aes('cubic-in-out') + ##suavizar animación
    ggtitle('Now showing {closest_state}',
            subtitle = 'Frame {frame} of {nframes}') ##Título con estados de la animación

animate(p, nframes=300, fps=30) 
anim_save("Animación2.gif", animation = last_animation())
```


[https://www.datanovia.com/en/blog/gganimate-how-to-create-plots-with-beautiful-animation-in-r/##show-preceding-frames-with-gradual-falloff](https://www.datanovia.com/en/blog/gganimate-how-to-create-plots-with-beautiful-animation-in-r/##show-preceding-frames-with-gradual-falloff)

Regresión:
[http://varianceexplained.org/files/loess.html](http://varianceexplained.org/files/loess.html)



#### Gráficos de países que se van adelantando
- [https://towardsdatascience.com/create-animated-bar-charts-using-r-31d09e5841da](https://towardsdatascience.com/create-animated-bar-charts-using-r-31d09e5841da)
- [https://stackoverflow.com/questions/53162821/animated-sorted-bar-chart-with-bars-overtaking-each-other?source=post\_page---------------------------](https://stackoverflow.com/questions/53162821/animated-sorted-bar-chart-with-bars-overtaking-each-other?source=post_page---------------------------)

```
nata<-read.csv("nata.csv", sep=";")

names(nata)[2] <- "2000"
names(nata)[3] <- "2001"
names(nata)[4] <- "2002"
names(nata)[5] <- "2003"
names(nata)[6] <- "2004"
names(nata)[7] <- "2005"
names(nata)[8] <- "2006"
names(nata)[9] <- "2007"
names(nata)[10] <- "2008"
names(nata)[11] <- "2009"
names(nata)[12] <- "2010"
names(nata)[13] <- "2011"
names(nata)[14] <- "2012"
names(nata)[15] <- "2013"
names(nata)[16] <- "2014"
names(nata)[17] <- "2015"
names(nata)[18] <- "2016"

library(ggplot2)
library(gganimate)
library(tidyverse)
library(janitor)
library(scales)


### Aplicar guía a mis datos
            
### Cambiar formato de base de datos a "long format"
nata_tidy <- nata %>% 
      mutate_at(vars(contains("20")),as.numeric) %>% ##selecionar los años 
      gather(year,value,2:18) %>% ##elegir las columnas de los años
      janitor::clean_names() %>% 
      mutate(year = as.numeric(stringr::str_sub(year,1,4)))

write_csv(nata_tidy,"nata_tidy.csv")
View(nata_tidy)
View(nata)

### We’re going to filter our dataset to retain only the top 10 countries for every given year

nata_tidy <- read_csv("nata_tidy.csv")
nata_formatted <- nata_tidy %>%
      group_by(year) %>%
      ## The * 1 makes it possible to have non-integer ranks while sliding
      mutate(rank = rank(-value),
             Value_rel = value/value[rank==1],
             Value_lbl = paste0(" ",round(value/1e9))) %>%
      group_by(region) %>% 
      filter(rank <=10) %>%
      ungroup()

View(nata_formatted)

### Gráfico seguido de animación

staticplot = ggplot(nata_formatted, aes(rank, group = region, 
                                       fill = as.factor(region), 
                                       color = as.factor(region))) +
      geom_tile(aes(y = value/2,
                    height = value,
                    width = 0.9), alpha = 0.8, color = NA) +
      geom_text(aes(y = 0, label = paste(region, " ")), vjust = 0.2, hjust = 1) +
      geom_text(aes(y=value,label = paste(round(value,digits= 1)), hjust=-0.2)) +
      coord_flip(clip = "off", expand = FALSE) +
      scale_y_continuous(labels = scales::comma) +
      scale_x_reverse() +
      guides(color = FALSE, fill = FALSE) +
      theme(axis.line=element_blank(),
            axis.text.x=element_blank(),
            axis.text.y=element_blank(),
            axis.ticks=element_blank(),
            axis.title.x=element_blank(),
            axis.title.y=element_blank(),
            legend.position="none",
            panel.background=element_blank(),
            panel.border=element_blank(),
            panel.grid.major=element_blank(),
            panel.grid.minor=element_blank(),
            panel.grid.major.x = element_line( size=.1, color="grey" ),
            panel.grid.minor.x = element_line( size=.1, color="grey" ),
            plot.background=element_blank(),
            plot.margin = margin(1,1, 1, 4, "cm"))

animacion = staticplot + transition_states(year, transition_length = 2, state_length = 4) +
      view_follow(fixed_x = TRUE)  +
      labs(title = 'Tasa de natalidad anual: {closest_state}')

animate(animacion, nframes=640, fps=30, width=400, height=400, res=100, detail=2)
anim_save("Natalidad regiones.gif", animation = last_animation())
```
### Cortar datos en intervalos
![](DraggedImage.jpeg)![](DraggedImage-1.jpeg)

```
## Plot object p
p <- ggplot(diamonds, aes(x = carat, y = price))

## Use cut_interval
p + geom_boxplot(aes(group = cut_interval(carat, n=10)))

## Use cut_number
p + geom_boxplot(aes(group = cut_number(carat, n=10)))

## Use cut_width
p + geom_boxplot(aes(group = cut_width(carat, width=0.25)))
```
### Mapas
Graficar mapas en ggplot2

#### Graficar mapas de Chile
Paquete Chilemapas
[https://github.com/pachamaltese/chilemapas](https://github.com/pachamaltese/chilemapas)

#### Recortar mapa

```
mapa_cortado <- st_crop(mapa, 
	xmin = -20, xmax = 45,
	ymin = 30, ymax = 73)
```
#### Cambiar formato de coordenadas
Necesario cuando se usan dos mapas distintos en un solo gráfico y sus sistemas de coordenadas difieren.

Revisar el formato de coordenadas de los dos mapas:
```
mapa1$geometry
mapa2$geometry
```

Cambiar uno por el del otro:
```
mapa2$geometry <- st_transform(mapa2$geometry, 
	crs = 32719)
```
#### Acercarse a un mapa
```
mapa +
coord_sf(ylim=c(-30, -10),
		 xlim=c(-80, -60))
```
#### Importar shape

El archivo .shp tiene que estar dentro de la carpeta con el resto de archivos necesarios.

```
mapa <- sf::st_read("Catastro_Campamentos_2019/Catastro_Campamentos_2019/Catastro_Campamentos_2019.shp")    

```
#### Geocodificar

[https://www.jessesadler.com/post/geocoding-with-r/](https://www.jessesadler.com/post/geocoding-with-r/)

## Figuras y capas
Agregar figuras o capas extra a un gráfico

### Agregar capas condicionales

```
switch=TRUE

datos %>%
ggplot(aes(x, y)) +
	{if(switch) geom_hline(yintercept = 15)}+
	geom_point()
```


```
geom_line(data = subset(afp_cotizantes2, región=="Iquique"), size=1) +
geom_line(data = subset(afp_cotizantes2, región!="Iquique"), size=0.5, show.legend = FALSE) +
```


[https://gist.github.com/jcheng5/3971908](https://gist.github.com/jcheng5/3971908)

### Agregar barras de brecha:

```
casen %>%
    filter(region=="Región de Tarapacá") %>%
    rename(trabajan=o1) %>%
    group_by(sexo, comuna, trabajan) %>%
    summarise(cantidad=n()) %>%
    mutate(porcentaje = cantidad/sum(cantidad)) %>%
    group_by(comuna) %>%
    mutate(diferencia = porcentaje[sexo == "Mujer"] - porcentaje) %>%
    group_by(comuna, trabajan) %>%
    mutate(mujer = porcentaje[sexo == "Mujer"]) %>%
    mutate(hombre = porcentaje[sexo == "Hombre"]) %>%
    filter(trabajan=="Sí") %>%
    ##filter(!is.na(trabajan)) %>%
    ##graficar
    ggplot(aes(fct_reorder(str_wrap(comuna, 4), diferencia), porcentaje, fill=sexo)) +
    ##facet_wrap(~comuna, strip.position = "bottom") +
    geom_col(position="dodge", width=0.8) +
    geom_text(aes(label = percent(porcentaje)), position = position_dodge2(width=0.8), 
              hjust = 1.2, vjust=0.5, size=3.5, angle=90, color="white") +
    geom_linerange(aes(ymin = mujer, ymax = hombre, linetype="Brecha\nde género"), size=3, col="##DF1A57")
```
### Líneas verticales grises
Agregar linea

Verticales:
```
theme(panel.grid.major.x = element_line(color="gray90"))
```

Horizontales:
```
theme(panel.grid.major.y = element_line(color="gray90"))
```
### Poner logo en esquina del gráfico

Importar logo: 
```
logo_tarapaca <- readPNG("logo_tarapaca_2.png")
```

```
coord_cartesian(clip="off") +
annotation_custom(grob = rasterGrob(logo_tarapaca_chico, width=unit(2,'cm'), hjust = 7, vjust=-0.3, x = unit(1,"npc"), y = unit(1,"npc")))
```
Ajustar `hjust` y `vjust`

Si el gráfico está horizontal:
```
coord_flip(clip="off") +
```
### Insertar flechas en el gráfico

```
library(gridExtra)

 annotate(
        "segment",
        x=dates,
        xend=dates,
        y=prices-11,
        yend=prices-1,
        color="blue",
        arrow=arrow(length=unit(0.05,"npc")
        ))
```


Afuera del gráfico
```
annotate("segment", x=4.5, xend=3, y=-70, yend=-70, col="black", arrow=arrow(length=unit(0.3, "cm"))) +
scale_y_continuous(expand=c(0,0)) +
coord_cartesian(ylim = c(0, 700), clip="off") +
theme(plot.margin = unit(c(1,1,3,1), "lines"))
```
### Agregar línea horizontal de promedio

```
geom_hline(yintercept = mean(Indcatotvalue), color="blue")
```
### Graficar una única variable

```
ggplot(mammals[mammals$vore == "Insectivore", ], aes(x = sleep_total, fill = vore)) +
  geom_density(col = NA, alpha = 0.35) +
  scale_x_continuous(limits = c(0, 24)) +
  coord_cartesian(ylim = c(0, 0.3))
```
### Insertar barras

```
geom_vline
geom_hline
```


```
geom_rect(data = recess,
         aes(xmin = begin, xmax = end, ymin = -Inf, ymax = +Inf),
         inherit.aes = FALSE, fill = "red", alpha = 0.2)
```

```
+ geom_vline(xintercept=0)
```
### Guardar y aplicar capas

```
BMI_fill <- scale_fill_brewer("BMI Category", palette = "Reds")
```
Luego esta capa puede aplicarse con `+ BMI_fill`

Otro ejemplo:
```
fix_strips <- theme(strip.text.y = element_text(angle = 0, hjust = 0, vjust = 0.1, size = 14),
                    strip.background = element_blank(),
                    legend.position = "none")

ggplot(...) + fix_strips
```
### Shapes

Las figuras `shape` de 21 a 25 tienen borde y relleno independientes.

## Texto
Operaciones que se pueden realizar sobre el texto de los gráficos

### Insertar texto en el gráfico

```
annotate("text", x=2.8, y=-0.025, hjust=1, col="black", label="Menores ingresos") +
annotate("text", x=8.4, y=-0.025, hjust=0, col="black", label="Mayores ingresos") +
```
`hjust = 1` significa que el texto se posiciona desde el borde derecho, `0` depende del borde izquierdo.

Para ponerlas fuera del gráfico:
```
    coord_cartesian(clip = 'off') +
    theme(plot.margin = unit(c(1,1,3,1), "lines")) + ##extender área hacia abajo
```
### Texto en barras

Crear variable que calcule el porcentaje:
```
basura <- basura %>% ##crear variable que mide el porcenaje
    mutate(Porcentaje = (`Toneladas al año` / sum(`Toneladas al año`) * 100))
```

```
+ geom_text(aes(label = percent(Porcentaje)), 
            color="gray25", size=3, hjust = -0.2) +
```

Cuando son barras stack:
```
geom_text(aes(label = percent(porcentaje)), color="gray25", size=3, hjust = 0.5, vjust=0.5, position="stack") +
```

Para centrar el número en las barras:
```
geom_text(aes(label = percent(porcentaje)), color="gray25", size=3, hjust = 0.5, vjust=0.5, position = position_stack(vjust = 0.5)) +
```


Para variables categóricas o factores:
```
geom_text(aes(y = ((..count..)/sum(..count..)), 
			label = scales::percent((..count..)/sum(..count..))), 
			stat = "count", hjust = -0.1, size=3, color="white") +
```

porcentaje total de las barras stacked con datos tidy:
```
stat_summary(fun.y = sum, aes(label = paste0(round(..y..*100, digits=1), "%"), group = Comuna), geom = "text", vjust=-0.5, size=3, col="gray25") +
```
Alternativa para pegar total
```
geom_text(
        aes(label = stat(y)), 
        stat = 'summary', fun.y = sum, vjust = -1
    ) +
```

Para barras dodge con `coord_flip`
```
turismo %>%
    filter(!is.na(edad)) %>%
    group_by(edad, genero, periodo) %>%
    summarize(cantidad=n()) %>%
    ggplot(aes(edad, cantidad)) +
    geom_col(aes(fill=genero), position = "dodge") + 
    coord_flip() + 
    geom_text(aes(label = cantidad), position = position_dodge2(width=1), 
              size=3.5,
              hjust=-0.5) +
    facet_wrap(~periodo)
```


Para permitir que el texto se salga del margen del gráfico hay que poner `clip = off` y  expandir el margen del gráfico con `plot.margin`:
```
coord_cartesian(clip = 'off') +
theme(plot.margin = unit(c(1,1,1,1),"cm")) ##top right bottom left
```
### Mostrar texto en el gráfico según condición

Mostrar etiquetas sólo para puntos o segmentos superiores a una cantidad.
Usando `mutate`, las etiquetas que no cumplan la función quedan en blanco, manteniendo su posición:

```
    ##Texto grande
    geom_text(aes(label = ifelse(Cantidad > 1000, Cantidad, "")), 
              position = position_dodge2(width=0.8), 
              size=3, color="red", hjust=1.2) +
    ##Texto chico
    geom_text(aes(label = ifelse(Cantidad < 1000, Cantidad, "")), 
              position = position_dodge2(width=0.8), 
              size=3, color="green", hjust=-0.2) +
```

Poner sólo los porcentajes grandes en un gráfico de barras stacked:
```
geom_text(aes(label = ifelse(Porcentaje > 0.12, percent(Porcentaje, accuracy = 0.1), "")), 
              ##position = position_dodge2(width=0.8),
              position = position_stack(vjust = .5),
              size=2.5, color="white") +
```

Para un texto más complejo (con paste, porcentaje y frecuencia)
```
    ##Texto grande
    geom_text(aes(label = ifelse(porcentaje > .1, paste(percent(porcentaje, accuracy = 0.1), "-", format(cantidad, big.mark=".")), "")), 
              position = position_dodge2(width=0.7), 
              size=3, color="red", hjust=1.2) +
    ##Texto chico
    geom_text(aes(label = ifelse(porcentaje < .1, paste(percent(porcentaje, accuracy = 0.1), "-", format(cantidad, big.mark=".")), "")), 
              position = position_dodge2(width=0.7), 
              size=3, color="green", hjust=-0.2) +
```


### Poner valores sobre las barras

```
geom_text(aes(label=variabley), vjust=1.5, hjust=0.5, col="white")
```

Para dodge:
```
geom_text(aes(label = percent(var1), 
                  y = var1 + .03), 
              position = position_dodge(0.9),
              vjust = 1)
```

Si se trata de un factor:
```
geom_text(stat='count', aes(label=..count..), vjust=0.5) +
```
### Repeler etiquetas de los puntos

```
library(ggplot2)
library(ggrepel)

x = c(0.8846, 1.1554, 0.9317, 0.9703, 0.9053, 0.9454, 1.0146, 0.9012, 
      0.9055, 1.3307)
y = c(0.9828, 1.0329, 0.931, 1.3794, 0.9273, 0.9605, 1.0259, 0.9542, 
      0.9717, 0.9357)
z= c("a", "b", "c", "d", "e", "f", 
             "g", "h", "i", "j")


df <- data.frame(x = x, y = y, z = z)
ggplot(data = df, aes(x = x, y = y)) + theme_bw() + 
geom_text_repel(aes(label = z), 
box.padding = unit(0.45, "lines")) +
geom_point(colour = "green", size = 3)
```


```
ggplot(dt, 
       aes(x = one, y = two, color = diff_cat)) +
  geom_point() +
  geom_text_repel(data = . %>% 
                    mutate(label = ifelse(diff_cat %in% c("type_1", "type_2") & abs(diff) > 2,
                                          name, "")),
                  aes(label = label), 
                  box.padding = 1,
                  show.legend = FALSE) + ##this removes the 'a' from the legend
  coord_cartesian(xlim = c(-5, 5), ylim = c(-5, 5)) +
  theme_bw()
```
### Convertir etiquetas a minúscula, mayúscula, titulares, o frase

```
stringr::str_to_upper(string, locale = "es")

stringr::str_to_lower(string, locale = "es")

stringr::str_to_title(string, locale = "es")

stringr::str_to_sentence(string, locale = "es")
```
### Poner suma de los factores sobre una barra stacked

```
stat_summary(fun.y = sum,                          ##pone como texto la suma de los factores en cada barra
               aes(label = ..y.., group = Año), 
               geom = "text", vjust=-0.5, size=3, col="gray25") + 
```
### Ajustar cita o referencia

Horizontalmente:
```
plot.caption = element_text(hjust = 1.4)) +
```
### Mover título y subtítulo

Horizontalmente:
```
plot.title = element_text(hjust = 0.3),
plot.subtitle = element_text(hjust = 0.3),
```
### Buscar y reemplazar palabras de las etiquetas

```
## buscar y reemplazar palabras para borrarlas de las etiquetas
eme2 <- eme2 %>% 
  mutate(tramo_ingresos = str_replace(tramo_ingresos, "Entre ", "")) %>%
  mutate(tramo_ingresos = str_replace(tramo_ingresos, "y", "a"))
```
### Redondear cifras
```
round(variable, digits=1)
```

Ejemplo:
```
geom_text(aes(label = 
                      paste0(##pegar símbolo de porcentaje
                            round(Porcentaje, digits=1),##redondear cifra
                            "%")), 
              color="white", size=3.5, position=position_stack(vjust = 0.5)) +
```
### Pegar signo de porcentaje
```
paste0(Porcentaje,"%")
```

Ejemplo:
```
geom_text(aes(label = 
                      paste0(##pegar símbolo de porcentaje
                            round(Porcentaje, digits=1),##redondear cifra
                            "%")), 
              color="white", size=3.5, position=position_stack(vjust = 0.5)) +
```
### Cambiar etiquetas del gráfico
Cambiar títulos de los ejes
```
+ labs(x="Título del eje x", y="Título del eje y")
```

```
titled_plot <- initial_plot + 
    labs(title = "Hell Is Other People In A Pressurized Metal Tube",
         subtitle = "Percentage of 874 air-passenger respondents who said action is very or somewhat rude",
         caption = "Source: SurveyMonkey Audience", 
         x = "", 
         y = "") 
```
### Poner nombre de barras dentro de las barras

Para que el texto o etiqueta del eje `y` o `x` aparezca dentro de la barra:

En gráficos con `coord_flip`:
```
geom_text(aes(label = str_to_title(variable), y=0.02), hjust=0, size = 3.2, col="white") +
theme(axis.text.y = element_blank()) ##ocultar eje
```

Sin `coord_flip`:
```
geom_text(aes(label = str_to_title(variable), y=0.02), angle=90, hjust=0, size = 3.2, col="white") +
theme(axis.text.x = element_blank())
```
### Calcular porcentajes

Calcular porcentaje por categorías:
```
group_by(gastos_forma, periodo, extranjeros) %>%
    summarise(cantidad = n()) %>%
    mutate(porcentaje = cantidad/sum(cantidad)) %>% ##Porcentaje
```


Calcular porcentaje respecto del total:
```
group_by(gastos_forma, periodo, extranjeros) %>%
    summarise(cantidad = n()) %>%
	ungroup() %>%
    mutate(porcentaje = cantidad/sum(cantidad)) %>% ##Porcentaje
```
Hay que agregar un `ungroup`.

Agregar fila con suma de totales:
```
adorn_totals("row") %>%
```

Agregar columna con suma de totales:
```
adorn_totals("col", name = "Total") %>%
```
### Poner texto al final del gráfico de líneas

```
    geom_text(aes(label = ifelse(Año==2018, 
                                 str_pad(number(media, accuracy = 1, big.mark="."), 20, side="right"),
                                 "")), 
              size=3, hjust=-0.15) +
```

Puede que sea necesario mover la leyenda hacia la derecha:
```
theme(legend.box.margin=margin(c(0,0,0,10))) +
```
### Formatear números
Quitar decimales a un número que por ejemplo es una media:
```
round(Toneladas, digits = 2)
```
### Añadir texto antes o después del nombre de la variable

```
ggplot(aes(x = paste("texto", variable)))
```

```
scale_x_continuous(labels = function(x) paste(x, "años"),
```
### Formatear una fecha
Hay que tener instalado el `locale` necesario, en este caso el de español. Activar el `locale`:
```
Sys.setlocale(category = "LC_TIME", locale="es_ES.UTF-8") ##Meses en español
```

Luego las fechas usarán meses en castellano:
```
format(max(covid_comuna$Fecha), "%d de %B")
```
### Aumentar el tamaño de todo el texto

```
theme(text = element_text(size=16))
```
### Cambiar tipografía
```
library(extrafont)

theme(plot.title = element_text(size=18, family="Bebas Kai", color="##1c2366"),
```


Cambiar todo el texto:
```
text = element_text(family="Open Sans"),
```


Ver tipografías instaladas:
```
extrafont::fonts()
```
### Cambiar color de un texto según condición

Crear la condición necesaria y poner como categorías de la variable los colores a elegir:

```
datos %>%
mutate(Region2 = case_when(Region=="Tarapacá" ~ "##red",
    TRUE ~ "gray80"))
```


Luego agregar en el geom:
```
geom_text(aes(x=Comuna, y=-50, label = Region),
	color = datos$Region2)
```
### Añadir valor o texto a las etiquetas del eje x

```
scale_x_discrete(labels = paste0(Region, "\n", Poblacion))
```
### Ajustar etiquetas largas

Para cortar la categorías largas, por ejemplo, en la leyenda de un gráfico o las etiquetas de un eje:
```
datos %>%
  ggplot(aes(variable, str_wrap(variable, width = 35))) +
  geom_line()
```
Donde el número es los caracteres del ancho de línea.

Para aplicar desde fuera:
```
scale_x_discrete(labels = function(x) str_wrap(x, width = 10))
```

Para mantener el orden de los factores:
```
str_wrap_factor <- function(x, ...) {
    levels(x) <- str_wrap(levels(x), ...)
    x
}
```

Y luego usar `str_wrap_factor` del mismo modo que `str_wrap`

Cortar factores:
```
mutate(ocupación_CIUO = str_trunc(as.character(ocupación_CIUO), 30, side="right")) %>%
```
Luego volver a convertir a factor.

### ggtext

[Enhance Your ggplot2 Data Visualizations with ggtext](https://thomasadventure.blog/posts/enhance-ggplot2-with-ggtext/)

## Escalas
Manipulación de las escalas de los gráficos, que son los elementos que controlan la disposición espacial de las observaciones en el plano.

### Ordenar grafico de barras
Ordenar las barras para que una categoría del stack vaya de mayor a menor: crear una variable con `case_when` que sea un valor numérico, luego sumar esos valores numéricos en `summarize` según los grupos.

```
turismo2 %>%
  mutate(orden = case_when(interés == "Es de interes" ~ "1", TRUE ~ "0")) %>%
  mutate(orden = as.numeric(orden)) %>%
  group_by(ubicación, interés, orden) %>%
  summarize(cantidad = n(),
            orden2 = sum(orden)) %>%
    ggplot(aes(fct_reorder(ubicación, orden2), porcentaje, fill=interés))
```


Alternativa: crear variable de orden con un subset
```
group_by(Region) %>%
  mutate(Orden = Valor[Grupo == "Casos"]) %>%
  ggplot(aes(fct_reorder(Region, Orden), 
             Valor, fill = Grupo)) +
```
### Expandir un eje

Por ejemplo, si una línea queda muy corta en la parte superior de un gráfico de densidad. Similar a `coord_cartesian`

```
scale_y_discrete(expand = expand_scale(add = c(0.3, 5.5))) +
```
### Poner comas en los ejes

```
scale_x_continuous(labels = scales::comma)
```
### Intercambiar ejes

```
+ coord_flip()
```

Intercambiar y cortar o extender:  
```
coord_flip(xlim=c(0, 800)) + 
```
### Cambiar orden de los ejes

```
ggplot(aes(x = logFoldChange, y = reorder(variable, variable_de_ordenamiento)) +
	geom_point()
```

Invertir el orden:
```
ggplot(datos, aes(x=fct_rev(var1), y=...))
```

Reordenar ascendente:
```
ggplot(datos, aes(x = fct_infreq(var1), y=...
```

Reordenar descendente
```
ggplot(datos, aes(x = fct_rev(fct_infreq(variable))))
```

Reordenar según otra variable
```
ggplot(datos, aes(x= fct_reorder(variable, referencia), y=...
```
Según otra pero en descendiente:
```
mutate(Genre = fct_reorder(Genre, n, .desc = TRUE))
```

Reordenar manualmente:
```
name = factor(name, levels=c("north", "north-east", "east", "south-east", "south", "south-west", "west", "north-west")))
```

Reordenar según suma de los valores del eje:
```
  ggplot(aes(x=fct_reorder(Comuna, Porcentaje, .fun=sum, .desc=TRUE)
```
Util cuando son barras stacked y hay que ordenar por la suma de los factores

### Girar etiquetas del eje x
Girar etiquetas del eje, dándole ángulo o poniéndola horizontal, por ejemplo

```
axis.text.x = element_text(angle = -90, hjust=0)) +
```
`hjust` justifica el texto

Girar a la derecha y justificar:
```
theme(axis.text.x = element_text(hjust=0, vjust=0.5, angle = -90)
```
### Cambiar márgenes de elementos

```
theme(axis.text.x = element_text(margin = margin(t = 0)),
	axis.text.y = element_text(margin = margin(r = -5)),
    plot.subtitle = element_text(margin = margin(b = 15)))
```
### Mostrar todas las etiquetas del eje x

Mostrar todas las etiquetas del eje x
```
scale_x_continuous("ID", labels = as.character(ID), breaks = ID)
```

```
scale_x_continuous(breaks = c(1973:1980))
```
### Definir cortes del eje y
```
scale_y_continuous(breaks = c(10, 50, 100, 150, 200)) +
```
También sirve para eliminar el 0 del eje. Para combinar con logaritmo: `, trans="log10"`


### Transformar escalas a logaritmo

```
## Transform the scale
d + scale_y_log10()

```

```
## Transform the coordinates
d + coord_trans(y="log10")
```
### Agregar alfombra
Muestra los puntos exactos donde existen datos.

`+ geom_rug()`

### Cambiar eje a logaritmo 
Para cambiar una escala a logarítmica: 
```
+ scale_x_log10()
```
### Ampliar eje

Para que un eje empiece desde cero y así se elimine el margen o espaciado por defecto de ggplot:
```
expand_limits(y=0)
```

```
coord_flip(expand=FALSE)
```

```
scale_x_discrete(expand = c(0, 0)) +
```

```
scale_x_continuous(expand = c(0, 0)) + scale_y_continuous(expand = c(0, 0))
```
### Insertar un nivel en blanco para una escala

Para que en la leyenda aparezca un espacio vacío entremedio.

Primero agregar el nivel blanco con `\n`:
```
previsión_t$previsión = factor(previsión_t$previsión, levels=c("Fonasa A", "Fonasa B", "Fonasa C", "Fonasa D", "Fonasa desconocido", "\n\n","Isapre", "FF.AA. y de Orden", "Ninguno (Particular)", "Otro sistema"))  
```

Luego definir el color blanco y determinar que no se salte el nivel al estar vacío.
```
scale_fill_manual(values = c(degradado1(4), "gray70",
                                 "white", ##Color del nivel en blanco
                                 degradado4(3), "gray70"),
                       drop = FALSE) + ##Determinar que el nivel en blanco no se salte
```
### Escalas de series de tiempo

[https://www.statworx.com/at/blog/customizing-time-and-date-scales-in-ggplot2/](https://www.statworx.com/at/blog/customizing-time-and-date-scales-in-ggplot2/)

Configurar el eje x cuando es fecha:
```
scale_x_date(breaks = seq(from = ymd('2020-03-30'), to = max(covid_comuna$Fecha), 
                            ##by=1),
                            length.out=12),
               date_labels = "%d/%B") +
```

La opción `by=1` pone un break por fecha, y `length.out` pone la cantidad de breaks definidos, dispersados entre el menos y el mayor.

### Cambiar escalas continuas
```
    scale_fill_viridis(option="magma", ##color
                       name = "Porcentaje \nde votantes", 
                       breaks = c(0, 25, 50, 75, 100),
                       labels=c("0%", "25%", "50%", "75%", "100%"),
                       limits=c(20,80)) +
```
### Escalas
Cambiar el rango de tamaños de los puntos
```
+ scale_size(range = c(1, 10))
```

Etiquetas en la escala manualmente:
```
scale_y_continuous(breaks = c(300000, 1000000,5000000,10000000))
```

Etiquetas menores en la escala:
```
scale_x_continuous(breaks = c(1990, 1995, 2000, 2005, 2010, 2014, 2017),
                       minor_breaks = seq(1991, 2016, 1)) +
```

Secuencia de breaks en la escala:
```
scale_y_continuous(limits = c(0, 12000), breaks = seq(0,12000,by = 2000)
```
### Escala en miles

Puntos de miles en la escala:
```
scale_y_continuous(labels = function(x) format(x, big.mark = ".")) +
```
Escala de miles

O bien: 
```
scale_size_continuous(labels = scales::number) +
```
### Escala en porcentajes

```
library(scales)

scale_y_continuous(labels = scales::percent_format(accuracy = 1)) +
```

Pegar porcentaje en eje (si los valores ya vienen multiplicados por 100:
```
scale_y_continuous(labels = function(x) paste0(x, "%")) +
```
## Colores
Operaciones que permiten controlar y modificar los colores utilizados en los gráficos.

### Agregar más de una escala de color

[https://eliocamp.github.io/ggnewscale/](https://eliocamp.github.io/ggnewscale/)

### Escalas continuas de colores (degradado)

Definir color del mínimo y máximo:
```
scale_fill_gradient(low = "gray90", high = color_verde) +
```


Definir color del mínimo, intermedio y máximo:
```
scale_color_gradient2(low = colorspace::darken(color_verde, 0.2), 
                            mid = colorspace::darken(color_verde, 0.4), 
                            high = "white", 
                            midpoint = 3.8) +
```
Opcionalmente, definir en `midpoint` el punto que equivale al intermedio.

### Aplicar paleta de colores específicas a determinadas variables

```
cyl <- sort(unique(mpg$cyl))
ncat <- length(cyl)          ## 4 types of cylinders

## create palettes
library(RColorBrewer)
purples <- tibble(cyl, colr = brewer.pal(ncat, "Purples"))
reds    <- tibble(manufacturer = "audi", cyl, colr = brewer.pal(ncat, "Reds"))
blues   <- tibble(manufacturer = "ford", cyl, colr = brewer.pal(ncat, "Blues"))

## merge them with the data
dd_p <- dd %>% filter(!(manufacturer %in% c("audi", "ford"))) %>% left_join(purples)
dd_r <- dd %>% filter(manufacturer == "audi") %>% left_join(reds)
dd_b <- dd %>% filter(manufacturer == "ford") %>% left_join(blues)

gg_dd <- rbind(dd_p, dd_r, dd_b) %>%
        left_join(mm)

gg_dd %>% 
        ggplot(mapping = aes(x = reorder(manufacturer, mcyl), y = n, fill = colr)) + 
        geom_bar(stat = "identity", position = "fill") +
        coord_flip() +
        scale_fill_identity() 
```
### Aplicar escala de color automática

Primero crear la escala de color con tantos colores como se necesiten:
```
degradado <- colorRampPalette(c("##DF1A57", "##AF87EB", "##1D3284"))
```

Luego aplicar la escala al gráfico, determinando el número de colores a usar:
```
scale_color_manual(values = degradado(7),
aesthetics = c("fill", "col")) +
```
### Crear escala o degradado de colores

```
degradado <- colorRampPalette(c("##DF1A57", "##c444c4", "##6739b2", "##1D3284"), bias=0.9)
```

Bias es la separación de los colores en los extremos de la escala. Un bias alto (mayor a 1) hace que los colores cambien más rápido y uno bajo (cercano a 0) distribuye los colores más suavemente.

### Previsualizar colores

Para ver un color o vector de colores:

```
scales::show_col("##DF1A57")

scales::show_col(c("##DF1A57", "##c444c4", "##6739b2", "##1D3284"))

scales::show_col(degradado7b(7))
```
### Aclarar u oscurecer colores

```
colorspace::lighten("red", amount = 0.5)
```

```
scales::show_col(colorspace::lighten(color_naranjo, amount = 0.6))
```
### RColorBrewer
```
scale_fill_brewer(palette = "Dark2") +
```

Para ver todas las paletas disponibles: 
```
RColorBrewer::display.brewer.all()
```

Extraer colores:
```
colores_presidencial <- rev(brewer.pal(9, 'YlGnBu')) ##extraer paleta de colores
```

Luego aplicar como gradiente:
```
scale_fill_gradientn(colours = colores_presidencial, ##crear gradiente de colores
                         name = "Porcentaje \nde votantes", 
                         breaks = c(10, 30, 50, 70, 90)) + 
```


### Crear degradados de color
Crear escala de colores entre colores específicos:
```
degradado1 <- colorRampPalette(c("##DF1A57", "##AF87EB", "##1D3284"))
```
Luego aplicar así:
```
scale_color_manual(values = degradado1(5)) +
```
Donde el número es la cantidad de colores

### Extender escalas de colores
```
## Definition of a set of blue colors
blues <- brewer.pal(9, "Blues") ## from the RColorBrewer package

## 1 - Make a color range using colorRampPalette() and the set of blues
blue_range <- colorRampPalette(blues)

## 2 - Use blue_range to adjust the color of the bars, use scale_fill_manual()
ggplot(Vocab, aes(x = education, fill = vocabulary)) +
  geom_bar(position = "fill") +
  scale_fill_manual(values=blue_range(11))
```
### Determinar colores para variable categórica
```
colores_redes<- c("Facebook"="##1877f2","WhatsApp y similares"="##25d366","Instagram"="##c32aa3","Skype"="##00aff0","Twitter"="##1da1f2","Tinder y similares"="##FF5864","Snapchat"="##fffc00","LinkedIn"="##007bb5")
```
Luego, dependiendo del tipo del elemento:
```
scale_fill_manual(values = colores_redes) + 
scale_color_manual(values = colores_redes) +
```


### Más escalas de colores


#### Viridis
```
scale_color_viridis() +
```

```
scale_fill_viridis(option="magma") +
```
 “magma”, “plasma”, and “inferno.”

```
discrete = TRUE
```

Más paletas: 
- [https://twitter.com/wearerladies/status/1180545410974257152?s=12](https://twitter.com/wearerladies/status/1180545410974257152?s=12)
- [https://github.com/EmilHvitfeldt/r-color-palettes/blob/master/type-sorted-palettes.md##qualitative-color-palettes](https://github.com/EmilHvitfeldt/r-color-palettes/blob/master/type-sorted-palettes.md##qualitative-color-palettes)



#### CartoColor
[https://github.com/Nowosad/rcartocolor](https://github.com/Nowosad/rcartocolor)
Ver colores:
```
cartocolor::display_carto_all()
```

Usar:
```
scale_fill_carto_c(name = "Life expectancy: ", type = "diverging", palette = "Earth", direction = -1)
```



#### Scico
Ver colores:
```
scico::scico_palette_show()
```

Generar paleta:
```
paleta <- scico::scico(30, palette = 'lapaz')
```

Usar escala:
```
ggplot(volcano, aes(x = x, y = y, fill = height)) + 
  geom_raster() + 
  scale_fill_scico(palette = 'davos') 
```


#### Fishualize
```
devtools::install_github("nschiett/fishualize", force = TRUE)
library(fishualize)

paleta <- fish(10, option = "Ostracion_cubicus")
```

Ver colores:
[https://nschiett.github.io/fishualize/articles/overview\_colors.html](https://nschiett.github.io/fishualize/articles/overview_colors.html)
```
scales::show_col(fishualize::fish(10, option = "Antennarius_commerson"))
```

Bonitas:
```
Oncorhynchus_tshawytscha
Bodianus_pulchellus
Antennarius_commerson
```

```
scales::show_col(fishualize::fish(10, option = "Oncorhynchus_keta"))
```

Ver lista de peces:
```
spp <- fishualize::fish_palettes()
```

```
##Escalas continuas:
scale_color_fish(option = "Hypsypops_rubicundus", direction = -1)

##Escalas discretas:
scale_color_fishd(option = "Hypsypops_rubicundus", direction = -1)

scale_color_fish(option = "Coris_gaimard", discrete = TRUE)
```


#### Ghibli
[https://ewenme.github.io/ghibli/index.html](https://ewenme.github.io/ghibli/index.html)![](https://ewenme.github.io/ghibli/reference/figures/README-palettes-1.png)
```
library(ghibli)
scale_colour_ghibli_d("LaputaMedium", direction = -1)
```

#### PaletteR
```
devtools::install_github("AndreaCirilloAC/paletter")

library(paletter)

image_path <- "path_to_your_image"
colours_vector <- create_palette(image_path = image_path,
number_of_colors =32,
type_of_variable = “categorical")

ggplot(data = mtcars, aes(x = rownames(mtcars),y = hp,color = rownames(mtcars),
                          fill = rownames(mtcars))) +
  geom_bar(stat = 'identity') +
  scale_color_manual(values = colours_vector) +
  scale_fill_manual(values=colours_vector)+
```


#### Pirate palette

```
yarrr::piratepal(palette = "all")
```




## Leyendas
Manipular la leyenda, o la sección del gráfico que contiene los colores y/o etiquetas de los elementos gráficos que lo componen.

### Crear gráfico con leyenda manual

Cuando los elementos el gráfico se hacen por capas separadas y por lo tanto no aparecen con leyenda:
```
cols <- c("Investigadores\nhombres"="##B077E5",
          "Investigadoras\nmujeres"="##DF1A57",
          "Total de\ninvestigadores"="##1D3284")

investigadores %>%
  rename(año=1) %>%
  ##pivot_longer(cols=c(3:4), names_to="género", values_to="valor") %>%
  ggplot(aes(año)) +
  geom_col(aes(y=total, fill="Total de\ninvestigadores")) +
  geom_line(aes(y=mujeres, col="Investigadoras\nmujeres"), size=2, alpha=0.6) +
  geom_point(aes(y=mujeres, col="Investigadoras\nmujeres"), size=4) +
  geom_line(aes(y=hombres, col="Investigadores\nhombres"), size=2, alpha=0.6) +
  geom_point(aes(y=hombres, col="Investigadores\nhombres"), size=4) +
  ##texto
  geom_text(aes(y= mujeres-3.5, label = mujeres), col="white") +
  geom_text(aes(y= hombres+3.5, label = ifelse(año!=2013, hombres, "")), col="white") +
  geom_text(aes(y= hombres+5.5, label = ifelse(año==2013, hombres, "")), col="white") +
  geom_text(aes(y= total+3, label = total)) +
  ##escalas
  scale_colour_manual(name="Error Bars", values = cols) + 
  scale_fill_manual(name="Bar", values = cols) +
  scale_x_continuous(breaks=c(2009:2017)) +
  labs(y="Cantidad de investigadores/as")
```



Alternativa más rápida: 
```
geom_hline(aes(yintercept = promedio, col="Arancel promedio")) +
scale_colour_manual(name="Error Bars", values = c("Arancel promedio"="red")) + 
```
### Invertir orden de leyenda

```
guides(fill = guide_legend(reverse = TRUE)) +
```
### Orientación y ubicación de la leyenda

Ubicación de la leyenda: `theme(legend.position = c(0.85, 0.85))`

Mover la leyenda en relación a su ubicación por defecto:
```
legend.box.margin=margin(c(0,0,0,-60)) ##moverla a la izquierda
```


Leyenda dentro del gráfico: 
```
theme(legend.position = c(.8,.8))
```

Eliminar leyenda: `theme(legend.position = "none")`

Añadir margen al gráfico: 
```
theme(panel.spacing.x=unit(2, "cm"), plot.margin=unit(c(1,2,1,1), "cm"))
```

Eliminar todos los rectángulos: `no_panels <- theme(rect = element_blank())`

Poner leyenda abajo:
```
theme(legend.position = "bottom")
```

Cambiar orientación de los elementos de la leyenda:  
```
theme(legend.direction = "horizontal")
```

Cambiar ubicación de leyenda:
```
+ theme(legend.position = "bottom",
          legend.box = "vertical") 
```


### Textos de leyenda
Cambiar título de leyenda:
```
+ scale_fill_discrete(name = "")
```

Si es una combinación de geoms:
```
labs(fill = "Nacionalidad", col = "Nacionalidad") +
```

Cambiar nombre de elementos de la leyenda:
```
+ scale_fill_discrete(name = "Padrón electoral", labels = c("Inscritos que no votaron", "Votantes")) +
```

Ocultar una leyenda específica:
```
+ guides(col = FALSE)
```
O poner dentro del geom: `show.legend=FALSE`


### Elementos de la leyenda
Cambiar espaciado horizontal de leyenda:
```
legend.spacing.x = unit(0.4, 'cm') ##NO SIRVE?
```

Cambiar espaciado vertical de elementos de leyenda:
```
legend.text = element_text(margin = margin(t=4, b = 4), size=9))
```

Tamaño de cuadrados de leyenda
```
legend.key.size = unit(1.7, 'lines')
```

Ajustar espacio vertical:
```
legend.text = element_text(margin = margin(t=10, b=10)),
```

Ajustar espaciado de leyendas:
```
legend.text = element_text(margin = margin(l = -2, r = 10), size=8))
```

Definir cantidad de filas en que aparecen las leyendas:
```
guides(fill = guide_legend(nrow = 3)) + ##cantidad de filas de la leyenda
```

Invertir elementos de leyenda:
```
guides(fill = guide_legend(reverse = TRUE))
```


Cambiar forma de la leyenda:
```
guides(colour = guide_legend(override.aes = list(shape = 15)))
```

Borrar el cuadrado gris de fondo de la leyenda:
```
theme(legend.key = element_blank())
```

Cambiar color de la leyenda:
```
guides(shape = guide_legend(override.aes = list(colour = "pink")))
```
### Margen de la leyenda
```
theme(legend.margin = margin(20, 20, 20, 0)) + ##caja de la leyenda
```
### Leyendas redondas

Cambiar una leyenda redonda de `geom_line` o `geom_point` por una cuadrada como de `geom_col`
```
guides(col = guide_legend(nrow = 3, override.aes = list(shape = 15, size=7))) +
```
Para que las barras tengan círculos en la leyenda:
- poner fill y col en aes()
- poner un `geom_point`  de size 0, alpha 0 
- show-legend F en las columnas
- que los títulos coincidan en labs, y que se use o no reverse en guides de forma consistente:
```
theme(legend.key = element_blank(),
        legend.background = element_blank()) +
  geom_point(size=0) +
  ##guides(fill = guide_legend(override.aes = list(fill = NA, text = NA, alpha = 1))) +
  guides(col = guide_legend(reverse = TRUE,
                            override.aes = list(size=5, fill=NA, text=NA)))
```


Ejemplo en gráfico de líneas
```
ggplot(aes(fecha, valor, col=parque, fill=parque)) +
  geom_line(show.legend = FALSE) +
  geom_point(size=0, alpha=0) +
  scale_y_continuous(labels = function(x) format(x, big.mark = ".")) +
  labs(y="Visitas") +
  theme_minimal() +
  theme(legend.position = "bottom",
        legend.title = element_blank(),
        axis.title.x = element_blank(),
        legend.text = element_text(margin = margin(t=3, b=3, r=6))) +
  guides(col = guide_legend(ncol=2,
                            override.aes = list(size=4, fill=NA, text=NA))) +
  guides(fill = guide_legend(override.aes = list(fill = NA, text = NA, alpha = 1)))
```
## Temas y espaciado

### Espaciado entre facetas
El espacio horizontal entre dos facetas de un gráfico, cuando el gráfico se separa en facetas con `facet_wrap()`
```
theme(panel.spacing.x=unit(2, "cm"))
```
### Reducir margen de gráficos

Especialmente útil para gráficos de torta
```
theme(plot.margin = margin(-20, 0, -20, -0)) +
```

Ejemplo:
```
plot.margin = margin(20, ##arriba
                               -90, ##derecha
                               10, ##abajo
                               -50) ##izquierda
          )
```
### Múltiples gráficos
Facetas

```
ggplot(comics, aes(x = align)) + 
  geom_bar() +
  facet_wrap(~ gender)
```

```
ggplot(email, aes(x= number)) +
  geom_bar() +
  facet_wrap(.~spam)
```


```
## 1 - Separate rows according to transmission type, am
p +
  facet_grid(am ~ .)
```

```
## 2 - Separate columns according to cylinders, cyl
p +
  facet_grid(. ~ cyl)
```

```
## 3 - Separate by both columns and rows 
p +
  facet_grid(am ~ cyl)
```

Liberar los ejes de los gráficos para que sean distintos:
```
facer_wrap(~ country, scales="free_y")
```

Eliminar cruces donde no hay datos:
```
p +
  facet_grid(vore ~ .,scale= "free_y", space = "free_y")
```


Espaciado entre facetas:
```
library(grid)
z + theme(panel.spacing.x=unit(2, "cm"))
```

Gráficos verticales
```
facet_wrap( ~ site, ncol = 1) + ## Facet layer
```


Espaciado entre facetas:
```
panel.spacing.y =unit(0.4, "cm")) +
```

Ocultar títulos de faceta:
```
theme(strip.background = element_blank(), strip.text = element_blank())
```

Facetas de lado
```
facet_wrap(~ str_to_title(tipo), nrow = 2, scales = "free_y", 
               strip.position="left")
```



Cortar textos de faceta (sin modificar los factores):
```
facet_wrap(~egreso, nrow=1, labeller = label_wrap_gen(width=10)) +
```
### Elementos y temas
```
+ theme()
```

Dentro de la capa `theme()`:

Especificar líneas: `=element_line()`
```
theme(
		axis.line=element_line(color="red")
)
```

Remover un elemento: `=element_blank()`
```
theme(
	panel.grid=element_blank()
)
```
Para especificar el eje afectado, se pone un punto y el eje al final del nombre del elemento, por ejemplo: `axis.text.x`

#### Elementos:
- `element_text()`
- `element_rect()`
- `element_line()`
- `element_blank()`

- Ejes:
	- Marcas en los ejes: `axis.ticks`
	- Líneas de los ejes: `axis.line`
	- Etiquetas de los ejes: `axis.text`

- Fondos:
	- `panel.background`
- Rejillas:
	- `panel.grid.major`
	- `panel.grid.minor`

#### Cambiar texto
- Texto de facetas: `strip.text`
- Título de los ejes: `axis.title`
- Números en los ejes: `axis.text`
```
plot +
  theme_minimal() +
  ## Customize the "minimal" theme with another custom "theme" call
  theme(
    text = element_text(family = "Bookman"),
    title = element_text(color = "gray25"),
    plot.caption = element_text(color = "gray30"),
    plot.subtitle = element_text(size = 12)
  )
```

Cambiar margen del texto:
```
  theme(axis.text.y = element_text(margin = margin(r = -10)),
        axis.text.x = element_text(margin = margin(b = -15))) +
```

Renombrar ejes:
```
labs(y="Cantidad de reclamos y consultas", x="Institución o vía de emisión") 
```


### Combinar múltiples gráficos
Unir dos gráficos:

Si usan los mismos datos:
```
library(gridExtra)
basura_x2 <- grid.arrange(basura_gg, basura_p_gg, ncol=2)
```

Para dos gráficos distintos:
```
ggsave("foo.pdf", arrangeGrob(plot1, plot2))
```


Con cowplot:
```
library(cowplot)
empresas_combinado_cowplot <- plot_grid(empresas_tamaño_porc_gg, 
          empresas_trabajadores_porc_gg,
          leyenda_1,
          nrow = 3,
          align = "v",
          rel_heights = c(3, 3, 1))  
```
### Ajustar espacio entre etiquetas de ejes y gráfico
Para acercar o alejar las etiquetas de las barras:
```
theme(axis.text.y = element_text(margin = margin(r = -3, l = 5))) +
```
### Acercar leyenda al gráfico
```
theme(legend.margin = margin(20, 20, 20, 0)) + ##caja de la leyenda
```
### Cambiar tamaño y hacer zoom en los datos

```
+ coord_cartesian(xlim=c(3,6))
```


Graficar con la misma relación entre ejes (si las unidades de medida son iguales)
```
+ coord_equal()
```
### Guardar y aplicar temas

Guardar la configuración de elementos de la capa `theme` en un tema:
```
mi_tema <- theme(element.axis...)
plot + mi_tema
```

Expandir temas guardados con nuevas configuraciones:
```
mi_tema2 <- mi_tema + theme(element...
```
Ejemplo:
```
z +
  no_panels +
  theme(plot.background = element_rect(fill = myPink, color="black", size=3))
```


Elegir un tema por defecto (que se aplique a todos lo gráficos):
```
theme_set(mi_tema)
```

The arguments for theme_update() are the same as for theme(). When you call theme_update() and assign it to an object (e.g. called old), that object stores the current default theme, and the arguments update the default theme. If you want to restore the previous default theme, you can get it back by using theme_update() again. Let's see how:_
```
## 2 - Update the default theme, and at the same time
## assign the old theme to the object old.
old <- theme_update(panel.background = element_blank(),
             legend.key = element_blank(),
             legend.background = element_blank(),
             strip.background = element_blank(),
             plot.background = element_rect(fill = myPink, color = "black", size = 3),
             panel.grid = element_blank(),
             axis.line = element_line(color = "red"),
             axis.ticks = element_line(color = "red"),
             strip.text = element_text(size = 16, color = myRed),
             axis.title.y = element_text(color = myRed, hjust = 0, face = "italic"),
             axis.title.x = element_text(color = myRed, hjust = 0, face = "italic"),
             axis.text = element_text(color = "black"),
             legend.position = "none")

## 3 - Display the plot z2 - new default theme used
z2

## 4 - Restore the old default theme
theme_set(old)

## Display the plot z2 - old theme restored
z2
```

##### Cargar temas con el paquete `ggthemes`
```
library(ggthemes)
```
## Exportar gráficos

```
ggsave(file="grafico7_7_2c.jpg", plot=basura_x2, dpi="retina")
```

Cambiar DPI para especificar resolución
```
ggsave("Gráfico.png", units="in", width=5, height=4, dpi=300)
```

Exportar animación:
```
anim_save("Animación.gif", animation = last_animation())
```