Jak zastąpić wiele podciągów ciągu?

Chciałbym użyć funkcji .replace do zastąpienia wielu ciągów.

Obecnie mam

string.replace("condition1", "")

ale chciałbym mieć coś takiego

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

chociaż nie wydaje się to dobrą składnią

jaki jest właściwy sposób to zrobić? tak jak w grep / regex możesz zrobić \1i \2zamienić pola na określone ciągi wyszukiwania

Oto krótki przykład, który powinien załatwić sprawę z wyrażeniami regularnymi:

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)

Na przykład:

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

Możesz po prostu zrobić przyjemną małą funkcję zapętlania.

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

gdzie textjest kompletnym ciągiem i dicsłownikiem - każda definicja jest ciągiem, który zastąpi dopasowanie do terminu.

Uwaga : w Pythonie 3 iteritems()został zastąpiony przezitems()

Ostrożnie: słowniki Pythona nie mają niezawodnej kolejności iteracji. To rozwiązanie rozwiązuje problem tylko wtedy, gdy:

• kolejność wymiany nie ma znaczenia
• wymiana może zmienić wyniki poprzednich wymian

Na przykład:

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

Możliwe wyjście nr 1:

„To jest moja świnia, a to moja świnia”.

Możliwe wyjście # 2

„To jest mój pies, a to moja świnia”.

Jedną z możliwych poprawek jest użycie polecenia OragedDict.

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)

Wynik:

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

Ostrożnie # 2: Niewystarczające, jeśli textłańcuch jest zbyt duży lub w słowniku jest wiele par.

Dlaczego nie jedno takie rozwiązanie?

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

Oto wariant pierwszego rozwiązania wykorzystującego redukcję, na wypadek gdybyś chciał być funkcjonalny. :)

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

jeszcze lepsza wersja martineau:

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

To tylko bardziej zwięzłe podsumowanie świetnych odpowiedzi FJ i MiniQuark. Wszystko, czego potrzebujesz, aby uzyskać jednoczesne zastępowanie ciągów, to następująca funkcja:

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)

Stosowanie:

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

Jeśli chcesz, możesz stworzyć własne dedykowane funkcje zastępcze, zaczynając od tej prostszej.

Zbudowałem to na doskonałej odpowiedzi 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)

Użycie jednego strzału:

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

Zauważ, że ponieważ wymiana odbywa się w jednym przejściu, „kawiarnia” zmienia się w „herbata”, ale nie zmienia się z powrotem w „kawiarnia”.

Jeśli musisz wykonać tę samą wymianę wiele razy, możesz łatwo utworzyć funkcję zamiany:

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

Ulepszenia:

• zamienił kod w funkcję
• dodano obsługę multilinii
• naprawiono błąd w ucieczce
• łatwo utworzyć funkcję dla określonej wielokrotnej zamiany

Cieszyć się! :-)

Chciałbym zaproponować użycie szablonów ciągów. Wystarczy umieścić ciąg do zamiany w słowniku i wszystko jest ustawione! Przykład z 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'

W moim przypadku potrzebowałem prostej zamiany unikatowych kluczy na nazwy, więc wymyśliłem to:

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

Zaczynając Python 3.8i wprowadzając wyrażenia przypisania (PEP 572) ( :=operator), możemy zastosować zamiany w ramach zrozumienia listy:

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

Oto moje 0,02 $. Opiera się na odpowiedzi Andrew Clarka, nieco jaśniej, i obejmuje również przypadek, gdy ciąg do zastąpienia jest podciągiem innego ciągu do zastąpienia (dłuższy ciąg wygrywa)

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)

To właśnie w tym tego GIST , nie krępuj się go zmodyfikować, jeśli masz jakieś propozycję.

Potrzebowałem rozwiązania, w którym ciągi do zamiany mogą być wyrażeniami regularnymi, na przykład, aby pomóc w normalizacji długiego tekstu przez zastąpienie wielu białych znaków jednym. Opierając się na szeregu odpowiedzi od innych, w tym MiniQuark i mmj, wymyśliłem:

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)

Działa z przykładami podanymi w innych odpowiedziach, na przykład:

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

Najważniejsze dla mnie jest to, że możesz również używać wyrażeń regularnych, na przykład, aby zamieniać tylko całe słowa lub normalizować białe znaki:

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

Jeśli chcesz używać kluczy słownika jako normalnych ciągów znaków, możesz uciec przed nimi przed wywołaniem wielu_replace przy użyciu np. Tej funkcji:

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"

Poniższa funkcja może pomóc w znalezieniu błędnych wyrażeń regularnych wśród kluczy słownika (ponieważ komunikat o błędzie z wielu_replace nie jest zbyt wymowny):

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

