Como substituir várias substrings de uma string?

Gostaria de usar a função .replace para substituir várias seqüências de caracteres.

Eu tenho atualmente

string.replace("condition1", "")

mas gostaria de ter algo como

string.replace("condition1", "").replace("condition2", "text")

embora isso não pareça uma boa sintaxe

qual é a maneira correta de fazer isso? tipo como no grep / regex você pode fazer \1e \2substituir os campos por certas strings de pesquisa

Aqui está um pequeno exemplo que deve funcionar com expressões regulares:

import re

rep = {"condition1": "", "condition2": "text"} # define desired replacements here

# use these three lines to do the replacement
rep = dict((re.escape(k), v) for k, v in rep.iteritems()) 
#Python 3 renamed dict.iteritems to dict.items so use rep.items() for latest versions
pattern = re.compile("|".join(rep.keys()))
text = pattern.sub(lambda m: rep[re.escape(m.group(0))], text)

Por exemplo:

>>> pattern.sub(lambda m: rep[re.escape(m.group(0))], "(condition1) and --condition2--")
'() and --text--'

Você poderia apenas criar uma pequena função de loop.

def replace_all(text, dic):
    for i, j in dic.iteritems():
        text = text.replace(i, j)
    return text

onde texté a string completa e dicé um dicionário - cada definição é uma string que substituirá uma correspondência com o termo.

Nota : no Python 3, iteritems()foi substituído poritems()

Cuidado: os dicionários Python não têm uma ordem confiável para iteração. Esta solução só resolve o seu problema se:

• a ordem das substituições é irrelevante
• não há problema em uma substituição alterar os resultados de substituições anteriores

Por exemplo:

d = { "cat": "dog", "dog": "pig"}
my_sentence = "This is my cat and this is my dog."
replace_all(my_sentence, d)
print(my_sentence)

Saída possível # 1:

"Este é o meu porco e este é o meu porco."

Saída possível # 2

"Este é o meu cachorro e este é o meu porco."

Uma correção possível é usar um OrderedDict.

from collections import OrderedDict
def replace_all(text, dic):
    for i, j in dic.items():
        text = text.replace(i, j)
    return text
od = OrderedDict([("cat", "dog"), ("dog", "pig")])
my_sentence = "This is my cat and this is my dog."
replace_all(my_sentence, od)
print(my_sentence)

Resultado:

"This is my pig and this is my pig."

Cuidado # 2: Ineficiente se sua textcorda for muito grande ou se houver muitos pares no dicionário.

Por que não uma solução como essa?

s = "The quick brown fox jumps over the lazy dog"
for r in (("brown", "red"), ("lazy", "quick")):
    s = s.replace(*r)

#output will be:  The quick red fox jumps over the quick dog

Aqui está uma variante da primeira solução usando o método reduzir, caso você queira ser funcional. :)

repls = {'hello' : 'goodbye', 'world' : 'earth'}
s = 'hello, world'
reduce(lambda a, kv: a.replace(*kv), repls.iteritems(), s)

a versão ainda melhor de martineau:

repls = ('hello', 'goodbye'), ('world', 'earth')
s = 'hello, world'
reduce(lambda a, kv: a.replace(*kv), repls, s)

Esta é apenas uma recapitulação mais concisa das ótimas respostas de FJ e MiniQuark. Tudo o que você precisa para obter várias substituições simultâneas de strings é a seguinte função:

def multiple_replace(string, rep_dict):
    pattern = re.compile("|".join([re.escape(k) for k in sorted(rep_dict,key=len,reverse=True)]), flags=re.DOTALL)
    return pattern.sub(lambda x: rep_dict[x.group(0)], string)

Uso:

>>>multiple_replace("Do you like cafe? No, I prefer tea.", {'cafe':'tea', 'tea':'cafe', 'like':'prefer'})
'Do you prefer tea? No, I prefer cafe.'

Se desejar, você pode criar suas próprias funções de substituição dedicadas a partir desta mais simples.

Eu construí isso com base na excelente resposta dos FJs:

