Tutorial R: readr y read.csv para importar datos

Importar CSV con read.csv vs readr::read_csv

Cuando trabajamos con datos en R, una de las tareas más frecuentes es importar información desde archivos CSV (Comma-Separated Values). R ofrece dos enfoques principales para esta tarea: la función read.csv() del paquete base y la función read_csv() del paquete readr. Aunque ambas cumplen el mismo propósito básico, presentan diferencias importantes que afectan tanto al rendimiento como a la facilidad de uso.

Función read.csv() del paquete base

La función read.csv() viene incluida en la instalación estándar de R, por lo que no requiere instalar paquetes adicionales. Esta es una ventaja para quienes están comenzando, ya que pueden importar datos inmediatamente.

Para usar read.csv(), simplemente especificamos la ruta al archivo:

# Importar un archivo CSV con read.csv
datos <- read.csv("ruta/al/archivo.csv")

Esta función tiene algunas características importantes:

• Convierte automáticamente las cadenas de texto en factores (variables categóricas)
• Asigna nombres de fila a los datos importados
• Utiliza punto y coma (;) como separador cuando usamos read.csv2()

Veamos un ejemplo sencillo:

# Crear un archivo CSV de ejemplo
datos_ejemplo <- data.frame(
  nombre = c("Ana", "Carlos", "Elena"),
  edad = c(25, 34, 29),
  ciudad = c("Madrid", "Barcelona", "Sevilla")
)

# Guardar como CSV
write.csv(datos_ejemplo, "ejemplo.csv", row.names = FALSE)

# Importar con read.csv
datos_importados <- read.csv("ejemplo.csv")

# Ver el resultado
head(datos_importados)

Por defecto, read.csv() convierte las columnas de texto en factores, lo que puede ser útil para análisis estadísticos pero a veces no es lo deseado:

# Comprobar la estructura
str(datos_importados)

Para evitar esta conversión automática, podemos usar el parámetro stringsAsFactors:

datos_texto <- read.csv("ejemplo.csv", stringsAsFactors = FALSE)
str(datos_texto)

Función read_csv() del paquete readr

El paquete readr, parte del conjunto de paquetes tidyverse, ofrece la función read_csv() como una alternativa moderna a read.csv(). Para utilizarla, primero debemos instalar y cargar el paquete:

# Instalar readr si no está instalado
if (!requireNamespace("readr", quietly = TRUE)) {
  install.packages("readr")
}

# Cargar el paquete
library(readr)

# Importar un CSV con read_csv
datos <- read_csv("ruta/al/archivo.csv")

Las principales características de read_csv() incluyen:

• Mayor velocidad de importación, especialmente con archivos grandes
• No convierte automáticamente strings a factores
• Devuelve un objeto tibble en lugar de un data.frame tradicional
• Muestra un resumen de la importación, incluyendo los tipos de datos detectados

Usando el mismo ejemplo anterior:

# Importar con read_csv
datos_readr <- read_csv("ejemplo.csv")

# Ver el resultado
datos_readr

La salida de read_csv() incluye información sobre los tipos de columnas detectados, lo que facilita identificar problemas de importación.

Comparación de rendimiento

Una de las ventajas principales de read_csv() es su velocidad. Para demostrarlo, podemos crear un archivo CSV más grande y comparar los tiempos:

# Crear un conjunto de datos más grande
set.seed(123)
datos_grandes <- data.frame(
  id = 1:100000,
  valor1 = rnorm(100000),
  valor2 = sample(letters[1:5], 100000, replace = TRUE)
)

# Guardar como CSV
write.csv(datos_grandes, "datos_grandes.csv", row.names = FALSE)

# Comparar tiempos
system.time(base_import <- read.csv("datos_grandes.csv"))
system.time(readr_import <- read_csv("datos_grandes.csv"))

Diferencias clave entre read.csv() y read_csv()

¿Cuándo usar cada función?

• Usa read.csv() cuando:

• Trabajas en un entorno donde no puedes instalar paquetes adicionales

• Necesitas compatibilidad con código R más antiguo

• Prefieres que las cadenas se conviertan automáticamente en factores

• Usa read_csv() cuando:

• Trabajas con archivos grandes donde el rendimiento es importante

• Prefieres un enfoque más moderno y consistente con el tidyverse

