8  Manejo de bases de datos con R

De acuerdo con R Core Team (2026), R, descrito en la literatura es un software estadístico ampliamente utilizado para el análisis de datos y la generación de gráficos y permite un ambiente integrado para el análisis estadístico, en particular de bases de datos. Esto significa que permite realizar procesos de análisis, programación, visualización y manejo de datos dentro de un mismo entorno.

En este anexo se utiliza el enfoque del tidyverse, cuya organización de datos se relaciona con los principios expuestos por Wickham (2014), y en particular el paquete dplyr, para organizar una secuencia lógica de trabajo con bases de datos: cargar la información, inspeccionarla, seleccionar variables, filtrar registros, ordenar filas, crear variables y producir resúmenes.

8.1 Preparación del entorno de trabajo

R es un lenguaje de programación de carácter colaborativo, lo que permite que su comunidad de usuarios y desarrolladores contribuya continuamente mediante la creación de funciones, paquetes y librerías especializadas. Gracias a este ecosistema abierto, es posible ampliar sus capacidades para distintos tipos de análisis estadístico y procesamiento de datos. Entre las librerías más utilizadas para el análisis de bases de datos se encuentran las siguientes:

• De acuerdo con Wickham, Averick, et al. (2026), la librería tidyverse corresponde a un conjunto de paquetes de R diseñados para apoyar distintas etapas del trabajo con datos, desde su importación y transformación hasta su exploración, análisis y visualización. Su uso se ha extendido ampliamente en ciencia de datos porque ofrece una forma de trabajo consistente y ordenada.

• Según Wickham, François, et al. (2026), el paquete dplyr ofrece herramientas para organizar y transformar bases de datos rectangulares. Su utilidad radica en que reúne, en una sintaxis simple y consistente, las operaciones más frecuentes del trabajo analítico con datos: seleccionar variables, filtrar registros, crear nuevas columnas, ordenar observaciones y resumir información.

• De acuerdo con Gutiérrez (2020), el paquete TeachingSampling ofrece funciones para seleccionar muestras probabilísticas y realizar inferencia sobre poblaciones finitas bajo diversos diseños de muestreo.

Antes de poder utilizar las diferentes funciones que cada librería tiene, es necesario descargarlas de antemano de la web. El comando install.packages permite realizar esta tarea. Note que algunas librerías pueden depender de otras, así que para poder utilizarlas es necesario instalar también las dependencias adicionales.

install.packages("dplyr")
install.packages("tidyverse")
install.packages("TeachingSampling")

Según Posit Software, PBC (2026), una vez instalados los paquetes, se cargan con library(). El primer comando limpia los objetos existentes en la sesión de trabajo, lo que ayuda a que los resultados del capítulo dependan solo del código que se ejecuta aquí. Debe tenerse en cuenta que un paquete solo puede cargarse si previamente ha sido instalado en el sistema. La opción rm(list = ls()) no sustituye el inicio de una sesión limpia: para favorecer la reproducibilidad, conviene iniciar los proyectos con un espacio de trabajo vacío y ejecutar un guion completo y autosuficiente.

rm(list = ls())

library(tidyverse)
library(dplyr)
library(TeachingSampling)

Una vez se descargan e instalan las librerías o paquetes en R, el paso recomendado es que todos los procesamientos se realicen mediante la creación de proyectos. Un proyecto de RStudio asocia un archivo .Rproj con un directorio de trabajo y guarda opciones del proyecto; los archivos de origen, datos y resultados permanecen como archivos separados dentro de ese directorio. Adicionalmente, contiene información que permite la compilación de cada archivo de R que se va a utilizar, mantiene la información para integrarse con sistemas de control de código fuente y ayuda a organizar la aplicación de los procesamientos en componentes lógicos.

8.2 Carga e inspección inicial de la base