import re

def multiple_replacer(*key_values):
    replace_dict = dict(key_values)
    replacement_function = lambda match: replace_dict[match.group(0)]
    pattern = re.compile("|".join([re.escape(k) for k, v in key_values]), re.M)
    return lambda string: pattern.sub(replacement_function, string)

def multiple_replace(string, *key_values):
    return multiple_replacer(*key_values)(string)

Uso de uma tomada:

>>> replacements = (u"café", u"tea"), (u"tea", u"café"), (u"like", u"love")
>>> print multiple_replace(u"Do you like café? No, I prefer tea.", *replacements)
Do you love tea? No, I prefer café.

Observe que, como a substituição é feita em apenas uma passagem, "café" muda para "chá", mas não volta para "café".

Se você precisar fazer a mesma substituição várias vezes, poderá criar uma função de substituição facilmente:

>>> my_escaper = multiple_replacer(('"','\\"'), ('\t', '\\t'))
>>> many_many_strings = (u'This text will be escaped by "my_escaper"',
                       u'Does this work?\tYes it does',
                       u'And can we span\nmultiple lines?\t"Yes\twe\tcan!"')
>>> for line in many_many_strings:
...     print my_escaper(line)
... 
This text will be escaped by \"my_escaper\"
Does this work?\tYes it does
And can we span
multiple lines?\t\"Yes\twe\tcan!\"

Melhorias:

• transformou o código em uma função
• suporte multilinha adicionado
• corrigido um erro ao escapar
• fácil criar uma função para uma substituição múltipla específica

Aproveitar! :-)

Eu gostaria de propor o uso de modelos de string. Basta colocar a string a ser substituída em um dicionário e tudo está pronto! Exemplo de docs.python.org

>>> from string import Template
>>> s = Template('$who likes $what')
>>> s.substitute(who='tim', what='kung pao')
'tim likes kung pao'
>>> d = dict(who='tim')
>>> Template('Give $who $100').substitute(d)
Traceback (most recent call last):
[...]
ValueError: Invalid placeholder in string: line 1, col 10
>>> Template('$who likes $what').substitute(d)
Traceback (most recent call last):
[...]
KeyError: 'what'
>>> Template('$who likes $what').safe_substitute(d)
'tim likes $what'

No meu caso, eu precisava de uma simples substituição de chaves exclusivas por nomes, então pensei nisso:

a = 'This is a test string.'
b = {'i': 'I', 's': 'S'}
for x,y in b.items():
    a = a.replace(x, y)
>>> a
'ThIS IS a teSt StrIng.'

Iniciando Python 3.8e introduzindo expressões de atribuição (PEP 572) ( :=operador), podemos aplicar as substituições dentro de uma compreensão de lista:

# text = "The quick brown fox jumps over the lazy dog"
# replacements = [("brown", "red"), ("lazy", "quick")]
[text := text.replace(a, b) for a, b in replacements]
# text = 'The quick red fox jumps over the quick dog'

Aqui meus $ 0,02. Baseia-se na resposta de Andrew Clark, um pouco mais clara, e também abrange o caso em que uma sequência a ser substituída é uma substring de outra sequência a ser substituída (vitórias mais longas)

def multireplace(string, replacements):
    """
    Given a string and a replacement map, it returns the replaced string.

    :param str string: string to execute replacements on
    :param dict replacements: replacement dictionary {value to find: value to replace}
    :rtype: str

    """
    # Place longer ones first to keep shorter substrings from matching
    # where the longer ones should take place
    # For instance given the replacements {'ab': 'AB', 'abc': 'ABC'} against 
    # the string 'hey abc', it should produce 'hey ABC' and not 'hey ABc'
    substrs = sorted(replacements, key=len, reverse=True)

    # Create a big OR regex that matches any of the substrings to replace
    regexp = re.compile('|'.join(map(re.escape, substrs)))

    # For each match, look up the new string in the replacements
    return regexp.sub(lambda match: replacements[match.group(0)], string)

