Skip to content

Python String Replace: Guía completa de str.replace() y más

Soren Atelier
Name
Soren Atelier

Updated on

El reemplazo de cadenas es una de las operaciones más frecuentes en el procesamiento de texto. Necesita limpiar entrada de usuario, normalizar formatos de datos, redactar información sensible o transformar cadenas de plantilla. El método str.replace() de Python maneja casos simples en una línea, pero se queda corto cuando necesita coincidencia insensible a mayúsculas, patrones regex o reemplazos condicionales. Elegir la herramienta incorrecta significa complicar tareas simples innecesariamente o escribir código frágil para las complejas.

Esta guía cubre cada enfoque para el reemplazo de cadenas en Python -- desde el básico str.replace() hasta re.sub() con regex, translate() a nivel de caracteres y patrones prácticos para el procesamiento de texto del mundo real.

📚

    str.replace(old, new, count)

    El método más simple y común. Reemplaza todas las ocurrencias de old con new. Un count opcional limita el número de reemplazos.

    text = "Hello World, Hello Python, Hello Everyone"
 
# Reemplazar todas las ocurrencias
print(text.replace("Hello", "Hi"))
# Hi World, Hi Python, Hi Everyone
 
# Reemplazar solo las primeras 2 ocurrencias
print(text.replace("Hello", "Hi", 2))
# Hi World, Hi Python, Hello Everyone
 
# Eliminar una subcadena (reemplazar con cadena vacía)
messy = "  extra   spaces   here  "
print(messy.replace(" ", ""))
# extraspaceshere

    Comportamiento clave

    • Devuelve una nueva cadena (las cadenas son inmutables en Python)
    • Sensible a mayúsculas por defecto
    • Reemplaza todas las ocurrencias a menos que se especifique count
    • Devuelve la cadena original sin cambios si old no se encuentra
    original = "Python is great"
new = original.replace("great", "awesome")
print(original)  # Python is great (sin cambios)
print(new)       # Python is awesome

    Reemplazo insensible a mayúsculas

    str.replace() siempre es sensible a mayúsculas. Para reemplazo insensible a mayúsculas, use re.sub() con la bandera re.IGNORECASE.

    import re
 
text = "Python is Great, python is Fun, PYTHON is Everywhere"
 
# Reemplazo insensible a mayúsculas
result = re.sub(r'python', 'Java', text, flags=re.IGNORECASE)
print(result)
# Java is Great, Java is Fun, Java is Everywhere

    Reemplazo con regex usando re.sub()

    re.sub(pattern, replacement, string, count, flags) reemplaza coincidencias de un patrón regex.

    import re
 
# Reemplazar dígitos con '#'
text = "Call 555-1234 or 555-5678"
print(re.sub(r'\d', '#', text))
# Call ###-#### or ###-####
 
# Reemplazar números de teléfono completos
print(re.sub(r'\d{3}-\d{4}', '[REDACTADO]', text))
# Call [REDACTADO] or [REDACTADO]
 
# Reemplazar múltiples espacios con uno solo
messy = "too    many     spaces   here"
print(re.sub(r'\s+', ' ', messy))
# too many spaces here

    Uso de grupos de captura

    import re
 
# Intercambiar nombre y apellido
names = "Smith, John\nDoe, Jane\nBrown, Bob"
swapped = re.sub(r'(\w+), (\w+)', r'\2 \1', names)
print(swapped)
# John Smith
# Jane Doe
# Bob Brown
 
# Agregar formato a fechas
dates = "Meeting on 2026-02-10 and 2026-03-15"
formatted = re.sub(r'(\d{4})-(\d{2})-(\d{2})', r'\2/\3/\1', dates)
print(formatted)
# Meeting on 02/10/2026 and 03/15/2026

    Uso de una función para reemplazo dinámico

    Pase una función en lugar de una cadena para reemplazos condicionales:

    import re
 
def censor_word(match):
    word = match.group()
    return word[0] + '*' * (len(word) - 1)
 
text = "The password is secret and the code is hidden"
censored = re.sub(r'secret|hidden', censor_word, text)
print(censored)
# The password is s***** and the code is h*****
    import re
 
# Convertir a mayúscula inicial solo palabras específicas
def smart_capitalize(match):
    word = match.group()
    minor_words = {'a', 'an', 'the', 'and', 'or', 'but', 'in', 'on', 'at', 'to'}
    if word.lower() in minor_words:
        return word.lower()
    return word.capitalize()
 
title = "the quick BROWN fox AND the lazy DOG"
result = re.sub(r'\b\w+\b', smart_capitalize, title)
print(result)
# the Quick Brown Fox and the Lazy Dog

    Reemplazos múltiples

    Encadenar llamadas a replace()

    text = "Hello World! How are you?"
result = text.replace("Hello", "Hi").replace("World", "Earth").replace("you", "they")
print(result)  # Hi Earth! How are they?

    Reemplazo basado en diccionario

    Para muchos reemplazos, use un diccionario con re.sub():

    import re
 
def multi_replace(text, replacements):
    """Reemplazar múltiples subcadenas usando un diccionario."""
    pattern = re.compile('|'.join(re.escape(k) for k in replacements))
    return pattern.sub(lambda m: replacements[m.group()], text)
 
text = "The cat sat on the mat with another cat"
replacements = {
    'cat': 'dog',
    'mat': 'rug',
    'sat': 'stood',
}
 