De acuerdo con Wickham, Çetinkaya-Rundel, y Grolemund (2023), es muy usual que al trabajar proyectos en R sea necesario importar bases de datos con información relevante para un estudio en particular. Los formatos que pueden importarse mediante R y sus paquetes son diversos; entre ellos se encuentran .xlsx, .csv, .txt y .dta, que es el formato utilizado por Stata. Una vez leída la base de datos en el formato pertinente es recomendable transformarla al formato nativo de R, es decir .RDS. Este es un formato más eficiente y propio de R, y su uso facilita la importación, la transformación y el almacenamiento dentro de un flujo reproducible de análisis.

Una vez se carga la base de datos se procede a utilizar las funciones en R para poder obtener resultados de los procesamientos agregados y gráficos de interés. Para ejemplificar el uso de funciones que permitan obtener resultados agregados, utilizaremos la base de datos BigCity del paquete TeachingSampling. Esta base corresponde a un conjunto de variables socioeconómicas de 150266 personas en un año en particular.

data(BigCity)
bigcity_data <- BigCity

El objeto bigcity_data contiene una copia de BigCity. La función head() permite observar las primeras filas y obtener una impresión rápida de la estructura de la base.

head(bigcity_data)

       HHID PersonID   Stratum     PSU  Zone    Sex Age MaritalST Income
1 idHH00001  idPer01 idStrt001 PSU0001 Rural   Male  38   Married    555
2 idHH00001  idPer02 idStrt001 PSU0001 Rural Female  40   Married    555
3 idHH00001  idPer03 idStrt001 PSU0001 Rural Female  20    Single    555
4 idHH00001  idPer04 idStrt001 PSU0001 Rural   Male  19    Single    555
5 idHH00001  idPer05 idStrt001 PSU0001 Rural   Male  18    Single    555
6 idHH00002  idPer01 idStrt001 PSU0001 Rural   Male  35   Married    298
  Expenditure Employment  Poverty
1         488   Employed  NotPoor
2         488   Employed  NotPoor
3         488   Inactive  NotPoor
4         488   Employed  NotPoor
5         488   Inactive  NotPoor
6         217   Employed Relative

Una vez cargada la base de datos en R, se puede empezar a realizar los procesamientos según las necesidades de cada investigador. En este sentido, una de las primeras revisiones que se realizan al cargar una base de datos es verificar su dimensión; es decir, identificar la cantidad de filas y columnas que contiene. Lo anterior se puede hacer con la función nrow, que identifica el número de registros en la base de datos, y con la función ncol, que muestra el número de variables. Los códigos computacionales son los siguientes:

nrow(bigcity_data)

[1] 150266

ncol(bigcity_data)

[1] 12

Una forma resumida de revisar la cantidad de filas y columnas de una base de datos es mediante la función dim, la cual devuelve un vector cuya primera componente corresponde al número de filas y cuya segunda componente indica el número de columnas.

dim(bigcity_data)

[1] 150266     12

En algunas ocasiones, las bases de datos pueden ser extensas, ya sea porque contienen un número considerable de variables observadas o porque el número de registros es grande. Por esta razón, para visualizarlas adecuadamente, puede ser conveniente abrirlas en una ventana independiente y explorar su contenido de forma tabular. Esto se realiza mediante la función View, como se muestra a continuación.

View(bigcity_data)

Otra verificación importante al cargar una base de datos en R consiste en identificar las variables que contiene. Para ello, se puede utilizar la función names, la cual muestra los nombres de las variables incluidas en la base de datos.

names(bigcity_data)

 [1] "HHID"        "PersonID"    "Stratum"     "PSU"         "Zone"       
 [6] "Sex"         "Age"         "MaritalST"   "Income"      "Expenditure"
[11] "Employment"  "Poverty"    

La salida anterior muestra los nombres de las variables contenidas en la base de datos. En este caso, la base cuenta con 12 variables. Las primeras variables corresponden a identificadores y elementos del diseño muestral, como HHID, PersonID, Stratum, PSU y Zone. Luego aparecen variables sociodemográficas, como Sex, Age y MaritalST. Finalmente, se incluyen variables económicas y de condición laboral o social, como Income, Expenditure, Employment y Poverty.

Si se desea profundizar en el tipo de información que almacena cada variable, puede utilizarse la función str, la cual muestra de manera compacta la estructura de un objeto y sus componentes. Para nuestra base de datos, esta función se utilizaría de la siguiente manera:

str(bigcity_data)

'data.frame':   150266 obs. of  12 variables:
 $ HHID       : chr  "idHH00001" "idHH00001" "idHH00001" "idHH00001" ...
 $ PersonID   : chr  "idPer01" "idPer02" "idPer03" "idPer04" ...
 $ Stratum    : chr  "idStrt001" "idStrt001" "idStrt001" "idStrt001" ...
 $ PSU        : chr  "PSU0001" "PSU0001" "PSU0001" "PSU0001" ...
 $ Zone       : chr  "Rural" "Rural" "Rural" "Rural" ...
 $ Sex        : chr  "Male" "Female" "Female" "Male" ...
 $ Age        : int  38 40 20 19 18 35 29 14 13 6 ...
 $ MaritalST  : Factor w/ 6 levels "Partner","Married",..: 2 2 5 5 5 2 2 5 5 NA ...
 $ Income     : num  555 555 555 555 555 ...
 $ Expenditure: num  488 488 488 488 488 ...
 $ Employment : Factor w/ 3 levels "Unemployed","Inactive",..: 3 3 2 3 2 3 3 NA NA NA ...
 $ Poverty    : Factor w/ 3 levels "NotPoor","Extreme",..: 1 1 1 1 1 3 3 3 3 3 ...

Como se observa en la salida anterior, la función str permite identificar la clase de cada variable incluida en la base de datos. Por ejemplo, la variable HHID es de tipo carácter, al igual que la variable Sex, mientras que las variables Income y Expenditure son de tipo numérico. Los demás atributos asociados con las variables también pueden revisarse directamente en la salida del código. Esta función resulta especialmente útil para obtener una visión general del contenido y la estructura de una base de datos.

8.3 Encadenamiento de operaciones

Según Bache y Wickham (2026), una de las contribuciones más útiles de R es la incorporación de las tuberías (pipelines), las cuales permiten construir consultas, transformaciones y nuevos objetos a partir de una base de datos de manera más intuitiva, ordenada y fácil de interpretar. El operador de encadenamiento %>%, parte del paquete magrittr y cargado automáticamente al utilizar la librería tidyverse, permite enlazar varias operaciones sucesivas, de modo que el resultado obtenido en un paso se convierte en el insumo del paso siguiente. A continuación, se presenta un ejemplo sencillo de su uso con la base de datos BigCity, en el cual se calcula el número total de elementos que contiene la base mediante la función count.

bigcity_data %>%
  count()

       n
1 150266

La línea de código anterior puede interpretarse de forma sencilla: se toma la base de datos como punto de partida y, sobre ella, se realiza un conteo de sus registros. Además de la función count, existe una amplia variedad de funciones que pueden combinarse con el operador %>% para realizar consultas, transformaciones y resúmenes sobre los datos. El paquete dplyr toma ventaja de este operador, permitiendo organizar las operaciones más comunes sobre una base rectangular. En las siguientes subsecciones se presentan algunas de ellas, siguiendo un orden típico de trabajo: reducir observaciones, conservar variables, ordenar la información, crear nuevas columnas y producir resultados agregados.

8.3.1 filter: selección de registros

filter(), una de las funciones de transformación de dplyr, conserva las filas que cumplen una o varias condiciones. En el siguiente ejemplo se crean dos subconjuntos de bigcity_data: uno con los hombres y otro con las mujeres. El resultado son dos objetos nuevos. male_data contiene únicamente registros con Sex == "Male", mientras que female_data contiene registros con Sex == "Female".

male_data <- bigcity_data %>%
  filter(Sex == "Male")
female_data <- bigcity_data %>%
  filter(Sex == "Female")

También puede filtrarse por condición de pobreza. En este caso se conservan solo las personas clasificadas como no pobres. El objeto nonpoor_data contiene el subconjunto de registros cuya variable Poverty toma el valor "NotPoor".

nonpoor_data <- bigcity_data %>%
  filter(Poverty == "NotPoor")

