Tutorial R: stringr para expresiones regulares

Manipulación básica de texto con stringr

El paquete stringr forma parte del ecosistema tidyverse y proporciona un conjunto de funciones coherentes para trabajar con cadenas de texto en R. Antes de adentrarnos en expresiones regulares complejas, es fundamental dominar las operaciones básicas que nos permiten manipular texto de manera eficiente.

Instalación y carga del paquete

Para comenzar a trabajar con stringr, primero debemos instalarlo y cargarlo:

# Instalación (solo necesario una vez)
install.packages("stringr")

# Carga del paquete
library(stringr)

También podemos cargarlo como parte del tidyverse completo:

library(tidyverse)
# Esto carga stringr junto con otros paquetes útiles

Funciones básicas de manipulación

Las funciones en stringr siguen una convención de nombres consistente: todas comienzan con str_ seguido de la operación que realizan. Esto facilita recordarlas y encontrarlas mediante autocompletado.

Longitud y conteo

Para conocer la longitud de una cadena de texto:

# Obtener la longitud de una cadena
str_length("Análisis de datos")
# [1] 17

# Longitud de múltiples cadenas
nombres <- c("Ana", "Roberto", "María")
str_length(nombres)
# [1] 3 7 5

Combinación de cadenas

Para unir cadenas de texto:

# Unir cadenas simples
str_c("Hola", "mundo")
# [1] "Holamundo"

# Unir con separador
str_c("Hola", "mundo", sep = " ")
# [1] "Hola mundo"

# Unir vectores elemento a elemento
nombres <- c("Ana", "Luis", "Carmen")
apellidos <- c("García", "Pérez", "López")
str_c(nombres, apellidos, sep = " ")
# [1] "Ana García" "Luis Pérez" "Carmen López"

Para colapsar múltiples elementos en una sola cadena:

frutas <- c("manzana", "naranja", "plátano")
str_c(frutas, collapse = ", ")
# [1] "manzana, naranja, plátano"

Subcadenas y extracción

Para extraer partes de una cadena:

# Extraer subcadena por posición
str_sub("Análisis de datos", 1, 8)
# [1] "Análisis"

# Extraer desde el final usando índices negativos
str_sub("Análisis de datos", -5, -1)
# [1] "datos"

# Aplicar a múltiples cadenas
palabras <- c("manzana", "pera", "uva")
str_sub(palabras, 1, 3)
# [1] "man" "per" "uva"

Duplicación de texto

Para repetir cadenas:

# Repetir una cadena
str_dup("R ", 3)
# [1] "R R R "

# Repetir múltiples cadenas diferentes veces
str_dup(c("a", "b"), c(2, 3))
# [1] "aa"  "bbb"

Transformación de texto

Cambio de mayúsculas y minúsculas

Para modificar la capitalización:

texto <- "Análisis de Datos en R"

# Convertir a minúsculas
str_to_lower(texto)
# [1] "análisis de datos en r"

# Convertir a mayúsculas
str_to_upper(texto)
# [1] "ANÁLISIS DE DATOS EN R"

# Capitalizar (primera letra de cada palabra en mayúscula)
str_to_title(texto)
# [1] "Análisis De Datos En R"

Recorte de espacios

Para eliminar espacios en blanco innecesarios:

# Eliminar espacios al inicio y final
str_trim("  datos en R  ")
# [1] "datos en R"

# Eliminar solo espacios a la izquierda
str_trim("  datos en R  ", side = "left")
# [1] "datos en R  "

# Eliminar solo espacios a la derecha
str_trim("  datos en R  ", side = "right")
# [1] "  datos en R"

Para eliminar todos los espacios en blanco (incluidos los del medio):

# Eliminar todos los espacios
str_remove_all("datos en R", "\\s")
# [1] "datosenR"

Detección básica de patrones

Para verificar si una cadena contiene un patrón específico:

# Verificar si contiene un patrón
str_detect(c("manzana", "naranja", "plátano"), "an")
# [1]  TRUE  TRUE FALSE

# Contar cuántas cadenas contienen el patrón
sum(str_detect(c("manzana", "naranja", "plátano"), "an"))
# [1] 2

Para contar ocurrencias de un patrón:

