Question

I’ve found tons of solutions doing exactly what I’m trying to do WITHOUT lambda…but I’m learning lambda today…

I have a string stri and I’m trying to replace some characters in stri that are all stored in a dictionary.

bad_chars={"\newline":" ","\n": " ", "\b":" ", "\f":" ", "\r":" ", "\t":" ", "\v":" ", "\0x00":" "} and then I want to print stri out all pretty and empty of all of these ugly characters. My current code print’s stri many many times.

format_ugly = lambda stri: [ stri.replace(i,j) for i,j in bad_chars.iteritems()]

Is there a way to make it print once, and with only 1 lambda function?

Answer 1

You can’t really do it that easily and if you could a lambda function is still not designed for your use case.

Multiple replacements like that are done using a regular for loop statement, and a lambda is limited to a single expression. If you have to use a function, use a normal function – it’s entirely equivalent to a lambda function except that it’s not limited to a single expression.

If you really must know how to do it in a single expression, you have three choices:

1) If you use unicode strings (or Python 3), and limit your bad substrings to single characters (i.e. remove "\newline"), you can use the unicode.translate method.

bad_chars = {u"\n": u" ", u"\b": u" ", u"\f": u" ", u"\r": u" ", u"\t": u" ", u"\v": u" ", u"\x00": u" "}
bad_chars_table = dict((ord(k), v) for k, v in bad_chars.iteritems())
translator = lambda s: s.translate(bad_chars_table)
print translator(u"here\nwe\tgo")

2) Use regular expressions:

   translator = lambda s: re.sub(r'[\n\b\f\r\t\v\x00]', ' ', s)

3) You can use reduce which can be used to reduce a sequence using a binary operation, essentially repeatedly calling a function of two arguments with the current value and an element of the sequence to get the next value.

translator = lambda s: reduce(lambda x, (from, to): x.replace(from, to), bad_chars.iteritems(), s)

As you can see, the last solution is much more difficult to understand than:

def translator(s):
    for original, replacement in bad_chars.iteritems():
        s = s.replace(original, replacement)
    return s

And both solutions do the same thing. It’s often better to program for the end, not for the means. For an arbitrary problem a comprehensible single-expression solution wouldn’t exist at all.