Qual é o equivalente 'pythônico' à função 'dobrar' da programação funcional?

Qual é a maneira mais idiomática de conseguir algo como o seguinte, em Haskell:

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

Ou seu equivalente em Ruby:

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

Obviamente, Python fornece a reducefunção, que é uma implementação de fold, exatamente como acima, no entanto, fui informado que a maneira 'pítônica' de programação era evitar lambdatermos e funções de ordem superior, preferindo compreensões de lista quando possível. Portanto, há uma maneira preferida de dobrar uma lista, ou estrutura semelhante a uma lista em Python que não seja a reducefunção, ou é reducea maneira idiomática de fazer isso?

A maneira pitônica de somar uma matriz está usando sum. Para outros fins, às vezes você pode usar alguma combinação de reduce(do functoolsmódulo) e o operatormódulo, por exemplo:

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

Esteja ciente de que reduceé realmente um foldl, em termos de Haskell. Não há sintaxe especial para realizar dobras, não há builtin foldre, na verdade, usar reducecom operadores não associativos é considerado um estilo incorreto.

Usar funções de ordem superior é bastante pitônico; faz bom uso do princípio do Python de que tudo é um objeto, incluindo funções e classes. Você está certo ao dizer que lambdas são desaprovados por alguns Pythonistas, mas principalmente porque eles tendem a não ser muito legíveis quando se tornam complexos.

Haskell

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

Pitão

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

Obviamente, esse é um exemplo trivial para ilustrar um ponto. Em Python, você apenas faria sum([1,2,3,4,5])e até mesmo os puristas de Haskell geralmente prefeririam sum [1,2,3,4,5].

Para cenários não triviais quando não há função de conveniência óbvia, a abordagem idiomática pythônica é escrever explicitamente o loop for e usar a atribuição de variável mutável em vez de usar reduceou a fold.

Esse não é o estilo funcional, mas é a forma "pítônica". Python não foi projetado para puristas funcionais. Veja como o Python favorece as exceções para controle de fluxo para ver como o python idiomático não é funcional.

No Python 3, o reducefoi removido: Notas de lançamento . No entanto, você pode usar o módulo functools

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

Por outro lado, a documentação expressa preferência por for-loop em vez de reduce, portanto:

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

A partir Python 3.8, e a introdução de expressões de atribuição (PEP 572) ( :=operador), que dá a possibilidade de nomear o resultado de uma expressão, podemos usar uma compreensão de lista para replicar o que outras línguas chamam de operações dobrar / dobrar / reduzir:

Dada uma lista, uma função redutora e um acumulador:

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

podemos dobrar itemscom a ffim de obter o resultado accumulation:

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

ou em forma condensada:

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

Observe que, na verdade, essa também é uma operação "scanleft", pois o resultado da compreensão da lista representa o estado da acumulação em cada etapa:

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

Você também pode reinventar a roda:

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)

Não é realmente uma resposta à pergunta, mas uma linha para foldl e foldr:

a = [8,3,4]

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

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

A resposta real para este problema (de redução) é: Basta usar um loop!

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

Isso será mais rápido do que reduzir e coisas como PyPy podem otimizar loops como esse.

BTW, o caso da soma deve ser resolvido com a sumfunção

Eu acredito que alguns dos respondentes desta questão perderam a implicação mais ampla da foldfunção como uma ferramenta abstrata. Sim, sumpode fazer a mesma coisa com uma lista de inteiros, mas este é um caso trivial. foldé mais genérico. É útil quando você tem uma sequência de estruturas de dados de formas variadas e deseja expressar claramente uma agregação. Então, em vez de ter que construir um forloop com uma variável agregada e recalcular manualmente a cada vez, uma foldfunção (ou a versão Python, que reduceparece corresponder a) permite que o programador expresse a intenção da agregação muito mais claramente, simplesmente fornecendo duas coisas:

• Um valor inicial ou "semente" padrão para a agregação.
• Uma função que obtém o valor atual da agregação (começando com a "semente") e o próximo elemento na lista e retorna o próximo valor de agregação.

Posso estar um pouco atrasado para a festa, mas podemos criar um costume foldrusando cálculo lambda simples e função curry. Aqui está minha implementação de foldr em 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))

Mesmo que a implementação seja recursiva (pode ser lenta), ela irá imprimir os valores 15e 120respectivamente