Manejo de Excel en R para Datos de Salud

Bienvenida

Antes de tocar una sola línea de código, conversemos. Si trabajas con datos de salud (en un hospital, un servicio de salud, un centro de investigación, una ONG, un seguro privado, lo que sea), una verdad incómoda es esta:

La gran mayoría de los datos que vas a recibir van a venir en Excel.

REM, fichas clínicas exportadas, encuestas, planillas de inscripción, listados de stock de farmacia, reportes mensuales, bases de datos “exportadas” desde un sistema que en realidad solo te entrega un .xlsx… Excel es el formato universal de intercambio de información en salud, te guste o no.

Este curso es sobre cómo dejar de pelearte con esas planillas y empezar a sacarles información útil desde R, usando código que puedas leer mañana, repetir el próximo mes y compartir con un colega.

Por qué no quedarse solo en Excel

Excel es excelente para mirar datos rápidamente, ordenar una columna, sumar un total, hacer un gráfico exploratorio o entregar un informe final a alguien no técnico. Para eso es muy bueno y nadie te lo va a quitar.

Pero usar Excel para todo lo demás es un riesgo — y en salud, donde los datos derivan en decisiones sobre pacientes, indicadores que llegan a la autoridad sanitaria o presupuestos asignados, los riesgos se vuelven inaceptables. Cuando tu trabajo crece, Excel empieza a fallar de formas concretas:

• No es reproducible. Si haces “ordenar por edad”, “filtrar mayores de 65”, “calcular promedio” a mano, el próximo mes tienes que volver a hacer todos los clics. Si te equivocas en un paso, no hay forma de rastrear qué pasó.
• Esconde lo que hiciste. Una fórmula en la celda H42 puede depender de otra en B17 que tú escribiste hace 3 meses. Nadie (ni tú) recuerda por qué.
• Se rompe con escala. Más de 100.000 filas y empieza a ir lento. Más de 1 millón y simplemente no puedes abrirlo.
• No se conecta a bases de datos. En cuanto los datos serios viven en una base de datos institucional (SQL Server, PostgreSQL, el sistema clínico del hospital, el data warehouse de la red), Excel queda fuera del juego. Lo máximo que se hace es exportar a .xlsx desde la BD — y ahí pierdes trazabilidad, te quedas con una foto vieja, y duplicas información que ya estaba viva en otra parte. Con R te conectas directo con DBI + dplyr y consultas la fuente fresca cada vez.
• No deja huella. No puedes versionar “qué cambió entre la planilla de enero y la de febrero” sin abrir las dos a mano.
• No se puede automatizar ni gobernar. No puedes programar Excel para que el día 1 de cada mes lea los archivos nuevos, valide reglas de negocio, marque registros sospechosos y entregue un informe. Y tampoco puedes establecer estándares de calidad y gobierno de datos (chequeos automáticos, trazabilidad de cambios, control de versiones, permisos por rol) sobre una planilla que cualquiera abre y edita a mano. En una organización seria, esto deja de ser opcional.

R resuelve los seis problemas: tu análisis queda escrito en un script, se puede volver a correr idéntico, queda documentado, soporta cualquier tamaño razonable de datos, se conecta directo a bases de datos institucionales (DBI + dplyr) y se integra con sistemas de calidad, validación y automatización (cron jobs, GitHub Actions, pipelines de datos, paquetes como pointblank o validate).

La meta de este curso es justamente esa: que aprendas a abrir el Excel desde R, hacer todo lo que necesites (con código auditable y reproducible), y guardar el resultado de vuelta en Excel — porque el resto de tu equipo te lo va a seguir pidiendo en ese formato.

El ciclo de trabajo con Excel desde R

Vamos a aprender un patrón que se repite en absolutamente todos los proyectos de análisis de datos cuando la fuente es una planilla:

Cada uno de los módulos de este curso cubre uno de esos pasos. No te saltes ninguno — son el mismo flujo que vas a hacer una y otra vez, en un solo proyecto y en cientos de proyectos.

