Python Lambda Practice

I will show three approaches in pairs, each time doing it via lambda and then via the equivalent generator expression. It's important to understand that generator expressions (and list comprehensions) are simply syntactic sugar for a pair of map and filter operations, and can be translated back and forth mechanically. However, the expression/comprehension way is generally considered more Pythonic.

The key to a problem like this is that you have to figure out what you want to do in the filter and what you want to do in the map. That is: you have to be able to write code that looks at one element and decides whether or not to include it; as well as code that looks at one element and transforms it into a more usable value.

So before we show the code, let's make sure that we can:

• given a letter, determine whether it is contained within our vowels string. That is trivial: we can literally ask Python whether letter in vowels (assuming letter is some variable - but beware that with vowels being a string, this does a substring search; you should convert vowels to a set first). To make a lambda out of that, we simply write: lambda letter: letter in vowels. (We can use whatever variable names we like here: it's the same as writing a function.)

• given a letter, translate it into a 1 if it is a vowel, and a 0 otherwise. Actually, using the letter in vowels result will work just as well, because that returns True or False, and those are usable as numeric values 1 and 0 respectively. Depending on how you interpret the Python axiom explicit is better than implicit, you might instead prefer to write int(letter in vowels), or even 1 if letter in vowels else 0. To cut down on the number of examples, I will just use letter in vowels, even though in my own code I'm fond of that last one :)

Also, let's simplify. As I noted earlier, our vowels should be a set. I will show that only once, here: vowels = set("AEIOUaeiou"). The functions shown below, naturally, assume that's a global ;) Finally, note that there is no reason to treat an empty string differently. You can perfectly well iterate over an empty string, find no elements, sum them to 0, find its length to be 0, etc. It does not change the logic at all. Special cases aren't special enough.

Onward to full code.

We can do what you wanted to do, which is: include elements that are vowels, and perform no transformation - determine the result by the length of the resulting vowel list.

def vowels_by_filter(string):
    return len(filter(lambda letter: letter in vowels, string))

def vowels_by_filter_expression(string):
    return len(letter for letter in string if letter in vowels)

Or we can transform all the letters to 1 or 0 (i.e., the "number of vowels" that each letter contains), and add up the results:

def vowels_by_map(string):
    return sum(map(lambda letter: letter in vowels, string))

def vowels_by_map_expression(string):
    return sum(letter in vowels for letter in string)

Or we can combine those approaches - include only the elements that are vowels, and then transform them to 1 (since everything we include is a vowel, it must transform to 1, and we don't need to check the value again):

def vowels_by_both(string):
    return sum(map(lambda letter: 1, filter(lambda letter: letter in vowels, string)))

def vowels_by_full_expression(string):
    return sum(1 for letter in string if letter in vowels)

The equivalence in each pair should be fairly obvious. With a generator expression (or list comprehension), the part before for is our map, and the part at the end after if (if included) is our filter. We always have to write a "map" with these (even if the transformation is the equivalent of lambda x: x), but it saves us from having to write out the full lambda syntax, and we use the same free variable for both the "map" and the "filter", when present (i.e., our iteration variable, the letter in for letter in string).