¿Cómo reemplazar múltiples subcadenas de una cadena?

Me gustaría usar la función .replace para reemplazar varias cadenas.

Actualmente tengo

string.replace("condition1", "")

pero me gustaría tener algo como

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

aunque eso no parece buena sintaxis

¿Cuál es la forma apropiada de hacer esto? algo así como cómo en grep / regex puedes hacer \1y \2reemplazar campos a ciertas cadenas de búsqueda

Aquí hay un breve ejemplo que debería hacer el truco con expresiones 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 ejemplo:

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

Podrías hacer una pequeña y agradable función de bucle.

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

donde textestá la cadena completa y dices un diccionario: cada definición es una cadena que reemplazará una coincidencia con el término.

Nota : en Python 3, iteritems()se ha reemplazado conitems()

Cuidado: los diccionarios Python no tienen un orden confiable para la iteración. Esta solución solo resuelve su problema si:

• orden de reemplazos es irrelevante
• está bien que un reemplazo cambie los resultados de reemplazos anteriores

Por ejemplo:

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

Salida posible # 1:

"Este es mi cerdo y este es mi cerdo".

Salida posible # 2

"Este es mi perro y este es mi cerdo".

Una posible solución es usar un 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)

Salida:

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

Cuidado # 2: ineficiente si su textcadena es demasiado grande o si hay muchos pares en el diccionario.

¿Por qué no una solución como esta?

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

Aquí hay una variante de la primera solución que usa reducir, en caso de que le guste ser funcional. :)

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

La versión aún mejor de martineau:

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

Esta es solo una recapitulación más concisa de las excelentes respuestas de FJ y MiniQuark. Todo lo que necesita para lograr múltiples reemplazos de cadena simultáneos es la siguiente función:

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

Si lo desea, puede realizar sus propias funciones de reemplazo dedicadas a partir de esta más simple.

Construí esto sobre la excelente respuesta de FJ:

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 un disparo:

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

Tenga en cuenta que dado que el reemplazo se realiza en una sola pasada, "café" cambia a "té", pero no vuelve a "café".

Si necesita hacer el mismo reemplazo muchas veces, puede crear una función de reemplazo fácilmente:

>>> 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!\"

Mejoras:

• convirtió el código en una función
• soporte multilínea agregado
• arreglado un error al escapar
• fácil de crear una función para un reemplazo múltiple específico

¡Disfrutar! :-)

Me gustaría proponer el uso de plantillas de cadena. ¡Simplemente coloque la cadena que se reemplazará en un diccionario y todo está listo! Ejemplo 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'

En mi caso, necesitaba un reemplazo simple de claves únicas con nombres, así que pensé esto:

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

Comenzando Python 3.8, y la introducción de expresiones de asignación (PEP 572) ( :=operador), podemos aplicar los reemplazos dentro de una comprensión 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'

Aquí mis $ 0.02. Se basa en la respuesta de Andrew Clark, un poco más clara, y también cubre el caso cuando una cadena para reemplazar es una subcadena de otra cadena para reemplazar (la cadena más larga gana)

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)

Es en esto en lo esencial , siéntase libre de modificarlo si tiene alguna propuesta.

Necesitaba una solución donde las cadenas a ser reemplazadas pueden ser expresiones regulares, por ejemplo, para ayudar a normalizar un texto largo reemplazando múltiples caracteres de espacios en blanco por uno solo. Partiendo de una cadena de respuestas de otros, incluidos MiniQuark y mmj, esto es lo que se me ocurrió:

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)

Funciona para los ejemplos dados en otras respuestas, por ejemplo:

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

Lo principal para mí es que también puedes usar expresiones regulares, por ejemplo para reemplazar solo palabras enteras o para normalizar espacios en blanco:

>>> 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"

Si desea utilizar las teclas del diccionario como cadenas normales, puede escapar de ellas antes de llamar a multiple_replace utilizando, por ejemplo, esta función:

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"

La siguiente función puede ayudar a encontrar expresiones regulares erróneas entre las teclas del diccionario (ya que el mensaje de error de multiple_replace no es muy revelador):

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())

