Saltar al contenido principal

Tutorial de Expresiones Regulares en Python

Descubre el poder de las expresiones regulares con este tutorial. Trabajarás con la biblioteca re, tratarás con la concordancia de patrones, aprenderás sobre la concordancia codiciosa y no codiciosa, ¡y mucho más!
Actualizado 11 sept 2024  · 20 min de lectura

Ejecute y edite el código de este tutorial en línea

Ejecutar código
banner

Las expresiones regulares, a menudo abreviadas como regex, son una secuencia de caracteres utilizada para comprobar si un patrón existe o no en un texto (cadena) dado. Si alguna vez has utilizado motores de búsqueda, herramientas de búsqueda y sustitución de procesadores de texto y editores de texto, ya habrás visto cómo se utilizan las expresiones regulares. Se utilizan en el lado del servidor para validar el formato de las direcciones de correo electrónico o las contraseñas durante el registro, se utilizan para analizar archivos de datos de texto para buscar, sustituir o eliminar determinadas cadenas, etc. Ayudan a manipular datos textuales, lo que suele ser un requisito previo para los proyectos de ciencia de datos que implican minería de textos.

Este tutorial te guiará a través de los conceptos importantes de las expresiones regulares con Python. Empezarás importando re - biblioteca de Python que admite expresiones regulares. A continuación, verás cómo se utilizan los caracteres básicos/ordinarios para realizar combinaciones, seguidos de los caracteres comodín o especiales. A continuación, aprenderás a utilizar repeticiones en tus expresiones regulares. También aprenderás a crear grupos y grupos con nombre dentro de tu búsqueda para facilitar el acceso a las coincidencias. A continuación, te familiarizarás con el concepto de emparejamiento codicioso frente al no codicioso.

Esto ya parece mucho, y por eso se incluye una práctica tabla resumen para ayudarte a recordar lo que has visto hasta ahora con definiciones breves. ¡Compruébalo!

Este tutorial también cubre algunas funciones muy útiles que proporciona la biblioteca re, como: compile(), search(), findall(), sub() para buscar y reemplazar, split(), y algunas más. También aprenderás sobre los indicadores de compilación que puedes utilizar para mejorar tus expresiones regulares.

Al final, hay un caso práctico, ¡donde puedes poner en práctica tus conocimientos! Así que vamos a regex...

Expresiones regulares en Python

En Python, las expresiones regulares están soportadas por el módulo re. Eso significa que si quieres empezar a utilizarlos en tus scripts de Python, tienes que importar este módulo con la ayuda de import:

import re

La biblioteca re de Python proporciona varias funciones que la convierten en una habilidad que merece la pena dominar. Verás algunas de ellas de cerca en este tutorial.

Patrones básicos: Personajes corrientes

Puedes abordar fácilmente muchos patrones básicos en Python utilizando caracteres ordinarios. Los caracteres ordinarios son las expresiones regulares más sencillas. Coinciden exactamente consigo mismas y no tienen un significado especial en su sintaxis de expresión regular.

Ejemplos: "A", "a", "X", "5".

Los caracteres ordinarios pueden utilizarse para realizar coincidencias exactas simples:

pattern = r"Cookie"
sequence = "Cookie"
if re.match(pattern, sequence):
    print("Match!")
else: print("Not a match!")
Match!

La mayoría de los alfabetos y caracteres se emparejarán solos, como has visto en el ejemplo.

La función match() devuelve un objeto coincidente si el texto coincide con el patrón. En caso contrario, devuelve None. El módulo re también contiene otras funciones, y aprenderás algunas de ellas más adelante en el tutorial.

Por ahora, ¡centrémonos en los personajes corrientes!

¿Notas el r al principio del patrón Cookie?
Esto se llama literal de cadena sin procesar. Cambia cómo se interpreta la cadena literal. Estos literales se almacenan tal y como aparecen.

