Comment remplacer plusieurs sous-chaînes d'une chaîne de caractères?

Voici un court exemple qui devrait faire l'affaire avec des expressions régulières:

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)

Par exemple:

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

Ici est une variante de la première solution à l'aide de réduire, dans le cas où vous aimez être fonctionnelle. 🙂

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

martineau est encore mieux version:

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

C'est juste un plus concis récapitulatif de F. J et MiniQuark de grandes réponses. Tous vous avez besoin pour réaliser multiples et simultanées de la chaîne de remplacement est la fonction suivante:

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)

Utilisation:

>>>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 vous le souhaitez, vous pouvez faire votre propre dédié fonctions de remplacement à partir de ce plus simple.

Je voudrais proposer l'utilisation de la chaîne de modèles. Il suffit de placer la chaîne à être remplacé dans un dictionnaire et tout est réglé! Exemple 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'

Ici mon de 0,02$. Il est basé sur Andrew Clark réponse, juste un peu plus clair, et il couvre également le cas lorsqu'une chaîne de caractères à remplacer une sous-chaîne d'une autre chaîne de caractères à remplacer (à longue chaîne victoires)

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)

C'est dans ce ce gist, n'hésitez pas à modifier si vous avez la moindre proposition.

J'ai besoin d'une solution où les chaînes de caractères à remplacer peut être une des expressions régulières,
par exemple, pour aider à normaliser un long texte, en remplaçant plusieurs caractères espace avec un seul. Bâtiment sur une chaîne de réponses des autres, y compris MiniQuark et mmj, c'est ce que je suis venu avec:

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)

Il travaille pour les exemples donnés dans d'autres réponses, par exemple:

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

La chose principale pour moi est que vous pouvez utiliser des expressions régulières ainsi, par exemple, de remplacer les mots entiers uniquement, ou à normaliser l'espace blanc:

>>> 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 vous souhaitez utiliser le dictionnaire clés comme normal chaînes,
vous pouvez échapper à ceux d'avant l'appel de multiple_replace par exemple à l'aide de cette fonction:

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 fonction suivante peut vous aider à trouver erronée des expressions régulières entre vos clés de dictionnaire (depuis le message d'erreur de multiple_replace n'est pas très parlant):

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

Noter qu'il n'enchaîne pas les remplacements, plutôt effectue simultanément. Cela le rend plus efficace sans pour autant nuire à ce qu'il peut faire. Pour imiter l'effet de chaînage, vous aurez juste besoin d'ajouter plus de chaîne de remplacement des paires et de garantir les attendus de la commande de l'paires:

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

Vous devriez vraiment pas faire de cette façon, mais je trouve ça juste trop cool:

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

Maintenant, answer est le résultat de tous les remplacements à son tour

encore une fois, c'est très hacky et n'est pas quelque chose que vous devriez être en utilisant régulièrement. Mais c'est juste agréable de savoir que vous pouvez faire quelque chose comme cela, si jamais vous avez besoin de.

Je ne sais pas à propos de la vitesse, mais c'est mon quotidien quick fix:

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

... mais j'aime bien le n ° 1 de la regex de la réponse ci-dessus. Remarque - si une nouvelle valeur est une sous-chaîne d'une autre puis l'opération n'est pas commutative.

Voici un autre moyen de le faire avec un dictionnaire:

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)

c'est ma solution pour le problème. Je l'ai utilisé dans un chatbot, de remplacer les différents mots à la fois.

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

cela va devenir The cat hunts the dog