How to optimize three consecutive str.replace() calls?

Question

expr='9subtract5equal4'

expr = expr.replace('subtract', '-')
expr = expr.replace('plus', '+')
expr = expr.replace('equal', '==')

I feel the last three lines code are very ugly, so I've tried to optimize using map and other functional programming functions. But I did't find a good way to achieve that. Any suggestions?

What does 'optimize' mean? Run faster? Use less characters? Use less run-time memory? — Jongware, Apr 29 '18 at 14:23
Hmmm, now I think this is a quite stupid question. I'm so sorry for that.. — WW00WW, Apr 29 '18 at 14:40
@Georgy Thank you very much, that's exactly what I want! And sorry for my poor search ability... — WW00WW, Apr 29 '18 at 14:51

Colin Ricardo · Answer 1 · 2018-04-29T14:44:10.443

5

You could do something like this:

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

s = '9subtract5equal4'

d = {
  'subtract': '-',
  'plus': '+',
  'equal': '==',
}

s = replace_all(s, d)

edited Apr 29 '18 at 14:44

answered Apr 29 '18 at 14:31

Colin Ricardo

16,488
11
47
80

score 2 · Answer 2 · answered Apr 29 '18 at 14:31

As it is the code is fine but you could operate directly on the return value at each step:

expr='9subtract5equal4'

expr = expr.replace('subtract', '-') \
    .replace('plus', '+') \
    .replace('equal', '==')

Or even

expr = '9subtract5equal4' \
    .replace('subtract', '-') \
    .replace('plus', '+') \
    .replace('equal', '==')

score 2 · Accepted Answer · answered Apr 29 '18 at 14:32

2

You could just do:

expr = expr.replace('subtract', '-').replace('plus', '+').replace('equal', '==')

Or, you could loop through a dictionary of replacements:

replace = {'subtract': '-', 'plus': '+', 'equal': '='}
for word in replace:
    expr = expr.replace(word, replace[word])

answered Apr 29 '18 at 14:32

Adi219

4,712
2
20
43

you could also use regex define a lambda: "repl = lambda x: expr[x.group(0)]" then call "re.sub('subtract|equal', string="9subtract5equal4", repl=repl)" where expr is a dict with your replacements – Apr 29 '18 at 15:02

score 2 · Answer 4 · answered Apr 29 '18 at 14:33

Create a dictionary that maps from operand name to the symbol:
```
ops = {'subtract':'-', 'add':'+', 'equal':'=='}
```
You can make it as long as you want, which clearly is an optimisation – adding more operands is extremely easy and does not need any further modification.
Loop over your expression using a list comprehension:
```
[x if x.isdigit() else ops[x] for x in re.findall(r'\d+|[a-z]+',expr)]
```
This uses a regex to separate digits and operands, so import re at the start. The regex returns
```
['9', 'subtract', '5', 'equal', '4']
```
and the list comprehension replaces not-digit strings with the items from the dictionary.

Result:

['9', '-', '5', '==', '4']

so you'd use

expr = ''.join([x if x.isdigit() else ops[x] for x in re.findall(r'\d+|[a-z]+',expr)])

to get your output

'9-5==4'

score 1 · Answer 5 · answered Apr 29 '18 at 14:37

Honestly, I would write it the way you wrote it, but if you want to do it "functionally" you probably need to use functools.reduce, as you need to "reduce" a list of substitutions into a single result:

import functools

expr = '9subtract5equal4'

# a list of our replacements, as pairs
REPLACEMENTS = [
    ('subtract', '-'),
    ('plus', '+'),
    ('equal', '=='),
]

result = functools.reduce(
    lambda word, old_new: word.replace(old_new[0], old_new[1]),
    REPLACEMENTS,
    expr
)

Here we just "accumulate" the results of the lambda function, which takes the last "accumulated" word and a substitution pair, and calls .replace() to get the next "accumulated" word.

But really this is not a Pythonic way to solve this problem (there is a reason why reduce got shoved into functools in Python 3), and your original approach is better.

How to optimize three consecutive str.replace() calls?

5 Answers5