Qué vas a saber al terminar

Al final del curso vas a poder, sin pánico:

• Recibir un archivo .xlsx con 3 hojas y dos filas de basura arriba.
• Abrirlo en R, leer la hoja que te interesa, saltarte la basura.
• Diagnosticar que la columna “edad” tiene un "99 años" que rompió el tipo de toda la columna.
• Convertir fechas que vinieron como número 45292 a fechas reales (2024-01-01).
• Reemplazar "S/I" por NA real.
• Filtrar los pacientes >65 con hipertensión, calcular el promedio de presión por sexo, y exportar el resultado en un Excel nuevo con dos hojas y los encabezados en negrita.

Todo eso lo vamos a hacer paso a paso, explicando cada línea de código.

Cómo está organizado el curso

Cada módulo tiene explicación narrativa, código paso a paso, errores comunes y un ejercicio con solución colapsable. Lee el módulo, prueba el código en tu propio R, falla un par de veces, lee la sección de errores comunes y vuelve al ejercicio. Así es como se aprende.

Convenciones de código de este curso

Para que el código sea coherente entre módulos, vamos a seguir tres convenciones desde el principio:

1. El pipe nativo |>, no %>%. Es parte de R desde la versión 4.1 (año 2021) y no necesita ningún paquete extra. Si has visto código viejo con %>%, no te asustes: hacen casi lo mismo, pero |> es el estándar moderno.
2. pak::pak("paquete") para instalar paquetes, en lugar de install.packages("paquete"). pak es más rápido, te explica mejor los errores y maneja las dependencias del sistema operativo (Rtools, librerías del sistema) sin que tengas que pelearte con ellas.
3. readxl para leer y openxlsx para escribir. Hay otros paquetes (xlsx, writexl, openpyxl para Python), pero estos dos cubren el 95% de los casos reales en salud y no requieren Java, que es la fuente número uno de dolor de cabeza con Excel desde R.

¿Y Python?

En cada bloque de código vas a ver dos pestañas: R (la principal, donde se enseña) y Python (como referencia, usando pandas). No es necesario que sepas Python para tomar el curso — es solo por si alguna vez te toca trabajar en un equipo donde Python es el lenguaje de la casa. El núcleo del curso es R.

Listo para empezar

En el próximo módulo vamos a dejar el entorno listo: R, Positron (el IDE que vamos a usar) y los paquetes del curso instalados con pak. Si ya tienes todo configurado puedes saltarte la parte de instalación, pero te recomiendo igual leer el módulo 2 porque ahí explico la diferencia entre “instalar” y “cargar” un paquete, que es una confusión clásica al partir.

La regla más importante del curso

Antes de leer tu Excel con R, léelo con tus propios ojos.

Suena obvio, pero el 80% de los errores que vas a ver más adelante (fecha rara, columna toda NA, nombres duplicados, números que aparecen como texto) tienen su origen en algo que se podía ver simplemente abriendo el archivo en Excel antes de tocarlo con código.

Este módulo entero está dedicado a esa inspección visual previa, y luego a confirmar con código lo que viste. Sin escribir nada todavía.

Las 5 preguntas que tienes que hacerle a tu Excel

Cuando recibas un nuevo .xlsx, ábrelo en Excel (o Google Sheets, o LibreOffice) y respóndete esto:

Tomar nota mental de esto te ahorra horas de debugging después.

Caso real: nuestro pacientes_ejemplo.xlsx

Para el resto del curso vamos a usar el archivo pacientes_ejemplo.xlsx (descargable desde la página de inicio). Vamos a inspeccionarlo paso a paso aplicando el checklist.

Paso A — Abre el archivo en Excel (o en LibreOffice si estás en Linux). Vas a ver lo siguiente:

Paso B — Anota qué te llamó la atención. En este archivo, las cosas que vamos a tener que resolver son:

