Here’s a function you might have written for the “ispeak” language:

def ispeak(text):

    result = ”

    for letter in text:

        if is_vowel(letter):

            result = result + ‘i’

        else:

            result = result + letter

    return result

And here’s a translation function for “Uasi”:

def uasi(text):

    result = ”

    for letter in text:

        if is_vowel(letter):

            idx = (‘aeiou’.find(letter.lower()) + 1) % 5

            subst = ‘aeiou'[idx]

            result = result + subst

        else:

            result = result + letter

    return result

You might also have written a function that translates a text to “l33t” like this:

def leet(text):

    result = ”

    for letter in text:

        if is_vowel(letter):

            subst = ‘4310µ'[‘aeiou’.find(letter)]

            result = result + subst

        else:

            result = result + letter

    return result

One for “Ubbi dubbi”:

def ubbidubbi(text):

    result = ”

    for letter in text:

        if is_vowel(letter):

            result = result + ‘ub’ + letter

        else:

            result = result + letter

    return result

And another one for the “b-language:

def bspeak(text):

    result = ”

    for letter in text:

        if is_vowel(letter):

            result = result + letter + ‘b’ + letter

        else:

            result = result + letter

    return result

If you did all the exercises, you might even have come up with a slightly more complicated function yet for the Scandinavian “robber-speak” language:

def robber(text):

    result = ”

    for letter in text:

        if is_vowel(letter) or letter in ‘ .’:

            result = result + letter

        else:

            result = result + letter + ‘o’ + letter

    return result

As well as a function that encrypts a message using Caesar’s cipher:

def caesar(text):

    result = ”

    for letter in text:

        if letter in ‘ .’:

            result = result + letter

        else:

            shifted = ord(letter.upper()) – 65 + 3

            result = result + chr((shifted % 26) + 65)

    return result

By now surely you’ve noticed that all these functions look very similar, even though they encode distinctly different rules that cannot be covered by simply adding another parameter. Whenever we find ourselves writing almost the same function over and over again it’s a good idea to stop and think about how we can formulate the idea in a more general way. What all of these functions have in common is that they take each letter of an input and according to a rule that’s different for each language either replace it for another text or leave it as is. If we think about the “rule” as a function that takes a letter as its input and returns whatever its rule prescribes, we can formulate a general translation function that does all the rest:

def translate(text, rule):

    result = ”

    for letter in text:

        result = result + rule(letter)

    return result

Notice the parentheses following the word “rule”? We didn’t define any function named “rule”, so how can we call it inside our “translate” function? Remember that “rule” is the name of an input for “translate”, a formal parameter. The actual value will be a function, not its result. That function can be any function, and it will be assigned to the parameter – a variable – named “rule”. Adding parentheses will then evaluate whichever function we give it.

Now we can reformulate the individual language-functions so they don’t have to deal with taking a text apart and putting it back together again. Instead we can write them in such a way that they can decide what to do to an individual character. Here’s how we can write this for the “ispeak” language:

def ispeak(letter):

    if is_vowel(letter):

        return ‘i’

    return letter

or even more concisely by using an inline version of the “if” statement, called a “ternary operator”:

def ispeak(letter):

    return ‘i’ if is_vowel(letter) else letter

We can translate our story to “ispeak” by calling the “translate” function on the story and by passing in the translation rule as another input:

translate(story, ispeak)

Notice that the second input named “ispeak” is not written with trailing parentheses, even though it is a function that we’ve already defined. Remember what happens when we “forget” to add parentheses when entering a function at the command prompt?

>>> ispeak

We get a reference to the function itself:

<function ispeak at 0x10abc5268>

This lets us call our “translate” function and let it operate on any rule we can formulate as a function!

The translation rules for our other six play-languages can also each be written much more concise:

def uasi(letter):

    if is_vowel(letter):

        return ‘aeiou'[(‘aeiou’.find(letter.lower()) + 1) % 5]

    return letter

def leet(letter):

    if is_vowel(letter):

        return ‘4310µ'[‘aeiou’.find(letter)]

    return letter

def ubbidubbi(letter):

    return ‘ub’ + letter if is_vowel(letter) else letter

def bspeak(letter):

    if is_vowel(letter):

        return letter + ‘b’ + letter

    return letter

def robber(letter):

    if is_vowel(letter) or letter in ‘ .’:

        return letter

    return letter + ‘o’ + letter

def caesar(letter):

    if letter in ‘ .’:

        return letter

    return chr(((ord(letter.upper()) – 65 + 3) % 26) + 65)

And now, finally, we can write a simple program that displays our story in all the seven play-languages we’ve defined in a single function call:

for rule in [ispeak, uasi, leet, ubbidubbi, bspeak,

robber, caesar]:

print(translate(story, rule))

And get all of them instantly:

Thi qiick briwn fix jimps ivir thi lizy dig.

Thi qaock bruwn fux jamps uvir thi lezy dug.

Th3 qµ1ck br0wn f0x jµmps 0v3r th3 l4zy d0g.

Thube qubuubick brubown fubox jubumps ubovuber thube lubazy dubog.

Thebe qubuibick brobown fobox jubumps oboveber thebe labazy dobog.

ToThohe qoquicockok bobrorowownon fofoxox jojumompopsos ovoveror tothohe lolazozyoy dodogog.

WKH TXLFN EURZQ IRA MXPSV RYHU WKH ODCB GRJ.