print(multi_replace(text, replacements))
# The dog stood on the rug with another dog

    Reemplazo a nivel de caracteres con translate()

    Para reemplazar caracteres individuales, str.translate() con str.maketrans() es la opción más rápida:

    # Reemplazar caracteres: a->@, e->3, o->0
table = str.maketrans('aeo', '@30')
text = "Hello World"
print(text.translate(table))
# H3ll0 W0rld
 
# Eliminar caracteres específicos
remove_vowels = str.maketrans('', '', 'aeiouAEIOU')
print("Hello World".translate(remove_vowels))
# Hll Wrld
 
# Reemplazar Y eliminar en una sola llamada
table = str.maketrans({'a': '@', 'e': '3', ' ': None})
print("apple pie".translate(table))
# @ppl3pi3

    Comparación de métodos

    MétodoMejor paraRegexVelocidadFlexibilidad
    str.replace()Reemplazos simples y literalesNoMás rápidoBaja
    re.sub()Coincidencia de patrones, reglas complejasSíModeradaMás alta
    str.translate()Mapeo de caracteres individualesNoMuy rápidoBaja
    .replace() encadenadoPocos reemplazos literalesNoRápidoBaja
    Dict + re.sub()Muchos reemplazos simultáneosSíModeradaAlta

    Ejemplos prácticos

    Limpiar y normalizar texto

    import re
 
def clean_text(text):
    """Normalizar texto para procesamiento."""
    text = text.strip()
    text = re.sub(r'\s+', ' ', text)           # Colapsar espacios en blanco
    text = re.sub(r'[^\w\s.,!?-]', '', text)   # Eliminar caracteres especiales
    text = text.lower()
    return text
 
raw = "  Hello!!!   This is    MESSY @#$ text...  "
print(clean_text(raw))
# hello!!! this is messy text...

    Reemplazo de cadenas de plantilla

    template = "Dear {name}, your order #{order_id} ships on {date}."
 
data = {
    'name': 'Alice',
    'order_id': '12345',
    'date': 'Feb 15, 2026',
}
 
# Usar str.format_map (mejor que reemplazo manual)
result = template.format_map(data)
print(result)
# Dear Alice, your order #12345 ships on Feb 15, 2026.

    Redactar datos sensibles

    import re
 
def redact_pii(text):
    """Redactar correos electrónicos, números de teléfono y SSNs."""
    text = re.sub(r'\b[\w.]+@[\w.]+\.\w+\b', '[EMAIL]', text)
    text = re.sub(r'\b\d{3}[-.]?\d{3}[-.]?\d{4}\b', '[TELÉFONO]', text)
    text = re.sub(r'\b\d{3}-\d{2}-\d{4}\b', '[SSN]', text)
    return text
 
msg = "Contact john@example.com or call 555-123-4567. SSN: 123-45-6789"
print(redact_pii(msg))
# Contact [EMAIL] or call [TELÉFONO]. SSN: [SSN]

    Procesamiento de datos de texto en Jupyter

    La limpieza y transformación de texto es un trabajo iterativo -- prueba patrones contra datos de muestra, ajusta regex y verifica resultados. RunCell (opens in a new tab) es un agente de IA para Jupyter que puede ayudarle a construir y depurar pipelines de procesamiento de texto interactivamente, probando patrones de reemplazo contra sus datos reales en tiempo real.

    FAQ

    ¿Cómo reemplazo una subcadena en Python?

    Use str.replace(old, new) para reemplazos simples: "hello world".replace("world", "python") devuelve "hello python". Esto reemplaza todas las ocurrencias. Agregue un tercer argumento para limitar reemplazos: text.replace("a", "b", 2) reemplaza solo las primeras 2 coincidencias.

    ¿Cómo hago un reemplazo insensible a mayúsculas en Python?

    Use re.sub() con la bandera re.IGNORECASE: re.sub(r'python', 'Java', text, flags=re.IGNORECASE). El método integrado str.replace() no soporta coincidencia insensible a mayúsculas.

    ¿Cómo reemplazo múltiples cadenas diferentes a la vez?

    Construya un patrón regex a partir de un diccionario de reemplazos: cree un patrón compilado que coincida con todas las claves, luego use un lambda para buscar el reemplazo de cada coincidencia. Alternativamente, encadene llamadas a .replace() para un pequeño número de reemplazos literales.

    ¿Cuál es la diferencia entre str.replace() y re.sub()?

    str.replace() solo hace coincidencia literal de cadenas -- es más rápido y simple. re.sub() usa expresiones regulares, soportando coincidencia de patrones, grupos de captura, referencias inversas y reemplazos basados en funciones. Use str.replace() para intercambios literales simples y re.sub() cuando necesite flexibilidad de patrones.

    ¿Cómo elimino caracteres de una cadena en Python?

    Tres enfoques: str.replace(char, "") elimina todas las ocurrencias de una subcadena específica. str.translate(str.maketrans("", "", chars)) elimina eficientemente todos los caracteres especificados. re.sub(r"[pattern]", "", text) elimina caracteres que coinciden con un patrón regex.

    Conclusión

    Python ofrece múltiples herramientas para el reemplazo de cadenas, cada una adecuada para diferentes niveles de complejidad. Use str.replace() para intercambios literales simples, re.sub() para coincidencia de patrones y reglas complejas, y str.translate() para mapeo rápido a nivel de caracteres. Para múltiples reemplazos simultáneos, un enfoque de re.sub() basado en diccionario mantiene su código limpio y mantenible.

    📚