Por ejemplo, \ es sólo una barra invertida cuando va precedida de r, en lugar de interpretarse como una secuencia de escape. Verás lo que esto significa con caracteres especiales. A veces, la sintaxis implica caracteres de escape de barra invertida, y para evitar que estos caracteres se interpreten como secuencias de escape, se utiliza el prefijo r en bruto.

TIP: En realidad no lo necesitas para este ejemplo; sin embargo, es una buena práctica utilizarlo por coherencia.

Personajes comodín: Caracteres especiales

Los caracteres especiales son caracteres que no coinciden por sí mismos, pero que tienen un significado especial cuando se utilizan en una expresión regular. Para que se entiendan fácilmente, se puede pensar en ellos como metacaracteres reservados que denotan otra cosa y no lo que parecen.

Veamos algunos ejemplos para ver los caracteres especiales en acción...

Pero antes, los ejemplos siguientes utilizan dos funciones: search() y group().
Con la función de búsqueda, recorres la cadena/secuencia dada, buscando la primera posición en la que la expresión regular produzca una coincidencia.
La función grupo devuelve la cadena coincidente con la re. Verás estas dos funciones con más detalle más adelante.

Volvamos ahora a los caracteres especiales.

. - Un periodo. Coincide con cualquier carácter, excepto el carácter de nueva línea.

re.search(r'Co.k.e', 'Cookie').group()
'Cookie'

^ - Un signo de intercalación. Coincide con el inicio de la cadena.

Esto es útil si quieres asegurarte de que un documento/una frase comienza con determinados caracteres.

re.search(r'^Eat', "Eat cake!").group()

## However, the code below will not give the same result. Try it for yourself:
# re.search(r'^eat', "Let's eat cake!").group()
'Eat'

$ - Coincide con el final de la cadena.

Esto es útil si quieres asegurarte de que un documento/una frase termina con determinados caracteres.

re.search(r'cake$', "Cake! Let's eat cake").group()

## The next search will return the NONE value, try it:
# re.search(r'cake$', "Let's get some cake on our way home!").group()
'cake'

[abc] - Coincide con a o b o c.
[a-zA-Z0-9] - Coincide con cualquier letra de (a a z) o (A a Z) o (0 a 9).

TIP: Los personajes que no estén dentro de un rango pueden emparejarse complementando el conjunto. Si el primer carácter del conjunto es ^, se emparejarán todos los caracteres que no estén en el conjunto.

re.search(r'[0-6]', 'Number: 5').group()
'5'
## Matches any character except 5
re.search(r'Number: [^5]', 'Number: 0').group()

## This will not match and hence a NONE value will be returned
#re.search(r'Number: [^5]', 'Number: 5').group()
'Number: 0'

\ - Barra invertida.
Quizás, ¡¡¡el metacarácter más diverso!!!

  • Si el carácter que sigue a la barra invertida es un carácter de escape reconocido, entonces se toma el significado especial del término (Escenario 1)
  • Si el carácter que sigue a \ no es un carácter de escape reconocido, entonces \ se trata como cualquier otro carácter y se pasa (Escenario 2).
  • \ puede utilizarse delante de todos los metacaracteres para eliminar su significado especial (Escenario 3).
## (Scenario 1) This treats '\s' as an escape character, '\s' defines a space
re.search(r'Not a\sregular character', 'Not a regular character').group()
'Not a regular character'
## (Scenario 2) '\' is treated as an ordinary character, because '\r' is not a recognized escape character
re.search(r'Just a \regular character', 'Just a \regular character').group()
'Just a \regular character'
## (Scenario 3) '\s' is escaped using an extra `\` so its interpreted as a literal string '\s'
re.search(r'Just a \\sregular character', 'Just a \sregular character').group()
'Just a \\sregular character'

Hay un conjunto predefinido de secuencias especiales que empiezan por "\" y que también son muy útiles a la hora de realizar búsquedas y coincidencias. Veamos algunas de ellas de cerca...

