Wie ersetze ich mehrere Teilzeichenfolgen eines Strings?

Ich möchte die .replace-Funktion verwenden, um mehrere Zeichenfolgen zu ersetzen.

Ich habe derzeit

string.replace("condition1", "")

möchte aber so etwas haben

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

obwohl sich das nicht nach guter Syntax anfühlt

Was ist der richtige Weg, um dies zu tun? Art wie wie in grep / regex Sie tun können , \1und \2Felder auf bestimmte Suchzeichenketten zu ersetzen

Hier ist ein kurzes Beispiel, das den Trick mit regulären Ausdrücken machen sollte:

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)

Beispielsweise:

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

Sie könnten einfach eine nette kleine Schleifenfunktion machen.

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

Dabei texthandelt es sich um die vollständige Zeichenfolge und dicein Wörterbuch. Jede Definition ist eine Zeichenfolge, die eine Übereinstimmung mit dem Begriff ersetzt.

Hinweis : In Python 3 iteritems()wurde durch ersetztitems()

Achtung: Python-Wörterbücher haben keine zuverlässige Reihenfolge für die Iteration. Diese Lösung löst Ihr Problem nur, wenn:

• Die Reihenfolge des Austauschs spielt keine Rolle
• Es ist in Ordnung, wenn ein Ersatz die Ergebnisse früherer Ersetzungen ändert

Zum Beispiel:

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

Mögliche Ausgabe Nr. 1:

"Das ist mein Schwein und das ist mein Schwein."

Mögliche Ausgabe # 2

"Das ist mein Hund und das ist mein Schwein."

Eine mögliche Lösung ist die Verwendung eines 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)

Ausgabe:

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

Vorsicht # 2: Ineffizient, wenn Ihre textZeichenfolge zu groß ist oder das Wörterbuch viele Paare enthält.

Warum nicht eine solche Lösung?

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

Hier ist eine Variante der ersten Lösung mit Reduce, falls Sie funktionsfähig sein möchten. :) :)

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

Martineaus noch bessere Version:

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

Dies ist nur eine präzisere Zusammenfassung der großartigen Antworten von FJ und MiniQuark. Alles, was Sie benötigen, um mehrere Zeichenfolgen gleichzeitig zu ersetzen, ist die folgende Funktion:

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)

Verwendungszweck:

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

Wenn Sie möchten, können Sie ausgehend von dieser einfacheren Funktion Ihre eigenen Ersatzfunktionen erstellen.

Ich habe dies auf FJs ausgezeichneter Antwort aufgebaut:

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)

One-Shot-Verwendung:

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

Da der Austausch in nur einem Durchgang erfolgt, ändert sich "Café" in "Tee", jedoch nicht wieder in "Café".

Wenn Sie denselben Austausch mehrmals durchführen müssen, können Sie einfach eine Ersatzfunktion erstellen:

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

Verbesserungen:

• verwandelte Code in eine Funktion
• Mehrzeilige Unterstützung hinzugefügt
• Ein Fehler beim Entkommen wurde behoben
• Einfach, eine Funktion für einen bestimmten Mehrfachersatz zu erstellen

Genießen! :-)

Ich möchte die Verwendung von Zeichenfolgenvorlagen vorschlagen. Platzieren Sie einfach die zu ersetzende Zeichenfolge in einem Wörterbuch und alles ist festgelegt! Beispiel aus 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'

In meinem Fall brauchte ich ein einfaches Ersetzen eindeutiger Schlüssel durch Namen, also dachte ich mir Folgendes aus:

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

Ab Python 3.8und Einführung von Zuweisungsausdrücken (PEP 572) ( :=Operator) können wir die Ersetzungen innerhalb eines Listenverständnisses anwenden:

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

Hier meine $ 0,02. Es basiert auf Andrew Clarks Antwort, die nur ein wenig klarer ist, und deckt auch den Fall ab, dass eine zu ersetzende Zeichenfolge eine Teilzeichenfolge einer anderen zu ersetzenden Zeichenfolge ist (längere Zeichenfolge gewinnt).

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)

In diesem Kern können Sie es jederzeit ändern, wenn Sie einen Vorschlag haben.

Ich brauchte eine Lösung, bei der die zu ersetzenden Zeichenfolgen reguläre Ausdrücke sein können, um beispielsweise einen langen Text zu normalisieren, indem mehrere Leerzeichen durch ein einzelnes ersetzt werden. Aufbauend auf einer Reihe von Antworten anderer, einschließlich MiniQuark und mmj, habe ich mir Folgendes ausgedacht:

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)

Es funktioniert für die Beispiele in anderen Antworten, zum Beispiel:

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

Die Hauptsache für mich ist, dass Sie auch reguläre Ausdrücke verwenden können, um beispielsweise nur ganze Wörter zu ersetzen oder Leerzeichen zu normalisieren:

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

Wenn Sie die Wörterbuchschlüssel als normale Zeichenfolgen verwenden möchten, können Sie diese vor dem Aufruf von multiple_replace mit folgender Funktion umgehen:

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"

Die folgende Funktion kann dabei helfen, fehlerhafte reguläre Ausdrücke in Ihren Wörterbuchschlüsseln zu finden (da die Fehlermeldung von multiple_replace nicht sehr aussagekräftig ist):

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