• La columna Nombre Completo tiene espacios “sucios”: al menos un valor ("Juan Soto") tiene doble espacio interno.
• La columna fecha_ingreso muestra 45292 (un número), no 2024-01-01. Es una fecha serializada de Excel.
• La columna presion_sistolica tiene celdas con "S/I" y celdas vacías mezcladas con números. Eso significa que cuando R la lea, la va a marcar como texto, no como número.
• La hoja resumen_REM no tiene los encabezados en la fila 1.

Nada de esto rompe el archivo, pero cada uno requiere una técnica distinta para limpiarlo desde R. Las vamos a aprender en los módulos 6 al 9.

Confirmar con código: excel_sheets()

Aunque la inspección visual es lo primero, también puedes preguntarle al archivo cuántas hojas tiene desde R, sin abrirlo:

library(readxl)

excel_sheets("datos/pacientes_ejemplo.xlsx")

import pandas as pd

archivo = pd.ExcelFile("datos/pacientes_ejemplo.xlsx")
archivo.sheet_names

Salida esperada:

[1] "pacientes"   "laboratorio" "resumen_REM" "oculta"

Sí, excel_sheets() también te muestra las hojas ocultas. Eso es útil: a veces alguien te dice “el archivo solo tiene 3 hojas” pero en realidad hay una cuarta escondida con datos viejos.

Confirmar con código: ver la primera “foto” sin importar

A veces quieres mirar un pedacito de la planilla sin cargarla entera, especialmente si es grande. Para eso read_excel() tiene el argumento n_max (lo veremos a fondo en el módulo 5):

library(readxl)

# Solo las primeras 5 filas de cada hoja
read_excel("datos/pacientes_ejemplo.xlsx",
           sheet = "pacientes",
           n_max = 5)

import pandas as pd

pd.read_excel("datos/pacientes_ejemplo.xlsx",
              sheet_name="pacientes",
              nrows=5)

Vas a ver una tabla con 5 filas. Mira los tipos debajo de cada columna (<chr>, <dbl>, etc.):

• <chr> = texto (character).
• <dbl> = número con decimales (double).
• <int> = número entero.
• <lgl> = TRUE/FALSE.
• <date> = fecha.

En nuestra hoja pacientes, presion_sistolica aparece como <chr>, no <dbl>, porque tiene los "S/I" mezclados. Es la confirmación con código de lo que viste con los ojos.

El principio

Cuándo conviene quedarse en Excel

Una nota honesta: no todo lo que recibes en Excel tiene que pasar por R. Si te llega una planilla con 10 filas, 3 columnas y tu pega es solo sumar, hazlo en Excel y sigue tu vida. R brilla cuando:

• El mismo proceso se repite mensualmente.
• Los datos son grandes (más de unas miles de filas).
• Necesitas combinar varias planillas.
• Necesitas dejar trazabilidad (“este número salió de esta fórmula”).
• Vas a generar un reporte que se distribuye a otros.

Si no es ninguno de esos casos, Excel está bien. Pero el momento exacto en que sientes que estás “perdiendo el hilo” entre celdas, fórmulas y pestañas, es cuando R te empieza a ahorrar tiempo de verdad.

Errores comunes en la inspección

Ejercicio

Cuando read_excel() no alcanza

En el módulo anterior aprendimos lo básico: read_excel("ruta", sheet = "hoja"). Eso funciona cuando la planilla está limpia: encabezados en la fila 1, una sola hoja de interés, sin metadata arriba.

Pero en planillas reales (REM, registros mensuales, exports de sistemas viejos) casi siempre hay alguna complicación:

• Dos filas de metadata arriba de los encabezados.
• Una fila de subtotales al final.
• Encabezados que tú quieres reemplazar.
• Columnas que R lee con el tipo equivocado.
• 12 hojas que quieres unir en una sola tabla.

read_excel() tiene argumentos para todo eso. Vamos a verlos uno por uno.

skip — saltarse filas de arriba