É nessa essência , sinta-se à vontade para modificá-la se você tiver alguma proposta.

Eu precisava de uma solução em que as seqüências a serem substituídas pudessem ser expressões regulares, por exemplo, para ajudar a normalizar um texto longo, substituindo vários caracteres de espaço em branco por um único. Com base em uma cadeia de respostas de outras pessoas, incluindo MiniQuark e mmj, é isso que eu criei:

def multiple_replace(string, reps, re_flags = 0):
    """ Transforms string, replacing keys from re_str_dict with values.
    reps: dictionary, or list of key-value pairs (to enforce ordering;
          earlier items have higher priority).
          Keys are used as regular expressions.
    re_flags: interpretation of regular expressions, such as re.DOTALL
    """
    if isinstance(reps, dict):
        reps = reps.items()
    pattern = re.compile("|".join("(?P<_%d>%s)" % (i, re_str[0])
                                  for i, re_str in enumerate(reps)),
                         re_flags)
    return pattern.sub(lambda x: reps[int(x.lastgroup[1:])][1], string)

Ele funciona para os exemplos dados em outras respostas, por exemplo:

>>> multiple_replace("(condition1) and --condition2--",
...                  {"condition1": "", "condition2": "text"})
'() and --text--'

>>> multiple_replace('hello, world', {'hello' : 'goodbye', 'world' : 'earth'})
'goodbye, earth'

>>> multiple_replace("Do you like cafe? No, I prefer tea.",
...                  {'cafe': 'tea', 'tea': 'cafe', 'like': 'prefer'})
'Do you prefer tea? No, I prefer cafe.'

O principal para mim é que você também pode usar expressões regulares, por exemplo, para substituir apenas palavras inteiras ou para normalizar o espaço em branco:

>>> s = "I don't want to change this name:\n  Philip II of Spain"
>>> re_str_dict = {r'\bI\b': 'You', r'[\n\t ]+': ' '}
>>> multiple_replace(s, re_str_dict)
"You don't want to change this name: Philip II of Spain"

Se você quiser usar as teclas de dicionário como seqüências normais, poderá escapar delas antes de chamar multiple_replace usando, por exemplo, esta função:

def escape_keys(d):
    """ transform dictionary d by applying re.escape to the keys """
    return dict((re.escape(k), v) for k, v in d.items())

>>> multiple_replace(s, escape_keys(re_str_dict))
"I don't want to change this name:\n  Philip II of Spain"

A função a seguir pode ajudar a encontrar expressões regulares incorretas entre as chaves do seu dicionário (já que a mensagem de erro de multiple_replace não é muito reveladora):

def check_re_list(re_list):
    """ Checks if each regular expression in list is well-formed. """
    for i, e in enumerate(re_list):
        try:
            re.compile(e)
        except (TypeError, re.error):
            print("Invalid regular expression string "
                  "at position {}: '{}'".format(i, e))

>>> check_re_list(re_str_dict.keys())

Observe que ele não encadeia as substituições, mas as executa simultaneamente. Isso o torna mais eficiente sem restringir o que ele pode fazer. Para imitar o efeito do encadeamento, talvez seja necessário adicionar mais pares de substituição de cadeia e garantir a ordem esperada dos pares:

>>> multiple_replace("button", {"but": "mut", "mutton": "lamb"})
'mutton'
>>> multiple_replace("button", [("button", "lamb"),
...                             ("but", "mut"), ("mutton", "lamb")])
'lamb'

Aqui está uma amostra que é mais eficiente em seqüências longas com muitas substituições pequenas.

source = "Here is foo, it does moo!"

replacements = {
    'is': 'was', # replace 'is' with 'was'
    'does': 'did',
    '!': '?'
}

def replace(source, replacements):
    finder = re.compile("|".join(re.escape(k) for k in replacements.keys())) # matches every string we want replaced
    result = []
    pos = 0
    while True:
        match = finder.search(source, pos)
        if match:
            # cut off the part up until match
            result.append(source[pos : match.start()])
            # cut off the matched part and replace it in place
            result.append(replacements[source[match.start() : match.end()]])
            pos = match.end()
        else:
            # the rest after the last match
            result.append(source[pos:])
            break
    return "".join(result)

