Apa persamaan 'pythonic' dengan fungsi 'fold' dari pemrograman fungsional?

Apa cara paling idiomatis untuk mencapai sesuatu seperti berikut ini, di Haskell:

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

Atau yang setara di Ruby:

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

Jelas, Python menyediakan reducefungsi, yang merupakan implementasi dari lipatan, persis seperti di atas, namun, saya diberitahu bahwa cara pemrograman 'pythonic' adalah untuk menghindari lambdaistilah dan fungsi tingkat tinggi, lebih memilih pemahaman daftar jika memungkinkan. Oleh karena itu, apakah ada cara yang disukai untuk melipat daftar, atau struktur seperti daftar di Python yang bukan reducefungsinya, atau reducecara idiomatik untuk mencapai ini?

Cara Pythonic untuk menjumlahkan sebuah array digunakan sum. Untuk tujuan lain, terkadang Anda dapat menggunakan beberapa kombinasi reduce(dari functoolsmodul) dan operatormodul, misalnya:

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

Sadarilah bahwa reducesebenarnya adalah foldl, dalam istilah Haskell. Tidak ada sintaks khusus untuk melakukan lipatan, tidak ada bawaan foldr, dan sebenarnya menggunakan reducedengan operator non-asosiatif dianggap gaya yang buruk.

Menggunakan fungsi tingkat tinggi cukup bersifat pythonic; itu memanfaatkan prinsip Python bahwa semuanya adalah objek, termasuk fungsi dan kelas. Anda benar bahwa lambda disukai oleh beberapa Pythonistas, tetapi sebagian besar karena mereka cenderung tidak terlalu mudah dibaca ketika menjadi kompleks.

Haskell

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

Python

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

Jelas, itu adalah contoh yang sepele untuk mengilustrasikan suatu hal. Dengan Python Anda hanya akan melakukannya sum([1,2,3,4,5])dan bahkan puritan Haskell umumnya lebih suka sum [1,2,3,4,5].

Untuk skenario non-trivial ketika tidak ada fungsi kemudahan yang jelas, pendekatan pythonic idiomatik adalah dengan secara eksplisit menulis loop for dan menggunakan tugas variabel yang bisa berubah daripada menggunakan reduceatau a fold.

Itu sama sekali bukan gaya fungsional, tetapi itu adalah cara "pythonic". Python tidak dirancang untuk puritan fungsional. Lihat bagaimana Python menyukai pengecualian untuk kontrol aliran untuk melihat bagaimana python idiomatik non-fungsional itu.

Di Python 3, reducetelah dihapus: Catatan rilis . Meskipun demikian, Anda dapat menggunakan modul functools

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

Di sisi lain, dokumentasi mengungkapkan preferensi terhadap for-loop daripada reduce, karenanya:

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

Memulai Python 3.8, dan pengenalan ekspresi tugas (PEP 572) ( :=operator), yang memberikan kemungkinan untuk memberi nama hasil ekspresi, kita dapat menggunakan pemahaman daftar untuk mereplikasi apa yang oleh bahasa lain disebut operasi lipat / lipat / kurangi:

Diberikan daftar, fungsi pereduksi dan akumulator:

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

kita dapat melipat itemsdengan funtuk mendapatkan dihasilkan tersebut accumulation:

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

atau dalam bentuk kental:

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

Perhatikan bahwa ini sebenarnya juga merupakan operasi "scanleft" karena pemahaman daftar menunjukkan status akumulasi di setiap langkah:

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

Anda juga dapat menemukan kembali 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)

Tidak benar-benar menjawab pertanyaan tersebut, tetapi satu baris untuk foldl dan foldr:

a = [8,3,4]

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

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

Jawaban sebenarnya untuk masalah (kurangi) ini adalah: Cukup gunakan satu putaran!

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

Ini akan lebih cepat daripada pengurangan dan hal-hal seperti PyPy dapat mengoptimalkan loop seperti itu.

BTW, kasus penjumlahan harus diselesaikan dengan sumfungsi

Saya yakin beberapa responden dari pertanyaan ini telah melewatkan implikasi yang lebih luas dari foldfungsi sebagai alat abstrak. Ya, sumdapat melakukan hal yang sama untuk daftar bilangan bulat, tetapi ini adalah kasus yang sepele. foldlebih umum. Ini berguna saat Anda memiliki urutan struktur data dengan berbagai bentuk dan ingin mengekspresikan agregasi dengan rapi. Jadi, alih-alih harus membangun forloop dengan variabel agregat dan menghitung ulang secara manual setiap kali, foldfungsi (atau versi Python, yang reducetampaknya sesuai) memungkinkan pemrogram untuk mengekspresikan maksud agregasi jauh lebih jelas dengan hanya menyediakan dua hal:

• Nilai awal atau "benih" default untuk agregasi.
• Fungsi yang mengambil nilai agregasi saat ini (dimulai dengan "seed") dan elemen berikutnya dalam daftar, dan mengembalikan nilai agregasi berikutnya.

Saya mungkin terlambat ke pesta, tetapi kita dapat membuat kustom foldrmenggunakan kalkulus lambda sederhana dan fungsi kari. Berikut adalah implementasi saya dari foldr dengan 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))

Meskipun implementasinya rekursif (mungkin lambat), itu akan mencetak nilai 15dan 120masing - masing