\w - La "w" minúscula. Coincide con cualquier letra, cifra o guión bajo.
\W - W mayúscula. Coincide con cualquier carácter que no forme parte de \w (w minúscula).

print("Lowercase w:", re.search(r'Co\wk\we', 'Cookie').group())

## Matches any character except single letter, digit or underscore
print("Uppercase W:", re.search(r'C\Wke', 'C@ke').group())

## Uppercase W won't match single letter, digit
print("Uppercase W won't match, and return:", re.search(r'Co\Wk\We', 'Cookie'))
Lowercase w: Cookie
Uppercase W: C@ke
Uppercase W won't match, and return: None

\s - La "s" minúscula. Coincide con un único carácter de espacio en blanco como: espacio, nueva línea, tabulador, retorno.
\S - S mayúscula. Coincide con cualquier carácter que no forme parte de \s (s minúscula).

print("Lowercase s:", re.search(r'Eat\scake', 'Eat cake').group())
print("Uppercase S:", re.search(r'cook\Se', "Let's eat cookie").group())
Lowercase s: Eat cake
Uppercase S: cookie

\d - D minúscula. Coincide con el dígito decimal 0-9.
\D - D mayúscula. Coincide con cualquier carácter que no sea un dígito decimal.

# Example for \d
print("How many cookies do you want? ", re.search(r'\d+', '100 cookies').group())
How many cookies do you want?  100

El símbolo + utilizado después del \d en el ejemplo anterior se utiliza para la repetición. Lo verás con más detalle en la sección de repetición más adelante...

\t - T minúscula. Ficha Coincidencias.
\n - N minúscula. Coincide con la nueva línea.
\r - R minúscula. Devuelve las coincidencias.
\A - Mayúscula a. Coincide sólo con el principio de la cadena. También funciona en varias líneas.
\Z - Z mayúscula. Coincide sólo con el final de la cadena.
CONSEJO: ^ y \A son efectivamente lo mismo, y también lo son $ y \Z. Excepto cuando se trata del modo MULTILINEAL. Más información en la sección banderas.

\b - B minúscula. Sólo coincide con el principio o el final de la palabra.

# Example for \t
print("\\t (TAB) example: ", re.search(r'Eat\tcake', 'Eat    cake').group())

# Example for \b
print("\\b match gives: ",re.search(r'\b[A-E]ookie', 'Cookie').group())
\t (TAB) example:  Eat    cake
\b match gives:  Cookie

Repeticiones

Resulta bastante tedioso si buscas patrones largos en una secuencia. Afortunadamente, el módulo re gestiona las repeticiones utilizando los siguientes caracteres especiales:

+ - Comprueba si el carácter precedente aparece una o más veces a partir de esa posición.

re.search(r'Co+kie', 'Cooookie').group()
'Cooookie'

* - Comprueba si el carácter precedente aparece cero o más veces a partir de esa posición.

# Checks for any occurrence of a or o or both in the given sequence
re.search(r'Ca*o*kie', 'Cookie').group()
'Cookie'

? - Comprueba si el carácter precedente aparece exactamente cero o una vez a partir de esa posición.

# Checks for exactly zero or one occurrence of a or o or both in the given sequence
re.search(r'Colou?r', 'Color').group()
'Color'

Pero, ¿y si quieres comprobar un número exacto de repetición de secuencia?

Por ejemplo, la comprobación de la validez de un número de teléfono en una aplicación. El módulo re también gestiona esto con mucha elegancia utilizando las siguientes expresiones regulares:

{x} - Repite exactamente x número de veces.
{x,} - Repite al menos x veces o más.
{x, y} - Repite al menos x veces pero no más de y veces.

re.search(r'\d{9,10}', '0987654321').group()
'0987654321'

Se dice que los calificadores + y * son greedy. Verás lo que esto significa más adelante.

Agrupación en expresiones regulares