# Contar ocurrencias de un patrón
str_count("banana", "a")
# [1] 3

# Contar en múltiples cadenas
str_count(c("manzana", "banana", "pera"), "a")
# [1] 3 3 1

Localización de patrones

Para encontrar la posición de un patrón:

# Encontrar primera ocurrencia
str_locate("banana", "a")
#      start end
# [1,]     2   2

# Encontrar todas las ocurrencias
str_locate_all("banana", "a")
# [[1]]
#      start end
# [1,]     2   2
# [2,]     4   4
# [3,]     6   6

Ejemplo práctico: Limpieza básica de datos

Veamos un ejemplo práctico de limpieza de datos textuales:

# Datos de ejemplo con problemas comunes
datos_crudos <- c(
  "  Juan Pérez  ", 
  "MARÍA LÓPEZ", 
  "carlos GARCÍA  ",
  "Ana  Martínez"
)

# Limpieza básica
datos_limpios <- datos_crudos %>%
  str_trim() %>%                # Eliminar espacios al inicio y final
  str_to_title() %>%            # Estandarizar capitalización
  str_replace_all("\\s+", " ") # Reemplazar múltiples espacios por uno solo

datos_limpios
# [1] "Juan Pérez"    "María López"   "Carlos García" "Ana Martínez"

Trabajando con vectores de caracteres

Una de las ventajas de stringr es que todas sus funciones están vectorizadas, lo que significa que operan de manera consistente sobre vectores de cadenas:

# Vector de correos electrónicos
correos <- c(
  "usuario1@ejemplo.com",
  "usuario2@empresa.es",
  "contacto@sitio.org"
)

# Extraer el dominio (todo después de @)
dominios <- str_extract(correos, "@[^@]+$") %>% 
  str_replace("@", "")

dominios
# [1] "ejemplo.com" "empresa.es"  "sitio.org"

Las funciones básicas de stringr nos proporcionan una base sólida para manipular texto antes de adentrarnos en el mundo más complejo de las expresiones regulares. Dominar estas operaciones fundamentales nos permitirá realizar tareas de limpieza y transformación de datos textuales de manera eficiente.

Patrones regex para búsqueda y extracción

Las expresiones regulares (regex) son patrones de búsqueda que nos permiten encontrar y manipular texto de forma mucho más flexible que las funciones básicas de texto. El paquete stringr integra perfectamente el poder de las expresiones regulares con la sintaxis consistente de R, facilitando operaciones complejas de búsqueda y extracción.

Fundamentos de expresiones regulares

Una expresión regular es un patrón que describe un conjunto de cadenas. En stringr, estos patrones se utilizan para buscar coincidencias dentro de textos. Veamos los elementos básicos:

# Datos de ejemplo
textos <- c("R es genial", "Python es útil", "SQL para bases de datos", "R versión 4.1.2")

Coincidencia exacta

El caso más simple es buscar una secuencia exacta de caracteres:

# Buscar textos que contengan "es"
str_detect(textos, "es")
# [1]  TRUE  TRUE FALSE FALSE

Metacaracteres básicos

Los metacaracteres son símbolos con significados especiales:

• . - Coincide con cualquier carácter excepto salto de línea
• ^ - Coincide con el inicio de la cadena
• $ - Coincide con el final de la cadena
• | - Alternativa (OR lógico)

# Buscar textos que empiecen con "R"
str_detect(textos, "^R")
# [1]  TRUE FALSE FALSE  TRUE

# Buscar textos que terminen con un dígito
str_detect(textos, "\\d$")
# [1] FALSE FALSE FALSE  TRUE

# Buscar textos que contengan "R" o "SQL"
str_detect(textos, "R|SQL")
# [1]  TRUE FALSE  TRUE  TRUE

Clases de caracteres

Las clases de caracteres permiten especificar conjuntos de caracteres:

• \\d - Dígitos (equivalente a [0-9])
• \\w - Caracteres de "palabra" (letras, números, guion bajo)
• \\s - Espacios en blanco (espacios, tabulaciones, saltos de línea)
• [abc] - Cualquier carácter entre los corchetes
• [^abc] - Cualquier carácter excepto los listados

# Extraer todos los dígitos
str_extract_all("R versión 4.1.2", "\\d")
# [[1]]
# [1] "4" "1" "2"

