Question

我正试图在座标上写一个治愈器。我是:

def curry(fun):    
    cache = []
    numargs = fun.func_code.co_argcount
    
    def new_fun(*args, **kwargs):
        print(args)
        print(kwargs)
        cache.extend(list(args))        
        if len(cache) >= numargs: # easier to do it explicitly than with exceptions            
            temp = []
            for _ in xrange(numargs):
                temp.append(cache.pop())
            fun(*temp)
            
    return new_fun

@curry
def myfun(a,b):
    print(a,b)

在以下案件中,这部法律课以罚款:

myfun(5)
myfun(5)

对于以下案件,它未能做到:

myfun(6)(7)

我如何能够正确这样做?

_{If you re just looking to bind arguments to a function and aren t interested in a specific design or the underlying computer science principles, see Python Argument Binders.}

Answer 1

以下是一些更准确的例子,即“购买花on”。

def curry(x, argc=None):
    if argc is None:
        argc = x.func_code.co_argcount
    def p(*a):
        if len(a) == argc:
            return x(*a)
        def q(*b):
            return x(*(a + b))
        return curry(q, argc - len(a))
    return p

@curry
def myfun(a,b,c):
    print  %d-%d-%d  % (a,b,c)



myfun(11,22,33)
myfun(44,55)(66)
myfun(77)(88)(99)

Answer 2

curry , 载于。

https://github.com/pytoolz/toolz/blob/master/toolz/functoolz.py

该科处理rg、 k、建筑功能和错误处理。它甚至把脚印重新排在 cur子上。

Answer 3

这里的许多答复未能解决这样一种事实,即一项治愈功能只应有一个论点。

A quote from Wikipedia:

In mathematics and computer science, currying is the technique of translating the evaluation of a function that takes multiple arguments (or a tuple of arguments) into evaluating a sequence of functions, each with a single argument (partial application).

选择使之脱钩 <> > > 重度和 <<> 无>>>> 代码>co_argcount<>/code>为一种体面的解决方案。

from functools import partial, wraps, reduce def curry(f): @wraps(f) def _(arg): try: return f(arg) except TypeError: return curry(wraps(f)(partial(f, arg))) return _ def uncurry(f): @wraps(f) def _(*args): return reduce(lambda x, y: x(y), args, f) return _

As shown above, it is also fairly trivial to write an uncurry decorator. :) Unfortunately, the resulting uncurried function will allow any number of arguments instead of requiring a specific number of arguments, as may not be true of the original function, so it is not a true inverse of curry. The true inverse in this case would actually be something like unwrap, but it would require curry to use functools.wraps or something similar that sets a __wrapped__ attribute for each newly created function:

def unwrap(f): try: return unwrap(f.__wrapped__) except AttributeError: return f

Answer 4

This one is fairly simple and doesn t use inspect or examine the given function s args

import functools


def curried(func):
    """A decorator that curries the given function.

    @curried
    def a(b, c):
        return (b, c)

    a(c=1)(2)  # returns (2, 1)
    """
    @functools.wraps(func)
    def _curried(*args, **kwargs):
        return functools.partial(func, *args, **kwargs)
    return _curried

Answer 5

当我冷静地书写粉饰时,我曾尝试过地雷:。

def curry(func):
    def curried(*args, **kwargs):
        if len(args) + len(kwargs) >= func.__code__.co_argcount:
            return func(*args, **kwargs)
        return (lambda *args2, **kwargs2:
                curried(*(args + args2), **dict(kwargs, **kwargs2)))
    return curried

Answer 6

这里是我的治疗版本,它没有部分使用,所有职能都完全接受一个参数:

def curry(func):
"""Truly curry a function of any number of parameters
returns a function with exactly one parameter
When this new function is called, it will usually create
and return another function that accepts an additional parameter,
unless the original function actually obtained all it needed
at which point it just calls the function and returns its result
""" 
def curried(*args):
    """
    either calls a function with all its arguments,
    or returns another functiont that obtains another argument
    """
    if len(args) == func.__code__.co_argcount:
        ans = func(*args)
        return ans
    else:
        return lambda x: curried(*(args+(x,)))

return curried

Answer 7

仅举一旁:

from functools import partial
curry = lambda f: partial(*[partial] * f.__code__.co_argcount)(f)

@curry
def add(x, y, z):
    return x + y + z

print(add(2)(3)(4))
# output = 9

Answer 8

我认为,我做得更好:

def curried (function):
    argc = function.__code__.co_argcount

    # Pointless to curry a function that can take no arguments
    if argc == 0:
        return function

    from functools import partial
    def func (*args):
        if len(args) >= argc:
            return function(*args)
        else:
            return partial(func, *args)
    return func

这一解决办法使用沙捞取自<条码>functools.partial的功能,而不是有效地恢复这一功能。这还使你能够提出比最低的论点更多的论据,即提出关键词,以及公正通过不需要争论的职能,因为这些职能是毫无道理的。 (原称,方案管理员应比处理零毒性或多毒性功能更清楚,但比在这种情况下产生新功能要好。)

<><>UPDATE: 谁,关键词部分实际上就不可行。此外,任择论点被算作是粗略的,但并非.。 Weird。

Answer 9

The solution from Roger Christman will not work with every constellation. I applied a small fix to also handle this situation:

curried_func(1)(2,3)

每一轮船的小型固定装置位于返回的Mlambda:

def curried(func):
    def curry(*args):
        if len(args) == func.__code__.co_argcount:
            ans = func(*args)
            return ans
        else:
            return lambda *x: curry(*(args+x))
    return curry

Answer 10

这是我的lambda作风代码(及其附录):

# ref: https://rosettacode.org/wiki/Y_combinator#Python
fixedpoint = lambda f: (lambda x: x(x)) (lambda y: f(lambda *args: y (y) (*args))) ;

# ref: https://python-course.eu/advanced-python/currying-in-python.php#Decorator-for-currying
curry = lambda func: fixedpoint (lambda curried: 
    lambda *args: (lambda x: curried (* (args + (x,)))) if 
    (len (args) != func.__code__.co_argcount) else 
    func (*args)) ;

# license: gpl-2.0. if you have better ideas show them plz ...

用途:

# e.g. def
@curry
def prod3 (x, y, z):
    return x + y + z

print (prod3 (3) (4) (5)) # 12

# e.g. lambda
prod_3 = curry (lambda x,y,z: x + y + z)
print (prod_3 (6) (7) (8)) # 21

缩略语 ?

Or you can use toolz by pip install toolz or pip install cytoolz if you use the cython. They have things about currying. Repo: pytoolz/toolz pytoolz/cytoolz

友情链接