La función de grupo de la expresión regular te permite recoger partes del texto coincidente. Las partes de un patrón de expresión regular delimitadas por paréntesis () se denominan grupos. El paréntesis no cambia lo que coincide con la expresión, sino que forma grupos dentro de la secuencia coincidente. En todos los ejemplos de este tutorial has utilizado la función group(). La dirección match.group() sin ningún argumento sigue siendo el texto coincidente completo, como siempre.

Vamos a entender este concepto con un ejemplo sencillo. Imagina que estás validando direcciones de correo electrónico y quieres comprobar el nombre de usuario y el host. Es entonces cuando querrás crear grupos separados dentro de tu texto emparejado.

statement = 'Please contact us at: support@datacamp.com'
match = re.search(r'([\w\.-]+)@([\w\.-]+)', statement)
if statement:
  print("Email address:", match.group()) # The whole matched text
  print("Username:", match.group(1)) # The username (group 1)
  print("Host:", match.group(2)) # The host (group 2)
Email address: support@datacamp.com
Username: support
Host: datacamp.com

Otra forma de hacer lo mismo es utilizar los corchetes de <>. Esto te permitirá crear grupos con nombre. Los grupos con nombre harán que tu código sea más legible. La sintaxis para crear un grupo con nombre es: (?P...). Sustituye la parte name por el nombre que quieras dar a tu grupo. La dirección ... representa el resto de la sintaxis de concordancia. Mira esto en acción utilizando el mismo ejemplo de antes...

statement = 'Please contact us at: support@datacamp.com'
match = re.search(r'(?P<email>(?P<username>[\w\.-]+)@(?P<host>[\w\.-]+))', statement)
if statement:
  print("Email address:", match.group('email'))
  print("Username:", match.group('username'))
  print("Host:", match.group('host'))
Email address: support@datacamp.com
Username: support
Host: datacamp.com

TIP: Siempre puedes acceder a los grupos con nombre utilizando números en lugar del nombre. Pero a medida que aumenta el número de grupos, se hace más difícil manejarlos utilizando sólo números. Por tanto, acostúmbrate siempre a utilizar grupos con nombre.

Codicioso vs. Emparejamiento no arbitrario

Cuando un carácter especial coincide con la mayor parte posible de la secuencia de búsqueda (cadena), se dice que es una "Coincidencia codiciosa". Es el comportamiento normal de una expresión regular, pero a veces no se desea este comportamiento:

pattern = "cookie"
sequence = "Cake and cookie"

heading  = r'<h1>TITLE</h1>'
re.match(r'<.*>', heading).group()
'<h1>TITLE</h1>'

El patrón <.*> coincide con toda la cadena, hasta la segunda aparición de >.

Sin embargo, si sólo querías que coincidiera con la primera etiqueta

, podrías haber utilizado el calificador codicioso *?, que coincide con el menor texto posible.

Si añades ? después del calificador, la coincidencia se realizará de forma mínima, es decir, con el menor número posible de caracteres. Cuando ejecutes <.*>, sólo obtendrás una coincidencia con

.
heading  = r'<h1>TITLE</h1>'
re.match(r'<.*?>', heading).group()
'<h1>'

Tabla resumen

Ya has avanzado mucho con las expresiones regulares. ¡Es mucha información y conceptos que comprender! La siguiente tabla resume todo lo que has visto hasta ahora en este tutorial. No te preocupes si aún no puedes hacerte a la idea de todos los metapersonajes. Con el tiempo y la práctica, serás capaz de ver la singularidad de estos personajes y aprenderás cuándo utilizar qué...

Este tutorial no trata todas las secuencias especiales que ofrece Python. Consulta la referencia Biblioteca Estándar para obtener una lista completa.

