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
Con la tecnología de

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!")
Con la tecnología de

Match!
Con la tecnología de

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()
Con la tecnología de

'Cookie'
Con la tecnología de

^ - 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()
Con la tecnología de

'Eat'
Con la tecnología de

$ - 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()
Con la tecnología de

'cake'
Con la tecnología de

[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()
Con la tecnología de

'5'
Con la tecnología de

## 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()
Con la tecnología de

'Number: 0'
Con la tecnología de

\ - 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()
Con la tecnología de

'Not a regular character'
Con la tecnología de

## (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()
Con la tecnología de

'Just a \regular character'
Con la tecnología de

## (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()
Con la tecnología de

'Just a \\sregular character'
Con la tecnología de

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'))
Con la tecnología de

Lowercase w: Cookie
Uppercase W: C@ke
Uppercase W won't match, and return: None
Con la tecnología de

\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())
Con la tecnología de

Lowercase s: Eat cake
Uppercase S: cookie
Con la tecnología de

\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())
Con la tecnología de

How many cookies do you want?  100
Con la tecnología de

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())
Con la tecnología de

\t (TAB) example:  Eat    cake
\b match gives:  CookieCon la tecnología de

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()
Con la tecnología de

'Cooookie'
Con la tecnología de

* - 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()
Con la tecnología de

'Cookie'
Con la tecnología de

? - 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()
Con la tecnología de

'Color'
Con la tecnología de

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()
Con la tecnología de

'0987654321'
Con la tecnología de

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: [email protected]'
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)
Con la tecnología de

Email address: support@datacamp.com
Username: support
Host: datacamp.com
Con la tecnología de

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: [email protected]'
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'))
Con la tecnología de

Email address: support@datacamp.com
Username: support
Host: datacamp.com
Con la tecnología de

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()
Con la tecnología de

'<h1>TITLE</h1>'
Con la tecnología de

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()
Con la tecnología de

'<h1>'Con la tecnología de

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.

¡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()
Con la tecnología de

'cookie'
Con la tecnología de

# This is equivalent to:
re.search(pattern, sequence).group()
Con la tecnología de

'cookie'
Con la tecnología de

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)
Con la tecnología de

<re.Match object; span=(9, 15), match='cookie'>
Con la tecnología de

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())
Con la tecnología de

Sequence 1:  None
Sequence 2:  C
Con la tecnología de

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: [email protected], [email protected]"

#'addresses' is a list that stores all the possible match
addresses = re.findall(r'[\w\.-]+@[\w\.-]+', statement)
for address in addresses:
    print(address)
Con la tecnología de

support@datacamp.com
xyz@datacamp.com
Con la tecnología de

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: [email protected], [email protected]"

#'addresses' is a list that stores all the possible match
addresses = re.finditer(r'[\w\.-]+@[\w\.-]+', statement)
for address in addresses:
    print(address)
Con la tecnología de

<re.Match object; span=(22, 42), match='[email protected]'>
<re.Match object; span=(44, 60), match='[email protected]'>
Con la tecnología de

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: [email protected]"
new_email_address = re.sub(r'([\w\.-]+)@([\w\.-]+)', r'[email protected]', statement)
print(new_email_address)
Con la tecnología de

Please contact us at: support@datacamp.com
Con la tecnología de

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: [email protected], [email protected]"
pattern = re.compile(r'[:,]')

address = pattern.split(statement)
print(address)
Con la tecnología de

['Please contact us at', ' [email protected]', ' [email protected]']
Con la tecnología de

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())
Con la tecnología de

Start index: 11
End index: 17
Tuple: (11, 17)Con la tecnología de

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: [email protected], [email protected]"

# 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)
Con la tecnología de

Address:  support@DataCamp.com
Address:  xyz@DATACAMP.com
Con la tecnología de

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)
Con la tecnología de

• 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))
Con la tecnología de

302
Con la tecnología de

• 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)
Con la tecnología de

• Ejercítate: Encuentra el número de veces que se citó a alguien ("") en el corpus.

len(re.findall(r'\”', book))
Con la tecnología de

0
Con la tecnología de

• 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.