La función filter() también permite conservar registros cuyos valores pertenecen a un conjunto específico. En los siguientes ejemplos se filtra por valores particulares de ingreso. Note que %in% evalúa si Income pertenece al conjunto indicado. Así, working_data conserva ingresos iguales a 265 o 600, y income_filter_data conserva ingresos iguales a 1000 o 2000.

working_data <- bigcity_data %>%
  filter(Income %in% c(265, 600))

income_filter_data <- bigcity_data %>%
  filter(Income %in% c(1000, 2000))

8.3.2 select: seleccionar variables

La función select() conserva columnas específicas. Para continuar con los ejemplos, se seleccionan variables de identificación de la persona y el hogar y otras como zona, sexo, edad e ingreso. El resultado es una base más reducida en columnas. Se mantiene Age porque será utilizada posteriormente para ordenar registros por edad.

working_data <- bigcity_data %>%
  select(PersonID, HHID, PSU, Zone, Sex, Age, Income)

Adicionalmente, select() también permite excluir variables. Para eliminar columnas, se antepone el signo menos (-) al nombre de cada variable. El objeto compact_data conserva las variables de working_data, excepto HHID y PersonID. Esta operación es útil cuando se desea trabajar con una base más compacta.

compact_data <- working_data %>%
  select(-HHID, -PersonID)

8.3.3 arrange: ordenamiento de filas

La función arrange() ordena las filas de una base según una o más variables. En el primer ejemplo, working_data se ordena de menor a mayor ingreso, mientras que sorted_data contiene las mismas columnas que working_data, pero sus filas quedan ordenadas por Income. La función head() muestra los primeros registros después del ordenamiento.

sorted_data <- working_data %>%
  arrange(Income)

sorted_data %>%
  head()

  PersonID      HHID     PSU  Zone    Sex Age Income
1  idPer01 idHH01522 PSU0112 Rural Female  82   10.0
2  idPer01 idHH22167 PSU0112 Rural Female  82   10.0
3  idPer01 idHH10745 PSU0893 Rural   Male  68   11.9
4  idPer01 idHH31390 PSU0893 Rural   Male  68   11.9
5  idPer01 idHH17632 PSU1432 Rural   Male  58   12.1
6  idPer02 idHH17632 PSU1432 Rural Female  50   12.1

El ordenamiento también puede realizarse considerando más de una variable. En este ejemplo, la base se organiza primero según la variable Sex y, posteriormente, dentro de cada grupo, de acuerdo con la variable Age. La siguiente salida permite revisar los primeros registros después de aplicar este criterio de ordenamiento.

working_data %>%
  arrange(Sex, Age) %>%
  head()

  PersonID      HHID     PSU  Zone    Sex Age Income
1  idPer04 idHH00009 PSU0001 Rural Female   0    152
2  idPer04 idHH20654 PSU0001 Rural Female   0    152
3  idPer06 idHH00042 PSU0004 Rural Female   0    528
4  idPer06 idHH20687 PSU0004 Rural Female   0    528
5  idPer04 idHH00191 PSU0014 Urban Female   0    355
6  idPer04 idHH20836 PSU0014 Urban Female   0    355

Para ordenar los registros de mayor a menor, se utiliza la opción desc() dentro de la función arrange(). En el siguiente ejemplo, la base se organiza de manera que las personas con mayor edad aparezcan en los primeros registros. Este tipo de ordenamiento permite identificar rápidamente los valores más altos de una variable dentro de la base reducida.

working_data %>%
  arrange(desc(Age)) %>%
  head()

  PersonID      HHID     PSU  Zone    Sex Age Income
1  idPer02 idHH01024 PSU0076 Urban Female  98    135
2  idPer02 idHH21669 PSU0076 Urban Female  98    135
3  idPer01 idHH02916 PSU0219 Rural Female  98    137
4  idPer01 idHH23561 PSU0219 Rural Female  98    137
5  idPer01 idHH03863 PSU0290 Rural   Male  98    245
6  idPer01 idHH24508 PSU0290 Rural   Male  98    245

8.3.4 mutate: creación o transformación de variables

