6.  Control structures.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",
    "\n",
    "A special thanks to Shayne Parker for noting the `is` anomaly discussed in Section 6.2.3.5\n",
    "*********************************************************************************************************"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6.  Control Structures  \n",
    " 6.1 [Overview](#Control-Structures-Overview)  \n",
    " 6.2 [`If` expressions](#Control-Structures-If-Expressions)  \n",
    " 6.3 [Non-scoping-related simple statements ](#Control-Structures-Non-Scoping-Related-Simple-Statements)  \n",
    " &ensp; 6.3.1 [Pass](#Control-Structures-Pass)  \n",
    " &ensp; 6.3.2 [Assignment](#Control-Structures-Assignment)  \n",
    " &ensp;&ensp;&ensp; 6.3.2.1 [Overview](#Control-Structures-Assignment-Overview)  \n",
    " &ensp;&ensp;&ensp; 6.3.2.2 [Multiple item assignment](#Control-Structures-Assignment-Multiple-Item-Assignment)  \n",
    " &ensp;&ensp;&ensp; 6.3.2.3 [Incremental update](#Control-Structures-Assignment-Incremental-Update)  \n",
    " &ensp;&ensp;&ensp; 6.3.2.4 [Shallow and deep copy](#Control-Structures-Assignment-Shallow-And-Deep-Copy)  \n",
    " &ensp;&ensp;&ensp; 6.3.2.5 [`is` and assignment - an anomaly](#Control-Structures-Assignment-Is-Anomaly)  \n",
    " &ensp;&ensp; 6.3.3 [Del](#Control-Structures-Del)  \n",
    " &ensp;&ensp; 6.3.4 [Import](#Control-Structures-Import)  \n",
    " &ensp;&ensp; 6.3.5 [Assert](#Control-Structures-Assert)  \n",
    " &ensp;&ensp; 6.3.6 [Raise](#Control-Structures-Raise)  \n",
    " 6.4 [Compound statements](#Control-Structures-Compound-Statements)  \n",
    " &ensp; 6.4.1 [If](#Control-Structures-If)  \n",
    " &ensp; 6.4.2 [For](#Control-Structures-For)  \n",
    " &ensp; 6.4.3 [While](#Control-Structures-While)  \n",
    " &ensp; 6.4.4 [Try](#Control-Structures-Try)  \n",
    " &ensp;&ensp; 6.4.4.1 [Basic `try/except`](#Control-Structures-Try-Except-Basic)  \n",
    " &ensp;&ensp; 6.4.4.2 [`Try/except/else/finally`](#Control-Structures-Try-Except-Else-Finally)  \n",
    " 6.5 [Simple statements that support compound statements](#Control-Structures-Simple-Statements-That-Support-Compound-Statements)  \n",
    " &ensp; 6.5.1 [Break](#Control-Structures-Break)  \n",
    " &ensp; 6.5.2 [Continue](#Control-Structures-Continue)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6.1  Overview <a name='Control-Structures-Overview'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Basic Python control structures can be divided into five groups:\n",
    "-  [`if` expressions](#Control-Structures-If-Expressions)\n",
    "-  [non-scoping-related simple statements](#Control-Structures-Non-Scoping-Related-Simple-Statements):",
    "    `pass`, `=` (assignment), `del`, `import`, `assert`, and `raise`\n",
    "-  [compound statements](#Control-Structures-Compound-Statements):  `if`, `while`, `for`, and `try`\n",
    "-  [simple statements that support compound statements](#Control-Structures-Simple-Statements-That-Support-Compound-Statements):",
    "     `break` and `continue`\n",
    "-  simple statements that qualify scoping: `global` and `nonlocal`\n",
    "\n",
    "`global` and `nonlocal` are presented later, in the section on [functions](./7.%20%20Functions.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6.2  `If` expressions <a name='Control-Structures-If-Expressions'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An `if` expression has the form  *value  if  condition  else  value*.  The `if` and `else` components are required. ",
    "*Multi-term expressions in `else` clauses should be parenthesized, to ensure that `else` evaluates the entire expression*.\n",
    "\n",
    "The following example uses these additional Python constructs:\n",
    "-  `lambda` - [a shorthand for a nameless function that maps its arguments to a single value](./7.%20%20Functions.ipynb#Functions-Lambda-Expressions)\n",
    "-  `math.inf` - math library representation for IEEE 754 characterization of infinity\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.2  using a nested \"if\" expression to manage division\n",
    "\n",
    "import math\n",
    "divide = lambda numerator, divisor: (-math.inf if numerator < 0 else math.inf) if divisor == 0 else numerator/divisor\n",
    "\n",
    "print( ' 4/0 is ', divide(4,0) )\n",
    "print( '-4/0 is ', divide(-4,0) )\n",
    "print( ' 4/1 is ', divide(4,1) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6.3  Non-scoping-related simple statements <a name='Control-Structures-Non-Scoping-Related-Simple-Statements'></a>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.3.1  Pass <a name='Control-Structures-Pass'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`pass`, the simplest of Python's simplest statements, takes no operands and does nothing.\n",
    "  `pass` is used primarily as a placeholder in mandatory sections of compound statements and functions that do nothing.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.3.2  Assignment <a name='Control-Structures-Assignment'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 6.3.2.1  Overview <a name='Control-Structures-Assignment-Overview'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A Python assignment statement updates a Python identifier's referent. ",
    "An assignment's effect depends on whether the assignment updated or modified an object.\n",
    "-  For non-updating assignments, assignment creates a shared reference to the assigned value.\n",
    "-  For updating assignments, assignment creates a new copy of that object.\n",
    "\n",
    "The following examples use these additional Python constructs:\n",
    "-  `id` - a function that returns an object's identity - typically, its address in memory\n",
    "-  `lambda` - a shorthand for a nameless function that maps its arguments to a single value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.3.2.1.a  the effect of assignment without update\n",
    "\n",
    "compare = lambda x, y: 'the same object' if id(x) == id(y) else 'different objects'\n",
    "\n",
    "x = 1\n",
    "y = x\n",
    "print( f'x ({x}) and y ({y}) reference {compare(x,y)} after y = x' )\n",
    "\n",
    "x = 'abc'\n",
    "y = x\n",
    "print( f'x ({x}) and y ({y}) reference {compare(x,y)} after y = x' )\n",
    "\n",
    "x = (1, 2, 3)\n",
    "y = x\n",
    "print( f'x ({x}) and y ({y}) reference {compare(x,y)} after y = x' )\n",
    "\n",
    "x = [1, 2, 3]\n",
    "y = x\n",
    "print( f'x ({x}) and y ({y}) reference {compare(x,y)} after y = x' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.3.2.1.b  the effect of assignment with update on mutable (i.e., sharable) objects\n",
    "\n",
    "compare = lambda x, y: 'the same object' if id(x) == id(y) else 'different objects'\n",
    "\n",
    "x = [1, 2, 3]\n",
    "print( 'before assignment: x is', x )\n",
    "y = x + [4]\n",
    "print( f'after assignment: x ({x}) and y ({y}) reference {compare(x,y)}'  )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.3.2.1.c  the effect of assignment with update on immutable (i.e., nonshared) objects\n",
    "\n",
    "compare = lambda x, y: 'the same object' if id(x) == id(y) else 'different objects'\n",
    "\n",
    "x = (1, 2, 3)\n",
    "print( 'before assignment: x is', x )\n",
    "y = x + (4,)\n",
    "print( f'after assignment: x ({x}) and y ({y}) reference {compare(x,y)}'  )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 6.3.2.2  Multiple item assignment <a name='Control-Structures-Assignment-Multiple-Item-Assignment'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python provides two functions for creating new copies of object referents on assignment.\n",
    "-  For non-updating assignments and assignments for immutable objects, assignment creates a shared reference to the assigned value.\n",
    "-  For assignments involving updated immutable objects, the assignment creates a new copy of that object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.3.2.2.a  Illustrating Python support for multiple item assignment\n",
    "\n",
    "a, b = 3, 4\n",
    "print( f'first, after a, b = 3, 4, a is {a} and b is {b}' )\n",
    "\n",
    "a, b = b, a      # Python idiom for item swap\n",
    "print( f'then,  after a, b = b, a, a is {a} and b is {b}' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.3.2.2.b  Effect of multiple assignment with too few assigned values\n",
    "a, b = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.3.2.2.c  Effect of multiple assignment with too many assigned values\n",
    "a, b = 1, 4, 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 6.3.2.3  Incremental update <a name='Control-Structures-Assignment-Incremental-Update'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python supports C-style assignment operators that incrementally update identifiers that reference defined values.",
    " Incremental versions of built-in operators include the following:\n",
    "-  +=, *=, /=, //=, %=\n",
    "    - addition, multiplication, division, int division, modulus\n",
    "-  <<=, >>=, &=, |=, -=, ^=\n",
    "   - shift left, shift right, and/set intersection, or/set union, subtraction/set difference, xor/set symmetric difference\n",
    "\n",
    "The following examples use this additional Python construct:\n",
    "- `del` - a function that removes a definition from the current environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.3.2.3.a Incremental assignment - arithmetic operators\n",
    "\n",
    "x = 7\n",
    "x_before = x\n",
    "x += 1\n",
    "print( f'x ({x_before}) after x += 1: {x}' )\n",
    "\n",
    "x_before = x\n",
    "x -= 1\n",
    "print( f'x ({x_before}) after x -= 1: {x}' )\n",
    "\n",
    "x_before = x\n",
    "x *= 2\n",
    "print( f'x ({x_before}) after x *= 2: {x}' )\n",
    "\n",
    "x_before = x\n",
    "x /= 2\n",
    "print( f'x ({x_before}) after x /= 2: {x}' )\n",
    "\n",
    "x_before = x\n",
    "x //= 2\n",
    "print( f'x ({x_before}) after x //= 2: {x}' )\n",
    "\n",
    "x_before = x\n",
    "x %= 3\n",
    "print( f'x ({x_before}) after x %= 3: {x}' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.3.2.3.b Incremental assignment - logical operators\n",
    "\n",
    "x = 21\n",
    "x_before = x\n",
    "x <<= 2\n",
    "print( f'x ({x_before}) after x <<= 2: {x}' )\n",
    "\n",
    "x_before = x\n",
    "x >>= 1\n",
    "print( f'x ({x_before}) after x >>= 1: {x}' )\n",
    "\n",
    "x_before = x\n",
    "x |= 20\n",
    "print( 'x b({}) after x |= 20: {}'.format(x_before, x) )\n",
    "\n",
    "x_before = x\n",
    "x &= 30\n",
    "print( f'x ({x_before}) after x &= 30: {x}' )\n",
    "\n",
    "x_before = x\n",
    "x ^= 25\n",
    "print( 'x b({}) after x ^= 25: {}'.format(x_before, x) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.3.2.3.c  Effect of incremental assignment with undefined identifier\n",
    "\n",
    "if 'x' in dir(): del x    # initialize the example\n",
    "x += 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 6.3.2.4  Shallow and deep copy <a name='Control-Structures-Assignment-Shallow-And-Deep-Copy'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python supports two functions for copying objects, shallow copy (`copy`) and deep copy (`deepcopy`).\n",
    "-  Shallow and deep copy both produce shared referents to scalars.  These referents will change if either identifier is updated.\n",
    "-  For copies of collections,\n",
    "   -  Shallow copy creates a copy *c* of a top-level collection object *s*,\n",
    "       then uses assignment to populate *c* with every object from *s*.\n",
    "      After a shallow copy *c* of an object *s* is created,\n",
    "       *c* and *s* share references to all mutable objects that were initially in *s*.\n",
    "   -  Deep copy creates a copy of *c* of a top-level collection object *s*,\n",
    "       then populates *c* with complete, new copies of every object from *s*.\n",
    "       After a deep copy *c* of an object *s* is created,\n",
    "       any changes to *s* have no effect on *c* and vice-versa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.3.2.4.a  illustrating effect of shallow and deep copy on scalars\n",
    "\n",
    "from copy import copy, deepcopy\n",
    "\n",
    "x = 1\n",
    "y = copy(x)\n",
    "z = deepcopy(x)\n",
    "\n",
    "print( f'identities of x, y, and z after y=copy(x) and z=deepcopy(x) are {id(x)}, {id(y)}, and {id(z)}' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.3.2.4.b  illustrating effect of shallow and deep copy on non-nested collections\n",
    "\n",
    "from copy import copy, deepcopy\n",
    "\n",
    "x = [1, 2, 3, 4]\n",
    "y = copy(x)\n",
    "z = deepcopy(x)\n",
    "\n",
    "print( f'identities of x, y, and z after y=copy(x) and z=deepcopy(x) are {id(x)}, {id(y)}, and {id(z)}' )\n",
    "x[0] = 'one'\n",
    "print( f'effect of updating x[0] on y is {y} and on z is {z}' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.3.2.4.c  illustrating effect of shallow and deep copy on nested collections\n",
    "\n",
    "from copy import copy, deepcopy\n",
    "\n",
    "x = [[1], 2, 3, 4]\n",
    "y = copy(x)\n",
    "z = deepcopy(x)\n",
    "\n",
    "print( f'identities of x, y, and z after y=copy(x) and z=deepcopy(x) are {id(x)}, {id(y)}, and {id(z)}' )\n",
    "x[0][0] = 'one'\n",
    "print( f'effect of updating x[0][0] on y is {y} and on z is {z}' )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 6.3.2.4.1:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following code cell, ",
    "construct an example that shows whether the list replication operator (&ast;) creates shallow or deep copies of its initial list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 6.3.2.5  `is` and assignment - an anomaly <a name='Control-Structures-Assignment-Is-Anomaly'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following example illustrates an anomaly involving Python's policies for object assignment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.3.2.5  why comparisons that use 'is' must be managed with care\n",
    "\n",
    "x, y = -300, -300\n",
    "print( 'following \\'x, y = -300, -300\\', x is y is', x is y )\n",
    "\n",
    "x, y = -3, -3\n",
    "print( 'following \\'x, y = -3, -3\\', x is y is', x is y )\n",
    "\n",
    "x, y = 3, 3\n",
    "print( 'following \\'x, y = 3, 3\\', x is y is', x is y )\n",
    "\n",
    "x, y = 300, 300\n",
    "print( 'following \\'x, y = 300, 300\\', x is y is', x is y, end='\\n\\n' )\n",
    "\n",
    "x = -300\n",
    "y = -300\n",
    "print( 'following \\'x = -300, y = -300 \\', x is y is', x is y )\n",
    "\n",
    "x = -3\n",
    "y = -3\n",
    "print( 'following \\'x = -3, y = -3 \\', x is y is', x is y )\n",
    "\n",
    "x = 3\n",
    "y = 3\n",
    "print( 'following \\'x = 3, y = 3 \\', x is y is', x is y )\n",
    "\n",
    "x = 300\n",
    "y = 300\n",
    "print( 'following \\'x = 300, y = 300 \\', x is y is', x is y )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 6.3.2.5.1:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following markdown cell, \n",
    "account for this anomaly.  Hint: a loop with appropriate bounds, together with an Internet search or three, might help.",
    "</span>\n",
    "***\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.3.3  Del <a name='Control-Structures-Del'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`del`, the inverse of assignment, removes identifiers from the Python environment.  It also removes elements from lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.3.3.a  Illustrating the effect of del on identifiers at global scope\n",
    "\n",
    "a = 3\n",
    "print( 'identifiers at global scope: ', dir(), end='\\n\\n' ) \n",
    "\n",
    "print( f\"a is currently {'' if 'a' in dir() else 'un'}defined\", end='\\n\\n' ) \n",
    "del a\n",
    "print( f\"after deleting a, a is {'' if 'a' in dir() else 'un'}defined\", end='\\n\\n' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.3.3.b  Illustrating the effect of del on items in collections\n",
    "\n",
    "x = [1, 1, 2, 3, 5, 8, 13]\n",
    "print( 'before removing x[0], x is', x )\n",
    "del x[0]\n",
    "print( 'after removing x[0], x is', x, '\\n' )\n",
    "print( 'before removing x[1], x is', x )\n",
    "del x[1]\n",
    "print( 'after removing x[1], x is', x )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.3.3.c  a proper way to drain a list's contents - progressing from end to front\n",
    "\n",
    "x = [1, 1, 2, 3, 5, 8, 13]\n",
    "for i in range(len(x)-1, -1, -1):  # the right way to clean up x, value by value\n",
    "  print( f'deleting x[{i}]' )\n",
    "  del x[i]\n",
    "  print( 'x is now', x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.3.3.d  a poor way to drain a list's contents - progressing from front to end\n",
    "\n",
    "x = [1, 1, 2, 3, 5, 8, 13]\n",
    "for i in range(len(x)):\n",
    "  print( f'deleting x[{i}]' )\n",
    "  del x[i]\n",
    "  print( 'x is now', x )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 6.3.3.1:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following markdown cell, ",
    "explain why last-to-first deletion succeeds and first-to-last deletion fails.",
    "</span>\n",
    "***\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.3.4  Import <a name='Control-Structures-Import'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`import` imports references to objects in supporting modules into the current environment, making the referents available for program use.\n",
    "\n",
    "The following examples use this additional Python construct:\n",
    "- `globals` - returns a list of Python's identifiers at global scope."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.3.4.a   the basic import statement\n",
    "# initialize this example by removing items to be imported, just in case they're currently in the environment\n",
    "\n",
    "if 'sys' in dir():   del sys\n",
    "if 'path' in dir():  del path\n",
    "\n",
    "is_global = lambda name: 'defined' if name in globals() else 'undefined'\n",
    "\n",
    "print( 'sys is initially', is_global('sys'), end='\\n\\n' )\n",
    "import sys\n",
    "print( f\"after 'import sys' sys is {is_global('sys')} and path is {is_global('path')}\" )\n",
    "print( '\\nsys.path is now', sys.path )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 6.3.4.1:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following markdown cell, \n",
    "explain why `is_in_globals` references `globals` rather than `dir`.",
    "</span>\n",
    "***\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.3.4.b   a first variant of import - from x import y\n",
    "# initialize this example by removing items to be imported, just in case they're currently in the environment\n",
    "\n",
    "if 'sys' not in dir():   import sys\n",
    "if 'path' in dir():  del path\n",
    "\n",
    "is_global = lambda name: 'defined' if eval( '\\'{}\\' in globals()'.format(name) ) else 'undefined'\n",
    "\n",
    "from sys import path\n",
    "\n",
    "print( \"after 'from sys import path' path is\", is_global('path'), end='\\n\\n' )\n",
    "print( 'sys.path is ', sys.path, end='\\n\\n', )\n",
    "print( f\"path is {'' if path == sys.path else 'not '}equal to sys.path\" )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.3.4.c   a second variant of import - from x import y as z\n",
    "# initialize this example by removing items to be imported, just in case they're currently in the environment\n",
    "\n",
    "if 'sys' not in dir():   import sys\n",
    "if 'module_dirs' in dir():  del module_dirs\n",
    "\n",
    "is_global = lambda name: 'defined' if eval( '\\'{}\\' in globals()'.format(name) ) else 'undefined'\n",
    "\n",
    "from sys import path as module_dirs\n",
    "\n",
    "print( \"after 'from sys import path as module_dirs' module_dirs is\", is_global('module_dirs'), end='\\n\\n' )\n",
    "print( 'sys.path is ', sys.path, end='\\n\\n' )\n",
    "print( f\"module_dirs is {'' if module_dirs == sys.path else 'not '}equal to sys.path\" )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.3.4.d   a third variant of import - from x import *.  This imports all definitions from x that x exports.\n",
    "# initialize this example by removing items to be imported, just in case they're currently in the environment\n",
    "\n",
    "if 'sys' not in dir():   import sys\n",
    "if 'path' in dir():  del path\n",
    "\n",
    "is_global = lambda name: 'defined' if eval( '\\'{}\\' in globals()'.format(name) ) else 'undefined'\n",
    "\n",
    "from sys import *\n",
    "\n",
    "print( \"after 'from sys import *' path is\", is_global('path'), end='\\n\\n' )\n",
    "print( 'sys.path is ', sys.path, end='\\n\\n' )\n",
    "print( f\"path is {'' if path == sys.path else 'not '}equal to sys.path\" )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.3.5  Assert <a name='Control-Structures-Assert'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Under ordinary interpreter operation, `assert` raises an exception if its first operand evaluates to `False`.",
    " This behavior can be disabled by invoking the interpreter with the \"optimize\" (`-O`) flag."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.3.5.a  Example of an assertion that succeeds\n",
    "\n",
    "assert 1==1, 'this statement shouldn\\'t throw an exception'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.3.5.b  Examples of an assertion that fails\n",
    "\n",
    "assert 1==0, 'this statement should throw an exception'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.3.6  Raise <a name='Control-Structures-Raise'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`raise` raises the specified exception. `raise`, if executed with no arguments in an except clause, re-raises the last exception.\n",
    "\n",
    "The following examples use this additional Python construct:\n",
    "-  `try/except` - exception-catching compound statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.3.6.a  Raise statement example\n",
    "\n",
    "raise LookupError(\"JAMES JAMES MORRISON'S MOTHER SEEMS TO HAVE BEEN MISLAID.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.3.6.b  Raise statement example with re-raise\n",
    "\n",
    "try:\n",
    "  raise LookupError(\"JAMES JAMES MORRISON'S MOTHER SEEMS TO HAVE BEEN MISLAID.\")\n",
    "except:\n",
    "  raise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6.4  Compound statements <a name='Control-Structures-Compound-Statements'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python's `if`, `for`, `while`, and `try/except` statements are like those in other programming languages. Key differences are as follows:\n",
    "\n",
    "-  Python uses whitespace to delimit a compound statement's blocks.    ",
    "  All statements that are subordinate to a clause in a compound statement-- ",
    "  e.g., an `if` statement's `if` and `else` blocks-- must be indented, relative to their \"master\" clause.\n",
    "-  All statements at the same level in a compound statement must have the same initial indentation string.",
    "    Care should be used with editors that automatically convert tabs to spaces,",
    "    since Python treats tabs and spaces as different characters.\n",
    "-  Top-level function and class definitions (see below) must end with a totally blank line:",
    "    i.e., one with no characters, not even whitespace.",
    "    Python's interpreter also enforces this requirement for top-level compound statements."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.4.1  If <a name='Control-Structures-If'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python's `if` statement, following its `if` clause, supports\n",
    "-  an optional sequence of `elif` clauses, followed by\n",
    "-  an optional, final `else` clause.\n",
    "\n",
    "The following example uses this additional Python construct:\n",
    "-  `def` - Python statement that defines a function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.4.1   a function that computes an order-of-magnitude approximation to log10(x)\n",
    "\n",
    "def magnitude(x):\n",
    "  assert isinstance(x, (int, float)), f'value ({x}) is not a real number'\n",
    "  if x == 0:\n",
    "    return f'value ({x}) is 0'\n",
    "  else:\n",
    "    if abs(x) < 1:\n",
    "      return f\"value ({x}) is between 0 and {'-' if x < 0 else ''}1\" \n",
    "    xsign = '-' if x < 0 else ''\n",
    "    xcopy = abs(x)\n",
    "    upperbound_log10_x = ''\n",
    "    while xcopy > 1:\n",
    "      xcopy /= 10\n",
    "      upperbound_log10_x += '0'\n",
    "    if xcopy % 1 == 0:\n",
    "      return f'value ({x}) is exactly {xsign}1{upperbound_log10_x}' \n",
    "    return 'value ({0}) is between {1}1{2} and {1}10{2}'.format(x, xsign, upperbound_log10_x[1:])\n",
    "\n",
    "print( magnitude(-30.3) )\n",
    "print( magnitude(-1) )\n",
    "print( magnitude(-0.2) )\n",
    "print( magnitude(0) )\n",
    "print( magnitude(1) )\n",
    "print( magnitude(4.2) )\n",
    "print( magnitude(10) )\n",
    "print( magnitude(11) )\n",
    "print( magnitude(20) )\n",
    "print( magnitude(100) )\n",
    "print( magnitude(101) )\n",
    "print( magnitude(594) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.4.2  For <a name='Control-Structures-For'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python `for` statements 'consume' items from sequences of arbitrary values. These values are not limited to integers, as in, say, C. \n",
    "\n",
    "Python `for` statements have optional `else` clauses.  These execute once, on normal loop termination.\n",
    "\n",
    "These examples are written with `for` loops for the sake of example.",
    " Where feasible-- ",
    "e.g., for `for` loops that are intended to always process each input, ",
    "rather than possibly break off processing in the middle of an input stream--",
    " using comprehensions in place of `for` loops yields cleaner, more concise code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.4.2.a  a straightforward \"for\" that prints 0..9, all on one line\n",
    "\n",
    "# since the loop contains one statement, it can also be written as\n",
    "#     for i in range(0,10):  print(i, end=\" \")\n",
    "\n",
    "for i in range(0,10):\n",
    "  print(i, end=\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.4.2.b  previous example with the \"for\" loop's optional \"else\" clause used to generate an EOL\n",
    "\n",
    "for i in range(0,10):\n",
    "  print(i, end=\" \")\n",
    "else:  print( )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.4.2.c1   using \"for\" statements to modify collections in place can fail\n",
    "# when the strategy implicitly relies on the collection's initial content\n",
    "\n",
    "x = [1, 2, 3, 4, 5, 6]\n",
    "for index in range(0, len(x), 2):          # len(x) is computed once, on loop entry\n",
    "  if index % 2 == 0:  print(x.pop(index))  # try to remove values at even indices, working forwards\n",
    "\n",
    "print( 'x is now ', x)    # fails, because len(x) changes as values are removed from x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.4.2.c2  using \"for\" statements to modify collections in place can fail\n",
    "# when the strategy implicitly relies on the collection's initial content\n",
    "\n",
    "x = [1, 2, 3, 4, 5, 6]\n",
    "for index in range(-1, -len(x)-1, -1):  # len(x) is computed once, on loop entry\n",
    "  if index % 2 == 0:  x.pop(index)      # try to remove at even indices, working backwards\n",
    "\n",
    "print( 'x is now ', x)    # also fails"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 6.4.2.1:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following code cell, ",
    "rewrite one of the ",
    "[list comprehensions](./5.%20%20Builtin%20data%20structures.ipynb#Builtin-Data-Structures-Lists-Comprehensions) ",
    "from the previous exercises that uses two `for` expressions ",
    "as an equivalent doubly nested `for` loop.",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 6.4.2.2:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following markdown cell, ",
    "compare the rewritten code to the original, comprehension-based code for concision. ",
    "Quantify the codes' relative length by comparing the codes' counts of characters, terms, expressions, and/or statements, ",
    "together with their counts of nonlocal identifiers.",
    "</span>\n",
    "***\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.4.3  While <a name='Control-Structures-While'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python `while` statements are like `while` statements in other languages.",
    " One unusual feature of Python's `while` is its support for `else` clauses.",
    "  These execute once, on normal loop termination."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.4.3.a  a straightforward \"while\" that prints 0..9, all on one line\n",
    "\n",
    "i = -1\n",
    "while i < 10:\n",
    "  i += 1\n",
    "  print(i, end=\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.4.3.b  previous example with the \"while\" loop's optional \"else\" clause used to generate an EOL\n",
    "\n",
    "i = -1\n",
    "while i < 10:\n",
    "  i += 1\n",
    "  print(i, end=\" \")\n",
    "else:\n",
    "  print( )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.4.4  Try <a name='Control-Structures-Try'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python's `try/except` statement functions much as it does in other languages.  Specifics:\n",
    "-  Except clauses take one of three forms:\n",
    "   -  except: - catches all exceptions\n",
    "   -  except *exception_type*: - catches exceptions of type *exception_type*\n",
    "   -  except *exception_type* as *exception_object*:  - catches exceptions of type *exception_type*,\n",
    "       associating *exception_object* with the exception object that the exception returned.\n",
    "-  Python exceptions are structured as a hierarchy, with class `Exception` at the hierarchy's root.\n",
    "-  Most, though not all, exception objects are associated with a string that describes the exceptional condition.",
    "    Displaying that string can be a best practice for handling exceptions-- but so is checking if the string is present",
    "    before attempting to reference it.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 6.4.4.1  Basic `try/except` <a name='Control-Structures-Try-Except-Basic'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following examples use this additional Python construct:\n",
    "-  `lambda` - a shorthand for a nameless function that maps its arguments to a single value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.4.4.1.a  illustrating the operation of \"try/except\" with normal try completion\n",
    "\n",
    "make_printable = lambda exception: '' if str(exception) is None else str(exception)\n",
    "\n",
    "numerator = 4\n",
    "denominator = 1\n",
    "try:\n",
    "  result = numerator/denominator\n",
    "  print( result )\n",
    "except Exception as exception:\n",
    "  print( make_printable( exception ) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.4.4.1.b  illustrating the operation of \"try/except\" with try exception\n",
    "\n",
    "make_printable = lambda exception: '' if str(exception) is None else str(exception)\n",
    "\n",
    "numerator = 4\n",
    "denominator = 0\n",
    "try:\n",
    "  result = numerator/denominator\n",
    "  print( result )\n",
    "except Exception as exception:\n",
    "  print( make_printable( exception ) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 6.4.4.2  `Try/except/else/finally` <a name='Control-Structures-Try-Except-Else-Finally'></a>\n",
    "`Try/except` statements also have two optional clauses.\n",
    "-  The one, `else`, executes if no exceptions trigger.\n",
    "-  The other, `finally`, executes after the `try/except` completes. It cannot contain a `continue` statement.\n",
    "\n",
    "The following examples use this additional Python construct:\n",
    "-  `def` - a function-defining compound statement\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.4.4.2.a illustrating the operation of \"try/except/else\" with normal try completion\n",
    "\n",
    "make_printable = lambda exception: '' if str(exception) is None else str(exception)\n",
    "\n",
    "numerator = 4\n",
    "denominator = 1\n",
    "try:\n",
    "  result = numerator/denominator\n",
    "  print( result )\n",
    "except Exception as exception:\n",
    "  print( make_printable( exception ) )\n",
    "else:\n",
    "  print( 'the operation completed normally' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.4.4.2.b illustrating the operation of \"try/except/else\" with try exception\n",
    "\n",
    "make_printable = lambda exception: '' if str(exception) is None else str(exception)\n",
    "\n",
    "numerator = 4\n",
    "denominator = 0\n",
    "try:\n",
    "  result = numerator/denominator\n",
    "  print( result )\n",
    "except Exception as exception:\n",
    "  print( make_printable( exception ) )\n",
    "else:\n",
    "  print( 'the operation completed normally' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.4.4.2.c  illustrating the operation of \"try/except/finally\" with normal try completion\n",
    "\n",
    "make_printable = lambda exception: '' if str(exception) is None else str(exception)\n",
    "\n",
    "numerator = 4\n",
    "denominator = 1\n",
    "try:\n",
    "  result = numerator/denominator\n",
    "  print( result )\n",
    "except Exception as exception:\n",
    "  print( make_printable( exception ) )\n",
    "finally:\n",
    "  print( 'exiting try/except block' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.4.4.2.d  illustrating the operation of \"try/except/finally\" with try exception\n",
    "\n",
    "make_printable = lambda exception: '' if str(exception) is None else str(exception)\n",
    "\n",
    "numerator = 4\n",
    "denominator = 0\n",
    "try:\n",
    "  result = numerator/denominator\n",
    "  print( result )\n",
    "except Exception as exception:\n",
    "  print( make_printable( exception ) )\n",
    "finally:\n",
    "  print( 'exiting try/except block' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.4.4.2.e  a more elaborate try/catch example, which shows \"else\", \"finally\", and exception re-raising\n",
    "\n",
    "make_printable = lambda exception: '' if str(exception) is None else str(exception)\n",
    "\n",
    "def try_test_with_finally(exception_type, message):\n",
    "  try:\n",
    "    if issubclass(exception_type, Exception): raise exception_type( message )\n",
    "  except FloatingPointError as exception:\n",
    "    print( 'floating point error:', make_printable( exception ) )\n",
    "  except ArithmeticError as exception:                     # superclass for FloatingPointError\n",
    "    print( 'arithmetic error:', make_printable( exception ) )\n",
    "  except Exception as exception:                           # superclass for AritmeticError  (and all exception classes)\n",
    "    print( 'some sort of error:', make_printable( exception ) )\n",
    "    raise\n",
    "  else:\n",
    "    print( 'no exception happened' )\n",
    "  finally:\n",
    "    print( 'ending routine' )\n",
    "    return 'result from finally clause'\n",
    "\n",
    "print(try_test_with_finally(int, 'this should raise no exceptions'))\n",
    "print( '-----------' )\n",
    "print(try_test_with_finally(FloatingPointError, 'this should be a floating point error message'))\n",
    "print( '-----------' )\n",
    "print(try_test_with_finally(ArithmeticError, 'this should be an arithmetic error message'))\n",
    "print( '-----------' )\n",
    "print(try_test_with_finally(OSError, 'this should be an OS error message'))    # \"finally\" catches the re-raise\n",
    "print( '-----------' )\n",
    "print(try_test_with_finally(None.__class__, 'default'))\n",
    "print( '-----------' )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6.5  Simple statements that support compound statements <a name='Control-Structures-Simple-Statements-That-Support-Compound-Statements'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.5.1  Break <a name='Control-Structures-Break'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`break` terminates a code's innermost loop, returning control to the statement after the loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.5.1.a  illustrating the operation of \"break\"\n",
    "\n",
    "for i in range(0,10):\n",
    "  print(i, end=\" \")\n",
    "  if i == 9:  break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.5.1.b  \"break\" bypasses \"else\"\n",
    "\n",
    "for i in range(0,10):\n",
    "  print(i, end=\" \")\n",
    "  if i == 9:  break\n",
    "else:  print('at loop\\'s end')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.5.1.c  \"break\" only breaks to one level\n",
    "\n",
    "for row in range(0,11):\n",
    "  for col in range(0,11):\n",
    "    print('% 5d' % (row*col), end=\" \")\n",
    "    if row+col >= 10:  break\n",
    "  print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.5.1.d   \"break\" outside of a loop is erroneous\n",
    "if True:\n",
    "  break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.5.2  Continue <a name='Control-Structures-Continue'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`continue` terminates the execution of the current loop iteration, starting the next."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.5.2.a  illustrating the operation of \"continue\"\n",
    "\n",
    "for i in range(0,10):\n",
    "  if i == 5:  continue\n",
    "  print(i, end=\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.5.2.b   \"continue\" outside of a loop is erroneous\n",
    "if True:\n",
    "  continue"
   ]
  }
 ],
 "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
}