Personaje(s) Qué hace
. Un periodo. Coincide con cualquier carácter, excepto el carácter de nueva línea.
^ Un signo de intercalación. Coincide con un patrón al principio de la cadena.
\A A mayúscula. Coincide sólo al principio de la cadena.
$ Signo del dólar. Coincide con el final de la cadena.
\Z Z mayúscula. Coincide sólo al final de la cadena.
[ ] Coincide con el conjunto de caracteres que especifiques en su interior.
\ ∙ Si el carácter que sigue a la barra invertida es un carácter de escape reconocido, se toma el significado especial del término.
∙ Si no, la barra invertida () se trata como cualquier otro carácter y se pasa.
∙ Se puede utilizar delante de todos los metacaracteres para eliminar su significado especial.
\w W minúscula. Coincide con cualquier letra, cifra o guión bajo.
\W W mayúscula. Coincide con cualquier carácter que no forme parte de \w (w minúscula).
\s S minúscula. Coincide con un único carácter de espacio en blanco como: espacio, nueva línea, tabulador, retorno.
\S S mayúscula. Coincide con cualquier carácter que no forme parte de \s (s minúscula).
\d D minúscula. Coincide con el dígito decimal 0-9.
\D D. mayúscula Coincide con cualquier carácter que no sea un dígito decimal.
\t T minúscula. Pestaña Partidos.
\n N minúscula. Coincide con la nueva línea.
\r R minúscula. Vuelven los partidos.
\b B minúscula. Sólo coincide con el principio o el final de la palabra.
+ Comprueba si el carácter precedente aparece una o más veces.
* Comprueba si el carácter precedente aparece cero o más veces.
? ∙ Comprueba si el carácter precedente aparece exactamente cero o una vez.
∙ Especifica una versión no codiciosa de +, *.
{ } Comprueba un número explícito de veces.
( ) Crea un grupo al realizar coincidencias.
< > Crea un grupo con nombre al realizar coincidencias.

¡Has abordado los conceptos básicos de regex! Sin embargo, hay algunos conceptos más que pueden ayudarte en tu camino para crear unas bonitas expresiones regulares para hacer búsquedas y coincidencias.

TIP: Aunque las expresiones regulares son muy potentes y útiles, desconfía de las expresiones largas y confusas que son difíciles de entender y mantener en el tiempo para los demás, y también para ti.

Función proporcionada por "re

La biblioteca re de Python proporciona varias funciones para facilitarte las tareas. Ya has visto algunos de ellos, como el re.search(), re.match(). Vamos a ver más...

compile(pattern, flags=0)

Python trata las expresiones regulares como cadenas. Sin embargo, con compile(), puedes computar un patrón de expresión regular en un objeto de expresión regular. Cuando necesites utilizar una expresión varias veces en un mismo programa, utilizar compile() para guardar el objeto expresión regular resultante y reutilizarlo es más eficaz que guardarlo como cadena. Esto se debe a que las versiones compiladas de los patrones más recientes pasados a compile() y a las funciones de concordancia a nivel de módulo se almacenan en caché.

pattern = re.compile(r"cookie")
sequence = "Cake and cookie"
pattern.search(sequence).group()
'cookie'
# This is equivalent to:
re.search(pattern, sequence).group()
'cookie'

search(pattern, string, flags=0)

Con esta función, escaneas la cadena/secuencia dada, buscando la primera posición en la que la expresión regular produzca una coincidencia. Devuelve un objeto coincidente si lo encuentra, en caso contrario devuelve None si ninguna posición de la cadena coincide con el patrón. Ten en cuenta que None es diferente de encontrar una coincidencia de longitud cero en algún punto de la cadena.

pattern = "cookie"
sequence = "Cake and cookie"

re.search(pattern, sequence)
<re.Match object; span=(9, 15), match='cookie'>

match(pattern, string, flags=0)

Devuelve un objeto coincidente si cero o más caracteres del principio de la cadena coinciden con el patrón. Si no, devuelve None, si la cadena no coincide con el patrón dado.

pattern = "C"
sequence1 = "IceCream"
sequence2 = "Cake"

# No match since "C" is not at the start of "IceCream"
print("Sequence 1: ", re.match(pattern, sequence1))
print("Sequence 2: ", re.match(pattern,sequence2).group())
Sequence 1:  None
Sequence 2:  C