# Extraer palabras que contengan una vocal seguida de 'n'
palabras <- c("función", "datos", "análisis", "sintaxis")
str_subset(palabras, "[aeiou]n")
# [1] "función"  "análisis"

Cuantificadores

Los cuantificadores especifican cuántas veces debe aparecer un patrón:

• ? - 0 o 1 vez (opcional)
• * - 0 o más veces
• + - 1 o más veces
• {n} - Exactamente n veces
• {n,} - Al menos n veces
• {n,m} - Entre n y m veces

# Encontrar palabras con doble vocal
str_extract_all("El análisis de datos requiere coordinación", "[aeiou]{2}")
# [[1]]
# [1] "oo"

# Encontrar palabras que empiecen con mayúscula
str_extract_all("R es un Lenguaje de Programación Estadística", "\\b[A-Z]\\w*")
# [[1]]
# [1] "R"            "Lenguaje"     "Programación" "Estadística"

Funciones de búsqueda con regex

Stringr ofrece varias funciones para trabajar con expresiones regulares:

Detección de patrones

# Datos de ejemplo
correos <- c("usuario@dominio.com", "contacto@empresa.es", "no-es-correo", "otro@sitio.org")

# Detectar correos electrónicos válidos (patrón simplificado)
patron_email <- "^[\\w.-]+@[\\w.-]+\\.[a-zA-Z]{2,}$"
str_detect(correos, patron_email)
# [1]  TRUE  TRUE FALSE  TRUE

# Filtrar solo los correos válidos
correos_validos <- str_subset(correos, patron_email)
correos_validos
# [1] "usuario@dominio.com" "contacto@empresa.es" "otro@sitio.org"

Extracción de información

La función str_extract extrae la primera coincidencia, mientras que str_extract_all extrae todas:

# Texto de ejemplo
texto <- "Contactos: juan@mail.com y maria@empresa.es. Más info en www.ejemplo.com"

# Extraer el primer correo electrónico
str_extract(texto, "[\\w.-]+@[\\w.-]+\\.[a-zA-Z]{2,}")
# [1] "juan@mail.com"

# Extraer todos los correos electrónicos
str_extract_all(texto, "[\\w.-]+@[\\w.-]+\\.[a-zA-Z]{2,}")
# [[1]]
# [1] "juan@mail.com"    "maria@empresa.es"

# Extraer URLs
str_extract_all(texto, "www\\.[\\w.-]+\\.[a-zA-Z]{2,}")
# [[1]]
# [1] "www.ejemplo.com"

Captura de grupos

Los grupos de captura permiten extraer partes específicas de un patrón utilizando paréntesis:

# Extraer usuario y dominio por separado
correo <- "usuario@dominio.com"
str_match(correo, "([\\w.-]+)@([\\w.-]+\\.[a-zA-Z]{2,})")
#      [,1]                [,2]      [,3]
# [1,] "usuario@dominio.com" "usuario" "dominio.com"

# Aplicar a múltiples correos
correos <- c("juan@mail.com", "maria@empresa.es")
str_match(correos, "([\\w.-]+)@([\\w.-]+\\.[a-zA-Z]{2,})")
#      [,1]               [,2]    [,3]
# [1,] "juan@mail.com"    "juan"  "mail.com"
# [2,] "maria@empresa.es" "maria" "empresa.es"

Para extraer todos los grupos de todas las coincidencias, usamos str_match_all:

texto <- "Contactos: juan@mail.com y maria@empresa.es"
str_match_all(texto, "([\\w.-]+)@([\\w.-]+\\.[a-zA-Z]{2,})")
# [[1]]
#      [,1]               [,2]    [,3]
# [1,] "juan@mail.com"    "juan"  "mail.com"
# [2,] "maria@empresa.es" "maria" "empresa.es"

Casos prácticos de extracción

Extracción de fechas

# Texto con fechas en diferentes formatos
texto <- "Reunión el 15/04/2023. Entrega prevista para 2023-06-30. Revisión el 7-8-2023."

# Extraer fechas en formato DD/MM/YYYY
str_extract_all(texto, "\\d{1,2}/\\d{1,2}/\\d{4}")
# [[1]]
# [1] "15/04/2023"

