Intro to Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to the Python programming language\n",
    "\n",
    "In this notebook we will cover the basic principals of the Python programming language, both in terms of development and philosophy. We will focus primarily on Python 3."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. What is Python?\n",
    "\n",
    "[Python is an interpreted, object-oriented, high-level programming language with dynamic semantics.](https://www.python.org/doc/essays/blurb/)\n",
    "\n",
    "First appearing in 1991, Python was designed by [Guido van Rossum](https://gvanrossum.github.io/).\n",
    "\n",
    "Python is interpreted. Unlike C and like programming languages which must be compiled, Python code is executed directly by a Python interpreter rather than a machine. As a high-level language, Python is also far-removed from the challenges associated with lower-level programming languages (such as assembly languages), making it much easier to learn.\n",
    "\n",
    "Python is further defined as an object-oriented language with dynamic semantics, what does that mean? In the next section we will review Python semantics and then tackle [Object Oriented Programming](https://en.wikipedia.org/wiki/Object-oriented_programming)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Python semantics\n",
    "\n",
    "So what's the connection between a programming language and semantics anyway? In programming, when we talk about [semantics](https://en.wikipedia.org/wiki/Semantics_(computer_science)) we are often concerned about what is [_syntactically_](https://en.wikipedia.org/wiki/Syntax_(programming_languages)) _valid_ in a given language. So then, what's considered \"syntactically valid\" in Python. For instance, if I wanted to write a small Python program that would just display the text \"Hello, world!\" on my screen, what would that look like?\n",
    "\n",
    "Let's get our first glimpse at the Python programming language, and then we can discuss our observation.\n",
    "\n",
    "The below cell is an *executable cell*. You can select it and press `run` to execute a block of Python code. Try executing the next cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Hello, world!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Well, that doesn't look much like a program, does it. But in fact, what you just observed is the foundation of Python and all [_imperative programming languages_](https://en.wikipedia.org/wiki/Imperative_programming). Wait, I thought we said Python was object oriented, why are we now calling it _imperative_. In fact, most object oriented languages are also imperative by their very nature. Let's consider why this matters, and how imperative programming relates to the code block we just executed above.\n",
    "\n",
    "First, consider what \"imperative programming\" means. Imperative languages are based on statements, and those statements determine the [flow of control](https://en.wikipedia.org/wiki/Control_flow) within a program. A statement that controls something? That probably sounds familiar, often we call these **instructions**, you can think of statements as instructions or micro instructions if you like. All actions within an imperative program are caused by, and only only occur because of, a given statement which produced the action. In other words, the program is strictly controlled by instructions.\n",
    "\n",
    "Above, you saw that philosophy in action, we declared the instruction (to print) _\"Hello, world!\"_ and we got back the output _\"Hello, world!\"_\n",
    "Our statement directly controlled what was output by the program. Try changing the code block above and see what outputs you can get. Afterward, we can consider the kinds of statements available in Python below."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 Python statements\n",
    "\n",
    "Programs in Python consists of lines composed of statements, which can be of the following type:\n",
    "\n",
    "- [simple statements](https://docs.python.org/3/reference/simple_stmts.html), such as a(n):\n",
    "    - [expression](https://docs.python.org/3/reference/simple_stmts.html#grammar-token-expression-stmt); [see also](https://docs.python.org/3/reference/expressions.html), as demonstrated in [#2.](#2.-Python-semantics)\n",
    "    - [assert](https://docs.python.org/3/reference/simple_stmts.html#grammar-token-assert-stmt)\n",
    "    - [assignment](https://docs.python.org/3/reference/simple_stmts.html#grammar-token-assignment-stmt)\n",
    "    - [pass](https://docs.python.org/3/reference/simple_stmts.html#grammar-token-pass-stmt)\n",
    "    - [delete](https://docs.python.org/3/reference/simple_stmts.html#grammar-token-del-stmt)\n",
    "    - [return](https://docs.python.org/3/reference/simple_stmts.html#grammar-token-return-stmt)\n",
    "    - [yield](https://docs.python.org/3/reference/simple_stmts.html#grammar-token-yield-stmt)\n",
    "    - [raise](https://docs.python.org/3/reference/simple_stmts.html#grammar-token-raise-stmt)\n",
    "    - [break](https://docs.python.org/3/reference/simple_stmts.html#grammar-token-break-stmt)\n",
    "    - [continue](https://docs.python.org/3/reference/simple_stmts.html#grammar-token-continue-stmt)\n",
    "    - [import](https://docs.python.org/3/reference/simple_stmts.html#grammar-token-import-stmt)\n",
    "    - [future](https://docs.python.org/3/reference/simple_stmts.html#grammar-token-future-stmt)\n",
    "    - [global](https://docs.python.org/3/reference/simple_stmts.html#grammar-token-global-stmt)\n",
    "    - [nonlocal](https://docs.python.org/3/reference/simple_stmts.html#grammar-token-nonlocal-stmt)\n",
    "- [compound statements](https://docs.python.org/3/reference/compound_stmts.html), such as a(n):\n",
    "    - [if](https://docs.python.org/3/reference/compound_stmts.html#grammar-token-if-stmt)\n",
    "    - [while](https://docs.python.org/3/reference/compound_stmts.html#grammar-token-while-stmt)\n",
    "    - [for](https://docs.python.org/3/reference/compound_stmts.html#grammar-token-for-stmt)\n",
    "    - [try](https://docs.python.org/3/reference/compound_stmts.html#grammar-token-try-stmt)\n",
    "    - [with](https://docs.python.org/3/reference/compound_stmts.html#grammar-token-with-stmt)\n",
    "    - [co-routine](https://docs.python.org/3/reference/compound_stmts.html#coroutines)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will not consider all of these statements in this lesson, but I encourage you to look at the documentation linked above for yourself.\n",
    "\n",
    "We can start our Python journey with expressions, we've already seen how expressions work, though to a limited degree. Below we will examine expressions in more detail."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.1.1 Expressions\n",
    "\n",
    "Expression statements are used to compute a value, write a value, or call a function. For instance observe the function call below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(1234)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above, we used a statement (remember, an instruction) that looks like this: `print(1234)`. This statement executed a type of function known as a procedure. That procedure did two thing, it printed `1234`, it's own input, into our output and then it returned a value, in that order. Wait, what value? Nothing happened besides the outputting of `1234`, right?\n",
    "\n",
    "Observe the following code block and prove to yourself that two actions did indeed occur, though one was ignored in the previous code block. We will compose a statement that looks like this: `print(print(1234))`. Remember, we observed that the [`print`](https://docs.python.org/3/library/functions.html#print) procedure takes it's own input and outputs it again, so what will be the output of these two procedures? Try to figure it out on your own before running the below code block."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(print(1234))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above we called the `print` procedure two times, once on the input `1234` and a second time, on the input of the _**returned value**_ of the procedure `print(1234)`. What do we observe? The `print` procedure caused `1234` to be output by our program, yes, but it also returns a value we did not write ourselves, `None`.\n",
    "\n",
    "You do not need to understand _how_ or _why_ a value was returned just yet, but you should understand that all functions, including procedures, return a value in Python, and _all procedures return `None`_.\n",
    "\n",
    "Also note that in a Jupyter notebook (or Python in interactive mode), the final expression in a code block is printed to the output, as if it were the input to a `print` procedure, _if the returned value is not `None`_. The below cell, for instance, will not produce an output, because the final expression evaluates to `None`.\n",
    "\n",
    "The Python docs describe this behavior this way: \n",
    "\n",
    "> In interactive mode, if the value is not `None`, it is converted to a string using the built-in `repr()` function and the resulting string is written to standard output on a line by itself (except if the result is None, so that procedure calls do not cause any output.)\n",
    "\n",
    "Pay attention to that bit about converting the value to a string, later on you'll see how that causes some funny behaviour if you try to substitute this interactive Python feature for the tried and true `print` procedure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'This text will not print.'\n",
    "None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Besides printing values, you will often need to perform practical operations as a Python developer. For instance, you may have to perform mathematical operations in Python. This can also be accomplished using Python expression statements. Consider the following code blocks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2 - 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "100 / 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2**8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above, we performed a number of simple addition, subtraction, multiplication, division, and exponential operations using Python expression statements. We observe that the returned value of these operations is their solution.\n",
    "\n",
    "You may have noticed something funny about one of the outputs. While `5 * 2` outputs `10`, `100 / 10` outputs `10.0`. Why the discrepancy here? Consider the following cells. Here we will be using the [`type`](https://docs.python.org/3/library/functions.html?highlight=type#type) function. Note that type is not a _procedure_ like `print`. `type` **returns** a value. Run the cells below, and see if you can figure out the meaning of the returned value of the `type` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(10.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above we observe that numbers containing decimals are classified under the \"type\" `float`, or floating-point numbers, while numbers without decimals are classified as `int`, or integers. \n",
    "\n",
    "Note that like the `None` which we printed earlier using two `print` procedures, you did not explicitly tell Python that `10` is an `int` and `10.0` is a `float`. Rather, [these types are built into the Python programming language](https://docs.python.org/3/library/stdtypes.html#built-in-types). Other types also exist, for instance, sequences (or strings) of characters wrapped in quotes fall under the [`str`](https://docs.python.org/3/library/stdtypes.html#str) type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type('Hello, world!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type('a')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A sequence of arbitrary data not wrapped in quotes can take the form of a [`list`](https://docs.python.org/3/library/stdtypes.html#list), a [`tuple`](https://docs.python.org/3/library/stdtypes.html?highlight=tuple#tuple), a [`set`](https://docs.python.org/3/library/stdtypes.html?highlight=tuple#set-types-set-frozenset), or a [`range`](https://docs.python.org/3/library/stdtypes.html?highlight=tuple#ranges)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type([1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type([1.1, 2.1, 3.1, 4.1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(['a', 1, 'c', 2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(('a', None, 'c', 'd'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(set([1, 2, 'Hello']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(range(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's good to remember though that at their root, a `str`, `list`, `tuple`, `set`, and `range` are all sequences, and therefore share common qualities and characteristics."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`None` has the type `NoneType`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Key-value pairs in the form of a hash map, also have a type, known as a `dict`, or dictionary in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type({'a': 1, 'b': 2})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Further, boolean values `True` and `False` have the `int` sub-type known as `bool`, or boolean."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can prove to yourself that `True` and `False` are indeed `int` types at heart by using them in arithmetic operations as demonstrated in the cells below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "10 - True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True + True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "10 * False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True / 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python's principal built-in types are numerics, sequences, mappings, classes, instances and exceptions.\n",
    "\n",
    "These built-in types are often _referred to_ as [primitive data types](https://en.wikipedia.org/wiki/Primitive_data_type). You are encouraged to read more about these types of data. However, as you may have noticed in the Python documentation, the concept of true primitives does not really exist in Python, in fact, technically speaking, primitives are not even a feature of the Python programming language. We said that Python is an object-oriented programming language, and while not the case for all such languages, [all data in a Python program is represented by objects or by relations between objects](https://docs.python.org/3/reference/datamodel.html#data-model). You can prove this to yourself by running the following cells."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print('Hello'.__doc__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "help(str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You will definitely use some data types more than others. For instance, it would not be that strange if a program never used a `range` at all, but it would be very unlikely that any Python program would not use a `bool`, explicitly or otherwise, at least at some point in the program. Consider for instance our final expressions in this section, [value comparisons](https://docs.python.org/3/reference/expressions.html#value-comparisons), [membership test operations](https://docs.python.org/3/reference/expressions.html#membership-test-operations), and [identity comparisons](https://docs.python.org/3/reference/expressions.html#is-not). \n",
    "\n",
    "Value comparisons:\n",
    "> The operators `<`, `>`, `==`, `>=`, `<=`, and `!=` compare the values of two objects. The objects do not need to have the same type.\n",
    "\n",
    "Membership test operations:\n",
    "> The operators `in` and `not in` test for membership. `x in s` evaluates to `True` if `x` is a member of `s`, and False otherwise... All built-in sequences and set types support this as well as dictionary, for which `in` tests whether the dictionary has a given key. For container types such as `list`, `tuple`, `set`, `frozenset`, `dict`, or `collections.deque`, the expression `x in y` is equivalent to `any(x is e or x == e for e in y)`.\n",
    "\n",
    "Identity comparisons:\n",
    "> The operators `is` and `is not` test for an object’s identity: `x is y` is `True` if and only if `x` and `y` are the same object. An Object’s identity is determined using the `id()` function.\n",
    "\n",
    "You will more than likely at some point be comparing and testing membership in Python. These expressions return data in the type of `bool`. Consider the cells below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'String' == 'Str' + 'ing'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'S' in 'String'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 == 0 + 1**100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[] == []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{} == dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 in [1, 2,] + [3, 4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'a' in {'a': 1, 'b': 2}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far, it seems like everything is `True`!\n",
    "\n",
    "What would a `False` comparison or membership test look like? Consider the cells below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'String' == 'string'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 == 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "['String'] == []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{'a': 1} == {'a': 10}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 in [5, 4, 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'a' in {}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above cells demonstrate that such tests are fairly logical. First of all, it is clear that for two things to be equal they should evaluate to the same value. Second, for a membership test to pass, the evaluated value must exist in the sequence, set, or container.\n",
    "\n",
    "So far, we've only tested a few value comparison operators, try out a few on your own. Afterward we'll consider identity comparisons."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We observed earlier that `[] == []` evaluates `True`. This was because two empty `list` objects evaluate to the same thing. But does that make them identical? Consider the cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[] is []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Clearly not, but why? We read that `is` is not concerned with the computed value of data, but rather with it's [_identity_](https://docs.python.org/3/library/functions.html#id), in [CPython](https://en.wikipedia.org/wiki/CPython), \"This is the address of the object in memory.\"\n",
    "\n",
    "In other words, the only way two things are identical is if the refer to the same bit of computer memory. Consider the below block."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = []\n",
    "y = x\n",
    "y is x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we are just about to look into assignments, so don't worry too much about what you just saw, just know that `y` and `x` are exactly identical, referencing the same data in memory. This is because `y` was assigned to reference the memory block that `x` is referencing.\n",
    "\n",
    "You can prove this to yourself by mutating `x` or `y` and observing the effect on it's counterpart."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x += [\"Hello\"]\n",
    "y += [\"World!\"]\n",
    "print(y)\n",
    "print(y == x, x is y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Clearly `y` and `x` are not simply equal, but are in fact identical by assignment. We will learn more about assignments in the next section. We will not discuss identity further, so please keep these ideas in mind and test for yourself as we tackle assignment statements."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.1.2 Assignments\n",
    "\n",
    "> Assignment statements are used to (re)bind names to values and to modify attributes or items of mutable objects.\n",
    "\n",
    "Likely, this is not a foreign concept to you. But let's consider assignments through the lens of Python's `dynamic semantics`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1\n",
    "print(x, type(x))\n",
    "\n",
    "x = 1.0\n",
    "print(x, type(x))\n",
    "\n",
    "x = 'Hello, world!'\n",
    "print(x, type(x))\n",
    "\n",
    "x = [1, \"a\", {\"b\": 1}, [1]]\n",
    "print(x, type(x))\n",
    "\n",
    "x = {}\n",
    "print(x, type(x))\n",
    "\n",
    "x = None\n",
    "print(x, type(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above we see in the simplest form, that a _variable_ can be assigned any arbitrary value. But what else do we see? For one, values can be assigned _dynamically_ irrespective of type. `x` was an `int`, then it was a `float`, then a `str`, then a `list`, then a `dict`, and finally `NoneType`. \n",
    "\n",
    "[This post](https://towardsdatascience.com/understanding-and-using-python-classes-3f7e8d1ef2d8) expresses it well:\n",
    "> objects are instances of values contained into constructs in the code, and they exist at run-time level. Furthermore, we can assign to one object multiple values, since it will update itself, differently from a static semantic language. Namely, if we set `a = 2` and then `a = 'hello'`, the string value will substitute the integer one as soon as the line is executed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also perform operations on these variables and even mutate them, consider the following cells and try to determine the output before running the cells:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = 1\n",
    "y = y + 1\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`y = y + 1` can further be simplified to `y += 1` in Python. The same can be done for other arithmetic operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = 1\n",
    "y += 1\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = 2\n",
    "y **= 8\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It probably goes without saying, but also note that _assignments_ are not _expressions_. Therefore, you must explicitly print the variables to observe their values, or you can use the variable in a singular expression. Consider the cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = \"I will not produce any output.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While we're on the topic of assignments, let's think about the data types `list` and `dict`. We know we can easily assign a list, for instance, to a variable, but what about the items within the list? Consider `my_list` below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [1, 2, 3, 4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What if I wanted to change the `int` `4` to the `str` `'Hello, world!'`?\n",
    "\n",
    "Well, consider the following assignment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list[3] = 'Hello, world!'\n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Well, that works, but how?\n",
    "\n",
    "Don't over think it, list items can be accessed by their `index`, that is to say, their sequential _position_ in the list, starting from the first value, which has an index of `0` to the last. In Python you can also access indexes using negative numbers, this traverses the list from right to left rather than left to right, starting from `-1`. Observe below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list[-1] = 4\n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same can be done with `dict` objects. Although here we access the values by referencing the dictionary keys. We can even assign values to _new keys_ that were not in the original dictionary. Consider the following cells."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_dictionary = {'a': 1, 'b': 2, 'c': 3}\n",
    "my_dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_dictionary['c'] = 'Hello, world!'\n",
    "my_dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_dictionary['d'] = None\n",
    "my_dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that you've considered assignments, you may wonder how to remove an assignment all together. Above, for instance, we set the value of the key `d` in `my_dictionary` to `None`. But what if we wanted `d` to not exist at all? What about `my_dictionary` all together? In the next section, we consider the `del` statement, which solves your problem."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.1.3 Deletions\n",
    "\n",
    "> Deletion of a name removes the binding of that name from the local or global namespace.\n",
    "\n",
    "Deletion does just what it sounds like. We delete a value from our program. Consider the below example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(my_dictionary)\n",
    "del my_dictionary['d']\n",
    "print(my_dictionary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We observe that the key-value pair `'d': None` is no longer part of the `my_dictionary` object at all. We can further delete the entire dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('my_dictionary' in globals())\n",
    "del my_dictionary\n",
    "print('my_dictionary' in globals())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above, we observe that the dictionary no longer exists after deletion, you can try to print `my_dictionary` yourself to prove that the Python compiler will throw, or return, an error to our output. The error warns us that `my_dictionary` cannot be referenced (it must be declared first) because it does not exist (any more)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far we've talked a lot about returned values, you have even experimented with them several times now. In the next section we will consider just what a `return` is."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.1.4 Returns\n",
    "\n",
    "> `return` may only occur syntactically nested in a function definition, not within a nested class definition.\n",
    "> If an expression list is present, it is evaluated, else `None` is substituted.\n",
    "\n",
    "That statement from the Python docs might be a lot to take in for someone who hasn't even considered function definitions nor class definitions. But don't worry, we'll get there shortly.\n",
    "\n",
    "For now let's consider the parts we already understand. I will define a function below, and we will call it and see what comes out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add1(number):\n",
    "    \"\"\"\n",
    "    Adds 1 to a number.\n",
    "\n",
    "    Args:\n",
    "        number: Any int or float. The number to be incremented.\n",
    "\n",
    "    Returns:\n",
    "        1 plus number.\n",
    "    \"\"\"\n",
    "    return number + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "incremented_number = add1(1)\n",
    "print(incremented_number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you observe such a simple function, even without knowing exactly what everything means, it is easy to see what is happening. For now, we'll focus just on the `return number + 1` statement.\n",
    "\n",
    "You probably already see that this is both a `return` statement as well as an arithmetic expression statement, we first increment the `number` variable by `1`, then we _**`return`**_ the value. Last time, we found that the `print` procedure always returned `None`, that's what made it a procedure. The `add1` function on the other hand will always return `number + 1`, that's what makes it a function.\n",
    "\n",
    "But we're not here to talk about functions just yet, we're here to talk about `return` statements.\n",
    "\n",
    "Try augmenting the return statement above, for instance try to return a `float` or another data type. Then, try to execute another statement after the return statement, for instance a `print` procedure or another `return` statement. Pay close attention to those indentations too, everyting belonging to that function needs to be indented, or syntactically nested, in it's function definition.\n",
    "\n",
    "What did you observe? Likely you found that the first `return` puts an end to the function call, nothing after it is evaluated. Further you saw that the `return` statement directly affects the _returned value_.\n",
    "\n",
    "We can try one more thing, if you haven't already, try to remove the expression portion of the statement, `number + 1`, from the `return` statement. Afterward, try to remove the `return` statement all together.\n",
    "\n",
    "What happened? Observe that in Python, `return` returns a value of `None` if no expression is supplied. Further, `None` is returned even if the `return` statement is not explicitly included."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far we've seen that expressions, assignments, deletions, and returns are key building blocks of Python programs. You will likely use all of them, maybe with the exception of `del`, in any normal Python program.\n",
    "\n",
    "However, the limitations of what we've considered so far are fairly obvious. From your exploration of the Python docs, you've seen that there are a number of really useful built-ins, however, what if we want to do more than simple operations?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.1.5 Imports\n",
    "\n",
    "The import statement has two forms, the basic `import` form and the `from` form\n",
    "\n",
    "> The basic import statement (no from clause) is executed in two steps:\n",
    "> 1. find a module, loading and initializing it if necessary\n",
    "> 2. define a name or names in the local namespace for the scope where the import statement occurs.\n",
    "\n",
    "> The from form uses a slightly more complex process:\n",
    "> 1. find the module specified in the from clause, loading and initializing it if necessary;\n",
    "> 2. for each of the identifiers specified in the import clauses:\n",
    ">  1. check if the imported module has an attribute by that name\n",
    ">  2. if not, attempt to import a submodule with that name and then check the imported module again for that attribute\n",
    ">  3. if the attribute is not found, ImportError is raised.\n",
    ">  4. otherwise, a reference to that value is stored in the local namespace, using the name in the as clause if it is present, otherwise using the attribute name\n",
    "\n",
    "We'll consider first the basic `import` form, and how it might be useful in a simple operation.\n",
    "\n",
    "Say you wanted to calculate the **factorial** of number. That should be fairly straight forward, maybe `8!`? Well, although it looks good, that expression will actually not accomplish what we want. In fact it results in a syntax error. In this case, the traditional math syntax does not align with Python semantics as it did for addition and subtraction.\n",
    "\n",
    "In fact, to solve this simple problem, we'd actually need to write a function such as this:\n",
    "\n",
    "```py\n",
    "def factorial(number):\n",
    "    \"\"\"\n",
    "    Calculates the factorial of a positive number.\n",
    "    \n",
    "    Args:\n",
    "        number: Positive int. The number in which the factorial is found.\n",
    "    \n",
    "    Returns:\n",
    "        The factorial of number.\n",
    "    \"\"\"\n",
    "    result = 1\n",
    "    for i in range(2, number + 1):\n",
    "        result *= i\n",
    "    return result\n",
    "```\n",
    "\n",
    "You can copy this code to a executable cell to prove to yourself that it does indeed calculate the factorial of any positive integer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, this would be a lot of work if we had to write functions for everything that was not directly built into to the Python language. Fortunately, `imports` provide an easy way to access extra functionality. Consider the cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "math.factorial(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What have we done? We've imported something called a [`module`](https://docs.python.org/3/tutorial/modules.html). Specifically, the [`math`](https://docs.python.org/3/library/math.html?highlight=math#module-math) module.\n",
    "\n",
    "> This module provides access to the mathematical functions defined by the C standard.\n",
    "\n",
    "importing modules gives us extended functionality in Python without writing cumbersome logic on our own. Often, such modules not only save time, but are also more computationally efficient. Take a moment to think about the kinds of modules that exist in the Python universe.\n",
    "\n",
    "Let's consider one more import together, and at the same time we can observe the `from` import form. We have already observed the Python `dict` which we learned was a type of collection. We did not talk about it's limitations too much, but it does have one big problem. A `dict` cannot remember the order in which data was inserted into it. This does become a problem when the order of data is important. Consider an alternative collection which we can import from the `collections` module, which addresses this issue. The [OrderedDict](https://www.tutorialsteacher.com/python/collections-module).\n",
    "\n",
    "> The OrderedDict is similar to a normal dictionary object in Python. However, it remembers the order of the keys in which they were first inserted.\n",
    "\n",
    "Consider how we import and use the `OrderedDict` collection below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import OrderedDict\n",
    "\n",
    "ordered_dictionary = OrderedDict()\n",
    "\n",
    "ordered_dictionary['c'] = 3\n",
    "ordered_dictionary['b'] = 2\n",
    "ordered_dictionary['a'] = 1\n",
    "\n",
    "ordered_dictionary.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above we see that the insertion order is preserved in `ordered_dictionary`, for instance, when accessing a list of it's keys. \n",
    "\n",
    "We also see that `OrderedDict` is imported from the `collections` module, and we can access `OrderedDict` directly by using the `from` import form. Notice how the same program can be written without the `from` form."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import collections\n",
    "\n",
    "ordered_dictionary = collections.OrderedDict()\n",
    "\n",
    "ordered_dictionary['c'] = 3\n",
    "ordered_dictionary['b'] = 2\n",
    "ordered_dictionary['a'] = 1\n",
    "\n",
    "ordered_dictionary.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above, `OrderedDict` is accessed through the `collections` name (or variable) as described in the `import` definition.\n",
    "\n",
    "You can also bind OrderedDict or collections to a different name during the import process. Consider the cells below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import collections as c\n",
    "\n",
    "o_d = c.OrderedDict()\n",
    "\n",
    "o_d['c'] = 3\n",
    "o_d['b'] = 2\n",
    "o_d['a'] = 1\n",
    "\n",
    "o_d.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import OrderedDict as od\n",
    "\n",
    "o_d = od()\n",
    "\n",
    "o_d['c'] = 3\n",
    "o_d['b'] = 2\n",
    "o_d['a'] = 1\n",
    "\n",
    "o_d.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that you've learned a great deal about syntax, semantics, and simple statements, it's time to dive into [control flow](https://en.wikipedia.org/wiki/Control_flow) with compound statements. \n",
    "\n",
    "> Compound statements contain (groups of) other statements; they affect or control the execution of those other statements in some way.\n",
    "\n",
    "While we did discuss the flow of control earlier in section [#2](#2.-Python-semantics), and of course we have already considered basic control flow through simple statements as demonstrated above. We will now consider groups of statements that make up what many programmers consider traditional control flow constructs.\n",
    "\n",
    "> The `if`, `while` and `for` statements implement traditional control flow constructs. `try` specifies exception handlers and/or cleanup code for a group of statements, while the `with` statement allows the execution of initialization and finalization code around a block of code. Function and class definitions are also syntactically compound statements.\n",
    "\n",
    "> A compound statement consists of one or more ‘clauses.’ A clause consists of a header and a ‘suite.’ The clause headers of a particular compound statement are all at the same indentation level. Each clause header begins with a uniquely identifying keyword and ends with a colon. A suite is a group of statements controlled by a clause. A suite can be one or more semicolon-separated simple statements on the same line as the header, following the header’s colon, or it can be one or more indented statements on subsequent lines. Only the latter form of a suite can contain nested compound statements."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.1.6 If\n",
    "\n",
    "The `if` statement is possibly one of the easiest compound statements to comprehend.\n",
    "\n",
    "> The if statement is used for conditional execution.\n",
    "\n",
    "Consider the cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if 1 == 1:\n",
    "    print('1 does equal 1')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We observe above that the `if` statement above consists of a single clause, containing a header:\n",
    "\n",
    "```py\n",
    "if 1 == 1:\n",
    "```\n",
    "\n",
    "As well as an indented suite, containing a single statement, a `print` procedure:\n",
    "\n",
    "```py\n",
    "    print(\"1 does equal 1\")\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is common to use additional clauses with the `if` statement. Namely, `elif` (else if) and `else`.\n",
    "\n",
    "Consider the following cells."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if 1 == 2:\n",
    "    print('1 does equal 2')\n",
    "elif 2 == 1:\n",
    "    print('2 does equal 1')\n",
    "elif 1 != 2:\n",
    "    print('1 does not equal 2')\n",
    "else:\n",
    "    print('1 neither equals 2 nor does it not equal 2')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if 1 == 2:\n",
    "    print('1 does equal 2')\n",
    "elif 1 > 2:\n",
    "    print('1 is greater than 2')\n",
    "else:\n",
    "    print('1 is neither equal nor greater than 2')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above we learn two things, first, the `else` clause acts like a catch-all if no other clause's header evaluates to `True`. Second, we see that each clause is considered sequentially, starting from `if`, and once one clause header evaluates to `True`, the _flow of control_ ends, and the `if` statement terminates.\n",
    "\n",
    "> It selects exactly one of the suites by evaluating the expressions one by one until one is found to be true; then that suite is executed (and no other part of the `if` statement is executed or evaluated). If all expressions are false, the suite of the `else` clause, if present, is executed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have a good understanding of `if` statements, let's move onto the slightly more complex `while` statement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.1.7 While\n",
    "\n",
    "> The `while` statement is used for repeated execution as long as an expression is true.\n",
    "\n",
    "Unlike the `if` statement, which only evaluates the expression in it's clause's header a total of one or zero times, the `while` statement repeatedly tests the expression in it's header until that expression is false.\n",
    "\n",
    "> This repeatedly tests the expression and, if it is true, executes the first suite; if the expression is false (which may be the first time it is tested) the suite of the `else` clause, if present, is executed and the loop terminates.\n",
    "\n",
    "Consider the following cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 0\n",
    "\n",
    "while i < 10:\n",
    "    i += 1\n",
    "    print(i)\n",
    "else:\n",
    "    i += 1\n",
    "    print('Finished at evaluation', i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can observe in the above cell, the while statement evaluated the expression `i < 10` exactly 11 times. The first 10 times, the suite was executed because `i` was less than `10`. At the final evaluation `i` was exactly equal to `10`, therefore the `else` clause was executed, we then incremented `i` one final time before passing the value to a `print` procedure.\n",
    "\n",
    "I encourage you to experiment with the `while` statement as it is. afterward we will consider some additional control flow which we can use in the suite."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 0\n",
    "\n",
    "while i < 10:\n",
    "    i += 1\n",
    "    \n",
    "    if i % 2 == 1:\n",
    "        continue\n",
    "    \n",
    "    print(i)\n",
    "    \n",
    "    if i == 10:\n",
    "        break\n",
    "else:\n",
    "    print('I will never execute')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above, you can observe the effect of two new statements which are unique to \"loops\" (such as the loop created by the `while` statement), `break` and `continue`.\n",
    "\n",
    "> A break statement executed in the first suite terminates the loop without executing the `else` clause’s suite. A continue statement executed in the first suite skips the rest of the suite and goes back to testing the expression.\n",
    "\n",
    "Therefore, in the above example, the while statement evaluated the expression `i < 10` exactly _**10**_ times, not 11 because of the `break` statement executed when on the eleventh iteration. Likewise, the suite only executed the `print` procedure 5 of 10 possible times, and only on the even value iterations of `i`. This was because of the `continue` statement which executed whenever `i` was an odd number, `i % 2 == 1`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I encourage you to continue expirimenting with the `while` statement. Afterward we can consider the more complex `for` statement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.1.8 For\n",
    "\n",
    "> The for statement is used to iterate over the elements of a sequence (such as a string, tuple or list) or other iterable object:\n",
    "\n",
    "Now that you see how control flow with compound statements works, this one should be a walk in the park. Consider the following cells."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "a_string = \"Hello, world!\"\n",
    "\n",
    "for character in a_string:\n",
    "    print(character)\n",
    "else:\n",
    "    print(\"done\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once again we observe a statement with two clauses, the first being:\n",
    "\n",
    "```py\n",
    "for character in a_string:\n",
    "    print(character)\n",
    "```\n",
    "\n",
    "And the second being:\n",
    "\n",
    "```py\n",
    "else:\n",
    "    print(\"done\")\n",
    "```\n",
    "\n",
    "The `else` clause behaves as expected. However, our first clause differs from what we have observed in any other clause until this point. Consider the evaluation of the expression list `a_string` as described in the below documentation.\n",
    "\n",
    "> The expression list is evaluated once; it should yield an iterable object. An iterator is created for the result of the expression list. The suite is then executed once for each item provided by the iterator, in the order returned by the iterator. Each item in turn is assigned to the target list _**(`character` in our example)**_ using the standard rules for assignments (see [Assignment statements](https://docs.python.org/3/reference/simple_stmts.html#assignment) [#2.1.2](#2.1.2-Assignments)), and then the suite is executed. When the items are exhausted (which is immediately when the sequence is empty or an iterator raises a `StopIteration` exception), the suite in the `else` clause, if present, is executed, and the loop terminates.\n",
    "\n",
    "Yes, the `for` statement is not looking for a true evaluation, rather it is looking for an _iterable object_. We've seen a lot of those in this notebook. For instance, recall that `str` is an iterable sequence, as demonstrated above.\n",
    "\n",
    "Observe the following cells to see how the `for` statement iterates over a collection such as the `OrderedDict` and another sequence such as a `tuple`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ordered_dictionary = collections.OrderedDict()\n",
    "\n",
    "ordered_dictionary['f'] = 6\n",
    "ordered_dictionary['e'] = 5\n",
    "ordered_dictionary['d'] = 4\n",
    "ordered_dictionary['c'] = 3\n",
    "ordered_dictionary['b'] = 2\n",
    "ordered_dictionary['a'] = 1\n",
    "\n",
    "for key in ordered_dictionary:\n",
    "    if key == 'b':\n",
    "        continue\n",
    "    \n",
    "    print(key)\n",
    "    \n",
    "    if key == 'a':\n",
    "        break\n",
    "else:\n",
    "    print(\"done\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = (1, 2, 3, 4, 5)\n",
    "\n",
    "for value in t:\n",
    "    if value == 4:\n",
    "        continue\n",
    "    \n",
    "    print(value)\n",
    "    \n",
    "    if value == 5:\n",
    "        break\n",
    "else:\n",
    "    print(\"done\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We observe here similar behavior to that of the `while` statement, this is expected because `while` and `for` statements both create similar loops, though the _action_ taken to create those loops is completely different.\n",
    "\n",
    "> A `break` statement executed in the first suite terminates the loop without executing the `else` clause’s suite. A `continue` statement executed in the first suite skips the rest of the suite and continues with the next item, or with the `else` clause if there is no next item.\n",
    "\n",
    "Therefore, the outcome is similar to what we experienced in the case of the `while` statement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now you have mastered the traditional control flow constructs, with this knowledge you can already build complete Python programs. However, I want you to take a moment to think of what a program would look like, had you only the above conceptual tools at your disposal.\n",
    "\n",
    "One problem you would face is that the code would be completely [_monolithic_](https://en.wikipedia.org/wiki/Monolithic_application). Just endless lines of control flow, without any organized structure. Worst yet, you have not learned to write any reusable, extendable (inheritable), or composable code. Such code would be a nightmare to maintain.\n",
    "\n",
    "We don't want that.\n",
    "\n",
    "Professionals usually want to write clean, efficient, modular, and optimized code. Let's consider first a foundation of such practices: functions and classes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 Python definitions\n",
    "\n",
    "> Function and class definitions are also syntactically compound statements.\n",
    "\n",
    "In this section, we will explore [function](https://docs.python.org/3/reference/compound_stmts.html#grammar-token-funcdef) and [class definitions](https://docs.python.org/3/reference/compound_stmts.html#grammar-token-classdef) which are syntactically equivalent to compound statements."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.2.1 Function\n",
    "\n",
    "We've talked a lot about functions already. Though you haven't written any yourself, you've read some of mine, for instance our `factorial` function.\n",
    "\n",
    "You've also come to know that some functions are also called procedures, in Python you saw that this was when a function returned the `NoneType`.\n",
    "\n",
    "So what _is_ a function definition?\n",
    "\n",
    "> A function definition is an executable statement. Its execution binds the function name in the current local namespace to a function object (a wrapper around the executable code for the function). This function object contains a reference to the current global namespace as the global namespace to be used when the function is called.\n",
    "\n",
    "> The function definition does not execute the function body; this gets executed only when the function is called.\n",
    "\n",
    "So, functions are reusable blocks of code that can be called arbitrarily. Functions may define zero or more parameters, for instance, the following function defines 2:\n",
    "\n",
    "```py\n",
    "def add(a=1, b=1):\n",
    "    \"\"\"\n",
    "    Sums a and b.\n",
    "\n",
    "    Args:\n",
    "        a: An int.\n",
    "        b: An int.\n",
    "\n",
    "    Returns: \n",
    "        The sum of a and b.\n",
    "    \"\"\"\n",
    "    return a + b\n",
    "```\n",
    "\n",
    "What's new here? Well, while the body of the function is nothing new to you, the head contains something interesting, `a=1, b=1`. What is this? Well, of course these are the same parameters you've read up until this point, but now they have _default parameter values_.\n",
    "\n",
    "> When one or more parameters have the form _parameter `=` expression_, the function is said to have “default parameter values.” For a parameter with a default value, the corresponding argument may be omitted from a call, in which case the parameter’s default value is substituted. If a parameter has a default value, all following parameters up until the “`*`” must also have a default value — this is a syntactic restriction that is not expressed by the grammar.\n",
    "\n",
    "> Default parameter values are evaluated from left to right when the function definition is executed. This means that the expression is evaluated once, when the function is defined, and that the same “pre-computed” value is used for each call. This is especially important to understand when a default parameter is a mutable object, such as a list or a dictionary: if the function modifies the object (e.g. by appending an item to a list), the default value is in effect modified. This is generally not what was intended. A way around this is to use None as the default, and explicitly test for it in the body of the function.\n",
    "\n",
    "> A function call always assigns values to all parameters mentioned in the parameter list, either from position arguments, from keyword arguments, or from default values.\n",
    "\n",
    "In the cell below, I want you to write a function definition of your own. It can do anything you want, take as many parameters as you want, and return whatever you want. But, I want you to write it yourself. At the moment, `my_function` is a useless procedure that does nothing but return `None`.\n",
    "\n",
    "If you need help thinking of something creative, why not consider some mathematical functions, such as the [sigmoid function](https://en.wikipedia.org/wiki/Sigmoid_function).\n",
    "\n",
    "Also, pay attention to the [_docstring_](https://www.python.org/dev/peps/pep-0257/#what-is-a-docstring):\n",
    "\n",
    "```py\n",
    "    \"\"\"\n",
    "    Does nothing.\n",
    "\n",
    "    Args:\n",
    "        \n",
    "    Returns: \n",
    "        None.\n",
    "    \"\"\"\n",
    "```\n",
    "\n",
    "It is common to include such forms of documentation when writing Python programs. You'll find a number of recognized docstring formats online, [this answer on StackOverflow makes some good points](https://stackoverflow.com/a/24385103)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_function():\n",
    "    \"\"\"Does nothing.\"\"\"\n",
    "    return None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's [call](https://docs.python.org/3/reference/expressions.html#calls) `my_function`. Remember to include any required arguments (those are what we call the corresponding values for your predefined parameters!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_function()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I'm sure you've written something very meaningful! Great work!\n",
    "\n",
    "Likely you found that functions are not so complicated after all. Aren't they basically just wrappers for everything else we've been doing this whole time? Yes, exactly, you're on the right track. Functions are neat little containers in which we can store reusable code.\n",
    "\n",
    "What you've made, regardless of how clean and optimized it is, is a great step towards professional Python programming.\n",
    "\n",
    "What else can we do with Python functions? One thing we should consider is [generators](https://docs.python.org/3/howto/functional.html#generators).\n",
    "\n",
    "> Any function containing a `yield` keyword is a generator function; this is detected by Python’s bytecode compiler which compiles the function specially as a result.\n",
    "\n",
    "Consider the example from the Python docs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_ints(N):\n",
    "    \"\"\"Does nothing.\n",
    "\n",
    "    Args:\n",
    "        N: int. Will be used to generate a range.\n",
    "        \n",
    "    Yields: \n",
    "        A integer.\n",
    "    \"\"\"\n",
    "\n",
    "    for i in range(N):\n",
    "        yield i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because this function contains a `yield` expression, we can treat it as if it were a iterable.\n",
    "\n",
    "> When you call a generator function, it doesn’t return a single value; instead it returns a generator object that supports the iterator protocol. On executing the `yield` expression, the generator outputs the value of `i`, similar to a `return` statement. The big difference between `yield` and a `return` statement is that on reaching a yield the generator’s state of execution is suspended and local variables are preserved. On the next call to the generator’s `__next__()` method, the function will resume executing.\n",
    "\n",
    "You can prove this behavior to yourself in the cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in generate_ints(10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, let's consider class definitions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.2.2 Class\n",
    "\n",
    "> A class definition defines a class object.\n",
    "\n",
    "You'll see that a class definition is not unlike a function definition. They are syntactically similar. Consider the following class definition, `MyClass` will not do anything, so we will use the _[`pass`](https://docs.python.org/3/reference/simple_stmts.html#the-pass-statement) statement_ so that we do not encounter an exception."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyClass:\n",
    "    \"\"\"An empty class.\"\"\"\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that unlike a function definition header, you can omit the `()` in a class definition header. This makes sense because class definition headers are not expecting a list of parameters like a function would, rather they expect an inheritance list.\n",
    "\n",
    "> The inheritance list usually gives a list of base classes, so each item in the list should evaluate to a class object which allows subclassing. Classes without an inheritance list inherit, by default, from the base class object.\n",
    "\n",
    "See the cell below for the same class, this time explicitly inheriting `object`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyOtherClass(object):\n",
    "    \"\"\"Another empty class.\"\"\"\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe below that the classes are practically identical."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_class = MyClass()\n",
    "my_other_class = MyOtherClass()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(my_class)\n",
    "help(my_other_class)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Classes can _inherit_ from other `class` objects. For instance, the following code is valid:\n",
    "\n",
    "```py\n",
    "class MyOtherOtherClass(MyOtherClass, MyClass):\n",
    "    \"\"\"Yet another empty class.\"\"\"\n",
    "    pass\n",
    "```\n",
    "\n",
    "So, what are classes good for?\n",
    "\n",
    "> Classes provide a means of bundling data and functionality together. Creating a new class creates a new _type_ of object, allowing new _instances_ of that type to be made. Each class instance can have attributes attached to it for maintaining its state. Class instances can also have methods (defined by its class) for modifying its state.\n",
    "\n",
    "So, if the following is an instance of a `OrderedDict` type (we know that the `OrderedDict` type too is an object), with all the attributes, methods, and features of an `OrderedDict`, which itself inherits from the `dict` type object:\n",
    "\n",
    "```py\n",
    "ordered_dict_instance = OrderedDict()\n",
    "```\n",
    "\n",
    "Then the following is an instance of the `MyOtherOtherClass` type (also an object), with all the attributes, methods, and features of `MyOtherOtherClass`, which itself inherits from the `MyOtherClass` and `MyClass` type objects:\n",
    "\n",
    "```py\n",
    "my_other_other_class_instance = MyOtherOtherClass()\n",
    "```\n",
    "\n",
    "Obviously, all of the types that we've used up until now have proved to be very handy. Classes provide a way to add even more functionality to the Python programming language.\n",
    "\n",
    "Before tackling classes in depth, you should consider [names and objects](https://docs.python.org/3/tutorial/classes.html#a-word-about-names-and-objects), and [scopes and namespaces](https://docs.python.org/3/tutorial/classes.html#python-scopes-and-namespaces).\n",
    "\n",
    "Use the cell below to experiment with the ideas from the linked material above. Afterward we will write a simple class together."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This line is a comment, we haven't spoken about them until now.\n",
    "# You can use comments like this one to document your code.\n",
    "# In the space below, try some of the examples from the links above.\n",
    "# I've already included one.\n",
    "\n",
    "def scope_test():\n",
    "    def do_local():\n",
    "         spam = \"local spam\"\n",
    "\n",
    "    def do_nonlocal():\n",
    "        nonlocal spam\n",
    "        spam = \"nonlocal spam\"\n",
    "\n",
    "    def do_global():\n",
    "        global spam\n",
    "        spam = \"global spam\"\n",
    "\n",
    "    spam = \"test spam\"\n",
    "    do_local()\n",
    "    print(\"After local assignment:\", spam)\n",
    "    do_nonlocal()\n",
    "    print(\"After nonlocal assignment:\", spam)\n",
    "    do_global()\n",
    "    print(\"After global assignment:\", spam)\n",
    "\n",
    "scope_test()\n",
    "print(\"In global scope:\", spam)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that ideas like scope and namespace are no longer foreign to you, let's go ahead and write a simple [class](https://docs.python.org/3/tutorial/classes.html#class-objects).\n",
    "\n",
    "Below, we'll implement an _iterator_, similar to the _generator_ we implemented in [#2.2.1 Function definitions](#2.2.1-Function-definitions)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyIterator:\n",
    "    \"\"\"Iterator for looping over a sequence.\"\"\"\n",
    "    def __init__(self, sequence):\n",
    "        self.sequence = sequence\n",
    "        self.index = 0\n",
    "        self.end = len(sequence)\n",
    "\n",
    "    def __iter__(self):\n",
    "        return self\n",
    "\n",
    "    def __next__(self):\n",
    "        if self.index == self.end:\n",
    "            raise StopIteration\n",
    "        \n",
    "        n = self.sequence[self.index]\n",
    "        self.index += 1\n",
    "        return n\n",
    "    \n",
    "    def start_over(self):\n",
    "        self.index = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above, we observe that a class can contain zero or more functions. Functions belonging to a class are called _methods_, some of these methods are [_special_](https://docs.python.org/3/reference/datamodel.html#special-method-names), like the `__init__` method (this is the one that is concerned about the arguments passed when calling a given class). Others methods are just like the functions and procedures we've seen before, such as the `start_over` procedure-method above. All methods expect `self` to be their first argument.\n",
    "\n",
    "Additionally, we can set any number of [attributes](https://docs.python.org/3/reference/datamodel.html#the-standard-type-hierarchy), such as `index` or `end` above, these values can changed after the class in instantiated, and can be observed using dot notation. Some attributes are also _special_.\n",
    "\n",
    "Read through the linked material to learn about the different special attributes and methods. Afterward, consider below how the `MyIterator` class is used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iterator = MyIterator('Hello, world!')\n",
    "\n",
    "print('self.sequence:', iterator.sequence)\n",
    "\n",
    "for i in iterator:\n",
    "    print('\\nself.index:', iterator.index)\n",
    "    print('return of __next__ at current iteration:', i)\n",
    "\n",
    "iterator.start_over()\n",
    "\n",
    "print('\\nBy calling the start_over() method, we can iterate through our string again.')\n",
    "print('Try commenting out iterator.start_over() to observe the StopIteration exception.')\n",
    "\n",
    "for _ in range(5):\n",
    "    print(iterator.__next__())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(iterator)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above, we observe that instantiating the class `MyIterator` returns an instance of the class `MyIterator`, which behaves like a sequence despite only inheriting the Python `object` type.\n",
    "\n",
    "I encourage you to now try writing your own classes. You can use the `MyClass` and `MyOtherClass` class definitions as a starting point, or you can create something completely from scratch."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.2.3 Decorator Syntax\n",
    "\n",
    "In some scenarios, it makes sense to modify or extend the behavior of a function definition or class without permanently modifying it. Consider the following example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add(a, b):\n",
    "    \"\"\"\n",
    "    Sums a and b.\n",
    "\n",
    "    Args:\n",
    "        a: An int.\n",
    "        b: An int.\n",
    "\n",
    "    Returns: \n",
    "        The sum of a and b.\n",
    "    \"\"\"\n",
    "    return a + b\n",
    "\n",
    "\n",
    "def sub(a, b):\n",
    "    \"\"\"\n",
    "    Subtracts b from a.\n",
    "\n",
    "    Args:\n",
    "        a: An int.\n",
    "        b: An int.\n",
    "\n",
    "    Returns: \n",
    "        The difference of a and b.\n",
    "    \"\"\"\n",
    "    return a - b\n",
    "\n",
    "\n",
    "def mul(a, b):\n",
    "    \"\"\"\n",
    "    Multiplies a by b.\n",
    "\n",
    "    Args:\n",
    "        a: An int.\n",
    "        b: An int.\n",
    "\n",
    "    Returns: \n",
    "        The product of a and b.\n",
    "    \"\"\"\n",
    "    return a * b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above example, the arguments provided to `add`, `sub`, and `mul` must be of type `int` otherwise the functions will not behave as expected. However, if we permanently modify each function definition to contain it's own validation logic, we'd find that the additional logic would be identical between the functions.\n",
    "\n",
    "One solution would be to create the following helper class and \"wrap\" each function with it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Validate:\n",
    "    def __init__(self, func):\n",
    "        self.func = func\n",
    " \n",
    "    def __call__(self, a, b):\n",
    "        \"\"\"Raises an error if `a` and `b` are not of type `int`\"\"\"\n",
    "        if isinstance(a, int) and isinstance(b, int):\n",
    "            return self.func(a, b)\n",
    "        else:\n",
    "            raise TypeError(\"Expected `a` and `b` to be of type `int`.\")\n",
    "\n",
    "\n",
    "valid_add = Validate(add)\n",
    "valid_sub = Validate(sub)\n",
    "valid_mul = Validate(mul)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now when we call each function we can be sure that no value will be returned (and an error will be raised!) unless both `a` and `b` are of type `int`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"3 + 3 = \", valid_add(3, 3))\n",
    "print(\"3 - 3 = \", valid_sub(3, 3))\n",
    "print(\"3 * 3 = \", valid_mul(3, 3))\n",
    "\n",
    "print(\"3 + '3' = \", valid_add(3, \"3\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To make this type of modification easier, Python introduced a special syntax known as a `decorator`. This special syntax causes the below defined `new_add` function to behave as the above defined `valid_add` function. Behind the scenes, the same modification is taking place."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@Validate\n",
    "def new_add(a, b):\n",
    "    \"\"\"\n",
    "    Sums a and b.\n",
    "\n",
    "    Args:\n",
    "        a: An int.\n",
    "        b: An int.\n",
    "\n",
    "    Returns: \n",
    "        The sum of a and b.\n",
    "    \"\"\"\n",
    "    return a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"3 + 3 = \", new_add(3, 3))\n",
    "print(\"3 + '3' = \", new_add(3, \"3\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With that, we can conclude this lesson on an introduction to the Python programming language. You now have a strong foundation as a Python programmer, yet, you still have much to learn. In the next lesson, we will continue to explore Python development, but this time with a focus on OOP or Object-Oriented Programming."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.4 ('geography-JXcH0ch2')",
   "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.10.4"
  },
  "vscode": {
   "interpreter": {
    "hash": "3652e7c851bf0ce6fd0727ec0ae4695fd1a1b87caaa42a9cc8fffee926780d21"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}