ruta - navegar entre carpetas con python

Carpetas de argumentos de Python

Question

¿Cómo puedo vincular argumentos a un método de Python para almacenar un functor nullary para una invocación posterior? Similar al boost::bind C ++.

Answer 1

Los funtores se pueden definir de esta manera en Python. Son objetos invocables. El "enlace" simplemente establece valores de argumento.

class SomeFunctor( object ):
def __init__( self, arg1, arg2=None ):
self.arg1= arg1
self.arg2= arg2
def __call___( self, arg1=None, arg2=None ):
a1= arg1 or self.arg1
a2= arg2 or self.arg2
# do something
return

Puedes hacer cosas como

x= SomeFunctor( 3.456 )
x( arg2=123 )
y= SomeFunctor( 3.456, 123 )
y()

Answer 2

Si functools.partial no está disponible, se puede emular fácilmente:

>>> make_printer = lambda s: lambda: sys.stdout.write("%s/n" % s)
>>> import sys
>>> print_hello = make_printer("hello")
>>> print_hello()
hello

O

def partial(func, *args, **kwargs):
def f(*args_rest, **kwargs_rest):
kw = kwargs.copy()
kw.update(kwargs_rest)
return func(*(args + args_rest), **kw)
return f
def f(a, b):
return a + b
p = partial(f, 1, 2)
print p() # -> 3
p2 = partial(f, 1)
print p2(7) # -> 8
d = dict(a=2, b=3)
p3 = partial(f, **d)
print p3(), p3(a=3), p3() # -> 5 6 5

Answer 3

Esto funcionaría, también:

def curry(func, *args):
def curried(*innerargs):
return func(*(args+innerargs))
curried.__name__ = "%s(%s, ...)" % (func.__name__, ", ".join(map(str, args)))
return curried
>>> w=curry(sys.stdout.write, "Hey there")
>>> w()
Hey there

Answer 4

functools.partial devuelve una función envolvente invocable con algunos o todos los argumentos congelados.

import sys
import functools
print_hello = functools.partial(sys.stdout.write, "Hello world/n")
print_hello()

Hello world

El uso anterior es equivalente a la siguiente lambda .

print_hello = lambda *a, **kw: sys.stdout.write("Hello world/n", *a, **kw)

Answer 5

No estoy demasiado familiarizado con boost :: bind, pero la función partial de functools puede ser un buen comienzo:

>>> from functools import partial
>>> def f(a, b):
... return a+b
>>> p = partial(f, 1, 2)
>>> p()
3
>>> p2 = partial(f, 1)
>>> p2(7)
8

Answer 6

¡Las lambdas te permiten crear una nueva función sin nombre con menos argumentos y llamar a la función!

>>> def foobar(x,y,z):
... print "%d, %d, %d" % (x,y,z)
>>> foobar(1,2,3) # call normal function
>>> bind = lambda x: foobar(x, 10, 20) # bind 10 and 20 to foobar
>>> bind(1) # print 1, 10, 20
>>> bind = lambda: foobar(1,2,3) # bind all elements
>>> bind() # print 1, 2, 3

editar

https://docs.python.org/2/library/functools.html#functools.partial

si está planeando usar un enlace de argumento con nombre en la llamada de función, esto también es aplicable:

>>> from functools import partial
>>> barfoo = partial(foobar, x=10)
>>> barfoo(y=5,z=6)
21

Tenga en cuenta que eso

>>> barfoo(5,6)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: foobar() got multiple values for keyword argument ''x''
>>> f = partial(foobar, z=20)
>>> f(1,1)
22