{"id":3576,"date":"2024-03-03T12:17:41","date_gmt":"2024-03-03T17:17:41","guid":{"rendered":"https:\/\/www.alpharithms.com\/?p=3576"},"modified":"2024-03-03T12:17:41","modified_gmt":"2024-03-03T17:17:41","slug":"python-reduce-function","status":"publish","type":"post","link":"https:\/\/www.alpharithms.com\/python-reduce-function-411712\/","title":{"rendered":"Python Reduce(): A Powerful Functional Programming Made Simple"},"content":{"rendered":"

Python hosts several classic functional-style programming tools like map and reduce. These offer powerful means to express functional patterns, often useful in data processing pipelines (among many other applications.) The Python reduce function can be difficult to understand without a background in functional programming. In this article, we’ll cover the basic concepts of reduce and walk through a simple example.<\/p>\n

Quick Intro: Reading the Manual<\/h2>\n

As of Python 3.0+, the reduce<\/code> function lives in the functools module<\/a>. Its functionality, as described by the official documentation:<\/p>\n

Apply function of two arguments cumulatively to the items of iterable, from left to right, so as to reduce the iterable to a single value. For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])` calculates ((((1+2)+3)+4)+5). The left argument, x, is the accumulated value and the right argument, y, is the update value from the iterable. If the optional initializer is present, it is placed before the items of the iterable in the calculation, and serves as a default when the iterable is empty. If initializer is not given and iterable contains only one item, the first item is returned.<\/em><\/p>\n

The documentation also provides the following example function, stating that reduce<\/code> is the rough equivalent in functionality:<\/p>\n

def reduce(function, iterable, initializer=None):\r\n    it = iter(iterable)\r\n    if initializer is None:\r\n        value = next(it)\r\n    else:\r\n        value = initializer\r\n    for element in it:\r\n        value = function(value, element)\r\n    return value<\/pre>\n
Figure 1: Python.org’s example of reduce functions basic operation.<\/em><\/p>\n
There are two key functionalities here to note:<\/p>\n
    \n
  1. The initialization of using either the initializer<\/code> value\u00a0or<\/em> falling back to the first item in iterable<\/code>.<\/li>\n
  2. The continuous update of value<\/code> in a looping fashion.<\/li>\n<\/ol>\n
    The first is less essential to the\u00a0nature<\/em> of reduce<\/code>, but essential to understanding starting conditions. The continuous updating of the return value is the crux of how reduce<\/code> works: it\u00a0accumulates<\/em><\/strong> a value based on previous calculations<\/strong>. Let’s break this down using a simple example.<\/p>\n
    Basic Example: Using Reduce on Integer Sequence<\/h2>\n
    Python’s reduce function takes two arguments: a function<\/em> and an interable<\/em>. Optionally, one can also provide an initializer that will be used as the starting value, as discussed in Figure 1 above. In our example, the function will be a simple function that adds two numbers and a list of integer values ranging from 1-5 (inclusive) from which to pull arguments. Let’s run this to see the output:<\/p>\n
    import functools\r\n\r\n# defines the iterable\r\nnums = [1, 2, 3, 4, 5]\r\n\r\n\r\ndef two_sum(a: int, b: int) -> int:\r\n    \"\"\"\r\n    Adds two arguments together.\r\n    \"\"\"\r\n    return a + b\r\n\r\n# uses the iterable and function as arguments for reduce\r\noutput = functools.reduce(two_sum, nums)\r\n\r\n>>> 15<\/pre>\n
    The function two_sum<\/code> is used here to be as explicit as possible. Conventionally, the syntax for this would be substituted with a\u00a0lambda function<\/a> as follows:<\/p>\n
    # use lambda instead of explicit function def.\r\nfunctools.reduce(lambda a, b: a + b, nums)\r\n\r\n>>> 15<\/pre>\n
    The answer is the same, and the syntax is much reduced. Now that we’ve seen the syntax for applying the reduce<\/code> function let’s break the process down. Essentially, the reduce<\/code> function maintains a state for two values at any given step:<\/p>\n
      \n
    1. accumulator<\/strong>: a running value from previous applications of the function<\/em> argument.<\/li>\n
    2. current<\/strong>: the current value is taken as the next item in the iterable <\/em>argument.<\/li>\n<\/ol>\n
      For the example above, using the simple a + b<\/code> function and the nums<\/code> iterable, the process can be recorded as such:<\/p>\n
        \n
      1. Initial step<\/strong>:\n