05-Methods_and_functions/03_high_order_functions.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Module 5: Methods and functions\n",
    "\n",
    "## Part 3: Higher order functions\n",
    "\n",
    "Higher-order functions are functions that can accept other functions as arguments and/or return functions as results. This powerful concept is supported in Python due to functions being treated as first-class objects. In this section, we will explore the characteristics and benefits of higher-order functions and how they can enhance code flexibility and modularity.\n",
    "\n",
    "### 3.1. Accepting functions as arguments\n",
    "\n",
    "Higher-order functions can accept other functions as arguments. This allows for the encapsulation of behavior that can be customized or parameterized by the caller. By passing functions as arguments, the higher-order function can invoke or use these functions internally to perform specific operations or transformations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def apply_operation(func, x, y):\n",
    "    return func(x, y)\n",
    "\n",
    "def add(a, b):\n",
    "    return a + b\n",
    "\n",
    "def subtract(a, b):\n",
    "    return a - b\n",
    "\n",
    "result = apply_operation(add, 5, 3)\n",
    "print(result)  # Output: 8\n",
    "\n",
    "result = apply_operation(subtract, 10, 4)\n",
    "print(result)  # Output: 6"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the apply_operation function is a higher-order function that accepts a function (func) as an argument along with two values (x and y). It applies the given function to the provided values and returns the result. The add and subtract functions are passed as arguments to apply_operation, resulting in the addition and subtraction of the given values, respectively.\n",
    "\n",
    "### 3.2. Returning functions as results\n",
    "\n",
    "Higher-order functions can also generate and return new functions as their results. This capability allows for the creation of specialized functions tailored to specific use cases or configurations. The returned functions can be assigned to variables or used immediately for further computations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_multiplier(n):\n",
    "    def multiplier(x):\n",
    "        return x * n\n",
    "    return multiplier\n",
    "\n",
    "double = create_multiplier(2)\n",
    "triple = create_multiplier(3)\n",
    "\n",
    "print(double(5))  # Output: 10\n",
    "print(triple(5))  # Output: 15"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the create_multiplier function is a higher-order function that takes an argument n and returns a new function multiplier. The returned function multiplier multiplies its argument by n. By invoking create_multiplier with different values, we create specialized multiplier functions (double and triple) that can be used to multiply numbers by 2 and 3, respectively.\n",
    "\n",
    "### 3.3. Function composition\n",
    "\n",
    "Higher-order functions enable function composition, which is the process of combining multiple functions to create a new function. This composition allows for the chaining and sequencing of operations, making complex operations more manageable and readable. Function composition is achieved by passing functions as arguments or returning functions from other functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compose(func1, func2):\n",
    "    def composed_function(x):\n",
    "        return func1(func2(x))\n",
    "    return composed_function\n",
    "\n",
    "def add_one(x):\n",
    "    return x + 1\n",
    "\n",
    "def multiply_by_two(x):\n",
    "    return x * 2\n",
    "\n",
    "composed = compose(add_one, multiply_by_two)\n",
    "\n",
    "result = composed(5)\n",
    "print(result)  # Output: 11"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the compose function is a higher-order function that takes two functions (func1 and func2) and returns a new function (composed_function). The returned function applies func2 to the argument x, then applies func1 to the result. The add_one and multiply_by_two functions are composed using compose, resulting in a new function (composed) that first multiplies a number by two and then adds one.\n",
    "\n",
    "### 3.4. Summary\n",
    "\n",
    "Higher-order functions provide a powerful way to manipulate and work with functions in Python. They enhance code flexibility and modularity by allowing behavior to be encapsulated, customized, and composed. Understanding higher-order functions empowers you to write more expressive and reusable code, enabling advanced programming techniques and functional programming paradigms."
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}