10 examples of 'python replace multiple characters in string' in Python

194
def replace(string, old, new):
195
    return string.replace(old, new)

329
def replace_string(self, string, search_for, replace_with, count=-1):
330
    """Replaces ``search_for`` in the given ``string`` with ``replace_with``.
331
332
    ``search_for`` is used as a literal string. See `Replace String
333
    Using Regexp` if more powerful pattern matching is needed.
334
    If you need to just remove a string see `Remove String`.
335
336
    If the optional argument ``count`` is given, only that many
337
    occurrences from left are replaced. Negative ``count`` means
338
    that all occurrences are replaced (default behaviour) and zero
339
    means that nothing is done.
340
341
    A modified version of the string is returned and the original
342
    string is not altered.
343
344
    Examples:
345
    | ${str} =        | Replace String | Hello, world!  | world | tellus   |
346
    | Should Be Equal | ${str}         | Hello, tellus! |       |          |
347
    | ${str} =        | Replace String | Hello, world!  | l     | ${EMPTY} | count=1 |
348
    | Should Be Equal | ${str}         | Helo, world!   |       |          |
349
    """
350
    count = self._convert_to_integer(count, 'count')
351
    return string.replace(search_for, replace_with, count)

34
def replace_escape_char(a_string):
35
    
36
    return _replace_by_regex(a_string, r'\[\s|\n]*')

50
def replace(s, old, new, maxsplit=None):
51
    if maxsplit is None:
52
        return s.replace(old, new)
53
    else:
54
        return s.replace(old, new, maxsplit)

470
def replace(instring, indict):
471
    """
472
    This function provides a simple but effective template system for your html 
473
    pages. Effectively it is a convenient way of doing multiple replaces in a 
474
    single string.
475
    
476
    Takes a string and a dictionary of replacements. 
477
    
478
    This function goes through the string and replaces every occurrence of every 
479
    dicitionary key with it's value.
480
    
481
    ``indict`` can also be a list of tuples instead of a dictionary (or anything 
482
    accepted by the dict function).
483
    """
484
    indict = dict(indict)
485
    if len(indict) > 40:
486
        regex = re.compile("(%s)" % "|".join(map(re.escape, indict.keys())))
487
        # For each match, look-up corresponding value in dictionary
488
        return regex.sub(lambda mo: indict[mo.string[mo.start():mo.end()]],
489
                                                                    instring)
490
    for key in indict:
491
        instring = instring.replace(key, indict[key])
492
    return instring

105
def replace_string(self, string, ignore_errors=False):
106
    """Replaces variables from a string. Result is always a string."""
107
    if not is_string(string):
108
        return unic(string)
109
    if self._cannot_have_variables(string):
110
        return unescape(string)
111
    return self._replace_string(string, ignore_errors=ignore_errors)

4
def replace(data, replacements):
5
    """
6
    Performs several string substitutions on the initial ``data`` string using
7
    a list of 2-tuples (old, new) defining substitutions and returns the resulting
8
    string.
9
    """
10
    return reduce(lambda a, kv: a.replace(*kv), replacements, data)

34
def replaceStrings(instring, mapping):
35
    for before, after in mapping.items():
36
        instring  = instring.replace(before, after)
37
    return instring

220
def string_replace(state):
221
	'''
222
	In third string on stack, replaces all occurences of second string with first string
223
	'''
224
	if len(state.stacks['_string']) > 2:
225
		replace_this = state.stacks['_string'].stack_ref(1)
226
		with_this = state.stacks['_string'].stack_ref(0)
227
		in_this = state.stacks['_string'].stack_ref(2)
228
		new_string = in_this.replace(replace_this, with_this)
229
		state.stacks['_string'].pop_item()
230
		state.stacks['_string'].pop_item()
231
		state.stacks['_string'].pop_item()
232
		state.stacks['_string'].push_item(new_string)
233
	return state

40
def regex_replace(value, pattern, replacement, ignorecase=False, multiline=False):
41
    """Do a regex search and replace on 'value'"""
42
    flags = 0
43
    if ignorecase:
44
        flags |= re.I
45
    if multiline:
46
        flags |= re.M
47
    compiled_pattern = re.compile(pattern, flags=flags)
48
    return compiled_pattern.sub(replacement, str(value))