Aaron Hall..

10

遞歸實現

這是一個相當優雅的遞歸實現,為了清晰起見,它使用了Python 3的功能:

def strict_compose(*funcs):

*funcs, penultimate, last = funcs

if funcs:

penultimate = strict_compose(*funcs, penultimate)

return lambda *args, **kwargs: penultimate(last(*args, **kwargs))

Python 2兼容版本:

def strict_compose2(*funcs):

if len(funcs) > 2:

penultimate = strict_compose2(*funcs[:-1])

else:

penultimate = funcs[-2]

return lambda *args, **kwargs: penultimate(funcs[-1](*args, **kwargs))

這是一個使用延遲評估遞歸的早期版本:

def lazy_recursive_compose(*funcs):

def inner(*args, _funcs=funcs, **kwargs):

if len(_funcs) > 1:

return inner(_funcs[-1](*args, **kwargs), _funcs=_funcs[:-1])

else:

return _funcs[0](*args, **kwargs)

return inner

兩者似乎都會在每次遞歸調用時創建一個新的元組和參數的dict.

所有建議的比較:

讓我們測試一些這些實現并確定哪個是最高性能的,首先是一些單個參數函數(謝謝你戳):

def square(x):

return x ** 2

def increment(x):

return x + 1

def half(x):

return x / 2

這是我們的實現,我懷疑我的迭代版本是第二高效的(手動編寫自然會最快),但這可能部分是由于它避免了在函數之間傳遞任意數量的參數或關鍵字參數的困難 - 在大多數情況下我們只會看到傳遞的瑣碎的一個論點.

from functools import reduce

def strict_recursive_compose(*funcs):

*funcs, penultimate, last = funcs

if funcs:

penultimate = strict_recursive_compose(*funcs, penultimate)

return lambda *args, **kwargs: penultimate(last(*args, **kwargs))

def strict_recursive_compose2(*funcs):

if len(funcs) > 2:

penultimate = strict_recursive_compose2(*funcs[:-1])

else:

penultimate = funcs[-2]

return lambda *args, **kwargs: penultimate(funcs[-1](*args, **kwargs))

def lazy_recursive_compose(*funcs):

def inner(*args, _funcs=funcs, **kwargs):

if len(_funcs) > 1:

return inner(_funcs[-1](*args, **kwargs), _funcs=_funcs[:-1])

else:

return _funcs[0](*args, **kwargs)

return inner

def iterative_compose(*functions):

"""my implementation, only accepts one argument."""

def inner(arg):

for f in reversed(functions):

arg = f(arg)

return arg

return inner

def _compose2(f, g):

return lambda *a, **kw: f(g(*a, **kw))

def reduce_compose1(*fs):

return reduce(_compose2, fs)

def reduce_compose2(*funcs):

"""bug fixed - added reversed()"""

return lambda x: reduce(lambda acc, f: f(acc), reversed(funcs), x)

并測試這些:

import timeit

def manual_compose(n):

return square(increment(half(n)))

composes = (strict_recursive_compose, strict_recursive_compose2,

lazy_recursive_compose, iterative_compose,

reduce_compose1, reduce_compose2)

print('manual compose', min(timeit.repeat(lambda: manual_compose(5))), manual_compose(5))

for compose in composes:

fn = compose(square, increment, half)

result = min(timeit.repeat(lambda: fn(5)))

print(compose.__name__, result, fn(5))

結果

我們得到以下輸出(Python 2和3中的相同幅度和比例):

manual compose 0.4963762479601428 12.25

strict_recursive_compose 0.6564744340721518 12.25

strict_recursive_compose2 0.7216697579715401 12.25

lazy_recursive_compose 1.260614730999805 12.25

iterative_compose 0.614982972969301 12.25

reduce_compose1 0.6768529079854488 12.25

reduce_compose2 0.9890829260693863 12.25

我的期望得到了證實:當然,最快的是手動功能組合,然后是迭代實現.惰性遞歸版本要慢得多 - 可能是因為每個函數調用都會創建一個新的堆棧幀,并為每個函數創建一個新的函數元組.

為了更好也許更現實的比較,如果您刪除**kwargs和更改*args到arg的功能,即用他們的將是更好的性能,我們可以更好地比較蘋果蘋果-從手工組成這里,一旁,reduce_compose1勝其次strict_recursive_compose:

manual compose 0.443808660027571 12.25

strict_recursive_compose 0.5409777010791004 12.25

strict_recursive_compose2 0.5698030130006373 12.25

lazy_recursive_compose 1.0381018499610946 12.25

iterative_compose 0.619289995986037 12.25

reduce_compose1 0.49532539502251893 12.25

reduce_compose2 0.9633988010464236 12.25

只有一個arg的函數:

def strict_recursive_compose(*funcs):

*funcs, penultimate, last = funcs

if funcs:

penultimate = strict_recursive_compose(*funcs, penultimate)

return lambda arg: penultimate(last(arg))

def strict_recursive_compose2(*funcs):

if len(funcs) > 2:

penultimate = strict_recursive_compose2(*funcs[:-1])

else:

penultimate = funcs[-2]

return lambda arg: penultimate(funcs[-1](arg))

def lazy_recursive_compose(*funcs):

def inner(arg, _funcs=funcs):

if len(_funcs) > 1:

return inner(_funcs[-1](arg), _funcs=_funcs[:-1])

else:

return _funcs[0](arg)

return inner

def iterative_compose(*functions):

"""my implementation, only accepts one argument."""

def inner(arg):

for f in reversed(functions):

arg = f(arg)

return arg

return inner

def _compose2(f, g):

return lambda arg: f(g(arg))

def reduce_compose1(*fs):

return reduce(_compose2, fs)

def reduce_compose2(*funcs):

"""bug fixed - added reversed()"""

return lambda x: reduce(lambda acc, f: f(acc), reversed(funcs), x)

總結

以上是生活随笔為你收集整理的python中编函数_在python中编写函数的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。