Pamiętaj, że nie łączy łańcuchów zamienników, zamiast tego wykonuje je jednocześnie. To sprawia, że ​​jest bardziej wydajny bez ograniczania tego, co może zrobić. Aby naśladować efekt łączenia, konieczne może być dodanie większej liczby par zamieniających łańcuchy i zapewnienie oczekiwanego uporządkowania par:

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

Oto próbka, która jest bardziej wydajna na długich ciągach z wieloma małymi zamiennikami.

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)

Chodzi o to, by uniknąć wielu połączeń długich łańcuchów. Przecinamy łańcuch źródłowy na fragmenty, zastępując niektóre fragmenty podczas tworzenia listy, a następnie łączymy całość z powrotem w łańcuch.

Naprawdę nie powinieneś tego robić w ten sposób, ale uważam to za zbyt fajne:

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

Teraz answerjest wynikiem wszystkich zamian po kolei

znowu, jest to bardzo zuchwałe i nie jest czymś, z czego powinieneś regularnie korzystać. Ale miło jest wiedzieć, że możesz zrobić coś takiego, jeśli zajdzie taka potrzeba.

Walczyłem również z tym problemem. Przy wielu podstawieniach wyrażenia regularne zmagają się i są około czterokrotnie wolniejsze niż zapętlenie string.replace(w warunkach mojego eksperymentu).

Powinieneś bezwzględnie spróbować użyć biblioteki Flashtext ( post na blogu tutaj , Github tutaj ). W moim przypadku było to nieco ponad dwa rzędy wielkości szybciej, od 1,8 s do 0,015 s (wyrażenia regularne trwały 7,7 s) dla każdego dokumentu.

Łatwo jest znaleźć przykłady użycia w powyższych linkach, ale jest to działający przykład:

    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)

Zauważ, że Flashtext dokonuje podstawień w jednym przebiegu (aby uniknąć a -> b i b -> c tłumaczenia „a” na „c”). Flashtext szuka również całych słów (więc „is” nie pasuje do „th is ”). Działa dobrze, jeśli twój cel składa się z kilku słów (zamieniając „To jest” na „Cześć”).

Wydaje mi się, że to pytanie wymaga jednokreskowej rekurencyjnej odpowiedzi na funkcję lambda dla kompletności, tylko dlatego. Więc tam:

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

Stosowanie:

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

Uwagi:

• To zużywa słownik wejściowy.
• Python dyktuje zachowanie kolejności kluczy od wersji 3.6; odpowiednie zastrzeżenia w innych odpowiedziach nie są już istotne. Dla kompatybilności wstecznej można zastosować wersję krotkową:

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

Uwaga: Podobnie jak w przypadku wszystkich funkcji rekurencyjnych w pythonie, zbyt duża głębokość rekurencji (tj. Zbyt duże słowniki zastępcze) spowoduje błąd. Zobacz np . Tutaj .

Nie wiem o prędkości, ale to moja szybka poprawka w dniu pracy:

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

... ale podoba mi się odpowiedź nr 1 powyżej. Uwaga - jeśli jedna nowa wartość jest podciągiem innej, wówczas operacja nie jest przemienna.

Możesz użyć pandasbiblioteki i replacefunkcji, która obsługuje zarówno dokładne dopasowania, jak i zamiany wyrażeń regularnych. Na przykład:

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

Zmodyfikowany tekst to:

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

Można znaleźć przykład tutaj . Zauważ, że zamiany tekstu są wykonywane w kolejności, w jakiej pojawiają się na listach

Aby zastąpić tylko jeden znak, użyj translateistr.maketrans jest moją ulubioną metodą.

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

próbny

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.

Począwszy od cennej odpowiedzi Andrew, opracowałem skrypt, który ładuje słownik z pliku i opracowuje wszystkie pliki w otwartym folderze w celu wykonania zamiany. Skrypt ładuje mapowania z zewnętrznego pliku, w którym można ustawić separator. Jestem początkującym, ale uważam, że ten skrypt jest bardzo przydatny podczas wielokrotnego zastępowania w wielu plikach. Załadował słownik z ponad 1000 pozycji w ciągu kilku sekund. To nie jest eleganckie, ale działało dla mnie

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

to jest moje rozwiązanie problemu. Użyłem go w chatbocie, aby zastąpić różne słowa naraz.

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

to się stanie The cat hunts the dog

Kolejny przykład: lista wprowadzania

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

Pożądane wyjście byłoby

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

Kod :

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

Lub po prostu szybki 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)

Oto inny sposób zrobienia tego za pomocą słownika:

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)