Bagaimana cara mengganti banyak substring dari suatu string?

Saya ingin menggunakan fungsi .replace untuk mengganti beberapa string.

Saat ini saya punya

string.replace("condition1", "")

tetapi ingin memiliki sesuatu seperti

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

meskipun itu tidak terasa seperti sintaks yang baik

apa cara yang tepat untuk melakukan ini? seperti bagaimana di grep / regex yang dapat Anda lakukan \1dan \2untuk mengganti bidang ke string pencarian tertentu

Berikut adalah contoh singkat yang harus dilakukan dengan ekspresi reguler:

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)

Sebagai contoh:

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

Anda bisa membuat fungsi looping kecil yang menyenangkan.

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

di mana textstring lengkap dan dickamus - setiap definisi adalah string yang akan menggantikan kecocokan dengan istilah tersebut.

Catatan : dalam Python 3, iteritems()telah diganti denganitems()

Hati-hati: kamus Python tidak memiliki urutan yang dapat diandalkan untuk iterasi. Solusi ini hanya menyelesaikan masalah Anda jika:

• urutan penggantian tidak relevan
• tidak apa-apa untuk penggantian untuk mengubah hasil penggantian sebelumnya

Misalnya:

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

Output yang mungkin # 1:

"Ini babi saya dan ini babi saya."

Output yang mungkin # 2

"Ini anjing saya dan ini babi saya."

Salah satu perbaikan yang mungkin adalah dengan menggunakan 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)

Keluaran:

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

Hati-hati # 2: Tidak efisien jika textstring Anda terlalu besar atau ada banyak pasangan di kamus.

Kenapa tidak ada satu solusi seperti ini?

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

Berikut adalah varian dari solusi pertama menggunakan pengurangan, jika Anda suka menjadi fungsional. :)

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

Martineau versi yang lebih baik:

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

Ini hanyalah rekap singkat dari jawaban bagus FJ dan MiniQuark. Yang Anda butuhkan untuk mencapai beberapa penggantian string simultan adalah fungsi berikut:

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)

Pemakaian:

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

Jika mau, Anda dapat membuat fungsi pengganti khusus Anda sendiri mulai dari yang lebih sederhana ini.

Saya membangun ini berdasarkan jawaban luar biasa 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)

Penggunaan satu tembakan:

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

Perhatikan bahwa karena penggantian dilakukan hanya dalam satu pass, "café" berubah menjadi "tea", tetapi itu tidak berubah kembali menjadi "café".

Jika Anda perlu melakukan penggantian yang sama berkali-kali, Anda dapat membuat fungsi penggantian dengan mudah:

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

Perbaikan:

• mengubah kode menjadi fungsi
• menambahkan dukungan multiline
• memperbaiki bug saat melarikan diri
• mudah untuk membuat fungsi untuk beberapa penggantian tertentu

Nikmati! :-)

Saya ingin mengusulkan penggunaan template string. Cukup tempatkan string yang akan diganti dalam kamus dan semua sudah diatur! Contoh dari 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'

Dalam kasus saya, saya perlu mengganti kunci unik dengan nama, jadi saya memikirkannya:

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

Mulai Python 3.8, dan pengenalan ekspresi penugasan (PEP 572) ( :=operator), kami dapat menerapkan penggantian dalam pemahaman daftar:

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

Di sini $ 0,02 saya. Ini didasarkan pada jawaban Andrew Clark, hanya sedikit lebih jelas, dan itu juga mencakup kasus ketika string untuk menggantikan adalah substring dari string lain untuk mengganti (string yang lebih lama menang)

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)

Dalam inti ini , jangan ragu untuk memodifikasinya jika Anda memiliki proposal.

Saya membutuhkan solusi di mana string yang akan diganti dapat berupa ekspresi reguler, misalnya untuk membantu dalam menormalkan teks yang panjang dengan mengganti beberapa karakter spasi putih dengan yang tunggal. Membangun rangkaian jawaban dari orang lain, termasuk MiniQuark dan mmj, inilah yang saya temukan:

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)

Ini berfungsi untuk contoh yang diberikan dalam jawaban lain, misalnya:

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

Hal utama bagi saya adalah Anda dapat menggunakan ekspresi reguler juga, misalnya untuk mengganti seluruh kata saja, atau untuk menormalkan ruang putih:

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

Jika Anda ingin menggunakan kunci kamus sebagai string normal, Anda dapat menghindarinya sebelum memanggil multiple_replace menggunakan mis. Fungsi ini:

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"

Fungsi berikut dapat membantu menemukan ekspresi reguler yang salah di antara kunci kamus Anda (karena pesan kesalahan dari multiple_replace tidak terlalu memberi tahu):

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

