Hàm 'pythonic' tương đương với hàm 'gấp' trong lập trình hàm là gì?

Cách thành ngữ nhất để đạt được điều gì đó như sau, trong Haskell:

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

Hoặc tương đương của nó trong Ruby:

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

Rõ ràng, Python cung cấp reducehàm, là một triển khai của gấp, chính xác như ở trên, tuy nhiên, tôi được biết rằng cách lập trình 'pythonic' là tránh lambdacác thuật ngữ và các hàm bậc cao hơn, ưu tiên danh sách hiểu rõ hơn nếu có thể. Do đó, có cách nào được ưu tiên để gấp một danh sách hoặc cấu trúc giống như danh sách trong Python mà không phải là reducehàm, hay là reducecách thành ngữ để đạt được điều này?

Cách Pythonic để tính tổng một mảng đang được sử dụng sum. Đối với các mục đích khác, đôi khi bạn có thể sử dụng một số kết hợp của reduce(từ functoolsmô-đun) và operatormô-đun, ví dụ:

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

Cần biết rằng đó reducethực sự là một foldl, theo thuật ngữ Haskell. Không có cú pháp đặc biệt nào để thực hiện các nếp gấp, không có nội trang foldrvà thực sự sử dụng reducevới các toán tử không liên kết được coi là kiểu xấu.

Sử dụng các hàm bậc cao là khá khó; nó sử dụng tốt nguyên tắc của Python rằng mọi thứ đều là một đối tượng, bao gồm các hàm và lớp. Bạn nói đúng rằng lambdas bị một số Pythonistas ghét bỏ, nhưng chủ yếu là vì chúng có xu hướng không dễ đọc khi chúng trở nên phức tạp.

Haskell

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

Python

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

Rõ ràng, đó là một ví dụ tầm thường để minh họa một điểm. Trong Python, bạn chỉ cần làm sum([1,2,3,4,5])và ngay cả những người theo chủ nghĩa thuần túy Haskell thường thích hơn sum [1,2,3,4,5].

Đối với các tình huống không tầm thường khi không có chức năng tiện lợi rõ ràng, cách tiếp cận quan trọng thành ngữ là viết rõ ràng vòng lặp for và sử dụng phép gán biến có thể thay đổi thay vì sử dụng reducehoặc a fold.

Đó hoàn toàn không phải là phong cách chức năng, mà đó là cách "pythonic". Python không được thiết kế cho những người theo chủ nghĩa thuần túy chức năng. Xem cách Python ủng hộ các ngoại lệ cho điều khiển luồng để xem python thành ngữ phi chức năng như thế nào.

Trong Python 3, reduceđã bị loại bỏ: Ghi chú phát hành . Tuy nhiên, bạn có thể sử dụng mô-đun functools

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

Mặt khác, tài liệu thể hiện ưu tiên đối với for-loop thay vì reduce, do đó:

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

Bắt đầu Python 3.8và sự ra đời của các biểu thức gán (PEP 572) ( :=toán tử), mang lại khả năng đặt tên cho kết quả của một biểu thức, chúng ta có thể sử dụng khả năng hiểu danh sách để sao chép những gì các ngôn ngữ khác gọi là hoạt động gấp / lật / giảm:

Cho một danh sách, một hàm giảm và một bộ tích lũy:

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

chúng ta có thể gấp itemsvới fđể có được kết quả accumulation:

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

hoặc ở dạng cô đặc:

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

Lưu ý rằng đây thực sự cũng là một hoạt động "scanleft" vì kết quả của việc hiểu danh sách đại diện cho trạng thái tích lũy ở mỗi bước:

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

Bạn cũng có thể phát minh lại bánh xe:

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)

Không thực sự trả lời cho câu hỏi, nhưng một lớp lót cho giấy gấp và giấy gấp:

a = [8,3,4]

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

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

Câu trả lời thực tế cho vấn đề (giảm) này là: Chỉ cần sử dụng một vòng lặp!

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

Điều này sẽ nhanh hơn so với giảm và những thứ như PyPy có thể tối ưu hóa các vòng lặp như vậy.

BTW, trường hợp tổng phải được giải quyết bằng sumhàm

Tôi tin rằng một số người trả lời câu hỏi này đã bỏ lỡ hàm ý rộng hơn của foldchức năng như một công cụ trừu tượng. Có, sumcó thể làm điều tương tự đối với danh sách các số nguyên, nhưng đây là một trường hợp nhỏ. foldchung chung hơn. Nó hữu ích khi bạn có một chuỗi cấu trúc dữ liệu có hình dạng khác nhau và muốn thể hiện rõ ràng một tập hợp. Vì vậy, thay vì phải tạo một forvòng lặp với một biến tổng hợp và tính toán lại nó theo cách thủ công mỗi lần, một foldhàm (hoặc phiên bản Python, có reducevẻ như tương ứng với) cho phép lập trình viên thể hiện ý định của biến tổng hợp một cách rõ ràng hơn nhiều bằng cách chỉ cần cung cấp hai điều:

• Giá trị bắt đầu hoặc giá trị "gốc" mặc định cho tập hợp.
• Một hàm nhận giá trị hiện tại của tổng hợp (bắt đầu bằng "hạt giống") và phần tử tiếp theo trong danh sách và trả về giá trị tổng hợp tiếp theo.

Tôi có thể đến bữa tiệc khá muộn, nhưng chúng ta có thể tạo tùy chỉnh foldrbằng cách sử dụng tính toán lambda đơn giản và hàm cà ri. Đây là cách thực hiện của tôi về trình gấp trong 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))

Mặc dù việc triển khai là đệ quy (có thể chậm), nó sẽ in ra các giá trị 15và 120tương ứng