part_two/4-functions-objects.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Functions as Objects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Functions in Python are **first-class objects**. \n",
    "\n",
    "Programming language theorists define a **first-class object** as a program entity that can be:\n",
    "\n",
    "- Created at runtime\n",
    "- Assigned to a variable or element in a data structure\n",
    "- Passed as an argument to a function\n",
    "- Returned as the result of a function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Integers, strings, and dictionaries are other examples of first-class objects in Python — nothing fancy here. \n",
    "\n",
    "But if you came to Python from a language where functions are **not** first-class citizens, this notbook and the rest focuses on the implications and practical applications of treating functions as objects."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Treating a Function like an Object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def factorial(n):\n",
    "    '''returns n!'''\n",
    "    return 1 if n < 2 else n * factorial(n-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1405006117752879898543142606244511569936384000000000"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factorial(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'returns n!'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factorial.__doc__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "function"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(factorial)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "##### Introspection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__annotations__',\n",
       " '__call__',\n",
       " '__class__',\n",
       " '__closure__',\n",
       " '__code__',\n",
       " '__defaults__',\n",
       " '__delattr__',\n",
       " '__dict__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__get__',\n",
       " '__getattribute__',\n",
       " '__globals__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__kwdefaults__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__module__',\n",
       " '__name__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__qualname__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__']"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(factorial)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "function"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factorial.__class__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Use function through a different name, and pass function as argument"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.factorial>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fact = factorial\n",
    "fact"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fact(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**Note**: Having first-class functions enables programming in a **functional style**. \n",
    "\n",
    "One of the hallmarks of functional programming is the use of **higher-order functions**.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Higher-Order Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    ">A function that takes a function as argument or returns a function as the result is a higher-order function. \n",
    "\n",
    "One example is `map`. Another is the built-in function `sorted`: an optional `key` argument lets you provide a function to be applied to each item for sorting, as seen in `list.sort` and the `sorted` functions.\n",
    "\n",
    "For example, to sort a list of words by length, simply pass the `len` function as the key:."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['fig', 'apple', 'cherry', 'banana', 'raspberry', 'strawberry']"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruits = ['strawberry', 'fig', 'apple', 'cherry', 'raspberry', 'banana']\n",
    "sorted(fruits, key=len)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Anonymous Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The `lambda` keyword creates an anonymous function within a Python expression.\n",
    "\n",
    "However, the simple syntax of Python limits the body of `lambda` functions to be pure expressions. \n",
    "\n",
    "In other words, the body of a lambda cannot make assignments or use any other Python statement such as `while`, etc.\n",
    "\n",
    "The best use of anonymous functions is in the context of an argument list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['banana', 'apple', 'fig', 'raspberry', 'strawberry', 'cherry']"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruits = ['strawberry', 'fig', 'apple', 'cherry', 'raspberry', 'banana']\n",
    "sorted(fruits, key=lambda word: word[::-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Outside the limited context of arguments to higher-order functions, anonymous functions are rarely useful in Python. \n",
    "\n",
    "The syntactic restrictions tend to make nontriv‐ ial lambdas either unreadable or unworkable.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Lundh’s lambda Refactoring Recipe**\n",
    "\n",
    "If you find a piece of code hard to understand because of a lambda, Fredrik Lundh suggests this refactoring procedure:\n",
    "\n",
    "> 1. Write a comment explaining what the heck that lambda does. \n",
    "> 2. Study the comment for a while, and think of a name that captures the essence of\n",
    "the comment.\n",
    "> 3. Convert the lambda to a def statement, using that name.\n",
    "> 4. Remove the comment.\n",
    "\n",
    "These steps are quoted from the [Functional Programming HOWTO](https://docs.python.org/3/howto/functional.html), a **must read**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The `lambda` syntax is just syntactic sugar: a lambda expression creates a function object just like the def statement. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Function Annotations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Python 3** provides syntax to attach _metadata_ to the parameters of a function declaration and its return value. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def clip(text:str, max_len:'int > 0'=80) -> str:\n",
    "    \"\"\"Return text clipped at the last space before or after max_len\n",
    "    \"\"\"\n",
    "    end = None\n",
    "    if len(text) > max_len:\n",
    "        space_before = text.rfind(' ', 0, max_len)\n",
    "        if space_before >= 0:\n",
    "            end = space_before\n",
    "        else:\n",
    "            space_after = text.rfind(' ', max_len)\n",
    "            if space_after >= 0:\n",
    "                end = space_after\n",
    "    if end is None:  # no spaces were found\n",
    "        end = len(text)\n",
    "    return text[:end].rstrip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'max_len': 'int > 0', 'return': str, 'text': str}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clip.__annotations__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Annotations Overview:**\n",
    "\n",
    "- Each argument in the function declaration may have an annotation expression preceded by `:`. \n",
    "- If there is a _default value_, the annotation goes between the argument name and the `=` sign. \n",
    "- To annotate the `return` value, add `->` and another expression between the `)` and the `:` at the tail of the function declaration. \n",
    "\n",
    "The expressions may be of any type. The most common types used in annotations are classes, like `str` or `int`, or strings, like `'int > 0'`."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}