# Extraer fechas en formato YYYY-MM-DD
str_extract_all(texto, "\\d{4}-\\d{1,2}-\\d{1,2}")
# [[1]]
# [1] "2023-06-30"

# Extraer todas las fechas (combinando patrones)
patron_fechas <- "\\d{1,2}/\\d{1,2}/\\d{4}|\\d{4}-\\d{1,2}-\\d{1,2}|\\d{1,2}-\\d{1,2}-\\d{4}"
str_extract_all(texto, patron_fechas)
# [[1]]
# [1] "15/04/2023"  "2023-06-30" "7-8-2023"

Extracción de información estructurada

# Datos de productos
productos <- c(
  "Laptop HP 15.6\" 8GB RAM",
  "Monitor Samsung 24\" Full HD",
  "Teclado Logitech K380 Bluetooth"
)

# Extraer marca y características principales
str_match(productos, "(\\w+)\\s+([\\w\\s]+)\\s+(\\d+[\\.\\d]*[\"]?\\s*\\w*)")
#      [,1]                           [,2]       [,3]       [,4]
# [1,] "Laptop HP 15.6\" 8GB"         "Laptop"   "HP"       "15.6\" 8GB"
# [2,] "Monitor Samsung 24\" Full"    "Monitor"  "Samsung"  "24\" Full"
# [3,] "Teclado Logitech K380"        "Teclado"  "Logitech" "K380"

Extracción de códigos o referencias

# Texto con códigos de referencia
texto <- "Pedidos pendientes: REF-2023-001, REF-2023-042 y REF-2023-108"

# Extraer todos los códigos de referencia
codigos <- str_extract_all(texto, "REF-\\d{4}-\\d{3}")
codigos
# [[1]]
# [1] "REF-2023-001" "REF-2023-042" "REF-2023-108"

# Extraer solo el número secuencial (último grupo de dígitos)
numeros <- str_match_all(texto, "REF-\\d{4}-(\\d{3})")
numeros[[1]][, 2]  # Acceder a la columna del grupo capturado
# [1] "001" "042" "108"

Búsqueda con lookarounds

Los lookarounds son construcciones avanzadas que permiten buscar patrones solo si están precedidos o seguidos por otros patrones:

• (?=...) - Lookahead positivo: busca lo que sigue
• (?!...) - Lookahead negativo: busca lo que no sigue
• (?<=...) - Lookbehind positivo: busca lo que precede
• (?<!...) - Lookbehind negativo: busca lo que no precede

# Texto de ejemplo
texto <- "Precios: $100, €150, $75, £200"

# Extraer valores en dólares (números que siguen a $)
str_extract_all(texto, "\\$\\d+")
# [[1]]
# [1] "$100" "$75"

# Extraer solo los números de valores en dólares
str_extract_all(texto, "(?<=\\$)\\d+")
# [[1]]
# [1] "100" "75"

# Extraer valores que no sean en dólares
str_extract_all(texto, "(?<!\\$)\\d+")
# [[1]]
# [1] "150" "200"

Las expresiones regulares con stringr proporcionan una herramienta poderosa para buscar y extraer información de textos, permitiéndonos automatizar tareas que serían tediosas manualmente. Dominar estos patrones nos ayuda a manipular datos textuales de manera eficiente en nuestros análisis.

Reemplazo y división de textos

El manejo eficiente de datos textuales a menudo requiere modificar o dividir cadenas de texto. El paquete stringr ofrece funciones especializadas para estas tareas que complementan las capacidades de búsqueda y extracción que ya hemos visto.

Funciones de reemplazo

Las funciones de reemplazo nos permiten sustituir patrones específicos por otro texto. Esto es especialmente útil para limpiar datos o estandarizar formatos.

Reemplazo básico con str_replace y str_replace_all

La función str_replace reemplaza la primera coincidencia de un patrón, mientras que str_replace_all reemplaza todas las coincidencias:

# Reemplazar la primera coincidencia
texto <- "El análisis de datos requiere análisis cuidadoso"
str_replace(texto, "análisis", "examen")
# [1] "El examen de datos requiere análisis cuidadoso"