La función mutate() crea nuevas variables o modifica variables existentes. Dado que BigCity no incluye una variable de región geográfica explícita, se construye Region a partir de Stratum. Primero se extrae la parte numérica del estrato con gsub("\\D", "", Stratum), luego se convierte a número con as.numeric() y finalmente se divide en cinco intervalos con cut(). El resultado es una nueva columna Region dentro de bigcity_data, en la que sus categorías permiten producir resúmenes regionales en los pasos siguientes. Esta variable es únicamente una recodificación didáctica de los identificadores numéricos de Stratum; no debe interpretarse como una región geográfica observada ni emplearse como tal en un análisis sustantivo.

bigcity_data <- bigcity_data %>%
  mutate(
    Region = cut(
      as.numeric(gsub("\\D", "", Stratum)),
      breaks = 5,
      labels = c("North", "South", "Center", "West", "East")
    )
  )

En el análisis de bases de datos también es frecuente recodificar variables categóricas. El siguiente código crea region_id, una versión codificada de Region que conserva el orden de las regiones y asigna códigos de dos dígitos. Esta forma de recodificación facilita la presentación o el cruce con otras fuentes de información.

bigcity_data <- bigcity_data %>%
  mutate(
    region_id = factor(
      Region,
      levels = c("North", "South", "Center", "West", "East"),
      labels = c("01", "02", "03", "04", "05")
    )
  )

El siguiente ejemplo crea log_income, que corresponde al logaritmo natural del ingreso (transformación de la escala del ingreso). Esta operación se usa con frecuencia cuando una variable monetaria presenta alta dispersión. Luego se muestran las primeras filas de las variables relevantes. Como el logaritmo no está definido para ingresos iguales o menores que cero, esos casos se convierten explícitamente en valores faltantes antes de calcular la transformación.

log_income_data <- working_data %>%
  mutate(
    log_income = if_else(
      Income > 0,
      log(Income),
      NA_real_
    )
  )

log_income_data %>%
  select(PersonID, Income, log_income) %>%
  head()

  PersonID Income log_income
1  idPer01    555       6.32
2  idPer02    555       6.32
3  idPer03    555       6.32
4  idPer04    555       6.32
5  idPer05    555       6.32
6  idPer01    298       5.70

Note que mutate() puede crear más de una variable en el mismo paso. Además, las variables creadas al inicio de mutate() pueden ser utilizadas en cálculos posteriores dentro del mismo llamado. Por ejemplo, income_2 duplica el ingreso original e income_4 duplica income_2. La siguiente salida muestra que income_4 equivale a cuatro veces el ingreso inicial.

income_transform_data <- log_income_data %>%
  mutate(
    income_2 = 2 * Income,
    income_4 = 2 * income_2
  )

income_transform_data %>%
  select(PersonID, income_2, income_4) %>%
  head()

  PersonID income_2 income_4
1  idPer01     1110     2220
2  idPer02     1110     2220
3  idPer03     1110     2220
4  idPer04     1110     2220
5  idPer05     1110     2220
6  idPer01      597     1193

También se puede crear una variable categórica mediante condiciones. En este ejemplo, la función case_when() clasifica la edad en rangos y luego convierte el resultado en un factor ordenado. El resultado es age_group, una variable de grupos etarios ordenados. Esta transformación facilita la producción de tablas por tramos de edad.

bigcity_data <- bigcity_data %>%
  mutate(
    age_group = case_when(
      Age <= 5 ~ "0-5",
      Age <= 15 ~ "6-15",
      Age <= 30 ~ "16-30",
      Age <= 45 ~ "31-45",
      Age <= 60 ~ "46-60",
      TRUE ~ "Over 60"
    ),
    age_group = factor(
      age_group,
      levels = c(
        "0-5", "6-15", "16-30",
        "31-45", "46-60", "Over 60"
      ),
      ordered = TRUE
    )
  )

8.3.5 summarise: resúmenes descriptivos

