--- title: "Introducción al paquete {territorial}" description: "Instalación y primeros pasos con el paquete {territorial}." vignette: > %\VignetteIndexEntry{territorial} %\VignetteEngine{quarto::html} %\VignetteEncoding{UTF-8} --- ## Instalación Puedes instalar este paquete de R desde GitHub usando [el paquete `{pak}`](https://pak.r-lib.org): ```r # install.packages("pak") pak::pak("bastianolea/territorial") ``` Los siguientes ejemplos te ayudarán a familiarizarte con algunas de las funciones de `{territorial}`. ## Datos comunales Quizás lo más básico que podemos hacer a nivel comunal con `{territorial}` es obtener un vector con las comunas del país: ```{r} library(territorial) sample(comunas(), 12) ``` ### Tabla de comunas, provincias y regiones de Chile El paquete ofrece una tabla de datos que contiene todas las comunas del país con sus nombres oficiales, sus [códigos únicos territoriales](https://bastianolea.github.io/territorial/articles/codigos_unicos_territoriales.html), y lo mismo para las provincias y regiones del país. Para ver la tabla de comunas, provincias y regiones, ejecuta `territorial::territorios`: ```{r tabla} #| message: false #| warning: false library(dplyr) names(territorial::territorios) territorios ``` ```{r tabla_comunas} #| echo: false #| eval: false traduccion <- jsonlite::read_json('https://cdn.datatables.net/plug-ins/1.10.11/i18n/Spanish.json') DT::datatable( territorial::territorios, options = list( language = traduccion, pageLength = 10, lengthMenu = c(10, 15, 20, 50) ) ) ``` Esta tabla es la _fuente de verdad_ de toda la información territorial usada en el paquete, y corresponde a los datos oficiales de la [Subsecretría de Desarrollo Regional y Administrativo, Ministerio del Interior de Chile](https://www.subdere.gov.cl/documentacion/códigos-únicos-territoriales-actualizados-al-06-de-septiembre-2018). ### Validación de calidad de nombres de comunas Si tienes una tabla de datos con datos comunales, lo primero sería revisar la calidad de sus datos. La función `validar_comunas()` indica qué posibles problemas existen con los nombres de las comunas. Imaginemos una tabla de datos con _muy mala calidad_ de nombres de comunas. Usemos como ejemplo la siguiente tabla de datos: ```{r} #| message: false #| warning: false library(dplyr) datos <- tibble( nombre_comuna = c("PIRQUE", "El Monte", "Maipu", "santiago", "prohibidencia", "CERRILLOS", "San José De Maipo", "Puerto Saavedra", "OHiggins"), valores = c(4, 6, 2, 8, 6, 3, 5, 8, 10) ) ``` ```{r} datos ``` Para empezar a trabajar con estos datos, validamos su calidad primero: ```{r} datos |> validar_comunas(nombre_comuna) # cuando la columna con nombres de comunas se llama `nombre_comuna`, no es necesario especificarla ``` ### Limpieza de nombres de comunas de Chile Luego de saber más o menos el tipo de problemas que tienen los nombres de las comunas en esta tabla, podemos usar la función `limpiar_comunas()` para corregir automáticamente los nombres de las comunas: ```{r limpiar_comunas_1} datos |> limpiar_comunas() ``` Esta función realiza una limpieza de los nombres en tres pasos, que puedes leer en detalle en su documentación: `?limpiar_comunas`. En este caso, simplemente se aplica la función porque la tabla contiene la columna `nombre_comuna`, pero si la columna con nombres se llama distinto, puedes indicarla en la función. También puedes limpiar las comunas creando una variable nueva usando la función dentro de `mutate()`: ```{r limpiar_comunas_2} #| message: false #| warning: false library(dplyr) datos |> mutate(nombre_corregido = limpiar_comunas(nombre_comuna)) ``` En ambos casos, la función entrega mensajes relevantes sobre el proceso de limpieza y el tipo de problemas resueltos. Para evaluar el funcionamiento de la limpieza automática, usar el argumento `procedimiento = TRUE` para ver el paso a paso en columnas: ```{r} datos |> limpiar_comunas(procedimiento = TRUE) |> invisible() ``` #### Funciones para confirmar nombres de comunas Si necesitamos más control, también podemos confirmar los nombres manualmente consultando si las comunas son válidas: ```{r is_nombre_comuna} comunas <- c("Providencia", "Vitacura", "Las Condes", "Lo Barnechea", "Ratas", NA) is_nombre_comuna(comunas) ``` Lo anterior sería equivalente a hacer `comunas %in% territorial::comunas()`. Esto puede servir, por ejemplo, para validar datos en una aplicación Shiny. También se puede confirmar si los códigos únicos territoriales son válidos: ```{r is_codigo_comuna} comunas <- c(1101, 1107, NA, 99999) is_codigo_comuna(comunas) ``` ### Revisar presencia de comunas en una tabla Otro caso de validación de datos territoriales puede ser cuando nos encontramos con una tabla que tiene muchas observaciones, y queremos confirmar si tiene casos para todas las comunas del país, o bien, si hay comunas que están faltantes entre sus datos. Para el ejemplo, creemos una tabla de datos con muchas observaciones de comunas: ```{r datos_contar_comunas} #| message: false #| warning: false library(dplyr) n_comunas <- 324 base <- territorios |> select(nombre_comuna, codigo_comuna) |> slice_sample(n = n_comunas) |> mutate(a = runif(n = n_comunas), b = runif(n = n_comunas), c = runif(n = n_comunas)) |> tidyr::pivot_longer(cols = c(a, b, c)) |> arrange(value) base ``` Esta tabla tiene `{r} nrow(base)` filas, ¿cómo confirmar si existen datos para todas las comunas de Chile? Para eso está la función `contar_comunas()`: ```{r contar_comunas} base |> contar_comunas() ``` La función `contar_comunas()` nos indica cuántas comunas únicas hay, y las que faltan. Esto es útil porque muchas veces las bases de datos reales no tienen datos para todas las comunas, sobre todo las más pequeñas y remotas. Si dentro de esa tabla con comunas quieres confirmar si existe una en específico, o saber cómo viene escrita, usa la utilidad `buscar_comuna()`: ```{r buscar_comuna} base |> buscar_comuna("Alto") ``` ### Crear nombres de comunas a partir de códigos únicos territoriales Algo que suele pasar es tener datos comunales con las comunas mal escritas, pero que vienen con códigos únicos territoriales. En este caso, aparte de limpiarlas con `limpiar_comunas()`, podemos crear los nombres de comunas a partir de los códigos únicos territoriales: ```{r datos_as_nombre_comuna} #| message: false #| warning: false library(dplyr) datos <- tribble( ~codigo_comuna, ~municipio, 13110, "LA FLORIDA", 16103, "CHILLAN VIEJO", 10301, "OSORNO", 16302, "COIHUECO", 13132, "VITACURA", 13501, "MELIPILLA", 14204, "RIO BUENO", 11401, "CHILE CHICO", 16202, "COBQUECURA", 13116, "LO ESPEJO" ) ``` ```{r as_nombre_comuna} datos # crear nombres de comuna a partir de códigos comunales datos |> mutate(nombre_comuna = as_nombre_comuna(codigo_comuna)) ``` ### Obtener códigos únicos territoriales a partir de nombres de comunas También podemos tener el caso inverso: una tabla con datos comunales que vienen con nombres de comunas, pero sin códigos únicos territoriales. Podemos crear los códigos únicos territoriales a partir de los nombres de comunas: ```{r datos_as_codigo_comuna} #| message: false #| warning: false library(dplyr) datos <- tribble( ~nombre_comuna, ~valor, "Pirque", 1, "Cerrillos", 2, "Puente Alto", 1, "La Florida", 3, "Ñuñoa", 1, "Conchalí", 2 ) ``` ```{r as_codigo_comuna} datos # agregar códigos comunales a partir de nombres de comunas datos |> mutate(codigo_comuna = as_codigo_comuna(nombre_comuna)) ``` Naturalmente, lo anterior requiere que los nombres de las comunas estén bien escritos, así que habría que haber confirmado con `validar_comunas()` y/o haber limpiado con `limpiar_comunas()`. ### Agregar variables territoriales faltantes Si tenemos datos de nivel comunal pero les faltan variables territoriales, podemos _contextualizar_ los datos comunales al agregarles todas las variables que les faltan con la función `contextualizar()`: ```{r datos_contextualizar} datos <- tribble( ~nombre_comuna, ~valor, "Cerrillos", 1, "Arica", 2, "Putre", 3) ``` ```{r contextualizar} datos datos |> contextualizar(nombre_comuna) ``` ### Otras funciones para comunas Si tienes una comuna y quieres obtener la región a la que pertenece, usa `ubicar_comunas()`: ```{r ubicar_comunas} comuna <- "Curacautín" ubicar_comunas(comuna) ``` Si tienes varias comunas y quieres crear un texto que las contenga, usa `redactar_comunas()`: ```{r redactar_comunas} comunas <- c("Lo Espejo", "La Granja", "La Pintana", "Puente Alto") redactar_comunas(comunas) ``` Si quieres saber si una comuna clasifica como urbana, mixta o rural de acuerdo a la clasificación de la [Oficina de Estudios y Políticas Agrarias (Odepa)](https://bibliotecadigital.odepa.gob.cl/items/ce846880-f010-4868-a5d9-18c80f7ceabd), usa `agregar_clasificacion()`: ```{r agregar_clasificacion} comunas <- c("Curanilahue", "Melipilla", "San Pedro") agregar_clasificacion( as_codigo_comuna(comunas) ) ``` Estas funciones son particularmente útiles para cuando estés [creando reportes](https://bastianolea.rbind.io/blog/quarto_reportes/) o [aplicaciones web Shiny.](https://bastianolea.rbind.io/blog/shiny/) ## Datos regionales Las siguientes son funciones de R centradas en las regiones de Chile. Puedes obtener las regiones con la función `regiones()`: ```{r} library(territorial) regiones() ``` Las regiones con sus códigos territoriales puedes sacarlas de la tabla `territorial::territorios`: ```{r datos_ordenar_regiones} #| message: false #| warning: false library(dplyr) regiones <- territorios |> select(contains("region")) |> distinct() regiones ``` ### Ordenar regiones de Chile Cuando trabajamos datos de nivel regional, una necesidad común es [ordenar las regiones en el orden geográfico](https://bastianolea.rbind.io/blog/ordenar_regiones/); es decir, de norte a sur. Para ello existe la función `ordenar_regiones()`: ```{r} regiones ``` Aquí tenemos las regiones en orden según su numeración, pero queremos ordenarlas de norte a sur: ```{r ordenar_regiones} regiones |> ordenar_regiones() ``` ### Acortar nombres de regiones de Chile Hay regiones de Chile con nombres extensos, y que en ciertos contextos requieren de una versión más breve. Por ejemplo, no siempre es relevante leer "Libertador General" o "General Carlos Ibáñez del Campo". Para eso podemos `acortar_regiones()`: ```{r datos_agregar_macrozona} regiones |> ordenar_regiones() |> mutate(nombre_region_corto = acortar_regiones(nombre_region)) ``` ### Clasificar regiones de Chile en macrozonas Algunos análisis requieren de agrupar las regiones de Chile en grupos, usualmente derivados de su posición geográfica. Con la función `agregar_macrozona()` se pueden clasificar las regiones del país en varios tipos de macrozona a partir de sus códigos regionales: ```{r agregar_macrozona} regiones |> ordenar_regiones() |> mutate( macrozona_1 = agregar_macrozona(codigo_region, tipo = 1), macrozona_2 = agregar_macrozona(codigo_region, tipo = 2), macrozona_3 = agregar_macrozona(codigo_region, tipo = 3), macrozona_4 = agregar_macrozona(codigo_region, tipo = 4) ) ``` Para más información, [ver la viñeta sobre macrozonas.](https://bastianolea.github.io/territorial/articles/mapas_regionales_macrozonas.html) ### Validación de calidad de nombres de regiones Otro problema que podemos tener son datos de regiones con los nombres mal escritos. Para eso tenemos la función `validar_regiones()`, que revisará los nombres de las regiones y reportará los problemas existentes: ```{r datos_validar_regiones} regiones <- tibble(nombre_region = c("los lagos", "nuble", "OHIGGINS", "Araucania")) regiones ``` ```{r validar_regiones} regiones |> validar_regiones() ``` ### Limpieza de nombres de regiones de Chile Al igual que con la función `limpiar_comunas()`, existe la función `limpiar_regiones()`, que aplica varios pasos de limpieza automatizada de textos para obtener nombres de regiones válidos. Veamos un ejemplo con una tabla de datos donde las regiones vienen mal escritas: ```{r} regiones <- tibble(nombre_region = c("NUBLE", "AISEN", "OHIGINS", "RM")) regiones ``` Usamos `limpiar_regiones()` para obtener versiones válidas de los nombres: ```{r} regiones |> limpiar_regiones() # asume que la columna es `nombre_region` ``` ### Obtener comunas de una región Para saber qué comunas forman parte de una región, usa `obtener_comunas()`: ```{r} region <- regiones()[4] region obtener_comunas(region) ``` ### Otras funciones para regiones Si tienes nombres de región y estás creando reportes o aplicaciones que usan las regiones dentro de párrafos, sabrás que hay regiones que se anteceden por preposiciones distintas (_Región "del" Maule, Región "de" O'Higgins_), e incluso sin preposiciones (no se escribe _Región "de" Metropolitana_). Para eso existe la función `preposicion_region()`: ```{r preposicion_region} region <- c("Maule", "O'Higgins") preposicion_region(region) ``` La mejor forma de obtener el nombre redactado de la región sería con, obviamente, `redactar_region()`: ```{r redactar_region} redactar_region(region) ``` ## Datos de localidades El paquete también contiene datos a nivel sub-comunal de Chile, como son las localidades. Las localidades son asentamientos o áreas subcomunales que no son entidades administrativas. Puedes consultarlas en la tabla `territorial::localidades`: ```{r} localidades ``` Esta tabla de localidades proviene del estudio de _Identificación de localidades en condición de aislamiento_, realizado por la Subsecretaría de Desarrollo Regional y Administrativo y publicado el año 2021. ### Ubicar localidades del país en comunas Con la función `ubicar_localidades()`, podemos consultar nombres de localidades de Chile para ubicarlas geográficamente en la comuna donde se emplazan: ```{r} ubicar_localidades(c("Chada", "La Dormida", "Mallarauco")) ``` ---- Estas son algunas de las funciones principales, pero existen muchas más: [revisa el índice de funciones!](https://bastianolea.github.io/territorial/reference/index.html)