Recuerda la hoja resumen_REM de nuestro archivo de ejemplo: las primeras dos filas son metadata ("REPORTE ESTADÍSTICO MENSUAL — Año 2024" y "Fuente: ..."), y los encabezados reales (indicador, enero, febrero, …) están en la fila 3.

Si la leemos sin parámetros, sale un desastre:

library(readxl)

read_excel("datos/pacientes_ejemplo.xlsx",
           sheet = "resumen_REM")

import pandas as pd

pd.read_excel("datos/pacientes_ejemplo.xlsx",
              sheet_name="resumen_REM")

R interpreta "REPORTE ESTADÍSTICO..." como el nombre de la primera columna y todo queda corrido. La solución es skip = 2:

rem <- read_excel("datos/pacientes_ejemplo.xlsx",
                  sheet = "resumen_REM",
                  skip = 2)

rem

rem = pd.read_excel("datos/pacientes_ejemplo.xlsx",
                    sheet_name="resumen_REM",
                    skiprows=2)

rem

Ahora la fila 3 (indicador, enero, febrero…) se interpreta como encabezado. Salida esperada:

# A tibble: 4 × 7
  indicador        enero febrero marzo abril  mayo junio
  <chr>            <dbl>   <dbl> <dbl> <dbl> <dbl> <dbl>
1 Controles HTA      420     445   460   478   490   505
2 Controles DM       318     322   340   355   360   372
3 Controles EPOC      95     102   110   108   115   120
4 Vacunaciones       610     580   555   590   620   640

n_max — limitar cuántas filas leer

Útil para dos cosas:

1. Ver una “foto” de un archivo grande sin cargarlo entero.
2. Detenerte antes de una fila de totales o de basura al final.

# Solo las primeras 5 filas
read_excel("datos/pacientes_ejemplo.xlsx",
           sheet = "pacientes",
           n_max = 5)

pd.read_excel("datos/pacientes_ejemplo.xlsx",
              sheet_name="pacientes",
              nrows=5)

range — leer un bloque exacto de celdas

A veces la planilla tiene una tabla “metida” en medio de la hoja (por ejemplo, celdas B5:H50), rodeada de gráficos, notas o textos. Usas range:

# Lee solo el bloque B5:H50 de la hoja "pacientes"
read_excel("datos/pacientes_ejemplo.xlsx",
           sheet = "pacientes",
           range = "B5:H50")

# También puedes nombrar el rango con la hoja incluida:
read_excel("datos/pacientes_ejemplo.xlsx",
           range = "pacientes!B5:H50")

# Pandas no tiene un parámetro 'range' tan directo,
# se hace combinando skiprows + usecols + nrows:
pd.read_excel("datos/pacientes_ejemplo.xlsx",
              sheet_name="pacientes",
              skiprows=4,    # salta filas 1-4
              usecols="B:H", # columnas B a H
              nrows=46)      # 50 - 5 + 1

col_names — controlar los nombres de columnas

Tres modos:

Modo 1 — Usar los del archivo (por defecto):

read_excel("datos/pacientes_ejemplo.xlsx",
           sheet = "pacientes")
# col_names = TRUE por defecto

pd.read_excel("datos/pacientes_ejemplo.xlsx",
              sheet_name="pacientes")
# header=0 por defecto

Modo 2 — No usar encabezado, R inventa ...1, ...2, …:

read_excel("datos/pacientes_ejemplo.xlsx",
           sheet = "pacientes",
           col_names = FALSE)

pd.read_excel("datos/pacientes_ejemplo.xlsx",
              sheet_name="pacientes",
              header=None)

Modo 3 — Pasar los nombres que tú quieres:

read_excel("datos/pacientes_ejemplo.xlsx",
           sheet = "pacientes",
           col_names = c("id", "nombre", "edad", "sexo",
                         "dx", "fecha", "pas"),
           skip = 1)  # saltar el encabezado original