De acuerdo con Heeringa, West, y Berglund (2017), la función summarise() permite construir una tabla resumen a partir de una o varias variables de la base de datos. En el siguiente ejemplo se calculan dos estadísticas descriptivas de la variable Income: el total y la media. Como resultado, se obtiene una tabla con una sola fila que contiene la suma de los ingresos observados y el ingreso promedio de los registros incluidos en la base. Estos cálculos no incorporan pesos, estratos ni conglomerados; por tanto, describen los registros de BigCity, pero no deben interpretarse como estimaciones de una población obtenidas bajo un diseño muestral complejo.

bigcity_data %>%
  summarise(
    total_income = sum(Income),
    mean_income = mean(Income)
  )

  total_income mean_income
1     87893117         585

También pueden calcularse medidas de localización para describir la posición de los valores dentro de la distribución. En este caso, se obtiene la mediana, el primer decil, el noveno decil y la diferencia entre estos dos últimos. El resultado permite resumir distintos puntos de la distribución del ingreso, mientras que el rango decílico muestra la distancia entre el 10% inferior y el 10% superior de los ingresos observados.

bigcity_data %>%
  summarise(
    median_income = median(Income),
    decile_1 = quantile(Income, 0.1),
    decile_9 = quantile(Income, 0.9),
    decile_range = decile_9 - decile_1
  )

  median_income decile_1 decile_9 decile_range
1           449      165     1126          961

Con summarise() también es posible calcular medidas de dispersión, tales como la varianza, la desviación estándar, el valor mínimo, el valor máximo, el rango y el rango intercuartílico. Estas estadísticas permiten describir el grado de variabilidad de los ingresos observados en la muestra. En particular, el rango se obtiene como la diferencia entre el valor máximo y el valor mínimo, mientras que el rango intercuartílico resume la dispersión del 50% central de la distribución.

bigcity_data %>%
  summarise(
    variance_income = var(Income),
    sd_income = sd(Income),
    min_income = min(Income),
    max_income = max(Income),
    range_income = max_income - min_income,
    iqr_income = IQR(Income)
  )

  variance_income sd_income min_income max_income range_income iqr_income
1          332463       577         10      32920        32910        468

8.3.6 group_by: agrupación de casos

La función group_by() permite agrupar la base de datos de acuerdo con una o más variables. Al combinarla con summarise(), las estadísticas se calculan de manera independiente dentro de cada grupo definido. En el siguiente ejemplo, se cuenta el número de registros por región y luego se ordena el resultado de mayor a menor. La siguiente salida permite identificar cuántos registros están asociados con cada región de la base de datos.

bigcity_data %>%
  group_by(Region) %>%
  summarise(n = n()) %>%
  arrange(desc(n))

# A tibble: 5 × 2
  Region     n
  <fct>  <int>
1 East   39160
2 West   33868
3 Center 25944
4 South  25898
5 North  25396

Para los conteos simples, count() ofrece una forma abreviada de escribir la combinación entre group_by() y summarise(n = n()). En la práctica, ambas alternativas producen el mismo resultado, pues agrupan la base de datos según una variable categórica y calculan cuántos registros pertenecen a cada grupo. Por ejemplo, el siguiente código reproduce los mismos resultados que el código anterior.

bigcity_data %>%
  count(Region) %>%
  arrange(desc(n))

  Region     n
1   East 39160
2   West 33868
3 Center 25944
4  South 25898
5  North 25396

Para obtener el número de registros por sexo, se aplica la misma lógica de agrupación y conteo. En este caso, la base se agrupa según la variable Sex y luego se calcula el número de registros asociados con cada una de sus categorías. El resultado permite identificar cuántas observaciones corresponden a cada sexo dentro de la base de datos.

bigcity_data %>%
  count(Sex) %>%
  arrange(desc(n))

     Sex     n
1 Female 79190
2   Male 71076

El conteo también puede realizarse según la zona geográfica. En este caso, la base se agrupa por la variable Zone y se calcula el número de registros correspondiente a cada una de sus categorías. La siguiente salida permite conocer cómo se distribuyen las observaciones entre las distintas zonas de la base de datos.

bigcity_data %>%
  count(Zone) %>%
  arrange(desc(n))

   Zone     n
