Skip to content

Python String Replace: Guia completo de str.replace() e além

Soren Atelier
Name
Soren Atelier

Updated on

A substituição de strings é uma das operações mais frequentes no processamento de texto. Você precisa limpar entrada de usuário, normalizar formatos de dados, ocultar informações sensíveis ou transformar strings de template. O str.replace() do Python lida com casos simples em uma linha, mas fica aquém quando você precisa de correspondência case-insensitive, padrões regex ou substituições condicionais. Escolher a ferramenta errada significa complicar tarefas simples desnecessariamente ou escrever código frágil para as complexas.

Este guia cobre cada abordagem para substituição de strings em Python -- do básico str.replace() ao re.sub() com regex, translate() no nível de caracteres e padrões práticos para processamento de texto do mundo real.

📚

    str.replace(old, new, count)

    O método mais simples e comum. Substitui todas as ocorrências de old por new. Um count opcional limita o número de substituições.

    text = "Hello World, Hello Python, Hello Everyone"
 
# Substituir todas as ocorrências
print(text.replace("Hello", "Hi"))
# Hi World, Hi Python, Hi Everyone
 
# Substituir apenas as 2 primeiras ocorrências
print(text.replace("Hello", "Hi", 2))
# Hi World, Hi Python, Hello Everyone
 
# Remover uma substring (substituir por string vazia)
messy = "  extra   spaces   here  "
print(messy.replace(" ", ""))
# extraspaceshere

    Comportamento principal

    • Retorna uma nova string (strings são imutáveis em Python)
    • Sensível a maiúsculas/minúsculas por padrão
    • Substitui todas as ocorrências a menos que count seja especificado
    • Retorna a string original inalterada se old não for encontrado
    original = "Python is great"
new = original.replace("great", "awesome")
print(original)  # Python is great (inalterado)
print(new)       # Python is awesome

    Substituição case-insensitive

    str.replace() é sempre sensível a maiúsculas/minúsculas. Para substituição case-insensitive, use re.sub() com a flag re.IGNORECASE.

    import re
 
text = "Python is Great, python is Fun, PYTHON is Everywhere"
 
# Substituição case-insensitive
result = re.sub(r'python', 'Java', text, flags=re.IGNORECASE)
print(result)
# Java is Great, Java is Fun, Java is Everywhere

    Substituição regex com re.sub()

    re.sub(pattern, replacement, string, count, flags) substitui correspondências de um padrão regex.

    import re
 
# Substituir dígitos por '#'
text = "Call 555-1234 or 555-5678"
print(re.sub(r'\d', '#', text))
# Call ###-#### or ###-####
 
# Substituir números de telefone completos
print(re.sub(r'\d{3}-\d{4}', '[OCULTADO]', text))
# Call [OCULTADO] or [OCULTADO]
 
# Substituir múltiplos espaços por um único
messy = "too    many     spaces   here"
print(re.sub(r'\s+', ' ', messy))
# too many spaces here

    Usando grupos de captura

    import re
 
# Trocar nome e sobrenome
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
 
# Adicionar formatação a datas
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

    Usando uma função para substituição dinâmica

    Passe uma função em vez de uma string para substituições condicionais:

    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
 
# Converter para title case apenas palavras 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

    Substituições múltiplas

    Encadear chamadas de 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?

    Substituição baseada em dicionário

    Para muitas substituições, use um dicionário com re.sub():

    import re
 
def multi_replace(text, replacements):
    """Substituir múltiplas substrings usando um dicionário."""
    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

    Substituição no nível de caracteres com translate()

    Para substituir caracteres individuais, str.translate() com str.maketrans() é a opção mais rápida:

    # Substituir caracteres: a->@, e->3, o->0
table = str.maketrans('aeo', '@30')
text = "Hello World"
print(text.translate(table))
# H3ll0 W0rld
 
# Remover caracteres específicos
remove_vowels = str.maketrans('', '', 'aeiouAEIOU')
print("Hello World".translate(remove_vowels))
# Hll Wrld
 
