Як замінити кілька підрядків рядка?

Я хотів би використовувати .replace функцію для заміни декількох рядків.

На даний момент я маю

string.replace("condition1", "")

але хотілося б мати щось подібне

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

хоча це не відчуває себе гарним синтаксисом

який правильний спосіб це зробити? на кшталт того, як у grep / regex ви можете зробити \1та \2замінити поля певним рядкам пошуку

Ось короткий приклад, який повинен робити трюк з регулярними виразами:

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)

Наприклад:

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

Ви можете просто зробити гарну маленьку функцію циклічного циклу.

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

де textповна рядок і dicє словник - кожне визначення - це рядок, який замінить відповідність терміну.

Примітка : у Python 3 iteritems()замінено наitems()

Обережно: словники Python не мають надійного порядку ітерації. Це рішення вирішує вашу проблему лише в тому випадку, якщо:

• порядок заміни не має значення
• нормально, щоб заміна змінила результати попередніх замін

Наприклад:

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

Можливий вихід №1:

"Це моя свиня, і це моя свиня".

Можливий вихід №2

"Це моя собака, і це моя свиня".

Одне з можливих виправлень - використовувати OrdersDict.

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)

Вихід:

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

Обережно № 2: Неефективна, якщо ваш textрядок занадто великий або в словнику багато пар.

Чому б не одне таке рішення?

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

Ось варіант першого рішення з використанням зменшення, якщо вам подобається функціонувати. :)

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

ще краща версія мартіно:

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

Це лише більш стислий підсумок чудових відповідей FJ та MiniQuark. Все, що вам потрібно для досягнення кількох одночасних замін рядків, це наступна функція:

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)

Використання:

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

За бажанням ви можете зробити власні спеціальні функції заміни, починаючи з цієї більш простої.

Я будував це на чудовій відповіді 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)

Використання одного знімка:

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

Зауважте, що оскільки заміна виконується всього за один прохід, "кафе" переходить на "чай", але воно не змінюється назад на "кафе".

Якщо вам потрібно зробити одну і ту ж заміну багато разів, ви можете легко створити функцію заміни:

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

Покращення:

• перетворив код у функцію
• додано багатолінійну підтримку
• виправлено помилку у втечі
• легко створити функцію для певної багаторазової заміни

Насолоджуйтесь! :-)

Я хотів би запропонувати використання шаблонів рядків. Просто розмістіть рядок, який потрібно замінити, у словнику і все встановлено! Приклад з 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'

У моєму випадку мені потрібна була проста заміна унікальних ключів іменами, тому я придумав це:

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

Починаючи Python 3.8та вводячи вирази призначення (PEP 572) ( :=оператор), ми можемо застосувати заміни в межах розуміння списку:

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

Тут мій 0,02 долара. Він заснований на відповіді Ендрю Кларка, лише трохи зрозуміліше, і він також охоплює випадок, коли рядок, яку потрібно замінити, є підрядком іншої рядки, яку потрібно замінити (довга струна виграє)

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)

Саме в цій суті , сміливо змінюйте його, якщо у вас є якісь пропозиції.

Мені потрібно було рішення, де рядки, які слід замінити, можуть бути звичайними виразами, наприклад, щоб допомогти нормалізувати довгий текст, замінивши кілька символів пробілу на один. Спираючись на ланцюжок відповідей інших, включаючи MiniQuark і mmj, ось що я придумав:

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)

Це працює для прикладів, наведених в інших відповідях, наприклад:

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

Головне для мене, що ви можете також використовувати регулярні вирази, наприклад, замінити лише цілі слова або нормалізувати пробіл:

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

Якщо ви хочете використовувати клавіші словника як звичайні рядки, ви можете уникнути цих, перш ніж викликати multiple_replace, використовуючи, наприклад, цю функцію:

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"

Наступна функція може допомогти у знаходженні помилкових регулярних виразів серед ваших словникових клавіш (оскільки повідомлення про помилку від multiple_replace не дуже вказує):

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