search() frente a match()

La función match() busca una coincidencia sólo al principio de la cadena (por defecto), mientras que la función search() busca una coincidencia en cualquier parte de la cadena.

findall(pattern, string, flags=0)

Busca todas las posibles coincidencias en toda la secuencia y las devuelve como una lista de cadenas. Cada cadena devuelta representa una coincidencia.

statement = "Please contact us at: support@datacamp.com, xyz@datacamp.com"

#'addresses' is a list that stores all the possible match
addresses = re.findall(r'[\w\.-]+@[\w\.-]+', statement)
for address in addresses:
    print(address)
support@datacamp.com
xyz@datacamp.com

finditer(string, [position, end_position])

Similar a findall() - encuentra todas las posibles coincidencias en toda la secuencia, pero devuelve objetos de coincidencia regex como un iterador.

CONSEJO: finditer() puede ser una opción excelente cuando quieras que te devuelvan más información sobre tu búsqueda. El objeto de coincidencia regex devuelto contiene no sólo la secuencia que coincidió, sino también sus posiciones en el texto original.

statement = "Please contact us at: support@datacamp.com, xyz@datacamp.com"

#'addresses' is a list that stores all the possible match
addresses = re.finditer(r'[\w\.-]+@[\w\.-]+', statement)
for address in addresses:
    print(address)
<re.Match object; span=(22, 42), match='support@datacamp.com'>
<re.Match object; span=(44, 60), match='xyz@datacamp.com'>

sub(pattern, repl, string, count=0, flags=0)
subn(pattern, repl, string, count=0)

sub() es la función de sustitución. Devuelve la cadena obtenida reemplazando o sustituyendo las ocurrencias no solapadas más a la izquierda del patrón en la cadena por el reemplazo repl. Si no se encuentra el patrón, la cadena se devuelve sin cambios.

El subn() es similar a sub(). Sin embargo, devuelve una tupla que contiene el nuevo valor de la cadena y el número de sustituciones que se realizaron en la sentencia.

statement = "Please contact us at: xyz@datacamp.com"
new_email_address = re.sub(r'([\w\.-]+)@([\w\.-]+)', r'support@datacamp.com', statement)
print(new_email_address)
Please contact us at: support@datacamp.com

split(string, [maxsplit = 0])

Divide las cadenas donde coincida el patrón y devuelve una lista. Si el argumento opcional maxsplit es distinto de cero, se realiza el número máximo 'maxsplit' de divisiones.

statement = "Please contact us at: xyz@datacamp.com, support@datacamp.com"
pattern = re.compile(r'[:,]')

address = pattern.split(statement)
print(address)
['Please contact us at', ' xyz@datacamp.com', ' support@datacamp.com']

start() - Devuelve el índice inicial de la coincidencia.
end() - Devuelve el índice donde termina la coincidencia.
span() - Devuelve una tupla que contiene las posiciones (inicial, final) de la coincidencia.

pattern = re.compile('COOKIE', re.IGNORECASE)
match = pattern.search("I am not a cookie monster")

print("Start index:", match.start())
print("End index:", match.end())
print("Tuple:", match.span())
Start index: 11
End index: 17
Tuple: (11, 17)

Banderas de compilación

¿Te has fijado en el término re.IGNORECASE en el último ejemplo? ¿Te has dado cuenta de su importancia?

El comportamiento de una expresión puede modificarse especificando un valor de bandera. Puedes añadir banderas como argumento extra a las distintas funciones que has visto en este tutorial. Algunos de los más útiles son:

IGNORECASE (I) - Permite coincidencias sin distinción entre mayúsculas y minúsculas.
DOTALL (S) - Permite que . coincida con cualquier carácter, incluida la nueva línea.
MULTILÍNEA (M) - Permite que el anclaje de inicio de cadena (^) y de fin de cadena ($) coincida también con nuevas líneas.
VERBOSE (X) - Te permite escribir espacios en blanco y comentarios dentro de una expresión regular para hacerla más legible.

