Jeff Epler wrote: > Are there only a few, unchanging templates? If so, (dynamiclly) create > a function for each template. This will be nearly the fastest you can > go in Python, excluding the time to create and byte-compile the nesting > function. > > # This code is in the public domain > def make_nesting_expression(l, s): > result = [] > for c in l: > if isinstance(c, list): > sub, s = make_nesting_expression(c, s) > result.append(sub) > else: > result.append("l[%d]" % s) > s += 1 > print "make_nesting_expression", l, result > return "[" + ",".join(result) + "]", s > > def make_nesting_function(l): > return eval("lambda l: %s" % make_nesting_expression(l, 0)[0]) > > t = [['a1','a2'],['b1'],['c1'],['d1']] > l = [1, 2, 3, 4, 5] > f = make_nesting_function(t) > print f(l) > > Jeff
Nice approach! Though I'm wondering, because the "template" is so close to the function you're trying to create, why not just create the function directly? As in: >>> f5 = lambda p: (p[0:2], p[2], p[3], p[4]) >>> f5(('a', 'b', 'c', 'd', 'e', 'f')) (('a', 'b'), 'c', 'd', 'e') Or if you need to be able to remember what the template looks like (e.g. reading/writing it as a string in a file), you can always create the function by evaluating a (properly constructed) template string: >>> f5 = eval("lambda p: (p[0:2], p[2], p[3], p[4])") >>> f5(('a', 'b', 'c', 'd', 'e', 'f')) (('a', 'b'), 'c', 'd', 'e') If you want to avoid lambdas, the same ideas can be used with short defs, e.g.: def f5(p): return (p[0:2], p[2], p[3], p[4]) Incidentally, these solutions raise an IndexError if your list is too short, and silently drop the end of a list that's too long. That's my keep-it-simple-I-might-understand-it approach. Jason -- http://mail.python.org/mailman/listinfo/python-list