[EMAIL PROTECTED] wrote: > How do I get some > sort of macro behavior so I don't have to write the same thing over and > over again, but which is also not neatly rolled up into a function, > such as combining the return statements with a printing of <self-name>?
Decorators: http://www.python.org/peps/pep-0318.html > My application has a bunch of functions that must do different things, > then print out their names, and then each call another function before > returning. I'd like to have the last function call and the return in > one statement, because if I forget to manually type it in, things get > messed up. > > (ok, I'm writing a parser and I keep track of the call level with a tab > count, which gets printed before any text messages. So each text > message has a tab count in accordance with how far down the parser is. > Each time a grammar rule is entered or returned from, the tab count > goes up or down. If I mess up and forget to call tabsup() or tabsdn(), > the printing gets messed up. There are a lot of simple cheesy > production rules, [I'm doing this largely as an exercise for myself, > which is why I'm doing this parsing manually], so it's error-prone and > tedious to type tabsup() each time I enter a function, and tabsdn() > each time I return from a function, which may be from several different > flow branches.) def track(func): """Decorator to track calls to a set of functions""" def wrapper(*args, **kwargs): print " "*track.depth + func.__name__, args, kwargs or "" track.depth += 1 result = func(*args, **kwargs) track.depth -= 1 return result return wrapper track.depth = 0 # Then to apply the decorator to a function, e.g.: def f(x): return True # Add this line somewhere after the function definition: f = track(f) # Alternately, if you're using Python 2.4 or newer, just define f as: @track def f(x): return True # Test it: @track def fact(n): """Factorial of n, n! = n*(n-1)*(n-2)*...*3*2""" assert n >= 0 if n < 2: return 1 return n * fact(n-1) @track def comb(n, r): """Choose r items from n w/out repetition, n!/(r!*(n-r)!)""" assert n >= r return fact(n) / fact(r) / fact(n-r) print comb(5, 3) # Output: """ comb (5, 3) fact (5,) fact (4,) fact (3,) fact (2,) fact (1,) fact (3,) fact (2,) fact (1,) fact (2,) fact (1,) 10 """ --Ben -- http://mail.python.org/mailman/listinfo/python-list