función de composición y el módulo funcional

Question

Python 3.2 documentation refiere a Collin Winter's functional module que contiene la función compose:

El Componer() función implementa composición de la función. En otras palabras , devuelve un envoltorio alrededor de los candados exteriores e interiores, como , que el valor de retorno del interior se alimenta directamente al exterior.

Desafortunadamente, este módulo no se ha actualizado desde julio de 2006; Me pregunto si hay algún reemplazo disponible. Por favor, solo necesito la función compose. ¿La siguiente definición original de functional.compose sigue siendo buena para Python 3?

def compose(func_1, func_2, unpack=False): 
    """ 
    compose(func_1, func_2, unpack=False) -> function 

    The function returned by compose is a composition of func_1 and func_2. 
    That is, compose(func_1, func_2)(5) == func_1(func_2(5)) 
    """ 
    if not callable(func_1): 
     raise TypeError("First argument to compose must be callable") 
    if not callable(func_2): 
     raise TypeError("Second argument to compose must be callable") 

    if unpack: 
     def composition(*args, **kwargs): 
      return func_1(*func_2(*args, **kwargs)) 
    else: 
     def composition(*args, **kwargs): 
      return func_1(func_2(*args, **kwargs)) 
    return composition 

Esto SO question es algo relacionado; pregunta si Python debería soportar la sintaxis especial para compose.

Answer 1

Su implementación de compose es válida para Python 3.2 como se discutió en los comentarios anteriores. La mayoría de las funciones de la biblioteca que proporcionó tienen un equivalente de python escrito en el documentation.

Las funciones como map y filter ya están implementadas en python y también se pueden expresar simplemente como listas de comprensión. Python tiene una función id que devuelve la identidad de un objeto (como un entero), pero la función id de la biblioteca se puede expresar como lambda x: x.

Otros módulos que puedes encontrar interesantes son itertools y functools que tiene partial y reduce (que es similar a foldl pero el orden de los argumentos no es lo mismo).

Aquí es un simple implementaciones de algunos de ellos que no se encontró en la biblioteca estándar:

from functools import reduce 

def flip(f): 
    if not callable(f): 
     raise TypeError("Cannot filp a non-callable object") 
    def result(*args, **kw): 
     args = list(args) 
     args.reverse() 
     return f(*args, **kw) 
    return result 

def ilast(i): 
    return reduce(lambda _, x: x, i) 

def iscanl(f, v, seq): 
    yield v 
    for a in seq: 
     v = f(v, a) 
     yield v 

def scanl(*args, **kw): 
    return list(iscanl(*args, **kw)) 

def foldl(*args, **kw): 
    return ilast(iscanl(*args, **kw)) 
# Or using reduce 
#def foldl(f, v, seq): 
# return reduce(f, seq, v) 

def iscanr_reverse(f, v, seq): 
    return iscanl(flip(f), v, seq) 

def scanr(*args, **kw): 
    result = list(iscanr_reverse(*args, **kw)) 
    result.reverse() 
    return result 

def foldr(*args, **kw): 
    return ilast(iscanr_reverse(*args, **kw))