Що таке "пітонічний" еквівалент функції "складання" від функціонального програмування?

Який самий ідіоматичний спосіб досягти чогось подібного в Haskell:

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

Або його еквівалент у Ruby:

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

Очевидно, що Python забезпечує reduceфункцію, яка є реалізацією складки, точно так само, як вище, однак мені сказали, що "пітонічним" способом програмування було уникати lambdaтермінів і функцій вищого порядку, віддаючи перевагу розумінням списків, де це можливо. Отже, чи є кращий спосіб складання списку чи структури, подібної до списку, в Python, яка не є reduceфункцією, або це reduceідіоматичний спосіб досягнення цього?

Використовується пітонічний спосіб підсумовування масиву sum. Для інших цілей іноді можна використовувати комбінацію reduce(з functoolsмодуля) та operatorмодуля, наприклад:

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

Будьте в курсі, що reduceнасправді є foldl, з точки зору Haskell. Немає спеціального синтаксису для виконання складок, немає вбудованого foldr, і фактично використання reduceз неасоціативними операторами вважається поганим стилем.

Використання функцій вищого порядку досить пітонічне; він добре використовує принцип Python, що все є об'єктом, включаючи функції та класи. Ви маєте рацію, що лямбди нахмурюються деякими пітоністами, але в основному тому, що вони, як правило, не дуже читабельні, коли вони складні.

Хаскелл

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

Пітон

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

Очевидно, що це тривіальний приклад для ілюстрації точки. У Python ви просто зробили б, sum([1,2,3,4,5])і навіть пуристи Haskell, як правило, віддають перевагу sum [1,2,3,4,5].

Для нетривіальних сценаріїв, коли немає явної функції зручності, ідіоматичний пітонічний підхід полягає в тому, щоб явно виписати цикл for і використовувати призначення змінних змінних замість використання reduceабо a fold.

Це зовсім не функціональний стиль, але це "пітонічний" спосіб. Python не розроблений для функціональних пуристів. Подивіться, як Python надає перевагу виняткам для управління потоком, щоб побачити, як нефункціональний ідіоматичний пітон.

У Python 3 reduceбуло видалено: Примітки до випуску . Тим не менш, ви можете використовувати модуль functools

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

З іншого боку, документація виражає перевагу перед for-loop reduce, а не:

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

Початок Python 3.8та введення виразів призначення (PEP 572) (:= оператор), що дає можливість назвати результат виразу, ми можемо використовувати розуміння списку, щоб повторити те, що інші мови називають операціями fold / foldleft / reduction:

Дано список, функцію відновлення та акумулятор:

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

ми можемо скласти itemsз fметою отримання результуючий accumulation:

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

або у конденсованому вигляді:

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

Зауважте, що це насправді також операція "сканування", оскільки результат розуміння списку представляє стан накопичення на кожному кроці:

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

Ви також можете винаходити колесо:

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)

Не справді відповідь на питання, але одноразові для foldl та foldr:

a = [8,3,4]

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

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

Фактична відповідь на цю (зменшити) проблему: Просто використовуйте цикл!

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

Це буде швидше, ніж зменшення, і такі речі, як PyPy, можуть оптимізувати подібні петлі.

До речі, випадок суми повинен бути вирішений sumфункцією

Я вважаю, що деякі респонденти цього питання пропустили більш широке значення foldфункції як абстрактного інструменту. Так, sumможна зробити те ж саме для списку цілих чисел, але це тривіальний випадок. foldє більш загальним. Це корисно, коли у вас є послідовність структур даних різної форми і ви хочете чітко виразити агрегацію. Таким чином, замість того, щоб створювати forцикл із сукупною змінною та щоразу вручну перераховувати її, foldфункція (або версія Python, яка, як reduceвидається, відповідає) дозволяє програмісту виражати наміри агрегації набагато простіше, просто надаючи дві речі:

• За замовчуванням початкове або "насінне" значення для агрегації.
• Функція, яка приймає поточне значення агрегації (починаючи з "насіння") і наступний елемент у списку, і повертає наступне значення агрегації.

Я, можливо, запізнився на вечірку, але ми можемо створити на замовлення, foldrвикористовуючи просте обчислення лямбда та викривлену функцію. Ось моя реалізація foldr в 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))

Незважаючи на те, що реалізація є рекурсивною (може бути повільною), вона буде друкувати значення 15і 120відповідно