What is the 'pythonic' equivalent to the 'fold' function from functional programming?
fold, functional-programming, list, python, reduce
Solution
The Pythonic way of summing an array is using `sum`. For other purposes, you can sometimes use some combination of `reduce` (from the `functools` module) and the `operator` module, e.g.:
def product(xs):
return reduce(operator.mul, xs, 1)
Be aware that `reduce` is actually a `foldl`, in Haskell terms. There is no special syntax to perform folds, there's no builtin `foldr`, and actually using `reduce` with non-associative operators is considered bad style.
Using higher-order functions is quite pythonic; it makes good use of Python's principle that everything is an object, including functions and classes. You are right that lambdas are frowned upon by some Pythonistas, but mostly because they tend not to be very readable when they get complex.
Problem
What is the most idiomatic way to achieve something like the following, in Haskell: ``` foldl (+) 0 [1,2,3,4,5] --> 15 ``` Or its equivalent in Ruby: ``` [1,2,3,4,5].inject(0) {|m,x| m + x} #> 15 ``` Obviously, Python provides the `reduce` function, which is an implementation of fold, exactly as above, however, I was told that the 'pythonic' way of programming was to avoid `lambda` terms and higher-order functions, preferring list-comprehensions where possible. Therefore, is there a preferred way of folding a list, or list-like structure in Python that isn't the `reduce` function, or is `reduce` the idiomatic way of achieving this?