9 examples of 'python replace character in string' in Python

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)

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

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

52
def replace(match):
53
	s = match.group(0)
54
	try:
55
		return ESCAPE_DCT[s]
56
	except KeyError:
57
		n = ord(s)
58
		if n < 0x10000:
59
			return '\\u{0:04x}'.format(n)
60
			#return '\\u%04x' % (n,)
61
		else:
62
			# surrogate pair
63
			n -= 0x10000
64
			s1 = 0xd800 | ((n >> 10) & 0x3ff)
65
			s2 = 0xdc00 | (n & 0x3ff)
66
			return '\\u{0:04x}\\u{1:04x}'.format(s1, s2)

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

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)

84
def func_replace(context, text, old, new):
85
    return text.replace(old, new)

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

15
def replace(self, input):
16
    # We use regex substitution here, since earlier implementation didn't
17
    # work correctly if there are overlapping strings, i.e. doing
18
    # ' foo foo '.replace(' foo ', ' bar ') gives just ' bar foo '
19
    for source, _source_text, target in self.translations:
20
        input = source.sub(target, input)
21
    return input