# Substituir E remover em uma única chamada
table = str.maketrans({'a': '@', 'e': '3', ' ': None})
print("apple pie".translate(table))
# @ppl3pi3

    Comparação de métodos

    MétodoMelhor paraRegexVelocidadeFlexibilidade
    str.replace()Substituições simples e literaisNãoMais rápidoBaixa
    re.sub()Correspondência de padrões, regras complexasSimModeradaMais alta
    str.translate()Mapeamento de caracteres individuaisNãoMuito rápidoBaixa
    .replace() encadeadoPoucas substituições literaisNãoRápidoBaixa
    Dict + re.sub()Muitas substituições simultâneasSimModeradaAlta

    Exemplos práticos

    Limpar e normalizar texto

    import re
 
def clean_text(text):
    """Normalizar texto para processamento."""
    text = text.strip()
    text = re.sub(r'\s+', ' ', text)           # Colapsar espaços em branco
    text = re.sub(r'[^\w\s.,!?-]', '', text)   # Remover caracteres especiais
    text = text.lower()
    return text
 
raw = "  Hello!!!   This is    MESSY @#$ text...  "
print(clean_text(raw))
# hello!!! this is messy text...

    Substituição de string de template

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

    Ocultar dados sensíveis

    import re
 
def redact_pii(text):
    """Ocultar e-mails, números de telefone e SSNs."""
    text = re.sub(r'\b[\w.]+@[\w.]+\.\w+\b', '[EMAIL]', text)
    text = re.sub(r'\b\d{3}[-.]?\d{3}[-.]?\d{4}\b', '[TELEFONE]', 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 [TELEFONE]. SSN: [SSN]

    Processamento de dados de texto no Jupyter

    Limpeza e transformação de texto é um trabalho iterativo -- você testa padrões contra dados de amostra, ajusta regex e verifica resultados. RunCell (opens in a new tab) é um agente de IA para Jupyter que pode ajudá-lo a construir e depurar pipelines de processamento de texto interativamente, testando padrões de substituição contra seus dados reais em tempo real.

    FAQ

    Como substituir uma substring em Python?

    Use str.replace(old, new) para substituições simples: "hello world".replace("world", "python") retorna "hello python". Isso substitui todas as ocorrências. Adicione um terceiro argumento para limitar substituições: text.replace("a", "b", 2) substitui apenas as 2 primeiras correspondências.

    Como fazer uma substituição case-insensitive em Python?

    Use re.sub() com a flag re.IGNORECASE: re.sub(r'python', 'Java', text, flags=re.IGNORECASE). O método embutido str.replace() não suporta correspondência case-insensitive.

    Como substituir múltiplas strings diferentes de uma vez?

    Construa um padrão regex a partir de um dicionário de substituições: crie um padrão compilado que corresponda a todas as chaves, então use um lambda para buscar a substituição de cada correspondência. Alternativamente, encadeie chamadas a .replace() para um pequeno número de substituições literais.

    Qual é a diferença entre str.replace() e re.sub()?

    str.replace() faz apenas correspondência literal de strings -- é mais rápido e simples. re.sub() usa expressões regulares, suportando correspondência de padrões, grupos de captura, referências retroativas e substituições baseadas em funções. Use str.replace() para trocas literais simples e re.sub() quando precisar de flexibilidade de padrões.

    Como remover caracteres de uma string em Python?

    Três abordagens: str.replace(char, "") remove todas as ocorrências de uma substring específica. str.translate(str.maketrans("", "", chars)) remove eficientemente todos os caracteres especificados. re.sub(r"[pattern]", "", text) remove caracteres que correspondam a um padrão regex.

    Conclusão

    Python oferece múltiplas ferramentas para substituição de strings, cada uma adequada para diferentes níveis de complexidade. Use str.replace() para trocas literais simples, re.sub() para correspondência de padrões e regras complexas, e str.translate() para mapeamento rápido no nível de caracteres. Para múltiplas substituições simultâneas, uma abordagem de re.sub() baseada em dicionário mantém seu código limpo e manutenível.

    📚