7.  Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*********************************************************************************************************\n",
    "# A Tour of Python 3  \n",
    "version 1.0.1  \n",
    "Authors: Phil Pfeiffer, Zack Bunch, and Feyisayo Oyeniyi  \n",
    "East Tennessee State University  \n",
    "Last updated June 2021  \n",
    "*********************************************************************************************************"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 7.  Functions  \n",
    " 7.1 [Overview](#Functions-Overview)  \n",
    " 7.2 [Library functions](#Functions-Library-Functions)  \n",
    " &ensp;7.2.1  [Built-in library functions](#Functions-Library-Functions-Builtin)  \n",
    " &ensp;7.2.2  [Other library functions](#Functions-Library-Functions-Other)  \n",
    " 7.3 [User-Defined Functions](#Functions-Def)  \n",
    " &ensp; 7.3.1 [Overview](#Functions-Def-Overview)  \n",
    " &ensp;&ensp;&ensp; 7.3.1.1 [Functions without arguments](#Functions-Def-No-Arguments)  \n",
    " &ensp;&ensp;&ensp; 7.3.1.2 [Functional with positional arguments](#Functions-Def-Positional-Arguments)  \n",
    " &ensp;&ensp;&ensp; 7.3.1.3 [Functions with list arguments](#Functions-Def-Vararg-Functions)   \n",
    " &ensp;&ensp;&ensp; 7.3.1.4 [Functions with keyword arguments](#Functions-Def-Keyword-Arguments)  \n",
    " &ensp;&ensp;&ensp; 7.3.1.5 [Python and scoping](#Functions-Def-Scoping)  \n",
    " 7.4 [Lambda expressions](#Functions-Lambda-Expressions)  \n",
    " 7.5 [Generators](#Functions-Generators)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7.1  Overview <a name='Functions-Overview'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python can be thought of as providing four kinds of functions:\n",
    "-  [library functions](#Functions-Library-Functions)\n",
    "-  [user-defined, named functions](#Functions-Def)\n",
    "-  [user-defined, nameless functions, known as lambda expressions](#Functions-Lambda-Expressions)\n",
    "-  [coroutine-like named functions, known as *generators*](#Functions-Generators)\n",
    "\n",
    "A fifth function-like object, an *iterator*, is discussed in the [unit on classes](./10.%20Classes.ipynb#Classes-Operator-Customization-Iterators)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7.2  Library functions <a name='Functions-Library-Functions'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python's standard library of functions can be divided into two groups:\n",
    "-  built-in functions, which are loaded by default into the environment on startup\n",
    "-  module-based functions like math.ceil and math.log10 that must be imported into a user's session to be accessed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.2.1  Built-in library functions <a name='Functions-Library-Functions-Builtin'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Examples of Python built-ins from previous examples include `print`, `len`, `range`, and `dir`. \n",
    " The following examples show further examples of built-ins."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.2.1.a  built-ins for managing sequences:  sorted()\n",
    "\n",
    "x = [3, 1, 4, 2]\n",
    "print( f'x, sorted(x) are {x}, {sorted(x)}' )\n",
    "print( f'x, sorted(x, reverse=True) are {x}, {sorted(x, reverse=True)}' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.2.1.b  built-ins for managing sequences:  reversed()\n",
    "\n",
    "x = [3, 1, 4, 2]\n",
    "print( f'x, reversed(x) are {x}, {list(reversed(x))}' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.2.1.c  built-ins for managing sequences:  enumerate()\n",
    "\n",
    "[ (index, value) for (index, value) in enumerate( ['three', 'one', 'four', 'two'] ) ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.2.1.d  built-ins for managing sequences:  zip()\n",
    "\n",
    "x = [3, 1, 4, 2]\n",
    "y = ['three', 'one', 'four', 'two']\n",
    "print( f'x, y, zip(x, y) are {x}, {y}, {[v for v in zip(x, y)]}' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.2.1.e  built-ins for interpreting strings as code:  eval()\n",
    "# eval evaluates a single expression, returning a single value \n",
    "\n",
    "print( 'eval(3+4) is ', eval('3 + 4') )\n",
    "x = 3\n",
    "print( f\"eval(x+4) when x is {x} is {eval('x + 4')}\" )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.2.1.f  built-ins for interpreting strings as code:  eval()\n",
    "# eval doesn't evaluate statements \n",
    "\n",
    "x = 3\n",
    "eval('x = 3 + 4')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.2.1.g  built-ins for interpreting strings as code:  exec()\n",
    "# exec evaluates a statement block, returning None\n",
    "\n",
    "exec('x = 7; print( \\'x after exec(x=7) is \\', x )')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.2.1.h  identifying all built-in functions by searching for objects with the '__call__' attribute\n",
    "\n",
    "[ built_in for built_in in dir(__builtins__) if '__call__' in dir(eval(built_in)) ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For more documentation on Python built-ins, see [the Python library manual](https://docs.python.org/3/library/functions.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.2.2  Other library functions <a name='Functions-Library-Functions-Other'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The [Python 3.8 standard library documentation](http://docs.python.org/3/library/) devotes 33 sections to the non-built-in parts of Python's library. ",
    "For a list of these libraries, see this document or [Appendix C](./Appendix%20C%20-%20Python%20Libraries.ipynb) of this guide. ",
    "The next example shows functions from Python's file system access module.  They include the following:\n",
    "-  `os.walk` - recursively traverse a directory hierarchy, invoking error-handling callback as needed\n",
    "-  `os.open` - open a file for processing\n",
    "-  `os.path.splitext` - split a file name into the name proper [0] and its extension [1]\n",
    "-  `os.stat` - obtain statistics related to when and how file has been accessed\n",
    "-  `os.close` - close an open file\n",
    "-  `time.ctime` - print a value as a human-readable time\n",
    "-  `filestat.st_ctime` - time when file was created\n",
    "-  `filestat.st_atime` - time when file was last accessed\n",
    "-  `filestat.st_mtime` - time when file was last modified"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# library resources\n",
    "import os, stat, time\n",
    "\n",
    "# supporting functions\n",
    "make_printable = lambda exception: '' if str(exception) is None else str(exception)\n",
    "\n",
    "# walk a tree in a directory, returning properties of files with a given extension\n",
    "\n",
    "def dirwalk(directory, extension):\n",
    "  def _onerr(exception):\n",
    "    print( f\"can't access {directory}: {make_printable(exception)}\" )\n",
    "  try:\n",
    "    for (this_directory, _, these_filenames) in os.walk(directory, onerror=_onerr):\n",
    "      files_of_interest = [filename for filename in these_filenames if '.' + extension == os.path.splitext(filename)[1]]\n",
    "      if len(files_of_interest):\n",
    "        print(this_directory)\n",
    "        indent = '  '\n",
    "        for this_file in files_of_interest:\n",
    "          print(indent, this_file)\n",
    "          try:\n",
    "            this_file_fd = os.open(this_directory + '\\\\' + this_file, os.O_RDONLY)\n",
    "            try:\n",
    "              filestat = os.stat(this_file_fd)\n",
    "              print(3*indent, f'file size:     {filestat.st_size} bytes' )\n",
    "              print(3*indent, f'create time:   {time.ctime(filestat.st_ctime)}' )\n",
    "              print(3*indent, f'last accessed: {time.ctime(filestat.st_atime)}' )\n",
    "              print(3*indent, f'last modified: {time.ctime(filestat.st_mtime)}' )\n",
    "            except Exception as exception:\n",
    "              print(2*indent, f\"?? can't stat {this_file}: {make_printable(exception)}\" ) \n",
    "            finally:\n",
    "              os.close(this_file_fd)\n",
    "          except Exception as exception:\n",
    "            print(2*indent, f\"?? can't open {this_file}: {make_printable(exception)}\" )\n",
    "  except Exception as exception:\n",
    "    print( f\"can't access directory {this_directory}: {make_printable(exception)}\" )\n",
    "\n",
    "dirwalk('c:\\\\temp', 'txt')   # change this statement to access other directories and file types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7.3  User-Defined Functions <a name='Functions-Def'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.3.1  Overview <a name='Functions-Def-Overview'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions are defined using `def`.",
    "  `def` is an executable statement that, if successful, dynamically updates Python's *environment*: ",
    " the lists that Python searches to determine the values of identifiers in the expressions it executes.\n",
    "\n",
    "A `def` statement takes the following arguments:\n",
    "-  The name of a function - a valid Python identifier\n",
    "-  A prototype\n",
    "   -  An optional list of positional arguments, members in the tail end of which may have defaults (i.e., arg=value), followed by\n",
    "   -  An optional argument of the form &ast;*list_name*, where *list_name* names a list of arguments, followed by\n",
    "   -  An optional keyword argument of the form &ast;&ast;*keywords*, where *keywords* is a dict of arguments\n",
    "-  The function's body - a nonempty list of statements\n",
    "-  A final, blank line\n",
    "\n",
    "While functions can have attributes, they do not by default preserve state between calls.\n",
    "\n",
    "Functions can explicitly `return` values to their callers. ",
    "Functions that execute without executing a final `return` return `None`.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7.3.1.1  Functions without arguments <a name='Functions-Def-No-Arguments'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.3.1.1.a a function that takes no arguments and has no return statement\n",
    "\n",
    "def it_does_nothing():  pass\n",
    "print( it_does_nothing() )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.3.1.1.b a function that returns a constant value\n",
    "\n",
    "def it_just_returns_2():  return 2\n",
    "print( it_just_returns_2() )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7.3.1.2  Functions with positional arguments <a name='Functions-Def-Positional-Arguments'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.3.1.2.a the identity functions\n",
    "\n",
    "def it_just_returns_2():  return 2\n",
    "def ident(x):  return x\n",
    "\n",
    "print('ident is ', ident)\n",
    "print('ident(10) is ', ident(10))\n",
    "print('ident(it_just_returns_2) is ', ident(it_just_returns_2))\n",
    "print('ident(it_just_returns_2()) is ', ident(it_just_returns_2()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.3.1.2.b  return a pair of values\n",
    "\n",
    "def it_just_returns_2():  return 2\n",
    "def pair(x, y):  return (x, y)\n",
    "\n",
    "print('pair(3.2, 6) is ', pair(3.2, 6))\n",
    "print('pair(it_just_returns_2, 4) is ', pair(it_just_returns_2, 4))\n",
    "print('pair(pair, pair) is ', pair(pair, pair) )\n",
    "print('pair(pair(pair, pair), pair(3.2, 6)) is ', pair(pair(pair, pair), pair(3.2, 6)) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.3.1.2.c  return a pair of values, defaulting the second to 0\n",
    "\n",
    "def it_just_returns_2():  return 2\n",
    "def pair(x, y=0):  return (x, y)\n",
    "\n",
    "print('pair(3.2) is ', pair(3.2))\n",
    "print('pair(it_just_returns_2) is ',  pair(it_just_returns_2))\n",
    "print('pair(pair(pair)) is ', pair(pair(pair)) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.3.1.2.d  this should fail - all formals without defaults must precede all formals with defaults\n",
    "\n",
    "def it_just_returns_2():  return 2\n",
    "def pair(x=0, y):  return (x, y)\n",
    "\n",
    "print('pair(3.2) is ', pair(3.2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.3.1.2.e  return k copies of a pair of values\n",
    "\n",
    "def k_pairs(x, y, k):  return [(x, y)] * k\n",
    "\n",
    "print('k_pairs(3.2, 6, 0) is ', k_pairs(3.2, 6, 0) )\n",
    "print('k_pairs(3.2, 6, 1) is ', k_pairs(3.2, 6, 1) )\n",
    "print('k_pairs(3.2, 6, 4) is ', k_pairs(3.2, 6, 4) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.3.1.2.f  previous function, with check for k's validity\n",
    "\n",
    "def k_pairs(x, y, k):\n",
    "  assert isinstance(k, int) and k>=0, 'repeat count must be a nonnegative integer'\n",
    "  return [(x, y)] * k\n",
    "\n",
    "k_pairs(3.2, 6, -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.3.1.2.g  functions can accept and apply other functions as arguments\n",
    "\n",
    "def pair(x, y):  return (x, y)\n",
    "def apply(f, x, y):  return f(x, y)\n",
    "\n",
    "apply(pair, 2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue' >",
    "&#128073;&ensp;&ensp;**Exercise 7.3.1.2.1:**\n\n",
    "</span>",
    "<span style='color:navy' >",
    "In the following code cell, ",
    "write a function that generalizes ",
    "[the print Python docstrings](./4.%20%20Interactive%20help%20features.ipynb#Interactive-Help-Features-Docstrings) ",
    "example code by accepting one argument-- a module's name-- and outputs docstrings for all items in that module.",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following are more complex examples of function design, using Fibonacci series. ",
    "The following examples use this additional Python construct:\n",
    "-  `lru_cache` - A Python *decorator* that adds a *memoizing* capability to a function.\n",
    "\n",
    "The following three definitions should prove useful for interpreting these examples:\n",
    "-  *functional* - A function that returns a function\n",
    "-  *decorator* <a name='Functions-Decorator'></a> - A *functional* that wraps a function in logic that does either, or both, of two things:\n",
    "   -   preprocesses the function's inputs\n",
    "   -   postprocesses the function's outputs\n",
    "-  *memoization* - The use of a 'quick lookup table' to store maps from recent inputs to recent outputs, \n",
    "thereby taking up more space but potentially saving time by avoiding recomputation of results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.3.1.2.h  Fibonacci series, version 1:  efficient fib() with manual memoizing. \n",
    "# This is a little clumsy, in that the memoizing (i.e., helper) function is at the top level\n",
    "\n",
    "def fib_helper(k):\n",
    "  if k < 1:  return (0, None)\n",
    "  if k < 2:  return (1, 0)\n",
    "  k_1, k_2  = fib_helper(k-1)\n",
    "  return (k_1 + k_2, k_1)\n",
    "\n",
    "def fib(k): return fib_helper(k)[0]\n",
    "\n",
    "[fib(i) for i in range(1,36)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.3.1.2.i  Fibonacci series, version 2:  efficient fib() with manual memoizing. \n",
    "# Here, the helper function is local to fib()\n",
    "\n",
    "def fib(k):\n",
    "  def fib_helper(k):\n",
    "    if k < 1:  return (0, None)\n",
    "    if k < 2:  return (1, 0)\n",
    "    k_1, k_2 = fib_helper(k-1)\n",
    "    return (k_1 + k_2, k_1)\n",
    "  return fib_helper(k)[0]\n",
    "\n",
    "[fib(i) for i in range(36)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.3.1.2.j  Fibonacci series, version 3:  compact but inefficient (exponential) fib() with no memoization\n",
    "# depending on the platform, this may take some tens of seconds to complete\n",
    "\n",
    "def fib(k):  return 0 if k < 1 else 1 if k < 2 else fib(k-1) + fib(k-2)\n",
    "\n",
    "[fib(i) for i in range(36)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.3.1.2.k  Fibonacci series, version 4\n",
    "# efficient fib(), using Python library memoizing functional lru_cache\n",
    "\n",
    "from functools import lru_cache\n",
    "\n",
    "@lru_cache(maxsize=None)\n",
    "def fib(k):  return 0 if k < 1 else 1 if k < 2 else fib(k-1) + fib(k-2)\n",
    "\n",
    "[fib(i) for i in range(1,36)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A *closure* is a function that captures some sort of state when it's defined and that (typically) uses that state ",
    "to compute a result.  The following are two examples of closures."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.3.1.2.l  a simple closure; it retains one value, which remains constant\n",
    "\n",
    "def plus_n(n):\n",
    "  def f(x): return n+x\n",
    "  return f\n",
    "\n",
    "plus_4 = plus_n(4)   # the closure\n",
    "\n",
    "plus_4(-4), plus_4(0), plus_4(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.3.1.2.m  a function that updates its closure\n",
    "# note that functions can hold attributes:\n",
    "# here, a reference to a local attribute that f() uses to compute its result\n",
    "\n",
    "def f():\n",
    "  f.x = 0 if not(hasattr(f, 'x')) else f.x+1\n",
    "  return f.x\n",
    "\n",
    "print( f(), f(), f() )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7.3.1.3  Functions with list arguments <a name='Functions-Def-Vararg-Functions'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python, like C, supports functions that accept variable numbers of arguments.",
    " Python's `print` function is one such *vararg* function.  Examples of others are given below.\n",
    "\n",
    "NOTE: Python **does not** support overloading in the C++/ Java/ C# sense of the term!\n",
    "-  A redefinition of a function f in a given scope overwrites all earlier definitions, rather than overloading them.\n",
    "-  Functions, however, can be made to accept varying numbers of values-- a common goal of overloading-- using varargs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.3.1.3.a  a function that takes just varargs\n",
    "\n",
    "def f(*args):\n",
    "  for (index, arg) in enumerate(args):\n",
    "     print( f'vararg {index} is {arg}' )\n",
    "\n",
    "f(1, 2, 3, 'a', 'b', 'c', [4, 5, 6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.3.1.3.b  passing a list as a varargs argument, using an initial *\n",
    "\n",
    "def f(*args):\n",
    "  for (index, arg) in enumerate(args):\n",
    "     print( f'vararg {index} is {arg}' )\n",
    "\n",
    "arg_list = [1, 2, 3, 'a', 'b', 'c', [4, 5, 6]]\n",
    "f(*arg_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.3.1.3.c  the previous example, but without an initial * for the actual parameter list\n",
    "\n",
    "def f(*args):\n",
    "  for (index, arg) in enumerate(args):\n",
    "    print( f'vararg {index} is {arg}' )\n",
    "\n",
    "arg_list = [1, 2, 3, 'a', 'b', 'c', [4, 5, 6]]\n",
    "f(arg_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.3.1.3.d  mixing positional parameters and varargs - with an excess of positional parameters\n",
    "\n",
    "def f(a, b, c, *args):                # varargs must follow ordinary args\n",
    "  print( f'a, b, c are {a}, {b}, {c}' )\n",
    "  for (index, arg) in enumerate(args):\n",
    "    print( f'vararg {index} is {arg}' )\n",
    "\n",
    "f(1, 2, 3, 'a', 'b', 'c', [4, 5, 6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.3.1.3.e  mixing positional parameters and varargs - with just enough positional parameters\n",
    "\n",
    "def f(a, b, c, *args):\n",
    "  print( f'a, b, c are {a}, {b}, {c}' )\n",
    "  for (index, arg) in enumerate(args):\n",
    "     print( f'vararg {index} is {arg}' )\n",
    "\n",
    "f(1, 2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.3.1.3.f  mixing positional parameters and varargs - with insufficient positional parameters\n",
    "\n",
    "def f(a, b, c, *args):\n",
    "  print( f'a, b, c are {a}, {b}, {c}' )\n",
    "  for (index, arg) in enumerate(args):\n",
    "     print( f'vararg {index} is {arg}' )\n",
    "\n",
    "f(1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.3.1.3.g  mixing positional parameters, one with a default value, and varargs\n",
    "\n",
    "def f(a, b, c=17, *args): \n",
    "  print( f'a, b, c are {a}, {b}, {c}' )\n",
    "  for (index, arg) in enumerate(args):\n",
    "     print( f'vararg {index} is {arg}' )\n",
    "\n",
    "f(1, 2, 3, 'a', 'b', 'c', [4, 5, 6])     # succeeds\n",
    "print('---')\n",
    "f(1, 2, 3)                               # succeeds, but with no varargs\n",
    "print('---')\n",
    "f(1, 2)                                  # succeeds - again with no varargs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 7.3.1.3.1:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following code cell, ",
    "construct an example that shows whether a tuple, when preceded by an asterisk (&ast;), can be passed as a varargs argument.",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7.3.1.4  Functions with keyword arguments <a name='Functions-Def-Keyword-Arguments'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Keyword arguments are a second mechanism for defining functions that accept varying numbers of values.\n",
    "  Python allows one keywords parameter per function.  Keyword parameters can be specified in one of two ways:\n",
    "-  using a dictionary\n",
    "-  using named positional parameters, following an &ast; argument that separates named from unnamed parameters\n",
    "\n",
    "Keyword keys must be valid identifiers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.3.1.4.a  a function that takes just keywords\n",
    "\n",
    "def f(**kwds):\n",
    "  for (key, value) in kwds.items():\n",
    "    print( f'keyword {key} is {value}' )\n",
    "\n",
    "f(first=1, second=[2,2], third=(3,), fourth={4:'four', 'four':4})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.3.1.4.b  passing a dict to a function, using an initial **\n",
    "\n",
    "def f(**kwds):\n",
    "  for (key, value) in kwds.items():\n",
    "    print( f'keyword {key} is {value}' )\n",
    "\n",
    "kwd_dict = {'first':1, 'second':[2,2], 'third':(3,), 'fourth':{4:'four', 'four':4}}\n",
    "f(**kwd_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions can mix positional parameters and keywords.\n",
    "  If both are present, all positional parameters must precede the function's keyword argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.3.1.4.c  mixing positional parameters and keywords.\n",
    "# since first and second params lack defaults, both are required.\n",
    "\n",
    "def f( first, second, **kwds ): \n",
    "  print( 'first two parameters are %r and %r' % (first, second) )\n",
    "  for (key, value) in kwds.items():\n",
    "    print( f'keyword {key} is {value}' )\n",
    "\n",
    "kwd_dict = {'third':(3,), 'fourth':{4:'four', 'four':4}}\n",
    "f(1, [2,2], **kwd_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.3.1.4.d  the previous example, using * to separate positional and keyword parameters \n",
    "\n",
    "def f(first, second, *, third='default', fourth):      # first, second, and fourth are required\n",
    "  print( f'first two parameters are {first!r} and {second!r}' )\n",
    "  print( f\"keywords 'third' and 'fourth' are {third!r} and {fourth!r}\" )\n",
    "\n",
    "kwd_dict = { 'third':(3,), 'fourth':{4:'four', 'four':4} }\n",
    "f(1, [2,2], **kwd_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Combining positional arguments, varargs, and keyword parameters is also possible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.3.1.4.e  combining positional arguments, varargs, and keyword parameters\n",
    "\n",
    "def f(a=0, *args, **kwds):\n",
    "  print( 'a is', a )\n",
    "  for (argno, arg) in enumerate(args):\n",
    "    print( f'vararg {argno} is {arg}' )\n",
    "  for (key, value) in kwds.items():\n",
    "    print( f'keyword {key} is {value}' )\n",
    "\n",
    "arg_list = [1, 2, 3, ]\n",
    "kwd_dict = {'first':1, 'second':[2,2], 'third':(3,)}\n",
    "\n",
    "f(1, *arg_list, **kwd_dict)\n",
    "print('----')\n",
    "f(1, *arg_list)                # will succeed - no keywordsprint('----')\n",
    "f(1, **kwd_dict)               # will succeed - no varargs\n",
    "print('----')\n",
    "f(*arg_list, **kwd_dict)       # will succeed - no positional parameters\n",
    "print('----')\n",
    "f()                            # will succeed - no arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7.3.1.5  Python and scoping <a name='Functions-Def-Scoping'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A full understanding of `def`'s effect requires an understanding of the environment's structure.",
    " Python's environment can be thought of as a master list that names all identifiers that can be referenced ",
    " by codes outside of all function and class definitions: i.e., at an interpreter's global scope.\n",
    "-  Each function and class at global scope, in turn, contains a master list of identifiers at scope depth of 1: i.e.,\n",
    "    -  identifiers that are in that list, and\n",
    "    -  outside all other functions and classes that this list contains; i.e.,.\n",
    "-  Each function and class at scope depth 1, in turn, contains a master list of identifiers at a scope depth of 2: i.e.,\n",
    "    -  identifiers that are in that list, and\n",
    "    -  outside of all other functions and classes that this list contains.\n",
    "\n",
    "This nesting of \"code container\" objects within \"code container\" objects-can be continued indefinitely,",
    " like the nesting of scopes in lexically scoped, compiled languages like Pascal, C, C++, Java, and C#.\n",
    "\n",
    "The following are two **key** differences between Python and typical, lexically scoped, compiled languages:\n",
    "-   `def` and `class` are the only statements that open new scopes.\n",
    "    -  `while`, `try`, and `if` statements don't open new scopes.  \n",
    "    -  `for` statements treat their induction variables as local, but don't otherwise open a new scope. \n",
    "\n\n",
    "-  Since Python doesn't require identifier declarations, it can't use declarations to associate references with scopes. Rather,\n",
    "   -   Python associates every well-formed identifier with an object in exactly one of three scopes:\n",
    "       -  the global scope, the scope of the top-level interpreter\n",
    "       -  the local scope, the scope of current def or class declaration\n",
    "       -  some nonlocal scope, the scope of identifiers that lie \"above\" the current local scope and \"below\" global scope.\n",
    "   -   An identifier's scope is determined as follows:\n",
    "       -   All identifiers defined at Python's global scope are global:  i.e.,\n",
    "           -  Global declarations are ignored at the global level.\n",
    "           -  Nonlocal declarations are treated as erroneous.\n",
    "       -   All identifiers defined in non-global scopes are \"local\", unless declared as `global`, `nonlocal`, or as formal parameters.\n",
    "           -  Declaring an identifier as `global` *and* `nonlocal` in a common scope is erroneous.\n",
    "           -  Declaring a formal parameter as either \"global\" *or* \"nonlocal\" is erroneous.\n",
    "   -   The referent of an identifier *x* in a non-global scope is determined as follows:\n",
    "        -  if no declarations in the current scope name *x*, then *x* is treated as local identifier.\n",
    "        -  if *x* is a formal function parameter, \n",
    "           -   if *x* referenced an immutable value on call, then *x* functions as a local variable.\n",
    "           -   otherwise, *x* references whatever (mutable object) it was bound to.\n",
    "        -  if *x* is named in a `global` declaration, *x* is treated as a member of the global environment.\n",
    "        -  otherwise,\n",
    "              -  if *x* is read before being updated in the current scope, x is treated as a member of closest enclosing non-global scope.\n",
    "              -  otherwise, x is treated as a local value.\n",
    "\n",
    "The following examples illustrate these rules."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Global-scope-related examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  7.3.1.5.a   g() returns x's global value rather than its nonlocal value (0)\n",
    "\n",
    "x = 'global value for x'\n",
    "\n",
    "def f():\n",
    "  x = 'nonlocal value for x'\n",
    "  def g():\n",
    "    global x  # this declaration will cause the inner x to be ignored\n",
    "    return x\n",
    "  return g()\n",
    "\n",
    "print( 'f() returns ', f() )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  7.3.1.5.b.  Python flags this definition as erroneous, due to the naming conflict in g()\n",
    "\n",
    "x = 'global value for x'\n",
    "\n",
    "def f():\n",
    "  x = 'nonlocal value for x'\n",
    "  def g(x):\n",
    "    global x   # attempt to make a nonlocal 'x' reference a global 'x'\n",
    "    return x\n",
    "  return g(x)\n",
    "print( 'f() returns ', f() )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.3.1.5.c  h() returns x's global value rather than its nonlocal value\n",
    "\n",
    "x = 'global value for x'\n",
    "\n",
    "def f():\n",
    "  x = 'nonlocal value for x'\n",
    "  def g(x):\n",
    "    def h():\n",
    "      global x  # this declaration will cause the inner x to be ignored\n",
    "      return x\n",
    "    return h()\n",
    "  return g(x)\n",
    "\n",
    "print( 'f() returns ', f() )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.3.1.5.d  here, x references a global, since it's read before being written\n",
    "# and not defined in any enclosing scope\n",
    "\n",
    "x = 'global value for x'\n",
    "\n",
    "def f():\n",
    "  def g():\n",
    "    return x\n",
    "  return g()\n",
    "\n",
    "print( 'f() returns ', f() )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.3.1.5.e  a self-destructing function  (not recommended, as a rule...)\n",
    "\n",
    "def f():\n",
    "  global f\n",
    "  del f\n",
    "  # quote from an old Rolling Stones tune...\n",
    "  return \"this could be the last time, \\n\"*2 + \"maybe the last time, I don\\'t know\\n\"\n",
    "\n",
    "print(f())\n",
    "print(f())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nonlocal-scope-related examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.3.1.5.f  the nonlocal declaration is valid, since x is defined in f()\n",
    "\n",
    "def f():\n",
    "  x = 'nonlocal value for x'\n",
    "  def g():\n",
    "    nonlocal x\n",
    "    return x\n",
    "  return g()\n",
    "\n",
    "print( 'f() returns ', f() )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.3.1.5.g  like the previous example, except the nonlocal is updated\n",
    "\n",
    "def f():\n",
    "  x = 'nonlocal value for x'\n",
    "  def g():\n",
    "    nonlocal x\n",
    "    x += ', local update for x'\n",
    "  g()\n",
    "  return x\n",
    "\n",
    "print( 'f() returns ', f() )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.3.1.5.h this is invalid, since x is not \"homed\" in any nonglobal scope\n",
    "\n",
    "def f():\n",
    "  def g():\n",
    "    nonlocal x\n",
    "    x = 'value for nonlocal x'\n",
    "    return x\n",
    "  return g()\n",
    "\n",
    "print( 'f() returns ', f() )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.3.1.5.i  the following is valid, since x is \"homed\" in f's declaration\n",
    "\n",
    "def f(x):\n",
    "  def g():\n",
    "    return x+4\n",
    "  return g()\n",
    "\n",
    "print( 'f(4) returns ', f(4) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Local-scope-related examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.3.1.5.j  valid, since x is defined before use\n",
    "\n",
    "def f():\n",
    "  def g():\n",
    "    x = 'local value'\n",
    "    return x\n",
    "  return g()\n",
    "\n",
    "print( 'f() returns ', f() )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.3.1.5.k  an invalid use of a local variable, since x is referenced (via the +=) before being defined\n",
    "\n",
    "def f():\n",
    "  def g():\n",
    "    x += 'local value'\n",
    "    return x\n",
    "  return g()\n",
    "\n",
    "print( 'f() returns ', f() )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.3.1.5.l  a valid use of a local variable\n",
    "\n",
    "def f():\n",
    "  def g():\n",
    "    x = 'local'\n",
    "    x += ' value'\n",
    "    return x\n",
    "  return g()\n",
    "\n",
    "print( 'f() returns ', f() )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7.4  Lambda expressions <a name='Functions-Lambda-Expressions'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A `lambda` expression-- so named because its originator, mathematician Alonzo Church,",
    " used the Greek letter \"l\" as a shorthand for \"let\"-- is a nameless function that consists of\n",
    "-  the keyword \"lambda\", followed by\n",
    "-  a list of the function's arguments, followed by\n",
    "-  the function's body:  a single expression\n",
    "\n",
    "Intuitively,  \n",
    "&ensp; &ensp; `f = lambda ...parameters... : ...expression...`  \n",
    "\n",
    "is equivalent to the following Python definition:  \n",
    "&ensp; &ensp; `def f(...parameters...):`   \n",
    "&ensp; &ensp; &ensp; &ensp; `return ...expression...`\n",
    "\n",
    "Lambdas were supported in one of the first widely used higher level programming languages, Lisp. ",
    "Lambdas have been a staple of functional programming languages for decades. ",
    " More recently, lambdas have been incorporated into Microsoft's database programming language, LINQ.\n",
    "\n",
    "Lambda expressions are commonly used as either of the following:\n",
    "-  a quick shorthand for a simple function that just returns a value\n",
    "-  a way of passing a function that gets used by one other function as a parameter to another function--",
    " the idea being that there's no need to name the function if it's only being used in one context."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.4.a  it's possible to define a lambda without referencing or using it - but that's pretty useless\n",
    "\n",
    "lambda x, y: x+y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.4.b  an assortment of simple lambdas\n",
    "\n",
    "print( '(lambda: 3)()                        ==', (lambda: 3)())                         # this returns a constant 3\n",
    "print( '(lambda x: x)(3)                     ==', (lambda x: x)(3))                      # the identity function\n",
    "print( '(lambda x: x+4)(3)                   ==', (lambda x: x+4) (3))                   # returns 4 plus its argument\n",
    "print( '(lambda x, y: x+y)(3, 4)             ==', (lambda x, y: x+y) (3, 4))             # +, applied to numbers\n",
    "print( '(lambda x, y: x+y)(\\'a\\', \\'b\\')     ==', (lambda x, y: x+y)('a', 'b'))          # +, applied to strings\n",
    "print( '(lambda x, y: (x, y))(3, 4)          ==', (lambda x, y: (x, y))(3, 4))           # the 'pair' function \n",
    "print( '(lambda x, y: x if x<y else y)(3, 4) ==', (lambda x, y: x if x<y else y)(3, 4))  # the 'min' function "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.4.c  a lambda with positional, varargs, and keyword parameters\n",
    "\n",
    "print( ( lambda a, *args, **kwds: a + sum(*args) + sum(kwds.values()) ) (1, [2, 3], **{ 'four':4, 'five':5 } ) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.4.d  a lambda's keyword parameters must be identifiers\n",
    "\n",
    "print( ( lambda a, *args, **kwds: a + sum(*args) + sum(kwds.values()) ) (1, [2, 3], **{ 1:2, 3:4 } ) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.4.e  a lambda's body must be an expression\n",
    "\n",
    "print( (lambda x, y: x=y)     # fails:  x=y is a statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.4.f  binding a lambda to an identifier, then applying it to actual parameters\n",
    "\n",
    "f = lambda x, y: x+y\n",
    "print( f(3, 4) )\n",
    "print( f('a', 'b') )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.4.g  an example of a recursive lambda\n",
    "\n",
    "sum_between = lambda start, finish:  0 if start > finish else start + sum_between(start+1, finish)\n",
    "print( '0 + 1 + ... 4 = ', sum_between(0, 4) )\n",
    "print( 'sum_between(4, 0) =', sum_between(4, 0) )\n",
    "print( '-4 + -3 + ... 4 = ',  sum_between(-4, 4) )\n",
    "print( '20 + 21 + ... 30 = ', sum_between(20, 30) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.4.h  a second example of a recursive lambda\n",
    "# since this is an inefficient implementation of fib(), fib(36) may take time to finish\n",
    "\n",
    "fib = lambda k: 0 if k < 1 else 1 if k < 2 else fib(k-1) + fib(k-2)\n",
    "print( 'fib( 0) is ', fib(0) )\n",
    "print( 'fib( 1) is ', fib(1) )\n",
    "print( 'fib( 4) is ', fib(4) )\n",
    "print( 'fib(36) is ', fib(36))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While lambdas are best suited for simple functions that return a single value, ",
    "Python's sequence operator can be used to code lambdas that do multiple actions--though this is not recommended. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.4.i using the sequence (,) operator to code a lambda that does multiple print actions in a lambda\n",
    "\n",
    "f = lambda x: (print(x+1), print(x+2), print('-----'), None)[3]\n",
    "f(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.4.j using the sequence (,) operator to code a lambda that installs identifiers in Python's global environment\n",
    "\n",
    "def assign(x, value):  exec(x + '=' + value, globals())\n",
    "\n",
    "if 'a' in dir():  del a\n",
    "print( f\"a is initially {'' if 'a' in dir() else 'un'}defined\" )\n",
    "\n",
    "f = lambda w, x:  (assign(w, x), None)[1]\n",
    "f('a', '4')\n",
    "print( 'after update with exec, a is now', a )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.4.k  a lambda with a comprehension\n",
    "# \"take every nth\" is simpler to code as a slicing operation.  it's here for purposes of illustration.\n",
    "\n",
    "take_every_nth = lambda l, n, offset: [ l[i] for i in range(len(l)) if (i - offset) % n  == 0  ] \n",
    "\n",
    "print( 'take every third from range(10), starting at index 0 is ', take_every_nth( [i for i in range(10)], 3, 0) )\n",
    "print( 'take every third from range(10), starting at index 1 is ', take_every_nth( [i for i in range(10)], 3, 1) )\n",
    "print( 'take every third from range(10), starting at index 2 is ', take_every_nth( [i for i in range(10)], 3, 2) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.4.l  a lambda with a comprehension\n",
    "# \"drop every nth\", on the other hand, can't be coded simply using slices.\n",
    "\n",
    "drop_every_nth = lambda l, n, offset: [ l[i] for i in range(len(l)) if (i - offset) % n  != 0  ]\n",
    "\n",
    "print( 'drop every third from range(10), starting at index 0 is ', drop_every_nth( [i for i in range(10)], 3, 0) )\n",
    "print( 'drop every third from range(10), starting at index 1 is ', drop_every_nth( [i for i in range(10)], 3, 1) )\n",
    "print( 'drop every third from range(10), starting at index 2 is ', drop_every_nth( [i for i in range(10)], 3, 2) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 7.4.1:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following code cell, ",
    "show the use of a closure to transform `drop_every_nth` into a function that drops every third item from a list. \n",
    "Include examples that illustrate the function's operation on the following:</span>\n",
    "-  <span style='color:navy'>an empty list</span>\n",
    "-  <span style='color:navy'>a list with 1 item</span>\n",
    "-  <span style='color:navy'>a list with 3 items</span>\n",
    "-  <span style='color:navy'>a list with 4 items</span>\n",
    "-  <span style='color:navy'>a list with 5 or more items</span>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 7.4.2:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following code cell, ",
    "combine `take_every_nth` and `drop_every_nth` into a more general lambda, `filter_by_index`, that takes an additional argument:",
    "a function that accepts one, int argument and returns a boolean. ",
    "Then, using this lambda, create the following:</span>\n",
    "-  <span style='color:navy'>A closure that mimics the behavior of `take_every_nth`</span>\n",
    "-  <span style='color:navy'>A closure that mimics the behavior of `drop_every_nth`</span>\n",
    "\n",
    "<span style='color:navy'>",
    "Include examples that illustrate the operation of this closure for taking and dropping items.",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7.5  Generators <a name='Functions-Generators'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A *generator* is a type of state-maintaining function.",
    " Generators are typically created as a mechanism for driving loop-based computations.",
    " Their key characteristics are as follows:\n",
    "-  They use `yield` statements to return successive values\n",
    "-  They pick up where they left off when invoked on successive invocations, rather than restarting \"from scratch\"\n",
    "-  They execute `return` statements or raise StopIteration exceptions to end an iteration\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.5.a  using a generator that produces lower-case letters, with a \"for\" that consumes its values\n",
    "# generator stops by virtue of \"falling off its end\" and returning None,\n",
    "# the default return value when none is specified\n",
    "\n",
    "def lower_case_letters():\n",
    "  this_letter = ord('a') -1\n",
    "  while this_letter < ord('z'):\n",
    "    this_letter += 1\n",
    "    yield chr(this_letter)\n",
    "\n",
    "for lc in lower_case_letters():\n",
    "  print(lc, end=\" \")\n",
    "else:  print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.5.b  The previous example, with the increment following the yield\n",
    "\n",
    "def lower_case_letters():\n",
    "  this_letter = ord('a')\n",
    "  while this_letter <= ord('z'):\n",
    "    yield chr(this_letter)\n",
    "    this_letter += 1\n",
    "\n",
    "for lc in lower_case_letters():\n",
    "  print(lc, end=\" \")\n",
    "else:  print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.5.c  Like the previous examples, but using continue to skip vowels\n",
    "\n",
    "def lower_case_consonants():\n",
    "  this_letter = ord('a') -1\n",
    "  while this_letter < ord('z'):\n",
    "    this_letter += 1\n",
    "    if chr(this_letter) in 'aeiou':  continue\n",
    "    yield chr(this_letter)\n",
    "\n",
    "for lc in lower_case_consonants():\n",
    "  print(lc, end=\" \")\n",
    "else:\n",
    "  print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.5.d:  Fibonacci series generator with optional count of fib values to yield\n",
    "# count defaults to continue forever  (i.e., k = infinity)\n",
    "\n",
    "import math\n",
    "def fib(val_count = math.inf):\n",
    "  if val_count < 1:\n",
    "    return\n",
    "  yield 1\n",
    "  if val_count < 2:\n",
    "    return\n",
    "  yield 1\n",
    "  prev_2, prev_1, val_count = 1, 1, val_count-2\n",
    "  while val_count > 0:\n",
    "    val_count -= 1\n",
    "    yield prev_2 + prev_1\n",
    "    prev_2, prev_1 = prev_1, prev_2 + prev_1\n",
    "\n",
    "print( [i for i in fib(0)] )\n",
    "print( [i for i in fib(1)] )\n",
    "print( [i for i in fib(2)] )\n",
    "print( [i for i in fib(20)] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  7.5.e  previous example, with cutoff in main, rather than the iterator\n",
    "\n",
    "import math\n",
    "def fib():\n",
    "  prev_2 = 1\n",
    "  yield 1\n",
    "  prev_1 = 1\n",
    "  yield 1\n",
    "  while True:\n",
    "    yield prev_2 + prev_1\n",
    "    prev_2, prev_1 = prev_1, prev_2 + prev_1\n",
    "\n",
    "l = []\n",
    "for i in fib():\n",
    "  if i > 1000:  break\n",
    "  l += [i]\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 7.5.1:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following markdown cell, \n",
    "explain what happens when the \"while True\" version of `fib` shown above is accessed with `[i for i in fib() if i <= 1000]`",
    "</span>\n",
    "***\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n"
   ]
  }
 ],
 "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.9.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}