如何优化Python中三次连续的str.replace()调用？

Question #

I have the following code:

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

I think these three lines aren't concise enough. I tried using functional programming methods like map but couldn't find a proper implementation. Are there any optimization suggestions?

Answer #

Great question! Those repeated replace calls do feel a bit verbose, and you're right that functional programming tools can clean this up nicely. Let's break down a couple of solid approaches, including why map isn't the best fit here and what to use instead:

1. Use functools.reduce for chained replacements (functional programming approach)

Since we're applying a sequence of transformations to the same string (not processing a list of independent elements), reduce is the perfect functional tool here. It lets us chain all your replace calls into a single expression:

from functools import reduce

expr = '9subtract5equal4'
# Define your replacement pairs as a list of tuples
replacements = [('subtract', '-'), ('plus', '+'), ('equal', '==')]
# Use reduce to apply each replacement sequentially
expr = reduce(lambda current_str, replacement: current_str.replace(*replacement), replacements, expr)

How this works:

• reduce takes a lambda function (that applies one replacement), the list of replacement pairs, and the initial string (expr).
• It iterates over each replacement pair, applying replace to the current version of the string, and passes the result to the next iteration.
• This behaves exactly like your original three replace lines, but in a more concise, maintainable way (you can easily add/remove replacements by updating the list).

2. Use regex for single-pass replacement (efficient for many rules)

If you have a lot of replacement rules, a regex-based approach can be more efficient because it scans the string only once instead of multiple times. Here's how to do it:

import re

expr = '9subtract5equal4'
replace_map = {'subtract': '-', 'plus': '+', 'equal': '=='}
# Create a regex pattern that matches any of the keys
pattern = re.compile('|'.join(replace_map.keys()))
# Replace all matches with their corresponding values
expr = pattern.sub(lambda match: replace_map[match.group()], expr)

Note: This works best if your replacement keywords don't overlap (e.g., no keyword is a substring of another). If they do, you'll want to sort the keys by length (longest first) to avoid partial matches.

Why map isn't ideal here

map is designed to apply a function to each element in an iterable (e.g., converting every string in a list to uppercase). Since we're transforming a single string multiple times, not processing a collection of elements, map doesn't fit the use case. reduce, on the other hand, is made for accumulating a single result from a sequence of operations—exactly what we need for chained replacements.

内容的提问来源于stack exchange，提问作者WW00WW