Beachten Sie, dass die Ersetzungen nicht verkettet, sondern gleichzeitig ausgeführt werden. Dies macht es effizienter, ohne die Möglichkeiten einzuschränken. Um den Effekt der Verkettung nachzuahmen, müssen Sie möglicherweise nur weitere Zeichenfolgenersatzpaare hinzufügen und die erwartete Reihenfolge der Paare sicherstellen:

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

Hier ist ein Beispiel, das bei langen Saiten mit vielen kleinen Ersetzungen effizienter ist.

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)

Es geht darum, viele Verkettungen langer Zeichenfolgen zu vermeiden. Wir zerlegen die Quellzeichenfolge in Fragmente, ersetzen einige der Fragmente, während wir die Liste bilden, und verbinden dann das Ganze wieder zu einer Zeichenfolge.

Du solltest es wirklich nicht so machen, aber ich finde es einfach viel zu cool:

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

Nun answerist das Ergebnis aller Ersetzungen der Reihe nach

Auch dies ist sehr hackig und sollte nicht regelmäßig verwendet werden. Aber es ist nur schön zu wissen, dass Sie so etwas tun können, wenn Sie es jemals brauchen.

Ich hatte auch mit diesem Problem zu kämpfen. Bei vielen Substitutionen kämpfen reguläre Ausdrücke und sind ungefähr viermal langsamer als Schleifen string.replace(unter meinen Versuchsbedingungen).

Sie sollten unbedingt versuchen, die Flashtext- Bibliothek zu verwenden ( Blog-Beitrag hier , Github hier ). In meinem Fall war es etwas mehr als zwei Größenordnungen schneller, von 1,8 s bis 0,015 s (reguläre Ausdrücke dauerten 7,7 s). für jedes Dokument.

Es ist leicht, Anwendungsbeispiele in den obigen Links zu finden, aber dies ist ein funktionierendes Beispiel:

    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)

Beachten Sie, dass Flashtext Ersetzungen in einem einzigen Durchgang vornimmt (um zu vermeiden, dass a -> b und b -> c 'a' in 'c' übersetzen). Flashtext sucht auch nach ganzen Wörtern (also stimmt 'is' nicht mit 'th is ' überein ). Es funktioniert gut, wenn Ihr Ziel aus mehreren Wörtern besteht (indem Sie "Dies ist" durch "Hallo" ersetzen).

Ich bin der Meinung, dass diese Frage der Vollständigkeit halber eine einzeilige Antwort auf die rekursive Lambda-Funktion benötigt, nur weil. Also da:

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

Verwendungszweck:

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

Anmerkungen:

• Dies verbraucht das Eingabewörterbuch.
• Python-Dikte behalten die Schlüsselreihenfolge ab 3.6 bei. entsprechende Vorbehalte in anderen Antworten sind nicht mehr relevant. Aus Gründen der Abwärtskompatibilität könnte man auf eine Tupel-basierte Version zurückgreifen:

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

Hinweis: Wie bei allen rekursiven Funktionen in Python führt eine zu große Rekursionstiefe (dh zu große Ersatzwörterbücher) zu einem Fehler. Siehe zB hier .

Ich weiß nichts über Geschwindigkeit, aber dies ist meine tägliche schnelle Lösung:

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

... aber ich mag die # 1 Regex Antwort oben. Hinweis - Wenn ein neuer Wert eine Teilzeichenfolge eines anderen ist, ist die Operation nicht kommutativ.

Sie können die pandasBibliothek und die replaceFunktion verwenden, die sowohl exakte Übereinstimmungen als auch Regex-Ersetzungen unterstützt. Zum Beispiel:

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

Und der geänderte Text lautet:

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

Ein Beispiel finden Sie hier . Beachten Sie, dass die Ersetzungen im Text in der Reihenfolge erfolgen, in der sie in den Listen aufgeführt sind

Um nur ein Zeichen zu ersetzen, verwenden Sie das translateund str.maketransist meine Lieblingsmethode.

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

Demo

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.

Ausgehend von der wertvollen Antwort von Andrew entwickelte ich ein Skript, das das Wörterbuch aus einer Datei lädt und alle Dateien im geöffneten Ordner ausarbeitet, um die Ersetzungen vorzunehmen. Das Skript lädt die Zuordnungen aus einer externen Datei, in der Sie das Trennzeichen festlegen können. Ich bin ein Anfänger, aber ich fand dieses Skript sehr nützlich, wenn ich mehrere Ersetzungen in mehreren Dateien vornehme. Es wurde ein Wörterbuch mit mehr als 1000 Einträgen in Sekunden geladen. Es ist nicht elegant, aber es hat bei mir funktioniert

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

Das ist meine Lösung für das Problem. Ich habe es in einem Chatbot verwendet, um die verschiedenen Wörter gleichzeitig zu ersetzen.

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

das wird werden The cat hunts the dog

Ein weiteres Beispiel: Eingabeliste

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

Die gewünschte Ausgabe wäre

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

Code:

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

Oder nur für einen schnellen Hack:

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)

Hier ist eine andere Möglichkeit, dies mit einem Wörterbuch zu tun:

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)