Зауважте, що він не ланцюговує заміни, а виконує їх одночасно. Це робить його більш ефективним, не обмежуючи, що він може зробити. Щоб імітувати ефект ланцюжка, можливо, вам просто потрібно буде додати більше пар заміни рядків і забезпечити очікуване впорядкування пар:

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

Ось зразок, який є більш ефективним на довгих струнах з багатьма невеликими замінами.

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)

Сенс полягає в тому, щоб уникнути безлічі сполучень довгих струн. Ми подрібнюємо вихідний рядок до фрагментів, замінюючи деякі фрагменти під час формування списку, а потім приєднуємо всю річ назад до рядка.

Ви дійсно не повинні робити це так, але я просто вважаю це занадто крутим:

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

Тепер, answerпо черзі , це результат усіх замін

знову ж таки, це дуже хакі, і це не те, що вам слід регулярно користуватися. Але просто приємно знати, що ти можеш зробити щось подібне, якщо коли-небудь буде потрібно.

Я також боровся з цією проблемою. З багатьма замінами регулярні вирази борються, і приблизно в чотири рази повільніше, ніж циклічні string.replace(в моїх умовах експерименту).

Вам слід абсолютно спробувати скористатися бібліотекою Flashtext ( повідомлення в блозі тут , Github тут ). У моєму випадку це було трохи більше, ніж на два порядки швидше, від 1,8 с до 0,015 с (звичайні вирази займали 7,7 с) для кожного документа.

Легко знайти приклади використання за посиланнями вище, але це робочий приклад:

    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)

Зауважте, що Flashtext робить заміну за один прохід (щоб уникнути a -> b і b -> c, перекладаючи "a" на "c"). Flashtext також шукає цілі слова (тому "є" не збігається з " це є "). Це добре працює, якщо у вашої цілі кілька слів (замінивши "Це" на "Привіт").

Я вважаю, що це питання потребує однорядкової рекурсивної функції лямбда для повноти, просто тому. Так що:

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

Використання:

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

Примітки:

• Це споживає словник введення.
• Піктони Python зберігають ключовий порядок станом на 3,6; відповідні застереження в інших відповідях більше не актуальні. Для зворотної сумісності можна вдатися до версії на основі кортежу:

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

Примітка: Як і у всіх рекурсивних функцій python, занадто велика глибина рекурсії (тобто занадто великі словники заміщення) призведе до помилки. Дивіться, наприклад, тут .

Я не знаю про швидкість, але це мій робочий день швидкого виправлення:

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

... але мені подобається відповідь-регекс №1 вище. Примітка - якщо одне нове значення є підрядком іншого, то операція не є комутативною.

Ви можете використовувати pandasбібліотеку та replaceфункцію, яка підтримує як точні збіги, так і заміни регулярного вираження. Наприклад:

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

І змінений текст:

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

Ви можете знайти приклад тут . Зауважте, що заміни на тексті проводяться в тому порядку, який вони відображаються у списках

Для заміни лише одного символу використовуйте translateі str.maketransмій улюблений метод.

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

демонстрація

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.

Починаючи з дорогоцінної відповіді Ендрю, я розробив сценарій, який завантажує словник з файлу та опрацьовує всі файли у відкритій папці, щоб зробити заміни. Сценарій завантажує відображення із зовнішнього файлу, в якому можна встановити роздільник. Я початківець, але мені здалося, що цей скрипт дуже корисний при здійсненні декількох підстановок у кількох файлах. Він завантажив словник з більш ніж 1000 записами за секунди. Це не елегантно, але це працювало для мене

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

це моє вирішення проблеми. Я використовував це в чаті, щоб замінити відразу різні слова.

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

це стане The cat hunts the dog

Інший приклад: Список вводу

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

Бажаний вихід буде

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

Код:

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

Або просто для швидкого злому:

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)

Ось ще один спосіб зробити це зі словником:

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)