Tenga en cuenta que no encadena los reemplazos, sino que los realiza simultáneamente. Esto lo hace más eficiente sin limitar lo que puede hacer. Para imitar el efecto del encadenamiento, es posible que solo necesite agregar más pares de reemplazo de cadenas y garantizar el orden esperado de los pares:

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

Aquí hay una muestra que es más eficiente en cadenas largas con muchos reemplazos pequeños.

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)

El punto es evitar muchas concatenaciones de cadenas largas. Cortamos la cadena de origen en fragmentos, reemplazando algunos de los fragmentos a medida que formamos la lista, y luego unimos todo de nuevo en una cadena.

Realmente no deberías hacerlo de esta manera, pero me parece demasiado genial:

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

Ahora, answeres el resultado de todos los reemplazos a su vez.

De nuevo, esto es muy hacky y no es algo que debas usar regularmente. Pero es bueno saber que puedes hacer algo como esto si alguna vez lo necesitas.

Estaba luchando con este problema también. Con muchas sustituciones, las expresiones regulares luchan y son aproximadamente cuatro veces más lentas que los bucles string.replace(en las condiciones de mi experimento).

Debería intentar usar la biblioteca Flashtext ( publicación de blog aquí , Github aquí ). En mi caso , fue un poco más de dos órdenes de magnitud más rápido, de 1.8 sa 0.015 s (las expresiones regulares tomaron 7.7 s) para cada documento.

Es fácil encontrar ejemplos de uso en los enlaces anteriores, pero este es un ejemplo de trabajo:

    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)

Nota que Flashtext hace sustituciones en una sola pasada (para evitar a -> b y b -> c traducción 'a' en 'c'). Flashtext también busca palabras completas (por lo que 'es' no coincidirá con ' es '). Funciona bien si su objetivo son varias palabras (reemplazando 'Esto es' por 'Hola').

Siento que esta pregunta necesita una respuesta de función lambda recursiva de una sola línea para completar, solo porque. Por lo tanto, allí:

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

Uso:

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

Notas:

• Esto consume el diccionario de entrada.
• Python dicts preserva el orden de las claves a partir de 3.6; Las advertencias correspondientes en otras respuestas ya no son relevantes. Por compatibilidad con versiones anteriores, se podría recurrir a una versión basada en tuplas:

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

Nota: Al igual que con todas las funciones recursivas en Python, una profundidad de recursión demasiado grande (es decir, diccionarios de reemplazo demasiado grandes) dará como resultado un error. Ver, por ejemplo, aquí .

No sé acerca de la velocidad, pero esta es mi solución rápida para el día de trabajo:

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

... pero me gusta la respuesta # 1 de expresiones regulares anterior. Nota: si un nuevo valor es una subcadena de otro, entonces la operación no es conmutativa.

Puede usar la pandasbiblioteca y la replacefunción que admite coincidencias exactas y reemplazos de expresiones regulares. Por ejemplo:

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))

Y el texto modificado es:

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

Puedes encontrar un ejemplo aquí . Observe que los reemplazos en el texto se realizan con el orden en que aparecen en las listas

Para reemplazar solo un personaje, use translatey str.maketranses mi método favorito.

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

manifestación

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 de la preciosa respuesta de Andrew, desarrollé un script que carga el diccionario de un archivo y elabora todos los archivos en la carpeta abierta para hacer los reemplazos. El script carga las asignaciones de un archivo externo en el que puede establecer el separador. Soy un principiante, pero este script me pareció muy útil al hacer múltiples sustituciones en múltiples archivos. Cargó un diccionario con más de 1000 entradas en segundos. No es elegante pero funcionó para mí.

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 es mi solución al problema. Lo usé en un chatbot para reemplazar las diferentes palabras a la 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"})

esto se convertirá The cat hunts the dog

Otro ejemplo: lista de entrada

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

La salida deseada sería

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]] 

O simplemente para un truco 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)

Aquí hay otra forma de hacerlo con un diccionario:

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)