• Quieres evitar la conversión automática a factores

• Necesitas mejor información de diagnóstico durante la importación

Ejemplo práctico: Manejo de valores faltantes

Ambas funciones manejan los valores faltantes de manera diferente. Veamos un ejemplo:

# Crear datos con valores faltantes
datos_na <- data.frame(
  id = 1:5,
  valor = c(10, NA, 30, NA, 50),
  texto = c("a", "", "c", "NA", "e")
)

# Guardar como CSV
write.csv(datos_na, "datos_na.csv", row.names = FALSE)

# Importar con ambas funciones
base_na <- read.csv("datos_na.csv")
readr_na <- read_csv("datos_na.csv")

# Comparar resultados
base_na
readr_na

Por defecto, read.csv() reconoce "NA" como valor faltante, mientras que read_csv() es más flexible y permite especificar qué valores deben considerarse como NA:

# Especificar valores NA personalizados con read_csv
readr_na_custom <- read_csv("datos_na.csv", na = c("", "NA", "N/A"))
readr_na_custom

Manejo de delimitadores

Aunque estamos trabajando con archivos CSV (valores separados por comas), a veces los archivos utilizan otros delimitadores:

# Crear un archivo con punto y coma como delimitador
write.table(datos_ejemplo, "ejemplo_semicolon.csv", 
            sep = ";", row.names = FALSE)

# Importar con read.csv2 (para punto y coma)
datos_semicolon_base <- read.csv2("ejemplo_semicolon.csv")

# Importar con read_csv2 (readr para punto y coma)
datos_semicolon_readr <- read_csv2("ejemplo_semicolon.csv")

# Comparar resultados
head(datos_semicolon_base)
datos_semicolon_readr

La familia readr también incluye funciones para otros delimitadores comunes:

• read_csv(): para archivos separados por comas
• read_csv2(): para archivos separados por punto y coma
• read_tsv(): para archivos separados por tabulaciones
• read_delim(): para especificar cualquier delimitador personalizado

Opciones de parseo y tipos de columnas

Cuando importamos datos a R, el parseo (o análisis sintáctico) determina cómo se interpretan los valores del archivo original y qué tipos de datos se asignan a cada columna. Un control adecuado de este proceso es fundamental para evitar problemas en análisis posteriores.

Especificación de tipos de columnas

Tanto read.csv() como read_csv() intentan adivinar automáticamente el tipo de cada columna, pero a veces necesitamos más control. Veamos cómo especificar tipos de datos en ambas funciones:

Con read.csv() (R base)

En read.csv(), podemos usar el parámetro colClasses para especificar el tipo de cada columna:

# Especificar tipos de columnas con read.csv
datos <- read.csv("ejemplo.csv", 
                  colClasses = c("character", "numeric", "factor"))

Los tipos más comunes que podemos especificar son:

• "numeric": para números (enteros o decimales)
• "character": para texto
• "factor": para variables categóricas
• "Date": para fechas
• "logical": para valores TRUE/FALSE

Si tenemos muchas columnas, podemos crear un vector con nombres:

# Especificar tipos por nombre de columna
tipos <- c(id = "integer", 
           nombre = "character", 
           activo = "logical")

datos <- read.csv("ejemplo.csv", colClasses = tipos)

Con read_csv() (readr)

El paquete readr ofrece un sistema más flexible para especificar tipos de columnas mediante el parámetro col_types:

# Especificar tipos con read_csv
datos <- read_csv("ejemplo.csv", 
                  col_types = cols(
                    id = col_integer(),
                    nombre = col_character(),
                    fecha = col_date(),
                    valor = col_double()
                  ))

Las funciones de especificación más comunes en readr son:

• col_logical(): para valores lógicos (TRUE/FALSE)
• col_integer(): para números enteros
• col_double(): para números decimales
• col_character(): para texto
• col_factor(): para variables categóricas
• col_date(): para fechas
• col_datetime(): para fechas con hora
• col_skip(): para omitir columnas

También podemos usar una especificación compacta con una cadena de caracteres:

# Especificación compacta de tipos
datos <- read_csv("ejemplo.csv", 
                  col_types = "icDd")

Donde cada letra representa un tipo:

• i: integer (entero)
• c: character (texto)
• D: date (fecha)
• d: double (decimal)
• l: logical (lógico)
• f: factor (categórica)
• _: skip (omitir columna)