pd.read_excel("datos/pacientes_ejemplo.xlsx",
              sheet_name="pacientes",
              names=["id", "nombre", "edad", "sexo",
                     "dx", "fecha", "pas"],
              skiprows=1)

Encabezados con celdas combinadas (el caso REM clásico)

Muchas planillas oficiales (REM del MINSAL, encuestas, formularios) traen encabezados en dos filas con celdas combinadas, algo así:

A             B             C        D        E
┌─────────────────────────┬──────────────────────┐
│  Datos del paciente     │  Indicadores         │   ← fila 1 combinada A1:C1 y D1:E1
├──────────┬──────┬───────┼─────────┬────────────┤
│ id       │ run  │ edad  │ presion │ glicemia   │   ← fila 2 (los nombres reales)
├──────────┼──────┼───────┼─────────┼────────────┤
│ 1        │ ...  │ 67    │ 145     │ 110        │   ← desde aquí los datos

Si lees esto con read_excel() directamente, el resultado es un desastre: R toma la fila 1 como encabezado, ve "Datos del paciente" en una celda y NA en las celdas combinadas, y todo queda corrido.

La estrategia correcta es saltarse las filas combinadas y declarar tú los nombres. Hay dos caminos:

Camino 1 — skip + col_names manual (el más confiable):

library(readxl)

# Salta las 2 filas de encabezados y declara los nombres tú
pacientes <- read_excel("datos/rem_clasico.xlsx",
                        sheet = "datos",
                        skip = 2,
                        col_names = c("id", "run", "edad",
                                      "presion", "glicemia"))

pacientes = pd.read_excel("datos/rem_clasico.xlsx",
                          sheet_name="datos",
                          skiprows=2,
                          names=["id", "run", "edad",
                                 "presion", "glicemia"])

Camino 2 — range para apuntar exactamente al bloque de datos:

# Los datos viven en A3 hacia abajo. Apuntamos al bloque exacto:
pacientes <- read_excel("datos/rem_clasico.xlsx",
                        sheet = "datos",
                        range = "A3:E1000",    # ajusta el final al tamaño esperado
                        col_names = c("id", "run", "edad",
                                      "presion", "glicemia"))

Detectar celdas combinadas antes de leer

¿Cómo sabes si una planilla tiene encabezados combinados sin abrirla en Excel? Lee solo las primeras filas como texto sin encabezado y mira el patrón de NAs:

library(readxl)

# Vista cruda: primeras 3 filas, sin encabezado
crudo <- read_excel("datos/rem_clasico.xlsx",
                   sheet = "datos",
                   n_max = 3,
                   col_names = FALSE)
crudo
#> # A tibble: 3 × 5
#>   ...1                ...2  ...3   ...4         ...5
#>   <chr>               <chr> <chr>  <chr>        <chr>
#> 1 Datos del paciente  NA    NA     Indicadores  NA      ← celdas combinadas!
#> 2 id                  run   edad   presion      glicemia
#> 3 1                   ...   67     145          110

Las celdas combinadas se ven como una sola celda con texto seguida de varias NA consecutivas en la misma fila. Si ves ese patrón en la fila 1, casi seguro hay encabezados combinados y tu skip real es la fila donde aparecen los nombres reales.

col_types — forzar el tipo de cada columna

Recuerda que presion_sistolica salió como texto por culpa de los "S/I". Si tú sabes que esa columna debería ser numérica y quieres forzarlo (los "S/I" se convertirán en NA):

pacientes <- read_excel("datos/pacientes_ejemplo.xlsx",
                        sheet = "pacientes",
                        col_types = c("numeric",  # id
                                      "text",     # Nombre Completo
                                      "numeric",  # edad
                                      "text",     # Sexo
                                      "text",     # diagnostico
                                      "date",     # fecha_ingreso
                                      "numeric")) # presion_sistolica

