A Python function that does multiple string replace ops in a single pass.

replace.py

import re

def replace(string, substitutions):

    substrings = sorted(substitutions, key=len, reverse=True)
    regex = re.compile('|'.join(map(re.escape, substrings)))
    return regex.sub(lambda match: substitutions[match.group(0)], string)

Your code causes an error if there are non-string values in "substitutions". Numbers for example.

Non-string values should be an error. I could just call str to convert the args to strings, but it makes more sense to leave that to the user, if that's their intention. I don't want to coerce the wrong types, as that's not part of the function's purpose.

In edited version, regex pattern (re.compile) is created once after object is created (and can be cached).

It would be trivial to wrap my function in a function that takes a regex, and returns my function (now only accepting the substitutions, and enclosing the regex):

def f(regex):
    def myfunc(subs): etc(regex, subs)
    return myfunc

It's two extra lines. I'm just not seeing the need for even a simple class, or the purpose of the wacky method names??

You have your point of view, and I have my...
The principles of code readability are important to me.
I try to use lambda functions as little as possible, because they degrade performance and do not support typing.
In addition, I prefer to immediately make the functionality more flexible for adding new features in the future. It seems to me that it is more convenient to add a new methods or protocols than to rewrite everything.
I myself don't really like to use OOP unnecessarily, but I think the principle of encapsulation (in methods for example) is the most important.

PS: I only suggested my version, including your solution. With hope that this will help someone, according to OpenSource spirit.
I'm not attacking your programming principles =)