002-collections.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook is part of the [G2S3 2019 Python Bootcamp](https://github.com/hpcgarage/pyboot-g2s3).\n",
    "\n",
    "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/hpcgarage/pyboot-g2s3/blob/master/001-vals-vars-ds.ipynb)\n",
    "\n",
    "\n",
    "# Basic collections\n",
    "\n",
    "Key concepts:\n",
    "* Tuples\n",
    "* Lists\n",
    "* Variables are references!\n",
    "* Sets\n",
    "* Dictionaries\n",
    "* Nesting data structures\n",
    "\n",
    "For more detailed information, see Vanderplas or the [Python documentation on basic data structures](https://docs.python.org/3/tutorial/datastructures.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Although you can do a lot with operations on scalar values, programs are more compact and efficient when you can operate on collections of values."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples ##\n",
    "\n",
    "A tuple is a read-only (\"immutable\") fixed-length sequence of values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = (\"a\", \"pair\")\n",
    "print(z)\n",
    "print(\"element 0:\", z[0], \"\\nelement 1:\", z[1]) # Random access of values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(\"4-tuple\", 4, 1.2, False) # Mix values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"Immutability\" means you cannot modify the length of the tuple nor change its values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# z[1] = \"triple?\"   # Uncommenting and running this statement will produce an error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Aside: mutability.** Mutability is an important concept in Python, as certain critical operations may only be applied to mutable objects. A good discussion of mutability appears [here](https://medium.com/@meghamohan/mutable-and-immutable-side-of-python-c2145cf72747). You can think of the primitive built-in types––`int`, `float`, `bool`, `str`––as **immutable**. Tuples are, as noted above, also immutable, although it may hold mutable objects. Let's keep going and come back to this point later, after we meet a mutable object: the Python list (`list`)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists ##\n",
    "\n",
    "A list of values is a sequence, and is similar to arrays in other languages. It provides fast random access (`x[i]`, using zero-based indices) and fast appends, but slow arbitrary insertions and search. Individual values (elements) of a list need not have the same type. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [1, 2, 3]\n",
    "y = [4, \"xo\", 6.7, True]\n",
    "z = x + y\n",
    "print(\"Concat lists: {} + {} = {} (total length is {})\".format(x, y, z, len(z)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(z[2], z[4], z[6])\n",
    "print(z[2::2]) # slice (and later, dice)\n",
    "print(z[::-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**List constructor.** The list type, denoted by `list` in Python, can also be used to construct an empty list or a list object from another collection type. A pair of empty square brackets is synonymous."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "empty_list = []\n",
    "print(empty_list)\n",
    "\n",
    "another_empty_list = list()\n",
    "print(another_empty_list)\n",
    "\n",
    "list_from_string = list('abcdefg')\n",
    "print(list_from_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Modifying lists.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make a change\n",
    "print(z)\n",
    "z[2] = -(z[2] + z[3])\n",
    "print(z)\n",
    "\n",
    "# Undo the change\n",
    "z[2] *= -1\n",
    "z[2] -= z[3]\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z.append(\"one more value...\")  # Methods, some of which involve in-place modifications\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(z)\n",
    "z.reverse()\n",
    "print(z)\n",
    "z.reverse() # Undo\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**List comprehensions.** Use this compact construct to build up lists of values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = [2*xi for xi in x+y] # \"double\" every element\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Additionally, there is a conditional clause for filtering comprehension values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g = [i for i in range(10)] # 0 .. 9\n",
    "\n",
    "from random import shuffle\n",
    "shuffle(g) # permute randomly\n",
    "\n",
    "print('g =', g)\n",
    "\n",
    "# Select only even values\n",
    "h = [i for i in g if (i % 2) == 0]\n",
    "print('h = even(g) =', h)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Zipper iterations.** Use `zip(a, b, ...)` to \"merge\" two or more collections. Conceptually, `zip()` produces tuples of corresponding elements from each input collection."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# \"Merge\" forward and reverse lists\n",
    "[(f, b) for f, b in zip(c, c[::-1])]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Performance: append vs. insert.** Appending values to a list is fast compared to arbitrary insertions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Insert 100,000 values at the front of the list (index=0)\n",
    "c0 = []\n",
    "t_insert = %timeit -o -n1000 -r100 c0.insert(0, 'a')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Append 100,000 values at the end of the list\n",
    "c1 = []\n",
    "t_append = %timeit -o -n1000 -r100 c1.append('a')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Verify that the outputs of the above are the same\n",
    "assert all([a == b for a, b in zip(c0, c1)]), \"Answers differed?\"\n",
    "\n",
    "# Report the ratio of execution times\n",
    "print(\"==> (insert time) / (append time) for 100,000 ops: ~ {:.1f}x\".format(t_insert.average / t_append.average))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Demonstrate scaling: Same experiment as above, but triple the ops\n",
    "c0 = []\n",
    "t_insert = %timeit -o -n3000 -r100 c0.insert(0, 'a')\n",
    "\n",
    "# Append the same 100,000 values at the end of the list\n",
    "c1 = []\n",
    "t_append = %timeit -o -n3000 -r100 c1.append('a')\n",
    "\n",
    "# Verify that the outputs of the above are the same\n",
    "assert all([a == b for a, b in zip(c0, c1)]), \"Answers differed?\"\n",
    "\n",
    "# Report the ratio of execution times\n",
    "print(\"\\n==> (insert time) / (append time) for 300,000 ops: ~ {:.1f}x\".format(t_insert.average / t_append.average))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Performance, part 2: search.** Simple searches, which can be performed using the membership-test operator, `in`, can be slow."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "long_list = list(range(100000))\n",
    "shuffle(long_list)\n",
    "\n",
    "# Inspect first and last five elements:\n",
    "print('long_list =', long_list[:5], '...', long_list[-5:], '  (all values are unique)')\n",
    "first_elem = long_list[0]\n",
    "last_elem = long_list[-1]\n",
    "print('\\n{} in long_list == {}'.format(first_elem, first_elem in long_list))\n",
    "print('{} in long_list == {}'.format(last_elem, last_elem in long_list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print('\\nTimes to search a list of {} values (all unique):'.format(len(long_list)))\n",
    "t_first = %timeit -o first_elem in long_list\n",
    "t_last = %timeit -o last_elem in long_list\n",
    "\n",
    "print('\\n==> Ratio: ~ {:.1f}x'.format(t_last.average / t_first.average))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Aside: Variables are references\n",
    "\n",
    "One subtlety about variables is that you should always think of them as references or \"pointers\" to the underlying object or value. Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [1, 2, 3]\n",
    "y = x\n",
    "x.append(4)\n",
    "print(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe that `y` and `x` \"point\" to the same object. Here is a nice visualization of this code and concept: [Python Tutor](http://pythontutor.com/visualize.html#code=x%20%3D%20%5B1,%202,%203%5D%0Ay%20%3D%20x%0Ax.append%284%29%0Aprint%28x%29%0Aprint%28y%29&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=py3anaconda&rawInputLstJSON=%5B%5D&textReferences=false)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Python `is` operator can be used to test whether two references are identical, and `.copy()` can be used to clone a list to be distinct references."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(x is y)\n",
    "print(x is not y) # By the way..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = y.copy()\n",
    "print(x is z)\n",
    "\n",
    "x.append(len(x)+1)\n",
    "print(x, z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try out the `.copy()` code in [Python tutor](http://pythontutor.com/visualize.html#code=x%20%3D%20%5B1,%202,%203%5D%0Ay%20%3D%20x.copy%28%29%0Ax.append%284%29&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=py3anaconda&rawInputLstJSON=%5B%5D&textReferences=false)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sets\n",
    "\n",
    "A Python set is like a mathematical set: all values are unique and immutable (more later). Therefore, the underlying implementation is free to organize values in clever ways so that search or membership-test becomes much faster than with lists.\n",
    "\n",
    "> A set is itself mutable, even though its values must be immutable. If you require an immutable set, use [`frozenset`](https://docs.python.org/3/library/stdtypes.html#frozenset)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = {1, 2, 3, 4, 5}\n",
    "B = {3, 4, 5, 6, 7}\n",
    "print(A, '&', B, '==', A & B) # intersection\n",
    "print(A, '|', B, '==', A | B) # union\n",
    "print(A, '-', B, '==', A - B) # difference\n",
    "print(A, '<', B, '==', A < B) # proper subset (use `<=` for subset, `>` or `>=` for superset, or '==' for equality)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A.add(8)\n",
    "print(A)\n",
    "\n",
    "A.update({-1, -2, -3})\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set values are not necessarily unordered in the event you iterate over them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[a for a in A]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Values are not limited to integers and, like lists, elements may mix types. **However, the elements must be immutable**. Recall that the primitive built-in types (e.g., `int`, `float`, `str`, `bool`) are immutable, as is `tuple`. However, a `list` is mutable, and therefore cannot be a set element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "E = {'cat', 1.61803398875, ('a', 'b', 'c')}\n",
    "# E.add([1, 2, 3]) # Error!\n",
    "print(E)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> There is a subtlety -- although `tuple` is immutable, you can construct a `tuple` that contains mutable values, e.g., the triple `(1, 2, [3, 4, 5])` where the third element is a `list`, which is mutable. This tuple would, therefore, be an invalid set element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "C = {1, 2, 3.14159, bin(1387)}\n",
    "print(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Performance of membership tests.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "big_set = set(long_list) # Convert list to set\n",
    "\n",
    "print('{} in big_set == {}'.format(first_elem, first_elem in big_set))\n",
    "print('{} in big_set == {}'.format(last_elem, last_elem in big_set))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('\\nTimes to search a set of {} values (all unique):'.format(len(big_set)))\n",
    "t_first = %timeit -o first_elem in big_set\n",
    "t_last = %timeit -o last_elem in big_set\n",
    "\n",
    "print('\\n==> Ratio: ~ {:.1f}x'.format(t_last.average / t_first.average))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Another example.** Let's use sets, whose values will be unique, to count the number of unique values in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# http://socialgoodipsum.com/#/\n",
    "social_good_ipsum = \"Agile bandwidth; greenwashing citizen-centered; scale and impact shared value theory of change mass incarceration. Entrepreneur entrepreneur benefit corporation think tank effective her body her rights her body her rights strengthening infrastructure. Collective impact, her body her rights innovation thought provoking social enterprise boots on the ground. Radical black lives matter academic, our work energize granular inclusion expose the truth. Collective impact collective impact LGBTQ+ effective we must stand up. Collaborative cities; inspire, social intrapreneurship outcomes society impact bandwidth. Mass incarceration ecosystem problem-solvers, communities best practices social return on investment and synergy synergy. Shared value, equal opportunity; social innovation segmentation vibrant. Agile problem-solvers progress paradigm B-corp. State of play compelling, compelling; social innovation, effective systems thinking parse cultivate preliminary thinking. Global, triple bottom line; replicable, low-hanging fruit society collective impact society cultivate boots on the ground. Movements entrepreneur targeted, segmentation, game-changer. Empower communities, save the world thought leadership mobilize social entrepreneurship systems thinking impact investing. Correlation policymaker movements inspirational, empower communities, but, B-corp emerging. Social entrepreneurship, ideate scalable, philanthropy then thought leader. Save the world technology unprecedented challenge milestones challenges and opportunities sustainable a. Rubric collaborative consumption targeted, empathetic emerging; collaborative cities leverage. Corporate social responsibility inspire social return on investment cultivate shared vocabulary efficient commitment. State of play benefit corporation, theory of change strategy gender rights catalyze. Effective, change-makers engaging co-creation; circular think tank synergy we must stand up improve the world. Natural resources milestones the scale and impact silo compassion. Then, resilient, shared unit of analysis inspiring the inspire. Social return on investment change-makers strategize, co-create change-makers scale and impact issue outcomes overcome injustice. Correlation, social entrepreneurship shared value, social enterprise blended value LGBTQ+ strategy. Indicators, catalyze shared value inclusion; initiative unprecedented challenge and. Collaborative consumption, to, revolutionary ecosystem thought leader benefit corporation replicable engaging. Initiative gender rights collective.\"\n",
    "alpha_only = ''.join([c for c in social_good_ipsum if c.isalpha() or c.isspace()])\n",
    "tokens = alpha_only.split()\n",
    "print(f\"The original string has {len(tokens)} tokens.\")\n",
    "\n",
    "unique_tokens = set(tokens)\n",
    "print(f\"Of these, {len(unique_tokens)} are unique.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries\n",
    "\n",
    "A dictionary is a map of unique keys to values. Like set elements, keys must be unique."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {'pi_approx': 3.14159265359,\n",
    "     'e_approx': 2.71828182846,\n",
    "     'c_approx': '299,792,458 m/s',\n",
    "     'h_bar_approx': '6.62607004e-34 m^2 kg / s'}\n",
    "print('d =', d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The keys in the above example all have the same type, but need not. For example, let's add some integer keys."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "d[0] = 0.0\n",
    "d[1] = 1.0\n",
    "d[-1] = -1.0\n",
    "d['minus_one'] = d[-1]\n",
    "print(len(d), 'key-value pairs:', d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Deletion of keys:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d.pop('minus_one')\n",
    "print(len(d), 'key-value pairs:', d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(d['c_approx'])\n",
    "print(d.keys())\n",
    "print(d.values())\n",
    "print(d.items()) # (key, value) pairs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Key-membership testing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('h_bar_approx' in d)\n",
    "print('planck constant' in d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Referencing missing keys will produce an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# d['planck constant']   # Uncomment to see an error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example: Build an English-to-French dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "english = \"one two three four five six seven eight nine ten\".split()\n",
    "print(english)\n",
    "\n",
    "french = \"un deux trois quatre cinq six sept huit neuf dix\".split()\n",
    "print(french)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "e2f = {k: v for k, v in zip(english, french)} # Dictionary comprehension\n",
    "print(e2f['three'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Performance of key-membership testing.** The time to check if a key is present should be comparable to set-membership. That fact would imply that looking up a value in a dictionary will take about the same amount of time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "big_dict = {v: True for v in long_list} # Convert list to dictionary of (value, True) pairs\n",
    "\n",
    "print('{} in big_dict == {}'.format(first_elem, first_elem in big_dict))\n",
    "print('{} in big_dict == {}'.format(last_elem, last_elem in big_dict))\n",
    "\n",
    "print('\\nTimes to search a dictionary of {} keys:'.format(len(big_dict)))\n",
    "t_first = %timeit -o first_elem in big_dict\n",
    "t_last = %timeit -o last_elem in big_dict\n",
    "\n",
    "print('\\n==> Ratio: ~ {:.1f}x'.format(t_last.average / t_first.average))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Aside: Nesting\n",
    "\n",
    "Since lists and dictionaries can contain values (but not keys, in the case of dictionaries) of arbitrary types, you can nest data structures."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Example: Dictionary of dictionaries.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = {i+1: {'english': english[i], 'french': french[i]} for i in range(10)}\n",
    "\n",
    "print('5 is \"{english}\" in English and \"{french}\" in French.'.format(english=numbers[5]['english'],\n",
    "                                                                     french=numbers[5]['french']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Aside within an aside: argument unpacking with dictionaries.** One trick that a dictionary enables is called [argument unpacking](https://docs.python.org/3/tutorial/controlflow.html#tut-unpacking-arguments). That is the substituion of keys for named arguments.\n",
    "\n",
    "For example, look at the print statement above: the `.format(...)` subexpression requires named arguments. If you have any dictionary with the same keys, you can substitute those using the `**` operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "six = numbers[6]\n",
    "print(f\"Dictionary `six` is {six}.\")\n",
    "\n",
    "print('\\n==> 6 is \"{english}\" in English and \"{french}\" in French.'.format(**six))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}