# Reemplazar todas las coincidencias
str_replace_all(texto, "análisis", "examen")
# [1] "El examen de datos requiere examen cuidadoso"

Podemos aplicar estas funciones a vectores de texto:

# Vector de frases
frases <- c("R es genial", "Python es útil", "R para estadística")

# Reemplazar "R" por "Rlang"
str_replace_all(frases, "\\bR\\b", "Rlang")
# [1] "Rlang es genial"      "Python es útil"      "Rlang para estadística"

El patrón \\bR\\b utiliza límites de palabra (\\b) para asegurar que solo se reemplace "R" como palabra completa, no como parte de otras palabras.

Reemplazo con expresiones regulares

El verdadero poder de las funciones de reemplazo se manifiesta cuando las combinamos con expresiones regulares:

# Estandarizar formatos de fecha
fechas <- c("15/04/2023", "2023-06-30", "7-8-2023")

# Convertir todas a formato YYYY-MM-DD
fechas_estandarizadas <- fechas %>%
  # Formato DD/MM/YYYY a YYYY-MM-DD
  str_replace("(\\d{1,2})/(\\d{1,2})/(\\d{4})", "\\3-\\2-\\1") %>%
  # Formato D-M-YYYY a YYYY-MM-DD
  str_replace("(\\d{1,2})-(\\d{1,2})-(\\d{4})", "\\3-\\2-\\1")

fechas_estandarizadas
# [1] "2023-04-15" "2023-06-30" "2023-8-7"

En este ejemplo, los grupos de captura (entre paréntesis) nos permiten reorganizar las partes de la fecha durante el reemplazo. Las referencias \\1, \\2 y \\3 se refieren al primer, segundo y tercer grupo capturado.

Reemplazo con función

La variante str_replace_all puede recibir una función como segundo argumento, lo que permite realizar transformaciones más complejas:

# Convertir dígitos a su valor duplicado
str_replace_all("R versión 4.1.2", "\\d", function(x) as.character(as.numeric(x) * 2))
# [1] "R versión 8.2.4"

# Convertir palabras a mayúsculas
texto <- "análisis de datos en r"
str_replace_all(texto, "\\b\\w+\\b", function(x) {
  if (nchar(x) > 3) str_to_upper(x) else x
})
# [1] "ANÁLISIS de DATOS en r"

Funciones de división

Las funciones de división nos permiten separar cadenas de texto en partes más pequeñas, lo que facilita el análisis y la extracción de información estructurada.

División básica con str_split

La función str_split divide una cadena en un vector de subcadenas basándose en un delimitador:

# Dividir por espacio
str_split("análisis de datos", " ")
# [[1]]
# [1] "análisis" "de"       "datos"   

# Dividir múltiples cadenas
nombres_completos <- c("Juan Pérez", "María López")
str_split(nombres_completos, " ")
# [[1]]
# [1] "Juan"  "Pérez"
# 
# [[2]]
# [1] "María"  "López"

Por defecto, str_split devuelve una lista donde cada elemento contiene el resultado de dividir la cadena correspondiente. Para obtener una matriz, podemos usar el parámetro simplify = TRUE:

# Obtener resultado como matriz
str_split(nombres_completos, " ", simplify = TRUE)
#      [,1]    [,2]   
# [1,] "Juan"  "Pérez"
# [2,] "María" "López"

División con límite

Podemos limitar el número de divisiones con el parámetro n:

# Texto con múltiples separadores
texto <- "R,Python,SQL,Java,JavaScript"

# Dividir en máximo 3 partes
str_split(texto, ",", n = 3)
# [[1]]
# [1] "R"                  "Python"             "SQL,Java,JavaScript"

Esto es útil cuando solo necesitamos extraer ciertos elementos o cuando el delimitador puede aparecer dentro de los elementos que queremos conservar.

División con expresiones regulares

Podemos usar expresiones regulares como patrón de división:

# Dividir por cualquier carácter no alfanumérico
texto <- "R;Python,SQL.Java"
str_split(texto, "[^[:alnum:]]")
# [[1]]
# [1] "R"        "Python"   "SQL"      "Java"    

# Dividir por uno o más espacios en blanco
direccion <- "Calle   Principal  123,  Ciudad"
str_split(direccion, "\\s+")
# [[1]]
# [1] "Calle"      "Principal"  "123,"       "Ciudad"

