İşlevsel programlamadaki 'katlama' işlevine eşdeğer 'pitonik' nedir?

Haskell'de aşağıdakine benzer bir şeyi başarmanın en deyimsel yolu nedir:

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

Veya Ruby'deki karşılığı:

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

Açıkçası, Python, reducekatlamanın bir uygulaması olan işlevi tam olarak yukarıdaki gibi sağlar, ancak bana 'pitonik' programlama yolunun, lambdamümkün olan yerlerde liste kavrayışlarını tercih ederek terimlerden ve üst düzey işlevlerden kaçınmak olduğu söylendi . Bu nedenle, Python'da bir listeyi bölmenin tercih edilen bir yolu veya liste benzeri yapı var mıdır reduce, bu işlev değil mi , yoksa reducebunu başarmanın deyimsel yolu mu?

Bir diziyi toplamanın Pythonic yolu kullanmaktır sum. Diğer amaçlar için, bazen reduce( functoolsmodülden) ve modülün bazı kombinasyonlarını kullanabilirsiniz operator, örneğin:

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

Haskell açısından reducebunun aslında a olduğunu unutmayın foldl. Katlamaları gerçekleştirmek için özel bir sözdizimi yoktur, yerleşik yoktur foldrve aslında reduceilişkisel olmayan işleçlerle kullanmak kötü stil olarak kabul edilir.

Üst düzey işlevleri kullanmak oldukça pitoniktir; Python'un işlevler ve sınıflar dahil her şeyin bir nesne olduğu ilkesini iyi kullanır. Lambdaların bazı Pythonistalar tarafından hoş karşılanmadığı konusunda haklısınız, ancak çoğunlukla karmaşık olduklarında çok okunaklı olmadıkları için.

Haskell

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

piton

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

Açıkçası, bu bir noktayı açıklamak için önemsiz bir örnek. Python'da sadece yaparsınız sum([1,2,3,4,5])ve Haskell uzmanları bile genellikle tercih ederdi sum [1,2,3,4,5].

Belirgin bir kolaylık işlevi olmadığında önemsiz olmayan senaryolar için, deyimsel pitonik yaklaşım, for döngüsünü açıkça yazmak ve reduceveya a kullanmak yerine değişken değişken atamasını kullanmaktır fold.

Bu hiç de işlevsel tarz değil, ama bu "pitonik" yoldur. Python, işlevsel sadelik uzmanları için tasarlanmamıştır. Python'un işlevsel olmayan deyimsel python'u görmek için akış kontrolü için istisnaları nasıl tercih ettiğini görün.

Python 3'te reduceşu kaldırılmıştır: Sürüm notları . Yine de functools modülünü kullanabilirsiniz

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

Öte yandan, dokümantasyon tercihi for-döngü yerine -döngü yerine ifade eder reduce, dolayısıyla:

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

Başlangıç Python 3.8ve bir ifadenin sonucunu isimlendirme imkanı veren atama ifadelerinin (PEP 572) ( :=operatör) tanıtılması, diğer dillerin katlama / bırakma / azaltma işlemleri dediği şeyi çoğaltmak için bir liste kavrama kullanabiliriz:

Bir liste, bir indirgeme işlevi ve bir toplayıcı verildiğinde:

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

Biz katlayabilir itemsile fhusule elde etmek amacıyla accumulation:

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

veya yoğunlaştırılmış bir şekilde:

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

Liste kavrama sonucunda her adımda birikimin durumunu temsil ettiğinden, bunun aslında bir "sol tarama" işlemi olduğunu unutmayın:

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

Tekerleği de yeniden keşfedebilirsiniz:

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)

Aslında soruya cevap değil, foldl ve foldr için tek gömlek:

a = [8,3,4]

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

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

Bu (azaltma) sorunun asıl cevabı şudur: Sadece bir döngü kullanın!

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

Bu, bir azaltmadan daha hızlı olacaktır ve PyPy gibi şeyler, döngüleri bu şekilde optimize edebilir.

BTW, toplam durum sumfonksiyonu ile çözülmelidir

Bu soruyu yanıtlayanların bir kısmının, foldfonksiyonun soyut bir araç olarak daha geniş anlamını gözden kaçırdığına inanıyorum . Evet, sumaynı şeyi bir tamsayı listesi için de yapabilir, ancak bu önemsiz bir durumdur. folddaha geneldir. Çeşitli şekillerde bir dizi veri yapınız olduğunda ve bir toplamayı temiz bir şekilde ifade etmek istediğinizde kullanışlıdır. Bu nedenle for, bir toplu değişkenle bir döngü oluşturmak ve her seferinde manuel olarak yeniden hesaplamak zorunda kalmak foldyerine , bir işlev (veya reducekarşılık geliyor gibi görünen Python sürümü ), programcının basitçe sağlayarak toplamanın amacını çok daha açık bir şekilde ifade etmesini sağlar. iki şey:

• Toplama için varsayılan bir başlangıç ​​veya "tohum" değeri.
• Toplamanın geçerli değerini ("tohum" ile başlayan) ve listedeki sonraki öğeyi alan ve sonraki toplama değerini döndüren bir işlev.

Partiye oldukça geç kalmış olabilirim, ancak foldrbasit lambda hesabı ve curried işlevi kullanarak özel oluşturabiliriz . İşte benim python'daki foldr uygulamam.

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))

Uygulama özyinelemeli olsa da (yavaş olabilir), değerleri 15ve 120sırasıyla