Parseo de fechas y horas

El manejo de fechas y horas merece especial atención, ya que suelen causar problemas durante la importación.

Con read.csv()

Para fechas en R base, normalmente necesitamos convertirlas después de importar:

# Importar y luego convertir fechas
datos <- read.csv("fechas.csv", stringsAsFactors = FALSE)
datos$fecha <- as.Date(datos$fecha, format = "%Y-%m-%d")

# Para fechas con hora
datos$fecha_hora <- as.POSIXct(datos$fecha_hora, 
                               format = "%Y-%m-%d %H:%M:%S")

Con read_csv()

En readr, podemos especificar el formato durante la importación:

datos <- read_csv("fechas.csv",
                  col_types = cols(
                    fecha = col_date(format = "%Y-%m-%d"),
                    fecha_hora = col_datetime(format = "%Y-%m-%d %H:%M:%S")
                  ))

Los códigos de formato más comunes son:

• %Y: año con cuatro dígitos (2023)
• %m: mes como número (01-12)
• %d: día del mes (01-31)
• %H: hora (00-23)
• %M: minutos (00-59)
• %S: segundos (00-59)

Manejo de valores faltantes personalizados

A veces, los archivos utilizan valores especiales para indicar datos faltantes, como "N/A", "NULL" o "-999".

Con read.csv()

# Especificar valores NA personalizados
datos <- read.csv("datos.csv", 
                  na.strings = c("NA", "N/A", "NULL", "-999"))

Con read_csv()

# Especificar valores NA personalizados
datos <- read_csv("datos.csv", 
                  na = c("NA", "N/A", "NULL", "-999"))

Control de nombres de columnas

Los nombres de columnas pueden requerir ajustes durante la importación.

Con read.csv()

# Importar sin encabezados y asignar nombres
datos <- read.csv("sin_encabezados.csv", 
                  header = FALSE,
                  col.names = c("id", "nombre", "valor"))

Con read_csv()

# Importar sin encabezados y asignar nombres
datos <- read_csv("sin_encabezados.csv", 
                  col_names = c("id", "nombre", "valor"))

# O simplemente indicar que no hay encabezados
datos <- read_csv("sin_encabezados.csv", col_names = FALSE)

Manejo de problemas de parseo

Una ventaja importante de readr es su capacidad para identificar y gestionar problemas de parseo.

# Importar datos con posibles problemas
problemas <- read_csv("datos_problematicos.csv")

# Ver problemas de parseo
problems(problemas)

La función problems() muestra las filas y columnas donde hubo dificultades al interpretar los datos, lo que facilita la depuración.

Para controlar cómo se manejan los problemas:

# Detener la importación al primer problema
datos <- read_csv("datos.csv", stop_on_problems = TRUE)

# Establecer un límite de problemas
datos <- read_csv("datos.csv", problem_max = 5)

Ejemplo práctico: Importación con control de tipos

Veamos un ejemplo completo que combina varias opciones de parseo:

# Crear datos de ejemplo
datos_ejemplo <- data.frame(
  id = 1:5,
  nombre = c("Ana", "Carlos", "Elena", "David", "Beatriz"),
  fecha_nacimiento = c("1990-05-15", "1985-12-03", "1992-07-22", 
                       "1988-02-10", "1995-09-30"),
  salario = c(28500, 32000, "N/A", 29800, 26500),
  activo = c("TRUE", "TRUE", "FALSE", "N/A", "TRUE")
)

# Guardar como CSV
write.csv(datos_ejemplo, "empleados.csv", row.names = FALSE)

# Importar con readr especificando tipos
library(readr)

empleados <- read_csv("empleados.csv",
                     col_types = cols(
                       id = col_integer(),
                       nombre = col_character(),
                       fecha_nacimiento = col_date("%Y-%m-%d"),
                       salario = col_double(),
                       activo = col_logical()
                     ),
                     na = c("N/A", "NA", ""))

# Ver el resultado
print(empleados)
str(empleados)

Localización y configuración regional

Los archivos CSV pueden usar diferentes convenciones para decimales y separadores según la región.

Con read.csv()

# Importar datos con formato europeo (coma como decimal)
datos_eur <- read.csv("datos_europeos.csv", 
                      dec = ",", 
                      sep = ";")

