¿Cuál es el equivalente 'pitónico' a la función 'plegar' de la programación funcional?

¿Cuál es la forma más idiomática de lograr algo como lo siguiente, en Haskell:

foldl (+) 0 [1,2,3,4,5]
--> 15

O su equivalente en Ruby:

[1,2,3,4,5].inject(0) {|m,x| m + x}
#> 15

Obviamente, Python proporciona la reducefunción, que es una implementación de fold, exactamente como arriba, sin embargo, me dijeron que la forma 'pitónica' de programar era evitar lambdatérminos y funciones de orden superior, prefiriendo listas por comprensión cuando fuera posible. Por lo tanto, ¿hay una forma preferida de plegar una lista o una estructura similar a una lista en Python que no sea la reducefunción, o es reducela forma idiomática de lograr esto?

La forma Pythonic de sumar una matriz está usando sum. Para otros propósitos, a veces puede usar alguna combinación de reduce(del functoolsmódulo) y el operatormódulo, por ejemplo:

def product(xs):
    return reduce(operator.mul, xs, 1)

Tenga en cuenta que en reducerealidad es una foldl, en términos de Haskell. No hay una sintaxis especial para realizar pliegues, no hay una función incorporada foldry, en realidad, el uso reducecon operadores no asociativos se considera de mal estilo.

El uso de funciones de orden superior es bastante pitónico; hace un buen uso del principio de Python de que todo es un objeto, incluidas las funciones y clases. Tienes razón en que algunos Pythonistas desaprueban las lambdas, pero sobre todo porque tienden a no ser muy legibles cuando se vuelven complejas.

Haskell

foldl (+) 0 [1,2,3,4,5]

Pitón

reduce(lambda a,b: a+b, [1,2,3,4,5], 0)

Obviamente, ese es un ejemplo trivial para ilustrar un punto. En Python simplemente lo haría sum([1,2,3,4,5])e incluso los puristas de Haskell generalmente preferirían sum [1,2,3,4,5].

Para escenarios no triviales cuando no hay una función de conveniencia obvia, el enfoque pitónico idiomático es escribir explícitamente el ciclo for y usar la asignación de variable mutable en lugar de usar reduceo a fold.

Ese no es en absoluto el estilo funcional, pero es la forma "pitónica". Python no está diseñado para puristas funcionales. Vea cómo Python favorece las excepciones para el control de flujo para ver qué tan no funcional es Python idiomático.

En Python 3, reducese ha eliminado: Notas de la versión . Sin embargo, puede utilizar el módulo de funciones

import operator, functools
def product(xs):
    return functools.reduce(operator.mul, xs, 1)

Por otro lado, la documentación expresa preferencia hacia for-loop en lugar de reduce, por lo tanto:

def product(xs):
    result = 1
    for i in xs:
        result *= i
    return result

A partir Python 3.8, y la introducción de expresiones de asignación (PEP 572) ( :=operador), que da la posibilidad de nombrar el resultado de una expresión, podemos usar una lista de comprensión para replicar lo que otros lenguajes llaman operaciones de plegar / plegar a la izquierda / reducir:

Dada una lista, una función reductora y un acumulador:

items = [1, 2, 3, 4, 5]
f = lambda acc, x: acc * x
accumulator = 1

podemos doblar itemscon el ffin de obtener el resultado accumulation:

[accumulator := f(accumulator, x) for x in items]
# accumulator = 120

o en forma condensada:

acc = 1; [acc := acc * x for x in [1, 2, 3, 4, 5]]
# acc = 120

Tenga en cuenta que esto también es una operación "scanleft" ya que el resultado de la comprensión de la lista representa el estado de la acumulación en cada paso:

acc = 1
scanned = [acc := acc * x for x in [1, 2, 3, 4, 5]]
# scanned = [1, 2, 6, 24, 120]
# acc = 120

También puedes reinventar la rueda:

def fold(f, l, a):
    """
    f: the function to apply
    l: the list to fold
    a: the accumulator, who is also the 'zero' on the first call
    """ 
    return a if(len(l) == 0) else fold(f, l[1:], f(a, l[0]))

print "Sum:", fold(lambda x, y : x+y, [1,2,3,4,5], 0)

print "Any:", fold(lambda x, y : x or y, [False, True, False], False)

print "All:", fold(lambda x, y : x and y, [False, True, False], True)

# Prove that result can be of a different type of the list's elements
print "Count(x==True):", 
print fold(lambda x, y : x+1 if(y) else x, [False, True, True], 0)

En realidad, no es la respuesta a la pregunta, pero sí frases para foldl y foldr:

a = [8,3,4]

## Foldl
reduce(lambda x,y: x**y, a)
#68719476736

## Foldr
reduce(lambda x,y: y**x, a[::-1])
#14134776518227074636666380005943348126619871175004951664972849610340958208L

La respuesta real a este problema (de reducción) es: ¡Simplemente use un bucle!

initial_value = 0
for x in the_list:
    initial_value += x #or any function.

Esto será más rápido que una reducción y cosas como PyPy pueden optimizar bucles como ese.

Por cierto, el caso de la suma debe resolverse con la sumfunción

Creo que algunos de los que respondieron a esta pregunta han pasado por alto la implicación más amplia de la foldfunción como herramienta abstracta. Sí, sumpuede hacer lo mismo con una lista de números enteros, pero este es un caso trivial. foldes más genérico. Es útil cuando tiene una secuencia de estructuras de datos de forma variable y desea expresar una agregación de forma limpia. Entonces, en lugar de tener que construir un forbucle con una variable agregada y volver a calcularlo manualmente cada vez, una foldfunción (o la versión de Python, que reduceparece corresponder) permite al programador expresar la intención de la agregación de manera mucho más sencilla simplemente proporcionando dos cosas:

• Un valor inicial predeterminado o "semilla" para la agregación.
• Una función que toma el valor actual de la agregación (comenzando con la "semilla") y el siguiente elemento de la lista, y devuelve el siguiente valor de agregación.

Puede que llegue bastante tarde a la fiesta, pero podemos crear personalización foldrutilizando un cálculo lambda simple y una función de curry. Aquí está mi implementación de foldr en python.

def foldr(func):
    def accumulator(acc):
        def listFunc(l):
            if l:
                x = l[0]
                xs = l[1:]
                return func(x)(foldr(func)(acc)(xs))
            else:
                return acc
        return listFunc
    return accumulator  


def curried_add(x):
    def inner(y):
        return x + y
    return inner

def curried_mult(x):
    def inner(y):
        return x * y
    return inner

print foldr(curried_add)(0)(range(1, 6))
print foldr(curried_mult)(1)(range(1, 6))

Aunque la implementación es recursiva (puede ser lenta), imprimirá los valores 15y 120respectivamente