5.  Builtin data 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",
    "*********************************************************************************************************"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5.  Built-in data structures  \n",
    " 5.1 [Overview](#Builtin-Data-Structures-Overview)  \n",
    " 5.2 [Strings](#Builtin-Data-Structures-Strings)  \n",
    " &ensp; 5.2.1 [String instantiation](#Builtin-Data-Structures-Strings-Instantiation)  \n",
    " &ensp; 5.2.2 [Formatting](#Builtin-Data-Structures-Strings-Formatting)  \n",
    " &ensp;&ensp; 5.2.2.1 [Printf-style string formatting](#Builtin-Data-Structures-Strings-Printf-Style-String-Formatting)   \n",
    " &ensp;&ensp; 5.2.2.2 [Formatting with the `format()` method](#Builtin-Data-Structures-Strings-Format-Style-String-Formatting)  \n",
    " &ensp;&ensp; 5.2.2.3 [Formatting with template strings](#Builtin-Data-Structures-Strings-Template-String-Style-String-Formatting)  \n",
    " &ensp;&ensp; 5.2.2.4 [Formatting with f-strings](#Builtin-Data-Structures-Strings-F-String-Style-String-Formatting)  \n",
    " &ensp; 5.2.3 [Strings as sequences](#Builtin-Data-Structures-Strings-As-Sequences)  \n",
    " &ensp;&ensp; 5.2.3.1 [Indexing](#Builtin-Data-Structures-Strings-Indexing)  \n",
    " &ensp;&ensp; 5.2.3.2 [Slicing](#Builtin-Data-Structures-Strings-Slicing)  \n",
    " &ensp;&ensp; 5.2.3.3 [Strings and iteration](#Builtin-Data-Structures-Strings-Strings-And-Iteration)  \n",
    " &ensp; 5.2.4 [Regular expressions](#Builtin-Data-Structures-Strings-Regular-Expressions)  \n",
    " 5.3 [Lists](#Builtin-Data-Structures-Lists)  \n",
    " &ensp; 5.3.1 [List instantiation](#Builtin-Data-Structures-Lists-Instantiation)  \n",
    " &ensp; 5.3.2 [List comprehensions](#Builtin-Data-Structures-Lists-Comprehensions)  \n",
    " &ensp; 5.3.3 [Update in place operations](#Builtin-Data-Structures-Lists-Update-In-Place)  \n",
    " &ensp; 5.3.4 [Additional list operations](#Builtin-Data-Structures-Lists-Additional-Operations)  \n",
    " 5.4 [Tuples](#Builtin-Data-Structures-Tuples)  \n",
    " &ensp; 5.4.1 [Tuple instantiation](#Builtin-Data-Structures-Tuple-Instantiation)  \n",
    " &ensp; 5.4.2 [Additional tuple operations](#Builtin-Data-Structures-Tuple-Operations)  \n",
    " 5.5 [Dicts](#Builtin-Data-Structures-Dicts)  \n",
    " &ensp; 5.5.1 [Dict instantiation](#Builtin-Data-Structures-Dict-Instantiation)  \n",
    " &ensp; 5.5.2 [Dict operations](#Builtin-Data-Structures-Dict-Operations)  \n",
    " 5.6 [Sets](#Builtin-Data-Structures-Sets)  \n",
    " &ensp; 5.6.1 [Set instantiation](#Builtin-Data-Structures-Set-Instantiation)  \n",
    " &ensp; 5.6.2 [Additional set operations](#Builtin-Data-Structures-Set-Operations)  \n",
    " &ensp; 5.6.3 [Additional in-place operations on sets](#Builtin-Data-Structures-Set-In-Place-Operations)  \n",
    " 5.7 [Frozensets](#Builtin-Data-Structures-Frozensets)  \n",
    " &ensp; 5.7.1 [Frozenset instantiation](#Builtin-Data-Structures-Frozenset-Instantiation)  \n",
    " &ensp; 5.7.2 [Additional frozenset operations ](#Builtin-Data-Structures-Frozenset-Operations)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.1  Overview <a name='Builtin-Data-Structures-Overview'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python supports six types of native data structures:\n",
    "[strings](#Builtin-Data-Structures-Strings), \n",
    "[lists](#Builtin-Data-Structures-Lists), \n",
    "[tuples](#Builtin-Data-Structures-Tuples), \n",
    "[dicts](#Builtin-Data-Structures-Dicts), \n",
    "[sets](#Builtin-Data-Structures-Sets), and \n",
    "[frozensets](#Builtin-Data-Structures-Frozensets). \n",
    "The following descriptions of these structures highlight selected operations from each. \n",
    "For more information, consult the Python library documentation on \n",
    "[strings](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), \n",
    "[lists](https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range), \n",
    "[tuples](https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range), \n",
    "[dicts](https://docs.python.org/3/library/stdtypes.html#mapping-types-dict), \n",
    "[sets](https://docs.python.org/3/library/stdtypes.html#set-types-set-frozenset), and \n",
    "[frozensets](https://docs.python.org/3/library/stdtypes.html#set-types-set-frozenset).\n",
    "\n",
    "Python's structures are divisible into what Python refers to as *mutable* and *immutable* objects.\n",
    "-  Mutable objects, which include lists, dicts, and sets, can be updated after being created.\n",
    "   -  This makes these objects potentially space-efficient.\n",
    "   -  For reasons of computational efficiency, however, Python will not hash these objects:\n",
    "       i.e., they can't be used as keys for [dicts](#Builtin-Data-Structures-Dicts)\n",
    "-  Immutable objects, which include numbers, strings, tuples, and frozensets, are not updateable, once created.\n",
    "   -  Operations that appear to \"change\" mutables produce new objects.\n",
    "   -  This makes immutable objects potentially space-inefficient, but effective for use as keys in dicts:\n",
    "       structures that map keys to associated values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.1 data structure hash functions\n",
    "\n",
    "print('documentation for immutable object hash functions:')\n",
    "print('int: ',       int.__hash__)\n",
    "print('float: ',     float.__hash__)\n",
    "print('complex: ',   complex.__hash__)\n",
    "print('str: ',       str.__hash__)\n",
    "print('tuple: ',     tuple.__hash__)\n",
    "print('frozenset: ', frozenset.__hash__)\n",
    "print()\n",
    "print('-----------------------------')\n",
    "print()\n",
    "print('documentation for mutable object hash functions:')\n",
    "print('list:', list.__hash__)\n",
    "print('dict:', dict.__hash__)\n",
    "print('set:',  set.__hash__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.2 Strings <a name='Builtin-Data-Structures-Strings'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings are unusual structures.  Some Python operators treat them as atomic values. Others treat them as lists of characters."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.2.1 String instantiation <a name='Builtin-Data-Structures-Strings-Instantiation'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.2.1.a  using single- and double-quotes to instantiate strings\n",
    "\n",
    "print( 'abc', \"easy as 1-2-3\" )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.2.1.b  using escapes to embed quotes in strings\n",
    "\n",
    "print( \"simple as \\\"do-re-mi\\\"\", '\\'abc\\'' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.2.1.c  using string concatenation to build strings\n",
    "\n",
    "'that\\'s how easy' + ' ' + 'love can be'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.2.1.d  using triple quoting to build strings that cross line boundaries.\n",
    "# The newlines become part of the string.\n",
    "# The string is closed with a matching triple quote.\n",
    "\n",
    "\"\"\"\n",
    "James James\n",
    "Morrison Morrison\n",
    "Weatherby George Dupree\n",
    "Took great\n",
    "Care of his Mother\n",
    "Though he was only three.\n",
    "James James\n",
    "Said to his mother,\n",
    "\"Mother\", he said, said he,\n",
    "\"You must never go down to the end of the town if you don't go down with me.\"\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.2.1.e  using Python's raw string construct\n",
    "\n",
    "r'prepending a single r to a string makes it a \"raw\" string: one where \\ does not escape content'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.2.1.f  using string replication to build strings\n",
    "\n",
    "'abc' * 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.2.1.g  using the cross-object method str() to instantiate object-describing strings\n",
    "\n",
    "print( 'str(123)        is ', str(123) )\n",
    "print( 'str(\\'1, 2, 3\\')  is ', str('1, 2, 3') )\n",
    "print( 'str(123+456j)   is ', str(123+456j)   )\n",
    "print( 'str((1, 2, 3))  is ', str((1, 2, 3))  )\n",
    "print( 'str([1, 2, 3])  is ', str([1, 2, 3])  )\n",
    "print( 'str({1:2, 3:4}) is ', str({1:2, 3:4}) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.2.1.h1  using the cross-object method repr() to instantiate object-describing strings\n",
    "\n",
    "print( 'repr(123)        is ', repr(123) )\n",
    "print( 'repr(\\'1, 2, 3\\')  is ', repr('1, 2, 3') )\n",
    "print( 'repr(123+456j)   is ', repr(123+456j)   )\n",
    "print( 'repr((1, 2, 3))  is ', repr((1, 2, 3))  )\n",
    "print( 'repr([1, 2, 3])  is ', repr([1, 2, 3])  )\n",
    "print( 'repr({1:2, 3:4}) is ', repr({1:2, 3:4}) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.2.1.h2  Comparing output from str(), repr()\n",
    "\n",
    "print( 'str(\\'1, 2, 3\\') == repr(\\'1, 2, 3\\') is', str('1, 2, 3') == repr('1, 2, 3') )\n",
    "print( 'str(123) == repr(123) is', str(123) == repr(123) )\n",
    "print( 'str(123+456j) == repr(123+456j) is', str(123+456j) == repr(123+456j) )\n",
    "print( 'str((1, 2, 3)) == repr((1, 2, 3)) is', str((1, 2, 3)) == repr((1, 2, 3)) )\n",
    "print( 'str({1:2, 3:4}) == repr({1:2, 3:4}) is', str({1:2, 3:4}) == repr({1:2, 3:4}) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 5.2.1.1:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following markdown cell, \n",
    "explain the difference between `str()` and `repr()`.",
    "</span>\n",
    "***\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.2.2 Formatting <a name='Builtin-Data-Structures-Strings-Formatting'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python's string formatting operators generate strings by merging content from a sequence of items into a base string.",
    " This base string normally includes meta-substrings-- think of these of as \"holes\"-- that mark locations for receiving content;",
    " type the content to insert; and specify how to format that content.\n",
    "\n",
    "Python supports four mechanisms for string formatting:\n",
    "-  The oldest, [*printf*-style formatting](#Builtin-Data-Structures-Strings-Printf-Style-String-Formatting), uses expressions of the form *template % item_list*\n",
    "-  A somewhat newer mechanism uses expressions of the form [*template.format()*](#Builtin-Data-Structures-Strings-Format-Style-String-Formatting)\n",
    "-  A still newer mechanism uses formatted string literals, called [*template-strings*](#Builtin-Data-Structures-Strings-Template-String-Style-String-Formatting)\n",
    "-  A final mechanism, [*f-strings*](#Builtin-Data-Structures-Strings-F-String-Style-String-Formatting), uses an initial `f` as a shorthand for a final .format() method\n",
    "\n",
    "The presence of four string formatting mechanisms in Python illustrates Mark Lutz's point about Python's departure from ",
    " *one-- and preferably only one-- obvious way to do it*.  But that's the way it is."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.2.2.1 Printf-style string formatting <a name='Builtin-Data-Structures-Strings-Printf-Style-String-Formatting'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The string-based % operator is similar to C's *printf* function.  % takes two arguments:\n",
    "-  The left-hand argument is a template to complete.\n",
    "   -  It consists of two types of content:\n",
    "      -  Plain old text.\n",
    "      -  Format specifiers, embedded in the text, which are prefixed with %.  They come in 7 basic types:\n",
    "         -  `%d`, `%i` - signed decimal integer\n",
    "         -  `%o` - signed octal\n",
    "         -  `%x`, `%X` - hexadecimal; show letters, when displayed, as lower- and upper-case, respectively\n",
    "         -  `%e`, `%E`, `%f`, `%F`, `%g`, `%G` - floating point formats; lower and upper case forms show exponent indicator as e and E, respectively.\n",
    "            -  `%e`, `%E` - show in exponent format\n",
    "            -  `%f`, `%F` - show in decimal point format\n",
    "            -  `%g`, `%G` - show in exponent format if exponent is -5 or less, else decimal format\n",
    "         -  `%c` - single character; also accepts 1-character strings\n",
    "         -  `%a`, `%s` `%r`, - string; convert argument using ascii(), str(), and repr(), respectively\n",
    "         -  `%%` - single percent sign; consumes no arguments\n",
    "   -  Optional qualifiers after the initial % specify the following:\n",
    "      -  zero padding (0)\n",
    "      -  field width (positive int)\n",
    "      -  left justification (-)\n",
    "      -  precision (., followed by positive int)\n",
    "      -  alternate format (#)\n",
    "      -  initial sign for all conversions (+)\n",
    "      -  (*key*) - the name of a key in the right-hand side argument; only valid when the right-hand argument is a dict\n",
    "-  The right-hand argument can be one of two types of constructs:\n",
    "   -  An object that yields a sequence of values: e.g., a tuple, a list\n",
    "   -  A *dict* - i.e., a collection of key-value pairs\n",
    "\n",
    "The following examples use these additional Python constructs:\n",
    "-  One-element tuples - these, like &ensp; (30,) &ensp;, must be written with a final comma to distinguish them from parenthesized terms\n",
    "-  *s &ast; n*  - when *s* is a tuple, list, or string, this returns *n* copies of the sequence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.2.2.1.a1  printf-style-formatting with a numeric constant\n",
    "\n",
    "print( '30. in different formats:  %d,  %e,  %E,  %f,  %F,  %g,  %G' % ((30.,) * 7) )\n",
    "print( '30. in alternate formats: %#d, %#e, %#E, %#f, %#F, %#g, %#G' % ((30.,) * 7) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.2.2.1.a2  octal and hex formats, which require an int, with a variable\n",
    "\n",
    "thirty_as_tuple = (30,) * 6\n",
    "print( '30 in different  formats: %o, %#o, %x, %X, %#x, %#X' % thirty_as_tuple )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.2.2.1.b  printf-style formatting with different justifications\n",
    "\n",
    "print( '30. in a five-space field, with different justifications and formats' )\n",
    "print( '>%-5d<   >%05d<    >%#5d<' % ( (30.,) * 3 ) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.2.2.1.c  printf-style string and character formatting\n",
    "\n",
    "print( '\"30\" in different formats: %c, %a, %r, %s' % (('30'[0],) + (('30',) * 3)) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.2.2.1.d  printf-style formatting using a dict\n",
    "\n",
    "print( '%(this)s %(is)s %(a)s %(message)s' % { 'a' : 'A', 'is' : 'iZ', 'message' : 'mesG', 'this' : 'thiz' } )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[The Python documentation](https://docs.python.org/3/library/stdtypes.html#old-string-formatting) \n",
    "cautions that printf-style formatting exhibits \"a variety of quirks that lead to a number of common errors \n",
    "(such as failing to display tuples and dictionaries correctly)\". \n",
    "For this reason, it recommends the two alternative formatting mechanisms described in what follows."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.2.2.2  Formatting with the `format()` method <a name='Builtin-Data-Structures-Strings-Format-Style-String-Formatting'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The string class's `format()` method supports a {}-based syntax for denoting holes.\n",
    "  The basic syntax is '*some string*'.format(*some values*)', as follows:\n",
    "-  *some values* can be one of two types of constructs:\n",
    "   -  An object that yields a sequence of values: e.g., a tuple, a list\n",
    "   -  A list of key-value pairs\n",
    "-  *some string* is a base string to format. It consists of two types of content:\n",
    "   -  Plain old text.\n",
    "   -  Format specifiers, embedded in the text.\n",
    "      -  These specifiers are denoted by matching braces ({}).\n",
    "      -  They can reference the *some values* collection in one of three basic ways:\n",
    "         -  `{}` - the value collection is a sequence; take the next item from the sequence\n",
    "         -  `{n}` - the value collection is a sequence; take the *n*th item from the sequence (0-index)\n",
    "         -  `{key}` - *key* is a key for a key-value pair; take the value associated with *key*\n",
    "      -  As described in [the Python library doc](https://docs.python.org/3/library/string.html#formatstrings),\n",
    "          these references can be qualified in one of three ways:\n",
    "         -  They can be prefixed with format specifiers.\n",
    "             These specifiers are like those for [printf-style formatting](#Builtin-Data-Structures-Strings-Printf-Style-String-Formatting),\n",
    "             with the following exceptions and additions:\n",
    "            -  `:` is used instead of % to prefix format qualifiers: e.g., %3.2f is comparable to {:3.2f}\n",
    "            -  `s` (string) is the default, and can be omitted: i.e., {} is the same as {!s)\n",
    "            -  `%` denotes a percentage; the value is multiplied by 100 and displayed as a fixed format value\n",
    "            -  `n` functions like `g`, but uses the current locale to render output\n",
    "            -  `,` and `_` specify the use of , and _ as thousands separators, respectively\n",
    "            -  `<`, `^`, and `>` specify left alignment, centering, and right alignment, respectively\n",
    "            -  `=` inserts padding after any sign but before all other digits\n",
    "         -  Non-atomic objects can be qualified with a suffix that selects one of their components\n",
    "         -  Objects can be qualified with a suffix that coerces their value, using one of three Python built-in functions:\n",
    "            -  `!a` - specifies *ascii()*\n",
    "            -  `!r` - specifies *repr()*\n",
    "            -  `!s` - specifies *str()*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.2.2.2.a  ordered retrieval of items by format() for template string insertion\n",
    "\n",
    "print('{} is a {} with {} {}'.format( 'This', 'string', 'inserted', 'content' ) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.2.2.2.b  positional retrieval of items, including repeated items, for template string insertion\n",
    "\n",
    "print( '30 in different formats: {int:d}, {int:o}, {int:x}, {fp:e}, {fp:03.3f}, {fp:g}'.format( fp=30., int=30 ) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.2.2.3  Formatting with template strings <a name='Builtin-Data-Structures-Strings-Template-String-Style-String-Formatting'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "According to the [Python library documentation](https://docs.python.org/3/library/string.html#template-strings), ",
    "template strings were introduced to provide improved support for string internationalization.",
    " Template string formatting, like format string formatting, is method-based.",
    " The basic syntax is &ensp; '*some string*'.`substitute`(*some values*). Here,\n",
    "-  *some string* is a base string to format. It consists of two types of content:\n",
    "   -  Plain old text.\n",
    "   -  Format specifiers, embedded in the text.  They take one of three forms:\n",
    "      - \\$ &#123; *identifier* &#125; \n",
    "      - \\$*identifier* - a shorthand for the former when *identifier* is followed by a non-word character.\n",
    "      - $$ - a shorthand for $\n",
    "-  *some values* is a list of key-value pairs\n",
    "\n",
    "`substitute` fails if any of the specified identifiers are not in *some values* list of keys.",
    "  A second method, `safe_substitute`, leaves *identifier* in place when it's missing from the key-values list.\n",
    "\n",
    "Note: as of the time when this document was written, the Windows port of Python lacked support for template strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.2.2.3.a  example of template string formatting, using substitute()\n",
    "\n",
    "if 'substitute' in dir(str):\n",
    "  print( '$this $_is $a $message'.substitute( a='A', _is='iZ', message='mesG', this='thiz' ) )\n",
    "else:\n",
    "  print( 'template strings aren\\'t supported in this implementation of Python.' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.2.2.3.b  example of template string formatting, using substitute(), with a missing key\n",
    "\n",
    "if 'substitute' in dir(str):\n",
    "  print( '$this $_is $a $message'.substitute( a='A', _is='iZ', this='thiz' ) )\n",
    "else:\n",
    "  print( 'template strings aren\\'t supported in this implementation of Python.' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.2.2.3.c  example of template string formatting, using safe_substitute(), with a missing key\n",
    "\n",
    "if 'safe_substitute' in dir(str):\n",
    "  print( '$this $_is $a $message'.safe_substitute( a='A', _is='iZ', this='thiz' ) )\n",
    "else:\n",
    "  print( 'template strings aren\\'t supported in this implementation of Python.' )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 5.2.2.3.1:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following markdown cell, \n",
    "explain why the above examples use `is_` as a key, rather than `is`.",
    "</span>\n",
    "***\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.2.2.4  Formatting with f-strings <a name='Builtin-Data-Structures-Strings-F-String-Style-String-Formatting'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As of this writing, `f-strings` are not described in the Python library documentation.",
    "Rather, they're documented in a [Python Enhancement Proposal (PEP) - PEP 498](https://www.python.org/dev/peps/pep-0498/), ",
    "which characterizes them as a simpler alternative to `str.format()`.",
    "Loosely speaking, `f-strings` are like `str.format`, with the following changes:\n",
    "-  an initial `f` in front of a string triggers formatting\n",
    "-  each expression to print is placed directly in paired curly braces\n",
    "-  operators for positioning values in fields aren't supported\n",
    "-  `{{` and `}}` can be used to include braces in f-strings\n",
    "-  backslash `(\\)` characters are disallowed in f-strings\n",
    "\n",
    "By default, the `f-string` formatting method, `__format__`, uses `__str__` to convert expressions to strings. ",
    "`!a` and `!r` can be appended to an expression to request ascii and `__repr__` conversions, respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.2.2.4  example of f-string formatting\n",
    "\n",
    "a = 3\n",
    "b = 4\n",
    "message_part_1 = 'a is'\n",
    "message_part_2 = '; b is'\n",
    "message_part_3 = '; a+b is'\n",
    "message_part_4 = '; a-b is'\n",
    "\n",
    "print( f'{message_part_1} {a}{message_part_2} {b}{message_part_3} {a+b}{message_part_4} {a-b}' )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.2.3  Strings as sequences <a name='Builtin-Data-Structures-Strings-As-Sequences'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings can behave as atomic values or sequences, depending on context.  Python supports two operators on sequences:\n",
    "-  an indexing operator, denoted by []\n",
    "-  a slicing operator, a generalization of the indexing operator, denoted by [:] or [::]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.2.3.1 Indexing <a name='Builtin-Data-Structures-Strings-Indexing'></a>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.2.3.1.a  using positive indexing to enumerate a string's characters\n",
    "\n",
    "from math import log10, floor\n",
    "test_string = 'abcdef'\n",
    "test_string_len_space_allocation = floor(log10(len(test_string))) + 1\n",
    "test_string_message_format = 'test string character %s%dd is %sc' % ( '%', test_string_len_space_allocation, '%' )\n",
    "\n",
    "for this_index in range(len(test_string)):\n",
    "  print( test_string_message_format % ( this_index , test_string[this_index] ) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.2.3.1.b  using negative indexing to enumerate a string's characters\n",
    "\n",
    "from math import log10, floor\n",
    "test_string = 'abcdef'\n",
    "test_string_len_space_allocation = floor(log10(len(test_string))) + 1\n",
    "test_string_message_format = 'test string character %s%dd is %sc' % ( '%', test_string_len_space_allocation, '%' )\n",
    "\n",
    "for this_index in range(-1,-len(test_string)-1,-1):\n",
    "  print( test_string_message_format % (this_index, test_string[this_index]) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.2.3.1.c  using Python's enumerate() built-in to enumerate a string's characters and their positions\n",
    "\n",
    "from math import log10, floor\n",
    "test_string = 'abcdef'\n",
    "test_string_len_space_allocation = floor(log10(len(test_string))) + 1\n",
    "test_string_message_format = 'test string character %s%dd is %sc' % ( '%', test_string_len_space_allocation, '%' )\n",
    "\n",
    "for (this_index, this_character) in enumerate(test_string):\n",
    "  print( test_string_message_format % (this_index, this_character) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.2.3.2  Slicing <a name='Builtin-Data-Structures-Strings-Slicing'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Slicing* is primarily useful for extracting content from sequence-based datasets. ",
    "These examples use strings to illustrate the operator's function.  Slicing can also be used to extract subsequences from tuples and lists.\n",
    "\n",
    "Python's slicing operator has two forms.  The operator's first form, [`begin`:`onebeyond`], extracts a contiguous substring from a base string `s`.\n",
    "-  The operator's first `begin` argument is the slice's initial index. \n",
    "   -   Nonnegative values relate to a string's leftmost element, starting with 0. \n",
    "   -   Negative values relate to a string's rightmost element:  i.e., `-len(s)` denotes a string's leftmost character.  \n",
    "-  The operator's second `onebeyond` argument is one position beyond the slice's final index.  \n",
    "   -   Nonnegative values relate to a string's leftmost element, starting with 0:  i.e., `len(s)+1` denotes all elements up to and including `s`'s rightmost character. \n",
    "   -   Negative values relate to a string's rightmost element:  i.e., -1 denotes all elements up to but not including `s`'s rightmost character" 
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.2.3.2.a  illustrating the default values for the [:] operator\n",
    "\n",
    "test_string = 'abcdef'\n",
    "print( 'test string is                                          ', test_string )\n",
    "print( 'test string sliced with a start index of 1     is       ', test_string[1:len(test_string)] )\n",
    "print( 'test string sliced with a final index of len-1 is       ', test_string[0:len(test_string)-1] )\n",
    "print( 'test string sliced with default start, final indices is ', test_string[:] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.2.3.2.b  using positive indexing to enumerate a string's substrings\n",
    "\n",
    "test_string = 'abcdef'\n",
    "for start_index in range(len(test_string)):\n",
    "  leading_padding = ' ' * start_index;\n",
    "  for end_index in range(start_index+1, len(test_string)+1):\n",
    "    slice = test_string[start_index:end_index]\n",
    "    print( f\"{test_string}[{start_index}:{end_index}] is {leading_padding}'{slice}'\" )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.2.3.2.c  using negative indexing with a negative stride to enumerate a string's substrings\n",
    "\n",
    "test_string = 'abcdef'\n",
    "for start_index in range(-len(test_string), 0):\n",
    "  leading_padding = ' ' * (len(test_string)+start_index);\n",
    "  for end_index in range(start_index+1, 0):\n",
    "    slice = test_string[start_index:end_index]\n",
    "    print( f\"{test_string}[{start_index}:{end_index}] is {leading_padding}'{slice}'\" )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 5.2.3.2.1:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following code cell, ",
    "for the previous two (positive and negative range) examples, ",
    "show what happens when the range of a slice expands beyond test_string's length.",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The slicing operator's second, [`begin`:`onebeyond`:`k`] form adds an explicit stride parameter.\n",
    "-  A positive stride, `k`, direct the operator to select every `k`th value from the sequence, moving from left to right. \n",
    "-  A negative stride, `k`, directs the operator to select every `k`th value from the sequence, moving from right to left."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.2.3.2.d  illustrating the default stride value for the [::] operator\n",
    "\n",
    "test_string = 'abcdef'\n",
    "print( 'test string is ', test_string )\n",
    "print( 'test string sliced with a stride of 1 is      ', test_string[0:len(test_string):1] )\n",
    "print( 'test string sliced with a stride of 2 is      ', test_string[0:len(test_string):2] )\n",
    "print( 'test string sliced with the default stride is ', test_string[0:len(test_string):] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.2.3.2.e  using positive indexing with a negative stride to enumerate a string's substrings\n",
    "\n",
    "test_string = 'abcdef'\n",
    "for start_index in range(0,len(test_string)):\n",
    "  leading_padding = ' ' * (len(test_string)-start_index);\n",
    "  for end_index in range(start_index):\n",
    "    slice = test_string[start_index:end_index:-1]\n",
    "    print( f\"{test_string}[{start_index}:{end_index}:-1] is {leading_padding}'{slice}'\" )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.2.3.2.f  using negative indexing to enumerate a string's substrings\n",
    "\n",
    "test_string = 'abcdef'\n",
    "for start_index in range(-1,-len(test_string)-1,-1):\n",
    "  leading_padding = ' ' * (-start_index-1);\n",
    "  for end_index in range(start_index-1, -len(test_string)-2, -1):\n",
    "    slice = test_string[start_index:end_index:-1]\n",
    "    print( f\"{test_string}[{start_index}:{end_index}:-1] is {leading_padding}'{slice}'\" )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.2.3.2.g  illustrating the effect of varying positive strides on positive indexing\n",
    "\n",
    "test_string = 'abcdefghijklmnop'\n",
    "for stride in range(1, len(test_string)+1):\n",
    "  print( f\"{test_string}[::{stride}] is '{test_string[::stride]}'\" )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.2.3.2.h illustrating the effect of varying negative strides on negative indexing\n",
    "\n",
    "test_string = 'abcdefghijklmnop'\n",
    "for stride in range(-1,-len(test_string)-1,-1):\n",
    "  slice = test_string[-1:-len(test_string)-1:stride]\n",
    "  print( f\"{test_string}[-1:{-len(test_string)-1}:{stride}] is '{slice}'\" )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 5.2.3.2.2:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following code cell, ",
    "illustrate the effect of specifying a stride of 0.",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 5.2.3.2.3:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following code cell, ",
    "illustrate a single slice with numeric first and second arguments and negative stride that returns the entirety of test_string. ",
    "If you can't do this, show that it can't be done, including examples to make your point.",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 5.2.3.2.4:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following code cell, ",
    "repeat the previous exercise, experimenting with `None` as a value for the slicing argument's first and second operators.",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.2.3.3  Strings and iteration  <a name='Builtin-Data-Structures-Strings-Strings-And-Iteration'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following examples illustrate a potential hazard that a string's dual nature as ",
    "an atomic value and a list of characters creates for loop-based string manipulation. \n",
    "\n",
    "**Including commas in singleton tuples is especially critical for strings.** ",
    "Failing to do so can totally give unexpected results WITHOUT generating an obvious program failure. ",
    "This makes the mistake particularly difficult to catch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.2.3.3.a looping through a singleton sequence of strings\n",
    "\n",
    "string_seq = ('abcdef',)    # final ',' a must, to ensure interpretation as a tuple rather than an atomic value\n",
    "for string in string_seq:\n",
    "  print( string )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.2.3.3.b looping through a string\n",
    "\n",
    "string_seq = ('abcdef')    # without the final ',' string_seq is interpreted as a list of characters\n",
    "for string in string_seq:\n",
    "   print( string )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.2.4 Regular expressions <a name='Builtin-Data-Structures-Strings-Regular-Expressions'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Regular expressions (regexps) were devised and explored in the late 1940's by U. Wisconsin-Madison mathematician Stephen Kleene.",
    " Regexps are essentially an expressive means for characterizing groups of related strings. ",
    " At base, all regexps are built from three basic string operators:\n",
    "-  xy – concatenation\n",
    "-  &ast; – repetition (any number of) \n",
    "-  | - alternation (either/or) \n",
    "\n",
    "Over time, the set of operators that various implementations of regexps offer has expanded greatly.",
    " Still, all of these operators can be characterized as shorthands for combinations of Kleene's original three operators.\n",
    "\n",
    "As of the mid-2010's, the Free Software Foundation supported 12 different regexp standards in its GNU suite of Unix utilities. ",
    "  Even so, the de facto regexp standard is the Perl programming language's implementation of regexps, which dates to the late 1980's. ",
    "  Python implements Perl-like regexps, providing support for the common regexp operators (e.g., &ast;, +, ?, {*m*,*n*}, [..]) ",
    " as well as more exotic operators, like these:\n",
    "-  positive and negative lookbehind ((?&lt;=...), (?&lt;!...))\n",
    "-  positive and negative lookahead  ((?=...), (?!...))\n",
    "-  noncapturing expressions (?:...)\n",
    "-  expression tagging (?P=(name)...)\n",
    "\n",
    "The following examples use this additional Python construct:\n",
    "-  `split` - split a string into multiple chunks, returning a list of chunks, using the specified string as a point of splitting (default: whitespace)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.2.4.a using regular expressions to retrieve non-backreferenced patterns.\n",
    "# re.findall - return all matching patterns in a given string\n",
    "\n",
    "import re\n",
    "\n",
    "# regular expression subpatterns for this example\n",
    "ASSERT_WORD_START=r'?<!\\w'\n",
    "FOUR_WORD_CHARS=r'\\w{4}'\n",
    "ASSERT_WORD_END=r'?!\\w'\n",
    "\n",
    "# the text to process\n",
    "text = \"\"\"James James\n",
    "Morrison Morrison\n",
    "Weatherby George Dupree\n",
    "Took great\n",
    "Care of his Mother\n",
    "Though he was only three.\n",
    "James James\n",
    "Said to his mother,\n",
    "\"Mother\", he said, said he,\n",
    "\"You must never go down to the end of the town if you don't go down with me.\"\"\" + '\"'\n",
    "\n",
    "# the pattern to attempt\n",
    "four_letter_words = []\n",
    "four_letter_word_pattern = '({}){}({})'.format(ASSERT_WORD_START, FOUR_WORD_CHARS, ASSERT_WORD_END)\n",
    "\n",
    "# go process\n",
    "for line in text.split('\\n'):\n",
    "  four_letter_words += re.findall( four_letter_word_pattern, line)\n",
    "print( 'four letter words in passage: ', ', '.join( four_letter_words ) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.2.4.b using regular expressions to retrieve backreferenced patterns.\n",
    "# This problem is more difficult, because of the need to avoid capturing irrelevant capture groups.\n",
    "# The problem can't be solved with re.findall, which returns all capture groups.\n",
    "# Instead, the code uses compiled search objects, which support a starting point argument.\n",
    "# then slides through each string, checking for matching patterns.\n",
    "\n",
    "import re\n",
    "\n",
    "# regular expression subpatterns for this example\n",
    "ASSERT_WORD_START=r'?<!\\w'\n",
    "WORD_CHARS=r'\\w+'\n",
    "TRAILING_COMMA='?:,'\n",
    "NONWORD_CHAR=r'\\W'\n",
    "NONWORD_CHARS=r'\\W+'\n",
    "STUFF='.*'\n",
    "_2ND_ITEM_IN_PARENS=r'\\2'\n",
    "_3RD_ITEM_IN_PARENS=r'\\3'\n",
    "ASSERT_WORD_END=r'?!\\w'\n",
    "\n",
    "# the text to process\n",
    "text = \"\"\"James James\n",
    "Morrison Morrison\n",
    "Weatherby George Dupree\n",
    "Took great\n",
    "Care of his Mother\n",
    "Though he was only three.\n",
    "James James\n",
    "Said to his mother,\n",
    "\"Mother\", he said, said he,\n",
    "\"You must never go down to the end of the town if you don't go down with me.\"\"\" + '\"'\n",
    "\n",
    "# what to process, and where to store results\n",
    "regexps_to_process_plus_matching_phrases = []\n",
    "\n",
    "# the list of all matches to attempt\n",
    "words_before_commas = []\n",
    "pattern_elements = [ ASSERT_WORD_START, WORD_CHARS, TRAILING_COMMA ]\n",
    "this_pattern = '({})(?P<pattern_to_seek>({}))({})'.format( *pattern_elements )\n",
    "word_before_commas_regexp = re.compile( this_pattern )\n",
    "regexps_to_process_plus_matching_phrases += [ ( word_before_commas_regexp, words_before_commas ) ]\n",
    "\n",
    "doubled_adjacent_words = []\n",
    "pattern_elements = [ ASSERT_WORD_START, WORD_CHARS, NONWORD_CHARS, _2ND_ITEM_IN_PARENS, ASSERT_WORD_END ]\n",
    "this_pattern = '({})(?P<pattern_to_seek>({})({})({}))({})'.format( *pattern_elements )\n",
    "doubled_adjacent_words_regexp = re.compile( this_pattern )\n",
    "regexps_to_process_plus_matching_phrases += [ (doubled_adjacent_words_regexp, doubled_adjacent_words ) ]\n",
    "\n",
    "phrases_with_doubled_words = []\n",
    "pattern_elements = [ ASSERT_WORD_START, WORD_CHARS, NONWORD_CHAR, STUFF, NONWORD_CHAR, _2ND_ITEM_IN_PARENS, ASSERT_WORD_END ]\n",
    "this_pattern = '({})(?P<pattern_to_seek>({}){}({}{})?{})({})'.format( *pattern_elements )\n",
    "phrase_with_doubled_words_regexp = re.compile( this_pattern ) \n",
    "regexps_to_process_plus_matching_phrases += [ (phrase_with_doubled_words_regexp, phrases_with_doubled_words ) ]\n",
    "\n",
    "reversed_two_word_phrases = []\n",
    "pattern_elements = [ ASSERT_WORD_START, WORD_CHARS, NONWORD_CHARS, WORD_CHARS, ASSERT_WORD_END, STUFF ]\n",
    "pattern_elements += [ ASSERT_WORD_START, _3RD_ITEM_IN_PARENS, NONWORD_CHARS, _2ND_ITEM_IN_PARENS, ASSERT_WORD_END ]\n",
    "this_pattern = '({})(?P<pattern_to_seek>({}){}({})({}){}(({}){}{}{}))({})'.format( *pattern_elements )\n",
    "reversed_two_word_phrase_regexp = re.compile( this_pattern )\n",
    "regexps_to_process_plus_matching_phrases += [ (reversed_two_word_phrase_regexp, reversed_two_word_phrases ) ]\n",
    "\n",
    "for line in text.split('\\n'):\n",
    "  for (regexp, matching_phrases) in regexps_to_process_plus_matching_phrases:\n",
    "    start_position = 0\n",
    "    while True:\n",
    "      this_match = regexp.search(line, start_position)\n",
    "      if not this_match:\n",
    "        break  # no more matches to be had for this line\n",
    "      matching_phrases += [ this_match.groupdict()[ 'pattern_to_seek' ] ]   # retrieve this match \n",
    "      start_position = this_match.span()[1]+1                               # continue after this pattern \n",
    "\n",
    "print( 'words before commas in passage: ',         words_before_commas )\n",
    "print( 'doubled adjacent words in passage: ',      doubled_adjacent_words )\n",
    "print( 'phrases with doubled words in passage: ',  phrases_with_doubled_words )\n",
    "print( 'four word phrases with reversed halves: ', reversed_two_word_phrases )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 5.2.4.1:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following markdown cell, ",
    "explain why the previous example's third test, which checks for phrases with doubled words, doesn't return all such phrases.",
    "</span>\n",
    "***\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 5.2.4.2:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following code cell, ",
    "update this example, fixing the logic that fixes this problem, and does so in a uniform way for all four checks.",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.2.5 Concluding exercises for strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 5.2.5.1:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following code cell, ",
    "show the use of the string type's [split](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str) operator",
    " to create examples that illustrate the following:</span>\n",
    "-  <span style='color:navy'>",
    "The effect of splitting a string s with a split string ss of length 2 or more.  Make sure s contains two or more instances of ss",
    "</span>\n",
    "-  <span style='color:navy'>",
    "The effect of splitting a string s with a zero-length split string.  Make sure s is nonempty",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 5.2.5.2:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following code cell, ",
    "show the use of the code in the section on [Docstrings](./4.%20%20Interactive%20help%20features.ipynb#Interactive-Help-Features-Docstrings) ",
    " to identify and obtain documentation on methods supported by class *str*",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 5.2.5.3:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following code cell, ",
    "repeat the previous exercise, modifying the \"for\" loop to skip names that begin and end with '\\_\\_'",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 5.2.5.4:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following code cell, ",
    "repeat the previous exercise, this time modifying the \"for\" loop to skip names that ",
    "begin with exactly two underscores ( '\\_\\_' ) -- no more -- and end with exactly two underscores -- no more.",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.3 Lists <a name='Builtin-Data-Structures-Lists'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists are core Python data structures.  They're commonly used to represent sequences of items and vectors (1-D arrays).",
    " Nested lists are commonly used to represent multi-dimensional arrays."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.3.1 List Instantiation <a name='Builtin-Data-Structures-Lists-Instantiation'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.3.1.a  using square brackets to instantiate lists\n",
    "\n",
    "print( [], [1], [1,2,3,4,5,6] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.3.1.b  using list concatenation to build lists\n",
    "\n",
    "[1, 2, 3] + [4, 5, 6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.3.1.c using list replication to build lists\n",
    "\n",
    "[1, 2, 3] * 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.3.1.d  using the cross-object method list() to instantiate object-describing strings\n",
    "\n",
    "print( 'list([1, 2, 3]) is       ', list([1, 2, 3]) )\n",
    "print( 'list((1, 2, 3)) is       ', list((1, 2, 3)) )\n",
    "print( 'list({1, 2, 3}) is       ', list({1, 2, 3}) )\n",
    "print( 'list({1:7, 2:8, 3:9}) is ', list({1:7, 2:8, 3:9}) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.3.2 List comprehensions <a name='Builtin-Data-Structures-Lists-Comprehensions'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comprehensions are an __essential__ construct to master for clarity of coding. ",
    "   Comprehensions build collections of values without the need for classic loop-like control blocks.",
    "   As such, they're highly concise constructs for denoting large, potentially complex structures.\n",
    "\n",
    "List comprehensions build lists.  Python's other built-in collection classes-- tuples, dicts, sets, and frozensets--",
    " also support comprehensions. These objects' comprehensions work similarly to what is described below.\n",
    "\n",
    "The basic form of a list comprehension is as follows: \n",
    "\n",
    "&ensp;&ensp;&ensp;&ensp;[ *value-returning expression* **for** *index variable* **in** *sequence of values* **if** *condition is True* ]\n",
    "\n",
    "  The final `if` clause is optional.",
    "  Intuitively, for each successive value returned by its *sequence of values* clause, a comprehension\n",
    "-  assigns that value to *index variable*\n",
    "-  if the `if` clause is missing, or if evaluating *sequence of values* relative to the value of *index variable* returns True\n",
    "   -  evaluates *value-returning expression*, relative to the value of *index variable*\n",
    "   -  inserts that value into the next position of the list to return\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.3.2.a  generate [0, 2, 4, 6], using different combinations of *range* and \"if\" clauses\n",
    "\n",
    "print([i for i in range(0, 8, 2)])\n",
    "print([-i for i in range(0, -8, -2)])\n",
    "print([2*i for i in range(4)])\n",
    "print([i for i in range(8) if i % 2 == 0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.3.2.b  generate a list of upper case letters from ascii character codes for those letters,\n",
    "# then display it as a list and a string\n",
    "\n",
    "x = [chr(i) for i in range(ord('A'), ord('Z')+1)]\n",
    "print( ''.join(x), '\\n', x )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.3.2.c  generate a list of lower-case consonants from ascii character codes for those letters,\n",
    "# then display it as a list and a string\n",
    "\n",
    "x = [chr(i) for i in range(ord('a'), ord('z')+1) if chr(i) not in 'aeiou']\n",
    "print( ''.join(x), '\\n', x )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.3.2.d  generate a list of lists of integers\n",
    "\n",
    "print([[i, 2*i] for i in range(10)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comprehensions can be doubly nested, like double-nested loops.\n",
    "  Double-nested comprehensions can be used to generate flat lists or lists of lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.3.2.e  generate a flat version of the single-digit multiplication table\n",
    "\n",
    "print( [ i*j for i in range(10) for j in range(10)] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.3.2.f  generate and pretty-print a two-dimensional version of the single-digit multiplication table\n",
    "\n",
    "mult_table = [ [row*col for col in range(10)] for row in range(10)]\n",
    "for multi_table_row in mult_table:\n",
    "  for item in multi_table_row:\n",
    "    print( '%4d' % item, end = '' )\n",
    "  print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.3.2.g  like the previous, except insert the formatted entries in the list \n",
    "\n",
    "mult_table = [ [ '%4d' % (row*col) for col in range(10)] for row in range(10)]\n",
    "for multi_table_row in mult_table:\n",
    "  for item in multi_table_row:\n",
    "    print( item, end = '' )\n",
    "  print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.3.2.h  generate and pretty-print the upper diagonal version of the single-digit multiplication table\n",
    "\n",
    "mult_table = [ [ '%4d' % (row*col) if row <= col else '    ' for col in range(10)] for row in range(10)]\n",
    "for multi_table_row in mult_table:\n",
    "  for item in multi_table_row:\n",
    "    print( item, end = '' )\n",
    "  print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 5.3.2.1:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following code cell, ",
    "craft an example that generates and pretty-prints the lower-diagonal version of the single-digit multiplication table.",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.3.2.i  filtering a list's items based on their lengths\n",
    "\n",
    "milne_phrase = \"Took great care of his Mother Though he was only three\"\n",
    "max_word_len = max([len(substr) for substr in milne_phrase.split()])\n",
    "for i in range(1, max_word_len+1):\n",
    "  print( f\"words of length {i}: {', '.join([substr for substr in milne_phrase.split() if len(substr) == i])}\" )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.3.2.j  constructing lists of booleans\n",
    "\n",
    "milne_phrase = \"Took great care of his Mother Though he was only three\"\n",
    "capital_letters = [chr(i) for i in range(ord('A'), ord('Z')+1)]\n",
    "print( 'word in phrase is capitalized', [ ( substr, substr[0] in capital_letters ) for substr in milne_phrase.split() ] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.3.2.k  filtering by type\n",
    "\n",
    "test_list = ['a', 1, 'b', 2, 'c', '3']\n",
    "for (valtype, typename) in (('int', 'integer'), ('str', 'string')):\n",
    "  items_of_valtype = [ str(item) for item in test_list if isinstance(item, eval(valtype)) ]\n",
    "  typename = typename if len(items_of_valtype) == 1 else typename+'s'\n",
    "  print( typename + ' in test list: ', ', '.join(items_of_valtype) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 5.3.2.2:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following code cell, ",
    "craft an example that shows whether the index identifiers that a comprehension employs-- ",
    "e.g., i in [i for i in range(10)]-- change the values of any identifiers with the same names that were in use before the comprehension executes.",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 5.3.2.3:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following code cell, ",
    "craft an example that shows whether the index variables that a comprehension employs-- ",
    "e.g., i in [i for i in range(10)]-- persist after the comprehension executes.",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.3.3 Update in place operations <a name='Builtin-Data-Structures-Lists-Update-In-Place'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All operations that update values in place return `None`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.3.3.a Append a value to a list\n",
    "\n",
    "x = [1, 2, 3]\n",
    "x.append(4)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.3.3.b Insert values into a list\n",
    "\n",
    "x = [2, 3, 4]\n",
    "print( 'initial list:                             ', x )\n",
    "x.insert(0, 1) \n",
    "print( 'after inserting 1 at list head:           ', x )\n",
    "x.insert(-len(x)-1, 0)\n",
    "print( 'after inserting 0 at list head:           ', x )\n",
    "x.insert(-1, 3.5)\n",
    "print( 'after inserting 3.5 before the last item: ', x )\n",
    "x.insert(len(x), 5)\n",
    "print( 'after inserting 5 after the last item:    ', x )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.3.3.c  Reverse a list in place\n",
    "\n",
    "x = [1, 2, 3]\n",
    "print( 'initial list:         ', x )\n",
    "x.reverse()\n",
    "print( 'list after reversal:  ', x )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.3.3.d  Treat a list as a stack, exhausting and printing its values\n",
    "\n",
    "x = [1, 2, 3, 4]\n",
    "print( 'initial list:   ', x )\n",
    "while x:\n",
    "  print(  'popped', x.pop(), 'from list ') \n",
    "  print(  'list is now    '       , x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.3.4 Additional list operations <a name='Builtin-Data-Structures-Lists-Additional-Operations'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.3.4.a  return a list's length\n",
    "\n",
    "print( 'length of [] is ', len([]) )\n",
    "print( 'length of [\\'a\\', \\'b\\', \\'c\\'] is ', len(['a', 'b', 'c']) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.3.4.b  return a list of pairs of parallel items from two lists in two ways\n",
    "\n",
    "list_abc = ['a', 'b', 'c']\n",
    "list_123 = [1, 2, 3]\n",
    "\n",
    "print( [(list_value1, list_value2) for (list_value1, list_value2) in zip(list_abc, list_123)] )\n",
    "print( [(list_value2, list_value1) for (list_value1, list_value2) in zip(list_abc, list_123)] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.4 Tuples  <a name='Builtin-Data-Structures-Tuples'></a>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples, like lists, are commonly used to represent sequences of items and vectors (1-D arrays).",
    " Unlike lists, tuples are immutable. This makes them suitable for use as indices for dicts."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.4.1 Tuple instantiation <a name='Builtin-Data-Structures-Tuple-Instantiation'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.4.1.a  using parenthesized expressions to instantiate tuples\n",
    "# IMPORTANT: a singleton tuple must be instantiated with a comma\n",
    "\n",
    "(), (1,), (1,2,3,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.4.1.b  Composing the contents of two tuples\n",
    "\n",
    "(1, 2, 3) + (4, 5, 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.4.1.c  using the cross-object method tuple() to instantiate tuples\n",
    "\n",
    "print( 'tuple([{1:2, 3:4}) is    ', tuple({1:2, 3:4}) )\n",
    "print( 'tuple([(1,2), (3,4)]) is ', tuple([(1,2), (3,4)]) )\n",
    "print( 'tuple(((1,2), (3,4))) is ', tuple(((1,2), (3,4))) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.4.2.d  tuple comprehension\n",
    "\n",
    "tuple( chr(code) for code in range( ord('a'), ord('z')+1 ) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.4.2 Additional tuple operations <a name='Builtin-Data-Structures-Tuple-Operations'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.4.2.a  length of a tuple\n",
    "\n",
    "print( 'length of () is ', len(()) )\n",
    "print( 'length of (1, 2, 3, 4) is ', len( (1, 2, 3, 4) ) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.5 Dicts  <a name='Builtin-Data-Structures-Dicts'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A Python dict (short for \"dictionary\") is an associative array that pairs immutable objects that key the dict's elements with other objects, referred to as values."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.5.1 Dict instantiation <a name='Builtin-Data-Structures-Dict-Instantiation'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.5.1.a  using curly braces to instantiate dicts\n",
    "\n",
    "{}, {1:2, 3:4}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.5.1.b  using the cross-object method dict() to instantiate dicts\n",
    "\n",
    "print( 'dict([{1:2, 3:4}) is    ', dict({1:2, 3:4}) )\n",
    "print( 'dict([(1,2), (3,4)]) is ', dict([(1,2), (3,4)]) )\n",
    "print( 'dict(((1,2), (3,4))) is ', dict(((1,2), (3,4))) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.5.1.c  using different, immutable keys for a dict\n",
    "\n",
    "x = {1:1, 2.0:2, 3+3j:3, 'four':4, (5,):5, frozenset((6,)):6}\n",
    "print( x[1], x[2.0], x[3+3j], x['four'], x[(5,)], x[frozenset((6,))] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.5.1.d  dict comprehension, mapping character codes for lower-case characters to their respective characters\n",
    "\n",
    "{ ( code, chr(code) ) for code in range( ord('a'), ord('z')+1 ) }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.5.2 Dict operations <a name='Builtin-Data-Structures-Dict-Operations'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following examples use these additional Python constructs:\n",
    "-  `lambda` - [a shorthand for a nameless function that maps its arguments to a single value](./7.%20Functions.ipynb#Functions-Lambda-Expressions)\n",
    "-  `set` -    returns a set; set intersection is &\n",
    "-  `&` -      set intersection operator\n",
    "-  `assert` - throw exception of first argument's logical expression is False, with string given by second"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.5.2.a  number of elements in a dict\n",
    "\n",
    "print( 'length of {} is ', len({}) )\n",
    "print( 'length of {1:2, 3:4, 5:6, 7:8} is ', len( {1:2, 3:4, 5:6, 7:8} ) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.5.2.b  return value if key present, else second if key absent\n",
    "\n",
    "x = { 1:2, 3:4, 5:6 }\n",
    "[ '%d = %s,' % (key, str(x.get(key,'not present'))) for key in range(7) ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.5.2.c  retrieving all keys as a list\n",
    "\n",
    "[k for k in { 1:2, 3:4, 5:6 }.keys()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.5.2.d  retrieving all values as a list\n",
    "\n",
    "[v for v in { 1:2, 3:4, 5:6 }.values()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.5.2.e  Composing the contents of two dictionaries\n",
    "\n",
    "x = {'a':'b', 'c':'d'}\n",
    "y = {1:2, 3:4, 5:6, 7:8}\n",
    "\n",
    "common_keys = set(x.keys()) & set(y.keys())\n",
    "assert not common_keys, 'can\\'t compose x and y, due to duplicate keys (%r)' % common_keys\n",
    "dict_to_list = lambda d: [(key,value) for (key,value) in d.items()]\n",
    "\n",
    "print( f'merge of {x} and {y} is {dict( dict_to_list( x ) + dict_to_list( y ) )}' )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 5.5.2.1:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following code cell, ",
    "create a code that *inverts* a dict: i.e., maps v to k wherever the original maps k to v.",
    "Your code should explicitly test for and print a descriptive error message if the original contains either of the following:\n",
    "-  <span style='color:navy'>",
    "two or more items with the same value ",
    "</span>\n",
    "-  <span style='color:navy'>",
    "any mutable values:  i.e., any values v for which `type(v).__hash__` is `None`.",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 5.5.2.2:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following code cell, ",
    "create a code that merges two dicts when each key that is common to the two dicts associates that key with the same value: ",
    "i.e., reject merges when the two dicts associate any shared key with different values.  Illustrate your logic with two examples: ",
    "one where the two dicts share a single, common (key, value) pair, and one where the dicts associate a common key with different values.",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  5.5.2.f   using a dict to represent a (sparse) matrix\n",
    "\n",
    "x = dict([ ((row,col), row*col) for col in range(10) for row in range(10) if row*col % 4 == 0 ])\n",
    "print( 'sparse array contains ', x, '\\n' )\n",
    "\n",
    "print( 'sparse array, displayed as array: \\n' )\n",
    "for row in range(10):             # again, be careful of the indentation\n",
    "  for col in range(10):\n",
    "    try:\n",
    "      print('{0:3d}'.format(x[(row,col)]), end=\"\")\n",
    "    except:\n",
    "      print('   ', end=\"\")\n",
    "  print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "More specialized types of dicts are provided by",
    " the [Python library's collections module](https://docs.python.org/3/library/collections.html#module-collections).",
    "One, a [ChainMap](./17.%20ChainMaps.ipynb), ",
    "creates a single, sequential view of a series of dicts\n",
    "Others not covered in this version of the Tour include the following:\n",
    "-   Counter - dict subclass for counting hashable objects\n",
    "-   OrderedDict - dict subclass that remembers the order entries were added\n",
    "-   defaultdict - dict subclass that calls a factory function to supply missing values\n",
    "-   UserDict - wrapper around dictionary objects for easier dict subclassing\n",
    "-   UserList - wrapper around list objects for easier list subclassing\n",
    "-   UserString - wrapper around string objects for easier string subclassing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.6  Sets <a name='Builtin-Data-Structures-Sets'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sets, including frozensets, were added relatively late to the core Python language.",
    " This decision is reflected in part by the use of curly braces, a variant of dict() syntax, to instantiate sets.\n",
    "\n",
    "Like dicts, sets and frozensets can only contain immutable values, due to Python's use of hashing to retrieve items in sets."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.6.1 Set instantiation <a name='Builtin-Data-Structures-Set-Instantiation'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.6.1.a  using curly braces to instantiate sets\n",
    "# IMPORTANT:  an empty set must be instantiated using the set constructor\n",
    "\n",
    "print( 'Value of {1} is                     ', {1}                                   )\n",
    "print( 'Value of {1,2,3,4} is               ', {1,2,3,4}                             )\n",
    "print( 'Value of {1, 1, 1, 1, 1, 2, 3, 4} is', {1, 1, 1, 1, 1, 2, 3, 4} )\n",
    "print( )\n",
    "print( 'type of {}  is ', type({}) )\n",
    "print( 'type of {1} is ', type({1}) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.6.1.b  Composing the contents of two sets\n",
    "\n",
    "print( 'Value of {1, 2, 3} | {4, 5, 6} is', {1, 2, 3} | {4, 5, 6} )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.6.1.c  set comprehension\n",
    "\n",
    "{ chr(code) for code in range( ord('a'), ord('z')+1 ) }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.6.1.c  using the cross-object method set() to instantiate sets\n",
    "\n",
    "print( 'set( )                is', set( )                )\n",
    "print( 'set( {1, 2, 3, 4} )   is', set( {1, 2, 3, 4} )   )\n",
    "print( 'set( {1:2, 3:4} )     is', set( {1:2, 3:4} )     )\n",
    "print( 'set( [(1,2), (3,4)] ) is', set( [(1,2), (3,4)] ) )\n",
    "print( 'set( ((1,2), (3,4)) ) is', set( ((1,2), (3,4)) ) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.6.2 Additional set operations <a name='Builtin-Data-Structures-Set-Operations'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.6.2.a  number of elements in a set\n",
    "\n",
    "print( 'length of set() is ', len( set() ) )\n",
    "print( 'length of { 1, 2, 3, 4 } is ', len( { 1, 2, 3, 4 } ) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.6.2.b  set-combining operations\n",
    "\n",
    "a = {1, 2, 3}\n",
    "b = {2, 3, 4}\n",
    "\n",
    "print( f'{a} union {b} is {a | b}' )\n",
    "print( f'{a} intersection {b} is {a & b}' )\n",
    "print( f'the set difference of {a} and {b} is {a - b}' )\n",
    "print( f'the set difference of {b} and {a} is {b - a}' )\n",
    "print( f'the symmetric difference of {a} and {b} is {a ^ b}' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.6.2.c  inclusion testing\n",
    "\n",
    "a = {1, 2, 3}\n",
    "b = {1, 2}\n",
    "\n",
    "print( f\"{a} is {'' if a > b else 'not '}a proper superset of {b}\" )\n",
    "print( f\"{a} is {'' if a > a else 'not '}a proper superset of {a}\" )\n",
    "print( f\"{b} is {'' if b > a else 'not '}a proper superset of {a}\", end='\\n\\n' )\n",
    "\n",
    "print( f\"{a} is {'' if a >= b else 'not '}a superset of {b}\" )\n",
    "print( f\"{a} is {'' if a >= a else 'not '}a superset of {a}\" )\n",
    "print( f\"{b} is {'' if b >= a else 'not '}a superset of {a}\", end='\\n\\n' )\n",
    "\n",
    "print( f\"{a} is {'' if a <= b else 'not '}a subset of {b}\" )\n",
    "print( f\"{a} is {'' if a <= a else 'not '}a subset of {a}\" )\n",
    "print( f\"{b} is {'' if b <= a else 'not '}a subset of {a}\", end='\\n\\n' )\n",
    "\n",
    "print( f\"{a} is {'' if a < b else 'not '}a proper subset of {b}\" )\n",
    "print( f\"{a} is {'' if a < a else 'not '}a proper subset of {a}\" )\n",
    "print( f\"{b} is {'' if b < a else 'not '}a proper subset of {a}\", end='\\n\\n' )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.6.3 Additional in-place operations on sets <a name='Builtin-Data-Structures-Set-In-Place-Operations'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All operations that update values in place return `None`.\n",
    "\n",
    "The following example uses this additional Python construct:\n",
    "`copy` - return a (shallow) copy of an object, instead of a reference to the original object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.6.3 in-place set operations\n",
    "\n",
    "import copy\n",
    "\n",
    "x = {1, 2, 3, 4}\n",
    "x_before = copy.copy(x)\n",
    "y = {5, 6, 7}\n",
    "x != y\n",
    "print( f'{x_before} | {y} is {x}' )\n",
    "\n",
    "x_before = copy.copy(x)\n",
    "y = {1, 2, 3, 4, 5}\n",
    "x &= y\n",
    "print( f'{x_before} & {y} is {x}' )\n",
    "\n",
    "x_before = copy.copy(x)\n",
    "y = {4, 5}\n",
    "x -= {4, 5}\n",
    "print( f'{x_before} - {y} is {x}' )\n",
    "\n",
    "x_before = copy.copy(x)\n",
    "y = {0, 2, 3, 4, 5}\n",
    "x ^= {0, 2, 3, 4, 5}\n",
    "print( f'{x_before} ^ {y} is {x}', end='\\n\\n' )\n",
    "\n",
    "print( 'clearing x\\'s contents' )\n",
    "while len(x) > 0: print(x.pop())\n",
    "\n",
    "print( )\n",
    "print( 'x\\'s final value is ', x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 5.6.3.1:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following code cell, ",
    "revise the re.findall example in ",
    "[the regular expressions examples](#Builtin-Data-Structures-String-Regular-Expressions)",
    " so that it eliminates duplicates. As part of this exercise, when checking for duplicates,",
    "treat words that differ only in how they're capitalized as the same. ",
    "Do, however, retain the original casing for at least one of the variants: e.g., ",
    "be sure that running your code on text that includes just 'FOOL 'and 'Fool' returns one or the other--not 'fool'.",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.7  Frozensets <a name='Builtin-Data-Structures-Frozensets'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Frozensets are immutable analogues of sets.  They share all the same operations as sets, except for update operations.",
    " Python associates no special punctuation symbols with frozensets; all references must use the constructor."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.7.1 Frozenset instantiation <a name='Builtin-Data-Structures-Frozenset-Instantiation'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.7.1.a  using the cross-object method frozenset() to instantiate sets\n",
    "\n",
    "print( 'frozenset( )                is', frozenset( )                )\n",
    "print( 'frozenset( {1, 2, 3, 4} )   is', frozenset( {1, 2, 3, 4} )   )\n",
    "print( 'frozenset( {1:2, 3:4} )     is', frozenset( {1:2, 3:4} )     )\n",
    "print( 'frozenset( [(1,2), (3,4)] ) is', frozenset( [(1,2), (3,4)] ) )\n",
    "print( 'frozenset( ((1,2), (3,4)) ) is', frozenset( ((1,2), (3,4)) ) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.7.1.b  Composing the contents of two frozensets\n",
    "\n",
    "print( 'Value of frozenset({1, 2, 3}) | frozenset({4, 5, 6}) is', frozenset({1, 2, 3}) | frozenset({4, 5, 6}) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.7.1.c  frozenset comprehension\n",
    "\n",
    "frozenset( { chr(code) for code in range( ord('a'), ord('z')+1 ) } )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.7.2 Additional frozenset operations <a name='Builtin-Data-Structures-Frozenset-Operations'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.7.2.a  number of elements in a frozenset\n",
    "\n",
    "print( 'length of frozenset() is ', len( frozenset() ) )\n",
    "print( 'length of frozenset({ 1, 2, 3, 4 }) is ', len( frozenset({ 1, 2, 3, 4 }) ) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.7.2.b  frozenset-combining operations\n",
    "\n",
    "a = frozenset( {1, 2, 3} )\n",
    "b = frozenset( {2, 3, 4} )\n",
    "\n",
    "print( f'{a} union {b} is {a | b}' )\n",
    "print( f'{a} intersection {b} is {a & b}' )\n",
    "print( f'the difference of {a} and {b} is {a - b}' )\n",
    "print( f'the difference of {b} and {a} is {b - a}' )\n",
    "print( f'the symmetric difference of {a} and {b} is {a ^ b}' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.7.2.c  inclusion testing\n",
    "\n",
    "a = frozenset( {1, 2, 3} )\n",
    "b = frozenset( {1, 2} )\n",
    "\n",
    "print( f\"{a} is {'' if a > b else 'not '}a proper superset of {b}\" )\n",
    "print( f\"{a} is {'' if a > a else 'not '}a proper superset of {a}\" )\n",
    "print( f\"{b} is {'' if b > a else 'not '}a proper superset of {a}\", end='\\n\\n' )\n",
    "\n",
    "print( f\"{a} is {'' if a >= b else 'not '}a superset of {b}\" )\n",
    "print( f\"{a} is {'' if a >= a else 'not '}a superset of {a}\" )\n",
    "print( f\"{b} is {'' if b >= a else 'not '}a superset of {a}\", end='\\n\\n' )\n",
    "\n",
    "print( f\"{a} is {'' if a <= b else 'not '}a subset of {b}\" )\n",
    "print( f\"{a} is {'' if a <= a else 'not '}a subset of {a}\" )\n",
    "print( f\"{b} is {'' if b <= a else 'not '}a subset of {a}\", end='\\n\\n' )\n",
    "\n",
    "print( f\"{a} is {'' if a < b else 'not '}a proper subset of {b}\" )\n",
    "print( f\"{a} is {'' if a < a else 'not '}a proper subset of {a}\" )\n",
    "print( f\"{b} is {'' if b < a else 'not '}a proper subset of {a}\" )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 5.7.2.1:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following markdown cell, </span>\n",
    "- <span style='color:navy'>",
    "Explain the difference between *set* and *frozenset*",
    "</span>\n",
    "- <span style='color:navy'>",
    "List functions that are supported by *set* but not *frozenset*",
    "</span>\n",
    "- <span style='color:navy'>",
    "List functions that are supported by *frozenset* but not *set*",
    "</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
}