¿Qué son las expresiones regulares?
Una expresión regular es una cadena de texto que permite crear patrones que ayudan a hacer coincidir, ubicar y administrar un texto.
Cuando intentas comprender las expresiones regulares por primera vez, parece que se trata de un idioma diferente. Sin embargo, dominarlas puede ahorrarte miles de horas si trabajas con texto o necesitas analizar grandes cantidades de datos.
Caracteres básicos de expresiones regulares
Ahora, antes de profundizar más en el tema, es fundamental que primero repasemos algunos de los conceptos básicos de las expresiones regulares.
Esto porque los ejemplos que aparecen más adelante en este artículo se basarán en algunos de los conceptos principales que se muestran a continuación: caracteres, agrupaciones y cuantificadores.
Caracteres
- Carácter de escape:\
- Cualquier carácter:.
- Dígito:\d
- Ni un dígito:\D
- Carácter de la palabra:\w
- No es un carácter de palabra:\W
- Espacio en blanco:\s
- No espacios en blanco:\S
- Límite de palabra:\b
- No es un límite de palabra:\B
- Comienzo de una cadena:^
- Fin de una cadena:$
Agrupaciones
- Coincide con los caracteres entre paréntesis:[ ]
- Coincide con los caracteres que no están entre paréntesis:[^ ]
- Cualquiera o:|
- Grupo de captura:( )
Cuantificadores
- 0 o más:*
- 1 o más:+
- 0 o 1:?
- Un número exacto de caracteres:{ }
- Rango de número de caracteres:{Minimum, Maximum}
5 ejemplos de expresiones regulares
Si los caracteres regex se te hacen muy extraños, descuida, pues simplemente sirven como referencias para los ejemplos que estamos a punto de ver.
1. Número de teléfono
Supongamos que tenemos un marco de datos llamado teléfono, que contiene una lista de números de teléfono de la siguiente manera:
Nos gustaría dividir estos números de teléfono en 3 componentes individuales: código de área (primeros 3 dígitos), intercambio (siguientes 3 dígitos) y número de línea (últimos 4 dígitos).
Como podemos ver, los patrones numéricos aquí no siempre son consistentes, es decir, tienen paréntesis, guiones y espacios inconsistentes. Sin embargo, con la ayuda de las expresiones regulares, podemos capturar fácilmente los grupos de números.
Primero, necesitaremos definir un patrón de expresiones regulares.
patrón_teléfono = “.?(\\d{3}).*(\\d{3}).*(\\d{4})”
¿Cómo interpretamos esto exactamente? Bueno, veamos esto paso a paso, de izquierda a derecha:
- .?0 o 1 carácter para tener en cuenta el paréntesis de apertura opcional
- (\\d{3})Caracteres de 3 dígitos (primer grupo de captura, es decir, los primeros 3 dígitos)
- .*0 o más caracteres para tener en cuenta los paréntesis de cierre, guiones y espacios opcionales
- (\\d{3})Caracteres de 3 dígitos (segundo grupo de captura, es decir, los siguientes 3 dígitos)
- .*0 o más caracteres para tener en cuenta los guiones y espacios opcionales
- (\\d{4})Caracteres de 4 dígitos (tercer grupo de captura, es decir, los últimos 4 dígitos)
Luego podemos usar la función str_match para recuperar los grupos de captura usando el patrón de expresión regular que hemos definido y colocarlos en columnas individuales en el marco de datos.
- phone$area_code = str_match(phone$original_number, phone_pattern)[, 2]
- phone$exchange = str_match(phone$original_number, phone_pattern)[, 3]
- phone$line_number = str_match(phone$original_number, phone_pattern)[, 4]
2. Fecha
Supongamos que tenemos otro marco de datos llamado fecha, que consta de fechas con delimitadores inconsistentes y queremos extraer los días, meses y años.
Usando un enfoque muy similar al que acabamos de ver con los números de teléfono, primero debemos definir un patrón de expresiones regulares, luego hacer coincidir el patrón con la columna de fecha original y finalmente crear una nueva columna para cada grupo de captura.
Primero, define el patrón de expresiones regulares para las fechas.
patrón_fecha = “(\\d{2}).(\\d{2}).(\\d{4})”
Aquí está la explicación del código:
- (\\d{2})Caracteres de 2 dígitos (primer grupo de captura, es decir, día)
- .un solo carácter para tener en cuenta todos los caracteres especiales
- (\\d{2})Caracteres de 2 dígitos (segundo grupo de captura, es decir, mes)
- .un solo carácter para tener en cuenta todos los caracteres especiales
- (\\d{4})Caracteres de 4 dígitos (tercer grupo de captura, es decir, año)
Ahora, podemos hacer coincidir el patrón y crear columnas individuales para el día, el mes y el año.
fecha$día = str_coincidencia(fecha$fecha_original, patrón_de_fecha)[, 2]
fecha$mes = str_coincidencia(fecha$fecha_original, patrón_de_fecha)[, 3]
fecha$año = str_coincidencia(fecha$fecha_original, patrón_de_fecha)[, 4]
3. Nombres
Hasta ahora, hemos explorado dos ejemplos de cadenas que contienen solo dígitos y caracteres especiales. A continuación, aprenderemos a cómo capturar palabras y letras.
Este es un marco de datos con nombres, apellidos, títulos y apodos de las personas.
Dividámoslos para que cada uno tenga sus propias columnas individuales.
nombre_patrón = “(\\w+),\\s(Sr|Sra|Sra|Dr).?\\s(\\w+)”
Y esta es la interpretación:
- (\\w+)1 o más caracteres de palabras (primer grupo de captura, es decir, apellido)
- ,carácter de coma
- \\sun solo carácter de espacio en blanco
- (Mr|Ms|Mrs|Dr)Mr, Ms, Mrs o Dr (segundo grupo de captura, es decir, título)
- .?0 o 1 carácter de punto final después del título
- \\sun solo carácter de espacio en blanco
- (\\w+)1 o más caracteres de palabra (tercer grupo de captura, es decir, nombre de pila)
Ahora, los pondremos en columnas individuales.
nombres$nombre_de_familia = str_match(nombres$nombre_completo, nombre_patrón)[, 2]
nombres$título = str_match(nombres$nombre_completo, nombre_patrón)[, 3]
nombres$nombre_dado = str_match(nombres$nombre_completo, nombre_patrón)[, 4]
4. URL
Veamos otro ejemplo de cadenas con palabras y letras.
A estas alturas, ya deberías estar familiarizado con el proceso.
url_pattern = “(https?)://(www)?.?(\\w+).(\\w+)/?(\\w+)?”
La interpretación:
- (https?)http o https (primer grupo de captura, es decir, esquema)
- ://cadena de caracteres especiales específicos
- (www)?www opcional (segundo grupo de captura, es decir, subdominio)
- .?0 o 1 carácter de punto final
- (\\w+)1 o más caracteres de palabra (tercer grupo de captura, es decir, dominio de segundo nivel)
- .un solo personaje de punto final
- (\\w+)1 o más caracteres de palabra (cuarto grupo de captura, es decir, dominio de nivel superior)
- /?0 o 1 carácter de barra invertida
- (\\w+)?1 o más caracteres de palabra opcionales (quinto grupo de captura, es decir, subdirectorio)
Separando los grupos de captura en columnas individuales, obtenemos:
url$esquema = str_match(url$url_completo, url_patrón)[, 2]
url$subdominio = str_match(url$url_completo, url_patrón)[, 3]
url$dominio_de_segundo_nivel = str_match(url$url_completo, url_patrón)[, 4]
url$ top_level_domain = str_match(url$full_url, url_pattern)[, 5]
url$subdirectorio = str_match(url$full_url, url_pattern)[, 6]
5. Dirección de correo electrónico
Utilizando el conocimiento que hemos adquirido hasta ahora sobre las expresiones regulares, veamos un último ejemplo de cadenas finales que contienen letras y números.
Supongamos que tenemos una lista de correos electrónicos en un marco de datos llamado correo electrónico:
Ahora, debes generar un patrón de expresión regular para que coincida con el nombre de usuario, el nombre de dominio y el dominio.
patrón_email = “([a-zA-Z0-9\\_\\-\\.]+)@([a-zA-Z]+).(.+)”
Echemos un vistazo más de cerca a la expresión regular y descifremos su significado.
- ([a-zA-Z0-9\\_\\-\\.]+)1 o más letras minúsculas, letras mayúsculas, dígitos y caracteres especiales, incluidos guiones bajos, guiones y puntos (primer grupo de captura, es decir, nombre de usuario)
- @en el símbolo
- ([a-zA-Z]+)1 o más letras minúsculas y mayúsculas (segundo grupo de captura, es decir, nombre de dominio)
- .un solo personaje de punto final
- (.+)1 o más caracteres (tercer grupo de captura, es decir, dominio)
Luego, aplicamos este patrón de expresiones regulares a la lista de correos electrónicos:
email$nombre de usuario = str_match(email$full_email, email_pattern)[, 2]
email$domain_name = str_match(email$full_email, email_pattern)[, 3]
email$domain = str_match(email$full_email, email_pattern)[, 4]
Espero que, a través de los cinco ejemplos que he demostrado en esta publicación de blog, no solo hayas obtenido una mejor comprensión de cómo funcionan las expresiones regulares sino, lo que es más importante, una apreciación de su flexibilidad para hacer coincidir patrones de cadenas complejos.
Si aspiras a convertirte en analista de datos o simplemente estás interesado en mejorar tus habilidades de manejo de datos, te recomiendo que agregues expresiones regulares a tu conjunto de herramientas.