¿Se puede aplicar parcialmente el segundo argumento de una función que no toma argumentos de palabra clave?

Question

Tomemos por ejemplo el python incorporado en la función pow().

xs = [1,2,3,4,5,6,7,8] 

from functools import partial 

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

>>> [2, 4, 8, 16, 32, 128, 256] 

pero ¿cómo elevaría el xs a la potencia de 2?

para obtener [1, 4, 9, 16, 25, 49, 64]

list(map(partial(pow,y=2),xs)) 

TypeError: pow() takes no keyword arguments 

sé listas por comprensión serían más fáciles.

Answer 1

Sin

Según the documentation, partial no puede hacer esto (el subrayado es mío):

parcial.args

Los más a la izquierda argumentos posicionales que se antepone a los argumentos posicionales

---

siempre se puede simplemente "fijar" pow tener argumentos de palabras clave:

_pow = pow 
pow = lambda x, y: _pow(x, y) 

Answer 2

Una forma de hacerlo sería:

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

pero esto implica la redefinición de la función pow.

si el uso de parcial no fue 'necesario', entonces un lambda sencilla sería hacer el truco

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

Y una manera específica para mapear el prisionero de guerra de 2 sería

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

pero ninguno de estos abordan completamente el problema directamente de la aplicación parcial en relación con los argumentos de palabra clave

Answer 3

Puede crear una función auxiliar para esto:

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) 

Descargo de responsabilidad: No he probado esto con argumentos de palabras clave por lo que podría explotar debido a ellos de alguna manera. Además, no estoy seguro de si esto es lo que @wraps debería usarse, pero parecía correcto.

Answer 4

podría utilizar un cierre

xs = [1,2,3,4,5,6,7,8] 

def closure(method, param): 
    def t(x): 
    return method(x, param) 
    return t 

f = closure(pow, 2) 
f(10) 
f = closure(pow, 3) 
f(10) 

Answer 5

Creo que solo usaría este sencillo de una sola línea:

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

Actualización:

También se le ocurrió una solución más divertido que útiles. Es un azúcar sintáctico hermoso, aprovechando el hecho de que el literal ... significa Ellipsis en Python3. Es una versión modificada de partial, que permite omitir algunos argumentos posicionales entre los más a la izquierda y los más a la derecha. El único inconveniente es que ya no puedes pasar Ellipsis como argumento.

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 

Así que la solución de la pregunta inicial sería con esta versión de parcial list(map(partial(pow, ..., 2),xs))

Answer 6

¿Por qué no crear una función lambda rápida que reordena los argumentos y parcial que

partial(lambda p, x: pow(x, p), 2) 

Answer 7

Como Ya dije que eso es una limitación de functools.partial si la función que desea partial no acepta argumentos de palabra clave.

Si no les importa usar una biblioteca externa podría utilizar iteration_utilities.partial que tiene una parcial que soporta marcadores de posición:

>>> from iteration_utilities import partial 
>>> square = partial(pow, partial._, 2) # the partial._ attribute represents a placeholder 
>>> list(map(square, xs)) 
[1, 4, 9, 16, 25, 36, 49, 64] 

---

responsabilidad: yo soy el autor de la biblioteca iteration_utilities (las instrucciones de instalación se pueden encontrar en in the documentation en caso de que le interese).

Answer 8

Usted puede hacer esto con lambda, que es más flexible que functools.partial():

pow_two = lambda base: pow(base, 2) 
print(pow_two(3)) # 9 

De manera más general:

def bind_skip_first(func, *args, **kwargs): 
    return lambda first: func(first, *args, **kwargs) 

pow_two = bind_skip_first(pow, 2) 
print(pow_two(3)) # 9 

Uno menos del lado de lambda es que algunas bibliotecas no son capaces de serializar eso.