What do you mean by "usable function literals"? Because Python has them, even if you have to do a bit of work to get them.

    def demo (n):
        def multiplier (m):
            return n * m
        return multiplier

    x5 = demo(5);
    print x5(4)

You can do anything in the inner closure that you might want. The only surprise is scoping - if you want to modify state you need to use a mutable data type because otherwise you'll be instantiating a private variable. But that hoop is easy to handle.

    def demo ():
        counter = [0]
        def increment ():
            counter[0] += 1
        def peek ():
            return counter[0]
        return (increment, peek)

    (increment1, peek1) = demo()
    (increment2, peek2) = demo()
    increment1()
    increment1()
    increment2()
    print peek1()
    print peek2()

So there. Function literals. They work.

But, you say, you really want anonymous classes? Well look up metaprogramming then. Python really has quite good support for it. There is no trouble creating anonymous classes on the fly with their own attributes, functions, and so on. They can even inherit from each other. http://www.voidspace.org.uk/python/articles/metaclasses.shtm... might be a good starting place on this for you.

(Note, I do not recommend metaprogramming unless the solution you make will be reused a lot.)