wk10/MY470_wk10_class.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### MY470 Computer Programming\n",
    "# Functional Programming in Python\n",
    "### Week 10 Lab"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## The procedural pogramming paradigm\n",
    "\n",
    "A programming paradigm is the standard practice, how you *think about* or *approach a problem*.\n",
    "\n",
    "Python at its core follows the procedural programming paradigm.\n",
    "\n",
    "- Think of programming like a recipe\n",
    "- You give specific instructions on what to do and how to do it\n",
    "- You have a global state that you are modifying\n",
    "\n",
    "You think about how things are changing over time rather that what methods you are calling to get the result you want."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## The functional programming paradigm\n",
    "\n",
    "Core principles:\n",
    "* Functions are deterministic and always produce the same output for the same input (set the random seed for stochastic process)\n",
    "* Functions have no side effects (e.g. modify arguments, modify global variables, print)\n",
    "* Variables and data are immutable\n",
    "* Functions can be passed to other functions as parameters, returned by other functions as output, and stored in data structures\n",
    "* Use recursion to implement iteration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## The functional programming paradigm\n",
    "\n",
    "![Functional programming](figs/functional_programming.png \"Functional programming\")\n",
    "Source: https://xkcd.com/1790/\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Advantages and disadvantages of functional programming\n",
    "\n",
    "* Advantages\n",
    "    * Code is easier to understand\n",
    "    * Code is easier to test and debug\n",
    "    * FP is needed to implement concurrency/parallelism\n",
    "* Disadvantages\n",
    "    * Pure functions and recursion can be difficult to understand\n",
    "    * Immutable values and recursion can decrease performance\n",
    "    * Immutable values require large memory space\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Functional programming in R vs. Python\n",
    "\n",
    "* R is, at heart, a functional programming language and R users espouse the paradigm\n",
    "    * `apply` functions\n",
    "    * piping `%>%` with `dplyr`\n",
    "    * anonymous functions: `lapply(mtcars, function(x) length(unique(x)))`\n",
    "    \n",
    "* Functional programming is enabled in Python but it is not the preferred paradigm\n",
    "    * `lambda` functions, `filter`, `map`, `reduce`\n",
    "    * Guido van Rossum would rather have you use list comprehensions\n",
    "    * FP tools can be helpful but there is no need to take the paradigm to an extreme\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Anonymous functions with `lambda`\n",
    "\n",
    "The lambda function:\n",
    "\n",
    "``` python\n",
    "lambda parameter_1, parameter_2: expression\n",
    "```\n",
    "\n",
    "is equivalent to:\n",
    "\n",
    "``` python\n",
    "def my_function(parameter_1, parameter_2):\n",
    "    expression\n",
    "```\n",
    "\n",
    "A function definition that is not bound to an identifier (i.e., it nas no name).\n",
    "\n",
    "Anonymous functions are also called function-literals.\n",
    "\n",
    "If the function is only used once, or a limited number of times, an anonymous function may be syntactically lighter than using a named function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Anonymous functions with `lambda`\n",
    "\n",
    "\n",
    "``` python\n",
    "lambda parameter_1, parameter_2: expression\n",
    "```\n",
    "\n",
    "The lambda function is an expression. You have a parameter list like you do in a user defined function. \n",
    "\n",
    "A lambda function can take **any number of arguments**, but can only have **one expression**.\n",
    "\n",
    "In lambda, your code must be on the same line. You can use a `\\` to break up lines, but anonymous functions should not be very long.\n",
    "\n",
    "The lambda expression **returns a callable** (i.e. function). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Anonymous functions with `lambda`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Roald Dahl',\n",
       " 'Zadie Smith',\n",
       " 'J.K. Rowling',\n",
       " 'George Orwell',\n",
       " 'Salman Rushdie']"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "authors = ['George Orwell', 'Zadie Smith', 'J.K. Rowling', \n",
    "           'Roald Dahl', 'Salman Rushdie']\n",
    "# Return list ordered by length of author name\n",
    "sorted(authors, key=len)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Roald Dahl',\n",
       " 'George Orwell',\n",
       " 'J.K. Rowling',\n",
       " 'Salman Rushdie',\n",
       " 'Zadie Smith']"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Return list ordered alphabetically by last name\n",
    "sorted(authors, key=lambda name: name.split()[-1])  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Iteration with `filter`\n",
    "\n",
    "The filter function:\n",
    "\n",
    "```python\n",
    "filter(function_to_evaluate_true, iterable)\n",
    "```\n",
    "\n",
    "is equivalent to:\n",
    "\n",
    "```python\n",
    "(item for item in iterable if function_to_evaluate_true(item))\n",
    "```\n",
    "\n",
    "Filter returns an iterable.\n",
    "\n",
    "Filter applies the function to each item in the passed iterable. If the result is `True`, then it adds the item to the iterator. If it is `False`, then it keeps going until it finds a `True` or reaches the end."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "my_var = filter(lambda a: a%2 == 1,\n",
    "                reversed(range(20)))\n",
    "\n",
    "# What is the first result of calling next() my_var?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "19"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# It returns odd numbers, counting back from 19\n",
    "next(my_var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Iteration with `filter`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['J.K. Rowling', 'Salman Rushdie']"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Return list of authors whose last name starts with 'R'\n",
    "list(filter(lambda name: name.split()[-1][0]=='R', authors))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Sian', 'Patrick', 'Milena', 'Yuanmo']"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Can use filter to remove empty strings from a list\n",
    "names = [\"Sian\", \"\", \"Patrick\", \"Milena\", \"\", \"Yuanmo\"]\n",
    "\n",
    "# We can pass None as the first argument\n",
    "# If function_to_evaluate_true is None, the identity function is assumed, \n",
    "# that is, all elements of iterable that are false are removed\n",
    "# In Python, empty strings evaluate as False\n",
    "filt_names = list(filter(None, names))\n",
    "filt_names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Iteration with `map`\n",
    "\n",
    "```python\n",
    "map(function_to_apply, iterable)\n",
    "```\n",
    "\n",
    "`map()` takes a function and one or more iterables. Returns an iterator.\n",
    "\n",
    "1. Takes each of the iterables.\n",
    "2. Calls next() on each of them. \n",
    "3. Passes these as a series of arguments to the function.\n",
    "4. The result of the iterator is the result of the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Takes x and y and adds them together; returns an iterable\n",
    "my_var = map(lambda x, y: x + y, range(10), range(10, 20))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(my_var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Iteration with `map`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[13, 11, 12, 10, 14]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get the length of each name in authors\n",
    "list(map(len, authors))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Orwell, George',\n",
       " 'Smith, Zadie',\n",
       " 'Rowling, J.K.',\n",
       " 'Dahl, Roald',\n",
       " 'Rushdie, Salman']"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Invert author name to Last, First\n",
    "list(map(lambda name: ', '.join(reversed(name.split())), authors))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## List comprehensions vs. `map`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "def area(r):\n",
    "    \"\"\"\n",
    "    Reurns area of a circle with radius 'r'.\n",
    "    Accepts numeric types\n",
    "    \"\"\"\n",
    "    return math.pi * (r**2)\n",
    "\n",
    "# What if we need to compute the area for lots of different circles?\n",
    "radii = [2, 5, 7.8, 4.2, 37]\n",
    "\n",
    "# List comprehension\n",
    "areas1 = [area(r) for r in radii]\n",
    "    \n",
    "# With map ... (can pass the map object to the list constructor)\n",
    "areas2 = list(map(area, radii))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List comprehension: 0.15523971099992195\n",
      "Map function: 0.15162779099955515\n"
     ]
    }
   ],
   "source": [
    "from timeit import timeit\n",
    "\n",
    "print('List comprehension:', timeit('[area(r) for r in radii]', \n",
    "                                    setup='from __main__ import area, radii', \n",
    "                                    number=10**5) )\n",
    "print('Map function:',  timeit('list(map(area, radii))', \n",
    "                               setup='from __main__ import area, radii', \n",
    "                               number=10**5) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Iteration with `reduce`\n",
    "\n",
    "Applies a rolling computation to sequential pairs of values in an iterable\n",
    "\n",
    "```\n",
    "data = [a, b, c, d, e, ... n]\n",
    "\n",
    "reduce(function, data):\n",
    "    Step 1: val_1 = function(a, b)\n",
    "    Step 2: val_2 = funtion(val_1, c)\n",
    "    Step 2: val_3 = funtion(val_2, d)\n",
    "    Step 2: val_4 = funtion(val_3, e)\n",
    "    [...]\n",
    "    Step n-1: val_n-1 = function(val_n-2, n)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'George Orwell, Zadie Smith, J.K. Rowling, Roald Dahl, Salman Rushdie'"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# No longer a built-in funtion in Python 3\n",
    "\n",
    "# Guido van Rossum: \"Use functools.reduce() if you really need it; \n",
    "# however 99% of the time an explict for-loop is more readable.\"\n",
    "\n",
    "from functools import reduce\n",
    "\n",
    "reduce(lambda x, y: x + ', ' + y, authors)  # equivalent to: ', '.join(authors)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Iteration with `reduce`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6469693230\n",
      "6469693230\n"
     ]
    }
   ],
   "source": [
    "# Multiply all numbers in a list\n",
    "\n",
    "data = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]\n",
    "\n",
    "# To use reduce, you need a funtion that takes two inputs.\n",
    "multiplier = lambda x, y: x*y\n",
    "print(reduce(multiplier, data))\n",
    "\n",
    "# For-loop\n",
    "product = 1\n",
    "for x in data:\n",
    "    product = product * x \n",
    "print(product)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Exercise 1: Use map() and lambda to add the elements of two lists below. \n",
    "# The answer should be [101, 210, 400, 1400, 10500].\n",
    "\n",
    "ls1 = [100, 200, 300, 400, 500]\n",
    "ls2 = [1, 10, 100, 1000, 10000]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# Exercise 2: Now use a list comprehension to solve Exercise 1.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Exercise 3: Use map() and lambda to create a list consisting of \n",
    "# the frequency of the letter \"a\" (regardless of case) in each string\n",
    "# in the list below. The answer should be [3, 4, 2, 3].\n",
    "\n",
    "states = [\"Alaska\", \"Alabama\", \"Arizona\", \"Arkansas\"]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# Exercise 4: Use filter() and lambda to get a list \n",
    "# of all the vowels in the string.\n",
    "\n",
    "sentence = 'They did nothing as the raccoon attacked the lady’s bag of food.'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 9, 4, 49, 64, 100, 9, 25, 16, 49] [1, 9, 4, 49, 64, 100, 9, 25, 16, 49]\n"
     ]
    }
   ],
   "source": [
    "# Exercise 5: Use functional programming to rewrite the list comprehension below.\n",
    "\n",
    "lst = [1, 3, 2, 4.5, 7, 8, 10, 3, 5, 4, 7, 3.33]\n",
    "\n",
    "ans = [i**2 for i in lst if type(i) == int] \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 6: Use functional programming to rewrite the list comprehension below.\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "x = np.random.normal(0, 1, 100)\n",
    "\n",
    "y = [\"Positive\" if i > 0 else \"Negative\" for i in x]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 7: Use functional programming to rewrite the code below.\n",
    "# The code sums the even integers from a given list.\n",
    "\n",
    "lst = [1, 3, 2, 4.5, 7, 8, 10, 3, 5, 4, 7, 3.33]\n",
    "\n",
    "summ = 0\n",
    "for i in lst:\n",
    "    if i % 2 == 0:\n",
    "        summ += i\n",
    "print(summ)"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}