Con read_csv()

# Importar datos con formato europeo
datos_eur <- read_csv2("datos_europeos.csv", 
                       locale = locale(decimal_mark = ","))

La función locale() de readr permite configurar muchos aspectos regionales:

# Configuración regional completa
mi_locale <- locale(
  decimal_mark = ",",
  grouping_mark = ".",
  date_format = "%d/%m/%Y",
  time_format = "%H.%M",
  encoding = "ISO-8859-1"
)

datos <- read_csv("datos_locales.csv", locale = mi_locale)

Control de encodings

El encoding determina cómo se representan los caracteres especiales (acentos, ñ, etc.).

Con read.csv()

# Especificar encoding
datos <- read.csv("datos_utf8.csv", 
                  fileEncoding = "UTF-8")

Con read_csv()

# Especificar encoding
datos <- read_csv("datos_utf8.csv", 
                  locale = locale(encoding = "UTF-8"))

# Para archivos con problemas de encoding, probar detección automática
guess_encoding("datos_desconocidos.csv")

La función guess_encoding() intenta detectar el encoding del archivo, lo que resulta muy útil cuando no estamos seguros de qué codificación se utilizó.

Optimización para archivos grandes

Cuando trabajamos con archivos voluminosos, podemos ajustar algunas opciones para mejorar el rendimiento:

# Leer solo las primeras filas para explorar
muestra <- read_csv("archivo_grande.csv", n_max = 1000)

# Leer solo columnas específicas
datos_parciales <- read_csv("archivo_grande.csv",
                           col_select = c(id, nombre, valor))

# Combinar ambas estrategias
muestra_columnas <- read_csv("archivo_grande.csv",
                            n_max = 1000,
                            col_select = c(id, nombre, valor))

Estas opciones nos permiten trabajar de manera más eficiente con conjuntos de datos grandes, explorando primero una muestra antes de procesar el archivo completo.

Importación desde Excel, JSON y bases de datos

Aunque los archivos CSV son muy comunes en el análisis de datos, frecuentemente necesitaremos trabajar con otros formatos como hojas de Excel, documentos JSON o datos almacenados en bases de datos. R ofrece diversas herramientas para importar información desde estas fuentes, permitiéndonos integrar datos de prácticamente cualquier origen en nuestros análisis.

Importación desde Excel

Los archivos de Excel (.xls y .xlsx) son ampliamente utilizados en entornos empresariales. Para trabajar con ellos en R, tenemos principalmente dos paquetes: readxl y openxlsx.

Usando readxl

El paquete readxl forma parte del ecosistema tidyverse y ofrece una interfaz sencilla para importar datos desde Excel:

# Instalar y cargar readxl
if (!requireNamespace("readxl", quietly = TRUE)) {
  install.packages("readxl")
}
library(readxl)

# Importar una hoja de Excel
datos_excel <- read_excel("archivo.xlsx")

Por defecto, read_excel() importa la primera hoja del libro. Para especificar una hoja concreta, podemos usar el parámetro sheet:

# Importar una hoja específica por nombre
ventas_2023 <- read_excel("datos_ventas.xlsx", sheet = "2023")

# O por número (la primera hoja es 1)
ventas_2023 <- read_excel("datos_ventas.xlsx", sheet = 2)

También podemos listar todas las hojas disponibles en un archivo:

# Ver todas las hojas del libro
hojas <- excel_sheets("datos_ventas.xlsx")
print(hojas)

Para importar solo ciertas filas o columnas:

# Importar un rango específico
datos_parciales <- read_excel("datos.xlsx", range = "B2:D15")

# Importar las primeras 100 filas
muestra <- read_excel("datos.xlsx", n_max = 100)

Manejo de celdas combinadas y formatos

Un desafío común al importar desde Excel son las celdas combinadas:

# Importar manteniendo solo la primera aparición del valor en celdas combinadas
datos <- read_excel("informe.xlsx", sheet = "Resumen", 
                   merge_cells = TRUE)

# Repetir el valor en todas las celdas que estaban combinadas
datos <- read_excel("informe.xlsx", sheet = "Resumen", 
                   merge_cells = FALSE)

Importación desde JSON

El formato JSON (JavaScript Object Notation) es muy utilizado en aplicaciones web y APIs. Para trabajar con JSON en R, el paquete jsonlite es la opción más popular:

# Instalar y cargar jsonlite
if (!requireNamespace("jsonlite", quietly = TRUE)) {
  install.packages("jsonlite")
}
library(jsonlite)

# Importar un archivo JSON
datos_json <- fromJSON("datos.json")

Los datos JSON pueden tener estructuras anidadas que se convierten automáticamente en listas o data frames:

# Ejemplo con JSON simple
json_texto <- '{"nombre": "Ana", "edad": 28, "ciudad": "Madrid"}'
persona <- fromJSON(json_texto)
print(persona)

# JSON con arrays
json_array <- '[
  {"id": 1, "producto": "Laptop", "precio": 899},
  {"id": 2, "producto": "Monitor", "precio": 349},
  {"id": 3, "producto": "Teclado", "precio": 79}
]'
productos <- fromJSON(json_array)
print(productos)

Para JSON con estructuras más complejas:

# JSON con estructura anidada
json_anidado <- '{
  "empresa": "TechSolutions",
  "empleados": [
    {"nombre": "Carlos", "departamento": "IT", "proyectos": ["Alpha", "Beta"]},
    {"nombre": "Elena", "departamento": "Marketing", "proyectos": ["Gamma"]}
  ],
  "ubicaciones": {"principal": "Madrid", "sucursales": ["Barcelona", "Valencia"]}
}'

datos_empresa <- fromJSON(json_anidado)
print(datos_empresa)

# Acceder a elementos anidados
print(datos_empresa$empleados)
print(datos_empresa$ubicaciones$sucursales)

Importar JSON desde una API web

Una aplicación común es obtener datos directamente desde una API:

# Obtener datos de una API pública
url_api <- "https://jsonplaceholder.typicode.com/posts/1"
respuesta <- fromJSON(url_api)
print(respuesta)

# Obtener múltiples registros
url_posts <- "https://jsonplaceholder.typicode.com/posts"
todos_posts <- fromJSON(url_posts)
head(todos_posts)

Importación desde bases de datos

La conexión con bases de datos es esencial para proyectos que manejan grandes volúmenes de información. R ofrece varias opciones dependiendo del sistema de base de datos.

Usando DBI y drivers específicos

El paquete DBI proporciona una interfaz común para conectarse a diferentes bases de datos:

# Instalar paquetes necesarios
if (!requireNamespace("DBI", quietly = TRUE)) {
  install.packages("DBI")
}
library(DBI)

# Para SQLite (base de datos ligera que no requiere servidor)
if (!requireNamespace("RSQLite", quietly = TRUE)) {
  install.packages("RSQLite")
}

Ejemplo con SQLite (base de datos de archivo único):

# Conectar a una base de datos SQLite
con <- dbConnect(RSQLite::SQLite(), "mi_base_datos.sqlite")

# Listar tablas disponibles
tablas <- dbListTables(con)
print(tablas)

# Importar una tabla completa
datos <- dbReadTable(con, "clientes")
head(datos)

# Ejecutar una consulta SQL
resultados <- dbGetQuery(con, "SELECT * FROM ventas WHERE monto > 1000")
head(resultados)

# Cerrar la conexión cuando terminemos
dbDisconnect(con)

Conexión a MySQL/MariaDB

Para bases de datos MySQL o MariaDB:

# Instalar el driver necesario
if (!requireNamespace("RMySQL", quietly = TRUE)) {
  install.packages("RMySQL")
}

# Establecer conexión
con_mysql <- dbConnect(RMySQL::MySQL(),
                      host = "localhost",
                      dbname = "mi_base_datos",
                      user = "usuario",
                      password = "contraseña")

# Importar datos
clientes <- dbReadTable(con_mysql, "clientes")

# Cerrar conexión
dbDisconnect(con_mysql)

Conexión a PostgreSQL

# Instalar el driver
if (!requireNamespace("RPostgres", quietly = TRUE)) {
  install.packages("RPostgres")
}

# Establecer conexión
con_pg <- dbConnect(RPostgres::Postgres(),
                   host = "localhost",
                   dbname = "mi_base_datos",
                   user = "usuario",
                   password = "contraseña",
                   port = 5432)

# Importar datos
ventas <- dbReadTable(con_pg, "ventas")