Perhatikan bahwa itu tidak mengikat penggantian, melainkan menjalankannya secara bersamaan. Ini membuatnya lebih efisien tanpa membatasi apa yang dapat dilakukan. Untuk meniru efek rantai, Anda mungkin hanya perlu menambahkan lebih banyak pasangan pengganti-string dan memastikan urutan pasangan yang diharapkan:

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

Inilah contoh yang lebih efisien untuk string panjang dengan banyak penggantian kecil.

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)

Intinya adalah menghindari banyak rangkaian string panjang. Kami memotong string sumber menjadi fragmen, mengganti beberapa fragmen saat kami membentuk daftar, dan kemudian menggabungkan semuanya kembali menjadi string.

Anda seharusnya tidak melakukannya dengan cara ini, tetapi saya merasa itu terlalu keren:

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

Sekarang, answeradalah hasil dari semua penggantian pada gilirannya

sekali lagi, ini sangat hacky dan bukan sesuatu yang harus Anda gunakan secara teratur. Tapi senang mengetahui bahwa Anda dapat melakukan hal seperti ini jika perlu.

Saya juga berjuang dengan masalah ini. Dengan banyak pengganti, ekspresi reguler mengalami kesulitan, dan sekitar empat kali lebih lambat daripada perulangan string.replace(dalam kondisi percobaan saya).

Anda harus benar-benar mencoba menggunakan pustaka Flashtext ( posting blog di sini , Github di sini ). Dalam kasus saya , itu sedikit lebih dari dua urutan besarnya lebih cepat, dari 1,8 detik menjadi 0,015 detik (ekspresi reguler mengambil 7,7 detik) untuk setiap dokumen.

Sangat mudah untuk menemukan contoh penggunaan di tautan di atas, tetapi ini adalah contoh yang berfungsi:

    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)

Perhatikan bahwa Flashtext membuat pergantian dalam satu pass (untuk menghindari a -> b dan b -> c menerjemahkan 'a' ke 'c'). Flashtext juga mencari seluruh kata (jadi 'is' tidak akan cocok dengan 'th is '). Ini berfungsi dengan baik jika target Anda adalah beberapa kata (mengganti 'Ini adalah' dengan 'Halo').

Saya merasa pertanyaan ini membutuhkan jawaban fungsi lambda rekursif single-line untuk kelengkapan, hanya karena. Jadi disana:

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

Pemakaian:

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

Catatan:

• Ini mengkonsumsi kamus input.
• Dicts python mempertahankan urutan kunci pada 3.6; peringatan yang sesuai dalam jawaban lain tidak relevan lagi. Untuk kompatibilitas mundur, orang dapat menggunakan versi berbasis tuple:

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

Catatan: Seperti halnya semua fungsi rekursif dalam python, kedalaman rekursi yang terlalu besar (yaitu kamus pengganti yang terlalu besar) akan menghasilkan kesalahan. Lihat misalnya di sini .

Saya tidak tahu tentang kecepatan tapi ini perbaikan cepat hari kerja saya:

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

... tapi saya suka jawaban regex # 1 di atas. Catatan - jika satu nilai baru adalah substring dari yang lain maka operasi tidak komutatif.

Anda dapat menggunakan pandaspustaka dan replacefungsi yang mendukung kedua kecocokan persis serta penggantian regex. Sebagai contoh:

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

Dan teks yang dimodifikasi adalah:

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

Anda dapat menemukan contoh di sini . Perhatikan bahwa penggantian teks dilakukan dengan urutan mereka muncul dalam daftar

Untuk mengganti hanya satu karakter, gunakan translatedanstr.maketrans adalah favorit saya.

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.

Mulai dari jawaban berharga Andrew i mengembangkan skrip yang memuat kamus dari file dan menguraikan semua file pada folder yang dibuka untuk melakukan penggantian. Script memuat pemetaan dari file eksternal di mana Anda dapat mengatur pemisah. Saya seorang pemula tetapi saya menemukan skrip ini sangat berguna ketika melakukan banyak penggantian dalam beberapa file. Itu memuat kamus dengan lebih dari 1000 entri dalam hitungan detik. Itu tidak elegan tetapi berhasil untuk saya

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

ini solusi saya untuk masalah ini. Saya menggunakannya di chatbot untuk mengganti kata-kata yang berbeda sekaligus.

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

ini akan menjadi The cat hunts the dog

Contoh lain: Daftar input

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

Output yang diinginkan adalah

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

Kode:

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

Atau hanya untuk retasan cepat:

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)

Berikut cara lain melakukannya dengan kamus:

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)