Clever Geek Handbook

A similar function for php str_replace in python?

Is there a similar function in python that takes search (array) and replace (array) as a parameter? Then it takes the value from each array and uses them to find and replace the object (string).

I know I can achieve this using for loops, but just looking in a more elegant way.

+2


source to share


4 answers


I believe the answer is no.

I would list your search / replace strings in a list and repeat it:

edits = [(search0, replace0), (search1, replace1), (search2, replace2)] # etc.
for search, replace in edits:
    s = s.replace(search, replace)


Even if python had the str_replace

-style function , I think I will still highlight find / replace strings as a list, so it really only takes one extra line of code.

Finally, it is a programming language. If it doesn't provide the function you want, you can always define it yourself.

+11


source


Heh - you can use a one-line snapshot whose elegance is second only to its convenience: -P

(acts like PHP when the search is longer than the replacement, if I read it correctly in the PHP docs.):



**** Edit: This new version works for all substrings that need to be replaced. ****

>>> subject = "Coming up with these convoluted things can be very addictive."
>>> search = ['Coming', 'with', 'things', 'addictive.', ' up', ' these', 'convoluted ', ' very']
>>> replace = ['Making', 'Python', 'one-liners', 'fun!']
>>> reduce(lambda s, p: s.replace(p[0],p[1]),[subject]+zip(search, replace+['']*(len(search)-len(replace))))
'Making Python one-liners can be fun!'
+2


source


Do it with regular expressions:

import re

def replace_from_list(replacements, str):
    def escape_string_to_regex(str):
        return re.sub(r"([\\.^$*+?{}[\]|\(\)])", r"\\\1", str)

    def get_replacement(match):
        return replacements[match.group(0)]

    replacements = dict(replacements)
    replace_from = [escape_string_to_regex(r) for r in replacements.keys()]
    regex = "|".join(["(%s)" % r for r in replace_from])
    repl = re.compile(regex)

    return repl.sub(get_replacement, str)

# Simple replacement:
assert replace_from_list([("in1", "out1")], "in1") == "out1"

# Replacements are never themselves replaced, even if later search strings match
# earlier destination strings:
assert replace_from_list([("1", "2"), ("2", "3")], "123") == "233"

# These are plain strings, not regexps:
assert replace_from_list([("...", "out")], "abc ...") == "abc out"

Using regular expressions to do this speeds up searches. It will not substitute a replacement for a replacement for subsequent replacements that would normally be required.

+1


source


Made a tiny recursive function for this

def str_replace(sbjct, srch, rplc):
    if len(sbjct) == 0:
        return ''

    if len(srch) == 1:
        return sbjct.replace(srch[0], rplc[0])

    lst = sbjct.split(srch[0])
    reslst = []
    for s in lst:
        reslst.append(str_replace(s, srch[1:], rplc[1:]))
    return rplc[0].join(reslst);
0


source






More articles:


All Articles