plural2.py

import re

def match_sxz(noun):
    return re.search('[sxz]$', noun)

def apply_sxz(noun):
    return re.sub('$', 'es', noun)

def match_h(noun):
    return re.search('[^aeioudgkprt]h$', noun)

def apply_h(noun):
    return re.sub('$', 'es', noun)

def match_y(noun):
    return re.search('[^aeiou]y$', noun)
       
def apply_y(noun):
    return re.sub('y$', 'ies', noun)

def match_default(moun):
    return 1

def apply_default(noun):
    return noun + 's'

rules = ((match_sxz, apply_sxz),
         (match_h, apply_h),
         (match_y, apply_y),
         (match_default, apply_default)
         )

def plural(noun):
    for matchesRule, applyRule in rules:
        if matchesRule(noun):
            return applyRule(noun)



if __name__ == '__main__':
    import sys
    if sys.argv[1:]:
        print plural(sys.argv[1])
    else:
        print __doc__

  
Using a for loop, you can pull out the match and apply rules two at a time (one match, one apply) from the
rules tuple. On the first iteration of the for loop, matchesRule will get match_sxz, and applyRule
will get apply_sxz. On the second iteration (assuming you get that far), matchesRule will be assigned
match_h, and applyRule will be assigned apply_h.

Remember that everything in Python is an object, including functions. rules contains actual functions; not
names of functions, but actual functions. When they get assigned in the for loop, then matchesRule and
applyRule are actual functions that you can call. So on the first iteration of the for loop, this is equivalent
to calling matches_sxz(noun).
On the first iteration of the for loop, this is equivalent to calling apply_sxz(noun), and so forth.


>>> import plural2
>>> plural2.rules
((, ), (, ), (, ), (, ))




If this additional level of abstraction is confusing, try unrolling the function to see the equivalence. This for loop is
equivalent to the following:


def plural(noun):
    if match_sxz(noun):
        return apply_sxz(noun)
    if match_h(noun):
        return apply_h(noun)
    if match_y(noun):
        return apply_y(noun)
    if match_default(noun):
        return apply_default(noun)

The benefit here is that that plural function is now simplified. It takes a list of rules, defined elsewhere, and iterates
through them in a generic fashion. Get a match rule; does it match? Then call the apply rule. The rules could be
defined anywhere, in any way. The plural function doesn't care.