Kann man teilweise gelten, das zweite argument eine Funktion, die keine keyword-Argumente?

Ich denke, ich würde nur verwenden Sie diese einfachen Einzeiler:

import itertools
print list(itertools.imap(pow, [1, 2, 3], itertools.repeat(2)))

Update:

Kam ich auch mit einer Lustiger als sinnvolle Lösung. Es ist eine schöne syntaktischen Zucker, profitiert von der Tatsache, dass die ... literal bedeutet Ellipsis in Python ist3. Es ist eine modifizierte version von partial, so dass das weglassen einige positionelle Argumente zwischen den ganz Links und ganz rechts ersetzt. Der einzige Nachteil ist, dass Sie nicht passieren können mehr Ellipse als argument.

import itertools
def partial(func, *args, **keywords):
    def newfunc(*fargs, **fkeywords):
        newkeywords = keywords.copy()
        newkeywords.update(fkeywords)
        return func(*(newfunc.leftmost_args + fargs + newfunc.rightmost_args), **newkeywords)
    newfunc.func = func
    args = iter(args)
    newfunc.leftmost_args = tuple(itertools.takewhile(lambda v: v != Ellipsis, args))
    newfunc.rightmost_args = tuple(args)
    newfunc.keywords = keywords
    return newfunc

>>> print partial(pow, ..., 2, 3)(5) # (5^2)%3
1
>>> print partial(pow, 2, ..., 3)(5) # (2^5)%3
2
>>> print partial(pow, 2, 3, ...)(5) # (2^3)%5
3
>>> print partial(pow, 2, 3)(5) # (2^3)%5
3

So das die Lösung für die ursprüngliche Frage wäre mit dieser version teilweise list(map(partial(pow, ..., 2),xs))

Könnten Sie eine helper-Funktion für diese:

from functools import wraps
def foo(a, b, c, d, e):
    print('foo(a={}, b={}, c={}, d={}, e={})'.format(a, b, c, d, e))

def partial_at(func, index, value):
    @wraps(func)
    def result(*rest, **kwargs):
        args = []
        args.extend(rest[:index])
        args.append(value)
        args.extend(rest[index:])
        return func(*args, **kwargs)
    return result

if __name__ == '__main__':
    bar = partial_at(foo, 2, 'C')
    bar('A', 'B', 'D', 'E') 
    # Prints: foo(a=A, b=B, c=C, d=D, e=E)

Disclaimer: ich habe nicht getestet, die mit keyword-Argumenten so könnte es sprengen, weil Sie irgendwie. Auch ich bin mir nicht sicher, ob dies ist, was @wraps verwendet werden soll, aber es schien, Recht -ish.

Einen Weg, es zu tun wäre:

def testfunc1(xs):
    from functools import partial
    def mypow(x,y): return x ** y
    return list(map(partial(mypow,y=2),xs))

aber dies beinhaltet re-Definition der pow-Funktion.

wenn die Verwendung von partiellen war nicht 'gebraucht', dann ist eine einfache lambda würde den trick tun

def testfunc2(xs):
    return list(map(lambda x: pow(x,2), xs))

Und eine bestimmte Art Karte der pow 2 wäre

def testfunc5(xs):
    from operator import mul
    return list(map(mul,xs,xs))

aber keiner von diesen voll das problem direkt von partiellen Einsatz in Bezug auf keyword-Argumente

Sehr vielseitig funcy umfasst eine rpartial Funktion, die genau diesem problem begegnet.

xs = [1,2,3,4,5,6,7,8]
from funcy import rpartial
list(map(rpartial(pow, 2), xs))
# [1, 4, 9, 16, 25, 36, 49, 64]

Es ist nur eine lambda-unter der Haube:

def rpartial(func, *args):
    """Partially applies last arguments."""
    return lambda *a: func(*(a + args))

Wenn Sie nicht verwenden können, lambda-Funktionen, können Sie auch schreiben, ein einfaches wrapper-Funktion, die ändert die Reihenfolge der Argumente.

def _pow(y, x):
    return pow(x, y)

dann rufen Sie

list(map(partial(_pow,2),xs))

>>> [1, 4, 9, 16, 25, 36, 49, 64]