pacientes = pd.read_excel("datos/pacientes_ejemplo.xlsx",
                          sheet_name="pacientes",
                          dtype={"id": "Int64",
                                 "edad": "Int64",
                                 "presion_sistolica": "Float64"})

Los tipos válidos en col_types son: "skip" (no leer), "guess" (que R adivine), "logical", "numeric", "date", "text", "list".

na — qué texto considerar como NA al leer

Por defecto, read_excel() interpreta solo las celdas vacías como NA. Si la planilla usa "S/I", "-" o "NA" como marcadores, son texto y “contaminan” la columna. Puedes decirle a read_excel() que esos también son NA:

pacientes <- read_excel("datos/pacientes_ejemplo.xlsx",
                        sheet = "pacientes",
                        na = c("", "S/I", "-", "NA"))

pacientes = pd.read_excel("datos/pacientes_ejemplo.xlsx",
                          sheet_name="pacientes",
                          na_values=["", "S/I", "-", "NA"])

Ahora los "S/I" ya son NA. Ojo: la columna sigue siendo <chr> porque en Excel está almacenada como texto. Para que sea <dbl> tienes que agregar col_types = "numeric" para esa columna (como en la sección anterior) o un mutate(presion_sistolica = as.numeric(presion_sistolica)) después. El na = c(...) por sí solo no re-tipa la columna, solo convierte los textos indicados a NA.

trim_ws — limpiar espacios en los textos

Si las celdas tienen espacios al inicio o final (" María Pérez " vs "María Pérez"), trim_ws = TRUE los recorta automáticamente al leer:

pacientes <- read_excel("datos/pacientes_ejemplo.xlsx",
                        sheet = "pacientes",
                        trim_ws = TRUE)  # TRUE es el default, pero conviene saberlo

# Pandas no tiene trim_ws nativo en read_excel;
# se hace después con .str.strip() por columna.

Importar varias hojas a la vez

Cuando tienes 12 hojas (enero, febrero, …) con la misma estructura, no quieres copiar read_excel() 12 veces. La idea es: lista las hojas, aplica read_excel() a cada una, junta el resultado.

library(readxl)
library(dplyr)

ruta <- "datos/pacientes_ejemplo.xlsx"

# 1. Listar todas las hojas (filtrando la oculta y la metadata)
hojas <- excel_sheets(ruta)
hojas <- hojas[hojas %in% c("pacientes", "laboratorio")]

# 2. Leer todas en una lista
todas <- lapply(hojas, function(h) read_excel(ruta, sheet = h))

# 3. Asignar nombres a la lista
names(todas) <- hojas

# Acceder a una:
todas$pacientes
todas$laboratorio

import pandas as pd

ruta = "datos/pacientes_ejemplo.xlsx"
hojas = ["pacientes", "laboratorio"]

todas = {h: pd.read_excel(ruta, sheet_name=h) for h in hojas}

todas["pacientes"]
todas["laboratorio"]

Si todas las hojas tienen la misma estructura (mismas columnas) y quieres unirlas en una sola tabla, agregas un bind_rows() final:

library(readxl)
library(dplyr)

ruta <- "datos/pacientes_ejemplo.xlsx"
hojas_mensuales <- c("enero", "febrero", "marzo")  # ejemplo ficticio

# Leer todas y agregar una columna 'mes' indicando de qué hoja vino
consolidado <- lapply(hojas_mensuales, function(h) {
  read_excel(ruta, sheet = h) |>
    mutate(mes = h)
}) |>
  bind_rows()

import pandas as pd

ruta = "datos/pacientes_ejemplo.xlsx"
hojas_mensuales = ["enero", "febrero", "marzo"]

consolidado = pd.concat([
    pd.read_excel(ruta, sheet_name=h).assign(mes=h)
    for h in hojas_mensuales
], ignore_index=True)

Importar varios archivos Excel en una sola tabla

Otro escenario muy frecuente: en vez de varias hojas en un archivo, tienes varios archivos en una carpeta. Por ejemplo, datos/ contiene:

datos/
├── enero_2024.xlsx
├── febrero_2024.xlsx
├── marzo_2024.xlsx
└── abril_2024.xlsx

Cada archivo tiene una sola hoja con la misma estructura (mismas columnas). El objetivo es leerlos todos y consolidarlos en una sola tabla.

El patrón es: listar archivos → leer cada uno → unir todo con bind_rows().

library(readxl)
library(dplyr)

# 1. Listar todos los .xlsx de la carpeta
archivos <- list.files("datos/",
                       pattern    = "\\.xlsx$",
                       full.names = TRUE)
archivos
#> [1] "datos/enero_2024.xlsx"  "datos/febrero_2024.xlsx"
#> [3] "datos/marzo_2024.xlsx"  "datos/abril_2024.xlsx"

# 2. Leer cada archivo y agregar columna 'archivo' para trazabilidad
consolidado <- lapply(archivos, function(f) {
  read_excel(f) |>
    mutate(archivo = basename(f))
}) |>
  bind_rows()

consolidado

import pandas as pd
from pathlib import Path

archivos = sorted(Path("datos").glob("*.xlsx"))

consolidado = pd.concat([
    pd.read_excel(f).assign(archivo=f.name)
    for f in archivos
], ignore_index=True)

Línea por línea:

1. list.files("datos/", pattern = "\\.xlsx$", full.names = TRUE) — pattern filtra solo archivos que terminen en .xlsx (el \\. escapa el punto y $ ancla al final). full.names = TRUE te devuelve la ruta completa ("datos/enero_2024.xlsx"), no solo el nombre.
2. lapply(archivos, function(f) ...) — aplica la función a cada archivo de la lista. Por cada uno: lee con read_excel(f) y agrega mutate(archivo = basename(f)).
3. basename(f) — extrae solo el nombre del archivo de la ruta completa: "datos/enero_2024.xlsx" → "enero_2024.xlsx". Es lo que queremos guardar como trazabilidad.
4. bind_rows() — apila todas las tablas verticalmente. Si una fila vino de enero_2024.xlsx, su columna archivo lo dice.

Importar varios archivos con varias hojas cada uno

El caso más exigente: tienes varios archivos y cada uno tiene varias hojas. Por ejemplo:

datos/
├── 2024.xlsx   (hojas: urgencias, consultas, vacunas)
├── 2025.xlsx   (hojas: urgencias, consultas, vacunas)
└── 2026.xlsx   (hojas: urgencias, consultas, vacunas)

Quieres consolidar todo en una sola tabla, conservando dos columnas de trazabilidad: archivo y hoja.

El patrón es un loop dentro de otro loop: por cada archivo, leer todas sus hojas, agregar las dos columnas, juntar todo.

library(readxl)
library(dplyr)

# 1. Listar archivos
archivos <- list.files("datos/",
                       pattern    = "\\.xlsx$",
                       full.names = TRUE)

# 2. Función auxiliar: leer todas las hojas de un archivo
leer_todas_las_hojas <- function(f) {
  hojas <- excel_sheets(f)
  lapply(hojas, function(h) {
    read_excel(f, sheet = h) |>
      mutate(archivo = basename(f),
             hoja    = h)
  }) |>
    bind_rows()
}

# 3. Aplicar la función a cada archivo y unir todo
consolidado <- lapply(archivos, leer_todas_las_hojas) |>
  bind_rows()

consolidado

import pandas as pd
from pathlib import Path

def leer_todas_las_hojas(f):
    partes = []
    for h in pd.ExcelFile(f).sheet_names:
        df = pd.read_excel(f, sheet_name=h)
        df["archivo"] = f.name
        df["hoja"]    = h
        partes.append(df)
    return pd.concat(partes, ignore_index=True)

archivos = sorted(Path("datos").glob("*.xlsx"))

consolidado = pd.concat(
    [leer_todas_las_hojas(f) for f in archivos],
    ignore_index=True
)