print replace(source, replacements)

O objetivo é evitar muitas concatenações de seqüências longas. Cortamos a string de origem em fragmentos, substituindo alguns dos fragmentos à medida que formamos a lista e, em seguida, juntamos tudo novamente em uma string.

Você realmente não deve fazê-lo dessa maneira, mas acho muito legal:

>>> replacements = {'cond1':'text1', 'cond2':'text2'}
>>> cmd = 'answer = s'
>>> for k,v in replacements.iteritems():
>>>     cmd += ".replace(%s, %s)" %(k,v)
>>> exec(cmd)

Agora, answeré o resultado de todas as substituições, por sua vez

novamente, isso é muito hacky e não é algo que você deveria usar regularmente. Mas é bom saber que você pode fazer algo assim, se precisar.

Eu estava lutando com esse problema também. Com muitas substituições, as expressões regulares lutam e são cerca de quatro vezes mais lentas que as repetidas string.replace(nas condições da minha experiência).

Você deve absolutamente tentar usar a biblioteca Flashtext ( postagem no blog aqui , Github aqui ). No meu caso , foi um pouco mais do que duas ordens de magnitude mais rápido, de 1,8 sa 0,015 s (expressões regulares levaram 7,7 s) para cada documento.

É fácil encontrar exemplos de uso nos links acima, mas este é um exemplo de trabalho:

    from flashtext import KeywordProcessor
    self.processor = KeywordProcessor(case_sensitive=False)
    for k, v in self.my_dict.items():
        self.processor.add_keyword(k, v)
    new_string = self.processor.replace_keywords(string)

Note-se que Flashtext faz substituições numa única passagem (para evitar a -> b e b -> c traduzindo 'a' em 'c'). O texto em Flash também procura palavras inteiras (portanto, 'is' não corresponderá a 'th is '). Funciona bem se o seu objetivo for várias palavras (substituindo 'Isto é' por 'Olá').

Eu sinto que esta pergunta precisa de uma resposta lambda recursiva de linha única para completar, apenas porque. Então aí:

>>> mrep = lambda s, d: s if not d else mrep(s.replace(*d.popitem()), d)

Uso:

>>> mrep('abcabc', {'a': '1', 'c': '2'})
'1b21b2'

Notas:

• Isso consome o dicionário de entrada.
• Os dicionários Python preservam a ordem das chaves a partir de 3,6; advertências correspondentes em outras respostas não são mais relevantes. Para compatibilidade com versões anteriores, pode-se recorrer a uma versão baseada em tupla:

>>> mrep = lambda s, d: s if not d else mrep(s.replace(*d.pop()), d)
>>> mrep('abcabc', [('a', '1'), ('c', '2')])

Nota: Como em todas as funções recursivas do python, uma profundidade de recursão muito grande (ou seja, dicionários de substituição muito grandes) resultará em um erro. Veja, por exemplo, aqui .

Não sei sobre velocidade, mas esta é a minha solução rápida para o dia-a-dia:

reduce(lambda a, b: a.replace(*b)
    , [('o','W'), ('t','X')] #iterable of pairs: (oldval, newval)
    , 'tomato' #The string from which to replace values
    )

... mas eu gosto da resposta regex nº 1 acima. Nota - se um novo valor for uma substring de outro, a operação não será comutativa.

Você pode usar a pandasbiblioteca e a replacefunção que suporta correspondências exatas e substituições de regex. Por exemplo:

df = pd.DataFrame({'text': ['Billy is going to visit Rome in November', 'I was born in 10/10/2010', 'I will be there at 20:00']})

to_replace=['Billy','Rome','January|February|March|April|May|June|July|August|September|October|November|December', '\d{2}:\d{2}', '\d{2}/\d{2}/\d{4}']
replace_with=['name','city','month','time', 'date']

print(df.text.replace(to_replace, replace_with, regex=True))

