在函数语言中Curry处理指，给函数闭包输入部分参数，则得到一个新的函数，此函数可以在以后填入剩余的参数后执行原来的函数。 例如在ocaml中

# let aaa a b c = a + b * c;;
val aaa : int -> int -> int -> int = <fun>
# aaa 4 5;;
- : int -> int = <fun>
# let bbb = aaa 4 5;;
val bbb : int -> int = <fun>
# bbb;;
- : int -> int = <fun>
# bbb 8;;
- : int = 44

使用python也可以做到 对函数的伪curry处理, 而使用decorator可以将curry处理的调用变得很简单。源代码如下:
# curry.py
class Curry:
    def __init__(self, function, pending_args = [], pending_kwargs = {}):
        self.func = function
        self.pending_args = pending_args
        self.pending_kwargs = pending_kwargs
        self.arg_count = self.func.func_code.co_argcount
        if self.func.func_defaults:
            self.arg_count -= len(self.func.func_defaults)

    def __call__(self, *args, **kwargs):       
        d = self.pending_kwargs.copy()
        d.update(kwargs)
        l = self.pending_args + list(args)
        if len(l) >= self.arg_count:
            return  self.func(*l, **d)           
        else:
            return Curry(self.func, l, d)

def curry(func):
    def curry_generator(*args, **kwargs):       
        return Curry(func)(*args, **kwargs)
    return curry_generator


使用方法也很简单,只要在需要curry处理的函数定义上增加一个decorator 申明@curry就可以了.

# test_curry.py
from curry import curry

@curry
def aaa( a, b, c, d = 9, **kwargs):
    print kwargs
    return a + b * c – d

def test_main():
    return aaa(1,2)

print test_main()(179)
print aaa(4)(5,6)
print aaa(4,5, d=4)(6, p=23)
print aaa(4,5,6)