statement = "Please contact us at: support@DataCamp.com, xyz@DATACAMP.com"

# Using the VERBOSE flag helps understand complex regular expressions
pattern = re.compile(r"""
[\w\.-]+ #First part
@ #Matches @ sign within email addresses
datacamp.com #Domain
""", re.X | re.I)

addresses = re.findall(pattern, statement)                       
for address in addresses:
    print("Address: ", address)
Address:  support@DataCamp.com
Address:  xyz@DATACAMP.com

TIP: También puedes combinar varias banderas utilizando el bitwise OR |.

Estudio de caso: Trabajar con expresiones regulares

Ahora que has visto cómo funcionan las expresiones regulares en Python estudiando algunos ejemplos, ¡es hora de ensuciarse las manos! En este caso práctico, pondrás en práctica todos tus conocimientos.

Trabajarás con la primera parte de un libro electrónico gratuito titulado "El idiota", escrito por Fiódor Dostoievski en el Proyecto Gutenberg. La novela trata del príncipe (Knyaz) Lev Nikoláievich Myshkin, un hombre cándido cuya naturaleza buena, amable y sencilla hace creer erróneamente a muchos que carece de inteligencia y perspicacia. El título es una referencia irónica a este joven.

Escribirás algunas expresiones regulares para analizar el texto y completar algunos ejercicios.

import re
import requests
the_idiot_url = 'https://www.gutenberg.org/files/2638/2638-0.txt'

def get_book(url):
    # Sends a http request to get the text from project Gutenberg
    raw = requests.get(url).text
    # Discards the metadata from the beginning of the book
    start = re.search(r"\*\*\* START OF THIS PROJECT GUTENBERG EBOOK .* \*\*\*",raw ).end()
    # Discards the text starting Part 2 of the book
    stop = re.search(r"II", raw).start()
    # Keeps the relevant text
    text = raw[start:stop]
    return text

def preprocess(sentence):
    return re.sub('[^A-Za-z0-9.]+' , ' ', sentence).lower()

book = get_book(the_idiot_url)
processed_book = preprocess(book)
#print(processed_book)
  • Ejercítate: Encuentra el número del pronombre "el" en el corpus. Pista: Utiliza la función len().
len(re.findall(r'the', processed_book))
302
  • Ejercítate: Intenta convertir cada instancia aislada de "i" en "I" en el corpus. Asegúrate de no cambiar la "i" que aparece dentro de una palabra:
processed_book = re.sub(r'\si\s', " I ", processed_book)
#print(processed_book)
  • Ejercítate: Encuentra el número de veces que se citó a alguien ("") en el corpus.
len(re.findall(r'\”', book))
0
  • Ejercítate: ¿Cuáles son las palabras conectadas por '--' en el corpus?
    ¡Pruébalo tú mismo! No dudes en compartir tu respuesta en los comentarios de abajo.

¡Enhorabuena!

¡Has llegado al final de este tutorial sobre expresiones regulares en Python! Hay mucho más que cubrir en tu viaje por la ciencia de datos con Python.

Las expresiones regulares pueden desempeñar un papel importante en la fase de preprocesamiento de datos. Consulta el curso de Limpieza de Datos en Python de DataCamp. Este curso te enseña formas de explorar mejor tus datos, ordenándolos y limpiándolos con fines de análisis de datos. También incluye un caso práctico al final en el que puedes poner en práctica tus conocimientos recién adquiridos.

Echa un vistazo a nuestro Tutorial de Reemplazo de Cadenas en Python.

Temas

Cursos de Python

Certificación disponible

curso

Introducción a Python

4 hr
5.5M
Domina los fundamentos del análisis de datos con Python en sólo cuatro horas. Este curso online introducirá la interfaz de Python y explorará paquetes populares.
Ver detallesRight Arrow
Comienza el curso
Ver másRight Arrow