División fija vs. expresiones regulares

Por defecto, str_split interpreta el patrón como una expresión regular. Si queremos dividir por una cadena literal, podemos usar fixed = TRUE:

# Dividir por punto y coma literal
texto <- "nombre;apellido;edad"
str_split(texto, ";", fixed = TRUE)
# [[1]]
# [1] "nombre"   "apellido" "edad"    

# Útil cuando el delimitador contiene caracteres especiales
codigo <- "función(x+y)"
str_split(codigo, "(", fixed = TRUE)
# [[1]]
# [1] "función" "x+y)"

Casos prácticos de reemplazo y división

Limpieza y estandarización de datos

# Datos de clientes con formato inconsistente
clientes <- c(
  "Pérez, Juan (Madrid)",
  "López,  María  (Barcelona)",
  "García,Carlos(Sevilla)"
)

# Limpiar y estandarizar
clientes_limpios <- clientes %>%
  # Eliminar espacios extra
  str_replace_all("\\s+", " ") %>%
  # Estandarizar formato
  str_replace_all("(\\w+),\\s*(\\w+)\\s*\\((\\w+)\\)", "\\2 \\1 - \\3")

clientes_limpios
# [1] "Juan Pérez - Madrid"     "María López - Barcelona" "Carlos García - Sevilla"

Extracción de componentes de URL

# Lista de URLs
urls <- c(
  "https://ejemplo.com/productos?id=123",
  "http://sitio.org/articulos/r-programacion",
  "https://datos.gob.es/dataset/covid"
)

# Extraer dominio y ruta
componentes <- str_split(urls, "://", simplify = TRUE)
dominios_rutas <- str_split(componentes[, 2], "/", n = 2, simplify = TRUE)

# Crear data frame con los resultados
resultado <- data.frame(
  protocolo = str_extract(urls, "^[^:]+"),
  dominio = dominios_rutas[, 1],
  ruta = ifelse(dominios_rutas[, 2] == "", NA, dominios_rutas[, 2])
)

resultado
#   protocolo      dominio                    ruta
# 1     https  ejemplo.com       productos?id=123
# 2      http    sitio.org  articulos/r-programacion
# 3     https   datos.gob.es         dataset/covid

Procesamiento de datos CSV en texto

# Texto en formato CSV
csv_texto <- "nombre,edad,ciudad
Juan,28,Madrid
María,34,Barcelona
Carlos,45,Valencia"

# Dividir por líneas y luego por comas
lineas <- str_split(csv_texto, "\n")[[1]]
encabezados <- str_split(lineas[1], ",")[[1]]

# Procesar cada línea de datos
datos <- lapply(lineas[-1], function(linea) {
  valores <- str_split(linea, ",")[[1]]
  names(valores) <- encabezados
  return(valores)
})

# Convertir a data frame
df <- do.call(rbind, datos) %>% 
  as.data.frame(stringsAsFactors = FALSE)

# Convertir edad a numérico
df$edad <- as.numeric(df$edad)

df
#   nombre edad    ciudad
# 1   Juan   28    Madrid
# 2  María   34 Barcelona
# 3 Carlos   45  Valencia

Normalización de nombres de variables

# Nombres de variables inconsistentes
nombres_vars <- c(
  "Edad_Usuario", "FECHA_REGISTRO", "codigo-postal",
  "Nivel Educativo", "ingresos.mensuales"
)

# Normalizar a snake_case
nombres_normalizados <- nombres_vars %>%
  # Convertir a minúsculas
  str_to_lower() %>%
  # Reemplazar espacios, puntos y guiones por guiones bajos
  str_replace_all("[\\s.-]+", "_")

nombres_normalizados
# [1] "edad_usuario"       "fecha_registro"     "codigo_postal"     
# [4] "nivel_educativo"    "ingresos_mensuales"

Las funciones de reemplazo y división de stringr son herramientas fundamentales para la manipulación de datos textuales en R. Combinadas con las capacidades de búsqueda y extracción que vimos anteriormente, nos permiten transformar datos desestructurados en formatos limpios y analizables, facilitando enormemente el trabajo con información textual en nuestros proyectos de análisis de datos.