# Cerrar conexión
dbDisconnect(con_pg)

Usando el paquete dplyr con bases de datos

El paquete dplyr permite trabajar con bases de datos usando la misma sintaxis que usaríamos con data frames:

# Instalar y cargar paquetes
if (!requireNamespace("dplyr", quietly = TRUE)) {
  install.packages("dplyr")
}
library(dplyr)

# Conectar a la base de datos
con <- dbConnect(RSQLite::SQLite(), "ventas.sqlite")

# Referenciar una tabla
ventas_tbl <- tbl(con, "ventas")

# Usar operaciones dplyr (no se ejecutan inmediatamente en la BD)
resultados <- ventas_tbl %>%
  filter(region == "Norte") %>%
  group_by(producto) %>%
  summarize(total = sum(monto, na.rm = TRUE)) %>%
  arrange(desc(total))

# Ver la consulta SQL generada
show_query(resultados)

# Ejecutar y traer los resultados a R
resultados_r <- collect(resultados)

# Cerrar conexión
dbDisconnect(con)

Importación desde otros formatos

Archivos XML

XML es otro formato común para intercambio de datos estructurados:

# Instalar y cargar xml2
if (!requireNamespace("xml2", quietly = TRUE)) {
  install.packages("xml2")
}
library(xml2)

# Leer archivo XML
datos_xml <- read_xml("datos.xml")

# Extraer nodos
nodos <- xml_find_all(datos_xml, "//producto")

# Convertir a data frame
productos <- data.frame(
  id = xml_attr(nodos, "id"),
  nombre = xml_text(xml_find_first(nodos, "./nombre")),
  precio = as.numeric(xml_text(xml_find_first(nodos, "./precio")))
)

Archivos SPSS, SAS y Stata

Para archivos de otros programas estadísticos, el paquete haven es la mejor opción:

# Instalar y cargar haven
if (!requireNamespace("haven", quietly = TRUE)) {
  install.packages("haven")
}
library(haven)

# Importar desde SPSS
datos_spss <- read_spss("archivo.sav")

# Importar desde SAS
datos_sas <- read_sas("archivo.sas7bdat")

# Importar desde Stata
datos_stata <- read_stata("archivo.dta")

Ejemplo práctico: Combinando datos de múltiples fuentes

Un escenario común es necesitar combinar datos de diferentes orígenes:

# Cargar paquetes necesarios
library(readxl)
library(jsonlite)
library(dplyr)

# 1. Importar datos de clientes desde Excel
clientes <- read_excel("clientes.xlsx")

# 2. Importar transacciones desde una API JSON
url_api <- "https://api.ejemplo.com/transacciones"
transacciones <- fromJSON(url_api)

# 3. Importar productos desde una base de datos SQLite
con <- dbConnect(RSQLite::SQLite(), "inventario.sqlite")
productos <- dbReadTable(con, "productos")
dbDisconnect(con)

# 4. Combinar los datos
# Primero unimos clientes con transacciones
datos_combinados <- transacciones %>%
  left_join(clientes, by = "id_cliente")

# Luego añadimos la información de productos
reporte_final <- datos_combinados %>%
  left_join(productos, by = "id_producto")

# Ver el resultado
head(reporte_final)

Consejos para importación eficiente

• Explorar antes de importar: Para archivos grandes, examina primero una muestra pequeña para entender su estructura.
• Documentar las fuentes: Mantén un registro de dónde provienen tus datos y cómo los importaste.
• Automatizar importaciones regulares: Si necesitas actualizar datos frecuentemente, crea scripts reutilizables.
• Verificar tipos de datos: Después de importar, revisa que los tipos de datos sean correctos con str() o glimpse().
• Considerar la memoria: Para conjuntos de datos muy grandes, considera técnicas de importación por partes o usar bases de datos.

# Ejemplo de verificación después de importar
library(dplyr)

# Importar datos
datos <- read_excel("ventas_2023.xlsx")

# Verificar estructura
glimpse(datos)

# Corregir tipos si es necesario
datos <- datos %>%
  mutate(
    fecha = as.Date(fecha),
    monto = as.numeric(monto),
    completado = as.logical(completado)
  )

Con estas herramientas y técnicas, podemos importar prácticamente cualquier tipo de datos a R, preparándolos para su análisis posterior.