E o texto modificado é:

0    name is going to visit city in month
1                      I was born in date
2                 I will be there at time

Você pode encontrar um exemplo aqui . Observe que as substituições no texto são feitas com a ordem em que aparecem nas listas

Para substituir apenas um caractere, use o método translatee str.maketransé o meu favorito.

tl; dr> result_string = your_string.translate(str.maketrans(dict_mapping))

demonstração

my_string = 'This is a test string.'
dict_mapping = {'i': 's', 's': 'S'}
result_good = my_string.translate(str.maketrans(dict_mapping))
result_bad = my_string
for x, y in dict_mapping.items():
    result_bad = result_bad.replace(x, y)
print(result_good)  # ThsS sS a teSt Strsng.
print(result_bad)   # ThSS SS a teSt StrSng.

A partir da resposta preciosa de Andrew, desenvolvi um script que carrega o dicionário de um arquivo e elabora todos os arquivos da pasta aberta para fazer as substituições. O script carrega os mapeamentos de um arquivo externo no qual você pode definir o separador. Sou iniciante, mas achei esse script muito útil ao fazer várias substituições em vários arquivos. Carregou um dicionário com mais de 1000 entradas em segundos. Não é elegante, mas funcionou para mim

import glob
import re

mapfile = input("Enter map file name with extension eg. codifica.txt: ")
sep = input("Enter map file column separator eg. |: ")
mask = input("Enter search mask with extension eg. 2010*txt for all files to be processed: ")
suff = input("Enter suffix with extension eg. _NEW.txt for newly generated files: ")

rep = {} # creation of empy dictionary

with open(mapfile) as temprep: # loading of definitions in the dictionary using input file, separator is prompted
    for line in temprep:
        (key, val) = line.strip('\n').split(sep)
        rep[key] = val

for filename in glob.iglob(mask): # recursion on all the files with the mask prompted

    with open (filename, "r") as textfile: # load each file in the variable text
        text = textfile.read()

        # start replacement
        #rep = dict((re.escape(k), v) for k, v in rep.items()) commented to enable the use in the mapping of re reserved characters
        pattern = re.compile("|".join(rep.keys()))
        text = pattern.sub(lambda m: rep[m.group(0)], text)

        #write of te output files with the prompted suffice
        target = open(filename[:-4]+"_NEW.txt", "w")
        target.write(text)
        target.close()

esta é a minha solução para o problema. Usei-o em um chatbot para substituir as diferentes palavras de uma só vez.

def mass_replace(text, dct):
    new_string = ""
    old_string = text
    while len(old_string) > 0:
        s = ""
        sk = ""
        for k in dct.keys():
            if old_string.startswith(k):
                s = dct[k]
                sk = k
        if s:
            new_string+=s
            old_string = old_string[len(sk):]
        else:
            new_string+=old_string[0]
            old_string = old_string[1:]
    return new_string

print mass_replace("The dog hunts the cat", {"dog":"cat", "cat":"dog"})

isso vai se tornar The cat hunts the dog

Outro exemplo: lista de entrada

error_list = ['[br]', '[ex]', 'Something']
words = ['how', 'much[ex]', 'is[br]', 'the', 'fish[br]', 'noSomething', 'really']

A saída desejada seria

words = ['how', 'much', 'is', 'the', 'fish', 'no', 'really']

Código:

[n[0][0] if len(n[0]) else n[1] for n in [[[w.replace(e,"") for e in error_list if e in w],w] for w in words]] 

Ou apenas para um hack rápido:

for line in to_read:
    read_buffer = line              
    stripped_buffer1 = read_buffer.replace("term1", " ")
    stripped_buffer2 = stripped_buffer1.replace("term2", " ")
    write_to_file = to_write.write(stripped_buffer2)

Aqui está outra maneira de fazer isso com um dicionário:

listA="The cat jumped over the house".split()
modify = {word:word for number,word in enumerate(listA)}
modify["cat"],modify["jumped"]="dog","walked"
print " ".join(modify[x] for x in listA)