1 Urban 78164
2 Rural 72102

Además de los conteos, también es posible calcular medidas resumen por grupo, como la media. En este caso, para obtener el ingreso promedio por región junto con el número total de registros, se agrupa la base según la variable Region y luego se aplica summarise(). El resultado es una tabla regional que presenta, para cada región, el total de observaciones y el ingreso medio correspondiente.

bigcity_data %>%
  group_by(Region) %>%
  summarise(
    n = n(),
    mean_income = mean(Income)
  )

# A tibble: 5 × 3
  Region     n mean_income
  <fct>  <int>       <dbl>
1 North  25396        509.
2 South  25898        644.
3 Center 25944        701.
4 West   33868        571.
5 East   39160        530.

El mismo procedimiento puede aplicarse para calcular el ingreso medio por sexo. En este caso, la base se agrupa según la variable Sex y luego se obtiene el promedio de Income para cada categoría. La tabla resultante permite comparar el ingreso medio observado entre los distintos grupos definidos por el sexo.

bigcity_data %>%
  group_by(Sex) %>%
  summarise(
    n = n(),
    mean_income = mean(Income)
  )

# A tibble: 2 × 3
  Sex        n mean_income
  <chr>  <int>       <dbl>
1 Female 79190        579.
2 Male   71076        591.

Por último, se calculan la media, la desviación estándar y el rango intercuartílico de los ingresos según la condición de ocupación. Para ello, la base se agrupa por la variable Employment y luego se obtienen las estadísticas descriptivas de Income dentro de cada grupo. La siguiente salida presenta un resumen del comportamiento de los ingresos para cada categoría de ocupación.

bigcity_data %>%
  group_by(Employment) %>%
  summarise(
    n = n(),
    mean_income = mean(Income),
    sd_income = sd(Income),
    iqr_income = IQR(Income)
  )

# A tibble: 4 × 5
  Employment     n mean_income sd_income iqr_income
  <fct>      <int>       <dbl>     <dbl>      <dbl>
1 Unemployed  4630        429.      375.       392.
2 Inactive   44104        532.      553.       439.
3 Employed   62188        661.      606.       529.
4 <NA>       39344        541.      558.       407.

Bache, Stefan Milton, y Hadley Wickham. 2026. magrittr: A Forward-Pipe Operator for R. https://doi.org/10.32614/CRAN.package.magrittr.

Gutiérrez, Andrés. 2020. TeachingSampling: Selection of Samples and Parameter Estimation in Finite Population. https://doi.org/10.32614/CRAN.package.TeachingSampling.

Heeringa, Steven G., Brady T. West, y Patricia A. Berglund. 2017. Applied Survey Data Analysis. 2.ª ed. Boca Raton: Chapman & Hall/CRC. https://doi.org/10.1201/9781315153278.

Posit Software, PBC. 2026. RStudio Projects. Posit Software, PBC. https://docs.posit.co/ide/user/ide/guide/code/projects.html.

R Core Team. 2026. R: A Language and Environment for Statistical Computing. Vienna, Austria: R Foundation for Statistical Computing. https://www.R-project.org/.

Wickham, Hadley. 2014. «Tidy Data». Journal of Statistical Software 59 (10): 1-23. https://doi.org/10.18637/jss.v059.i10.

Wickham, Hadley, Mara Averick, Jennifer Bryan, Winston Chang, Lucy D’Agostino McGowan, Romain François, Garrett Grolemund, et al. 2026. tidyverse: Easily Install and Load the Tidyverse. https://doi.org/10.32614/CRAN.package.tidyverse.

Wickham, Hadley, Mine Çetinkaya-Rundel, y Garrett Grolemund. 2023. R for Data Science: Import, Tidy, Transform, Visualize, and Model Data. 2.ª ed. Sebastopol, CA: O’Reilly Media. https://r4ds.hadley.nz/.

Wickham, Hadley, Romain François, Lionel Henry, Kirill Müller, y Davis Vaughan. 2026. dplyr: A Grammar of Data Manipulation. https://doi.org/10.32614/CRAN.package.dplyr.