Resultado típico:

# A tibble: 36 × 6
  id_paciente diagnostico    valor fecha       archivo    hoja
        <dbl> <chr>          <dbl> <date>      <chr>      <chr>
1           1 HTA              145 2024-01-15  2024.xlsx  urgencias
2           1 DM               110 2024-01-15  2024.xlsx  urgencias
3           2 HTA              160 2024-02-20  2024.xlsx  urgencias
...

Con esas dos columnas (archivo, hoja) puedes filtrar, agrupar y verificar que todo lo que esperabas se leyó correctamente:

# Verificar conteo por archivo y hoja
consolidado |>
  count(archivo, hoja)

# Filtrar solo lo que vino de 2026
consolidado |>
  filter(archivo == "2026.xlsx")

Errores comunes con control fino

Ejercicio

library(readxl)
library(dplyr)

rem <- read_excel("datos/pacientes_ejemplo.xlsx",
                  sheet = "resumen_REM",
                  skip = 2)

glimpse(rem)
#> Rows: 4
#> Columns: 7
#> $ indicador <chr> "Controles HTA", "Controles DM", "Controles EPOC", "Vacunaciones"
#> $ enero     <dbl> 420, 318, 95, 610
#> ...

# Bonus
read_excel("datos/pacientes_ejemplo.xlsx",
           sheet = "resumen_REM",
           skip = 2,
           n_max = 3)

library(readxl)
library(dplyr)

ruta <- "datos/pacientes_ejemplo.xlsx"
hojas <- c("pacientes", "laboratorio")

consolidado <- lapply(hojas, function(h) {
  read_excel(ruta, sheet = h) |>
    mutate(origen = h)
}) |>
  bind_rows()

consolidado |>
  count(origen)
#> # A tibble: 2 × 2
#>   origen          n
#>   <chr>       <int>
#> 1 laboratorio    20
#> 2 pacientes      20

archivos <- list.files("mis_datos/", pattern = "\\.xlsx$", full.names = TRUE)

consolidado <- lapply(archivos, function(f) {
  read_excel(f) |>
    mutate(archivo = basename(f))
}) |>
  bind_rows()

library(readxl)
library(dplyr)

# 1. Primeras 5 filas, 3 columnas
parte_1 <- read_excel("datos/pacientes_ejemplo.xlsx",
                      sheet = "pacientes",
                      range = "A1:C6")
glimpse(parte_1)
#> Rows: 5
#> Columns: 3
#> $ id                <dbl> 1, 2, 3, 4, 5
#> $ `Nombre Completo` <chr> "María Pérez", "Juan  Soto", ...
#> $ edad              <dbl> 67, 45, 72, 58, 39

# 2. Filas 10 a 15 sin encabezado
parte_2 <- read_excel("datos/pacientes_ejemplo.xlsx",
                      sheet = "pacientes",
                      range = "A11:G16",
                      col_names = FALSE)
glimpse(parte_2)

library(readxl)
library(dplyr)

pacientes <- read_excel(
  "datos/pacientes_ejemplo.xlsx",
  sheet = "pacientes",
  col_types = c("numeric", "text", "numeric", "text",
                "text", "date", "numeric")
)
#> Warning: Expecting numeric in G3 / R3C7: got 'S/I'
#> Warning: Expecting numeric in G10 / R10C7: got 'S/I'
#> ...

glimpse(pacientes)
#> Rows: 20
#> Columns: 7
#> $ id                <dbl> 1, 2, 3, ...
#> $ `Nombre Completo` <chr> "María Pérez", "Juan  Soto", ...
#> $ edad              <dbl> 67, 45, 72, ...
#> $ Sexo              <chr> "F", "M", "F", ...
#> $ diagnostico       <chr> "Hipertensión", ...
#> $ fecha_ingreso     <dttm> 2024-01-01, 2024-01-10, ...
#> $ presion_sistolica <dbl> 145, NA, 160, ...