notebooks/03-control_flow.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "09670267",
   "metadata": {},
   "source": [
    "# Control flow\n",
    "## Data 765 tutoring\n",
    "\n",
    "Up until now your scripts in 765 have flowed linearly from top to bottom. Programs are rarely so neat—even in the data world!\n",
    "\n",
    "Instead, programs branch and repeat depending on the context. Branching (conditional statements) and repeating (looping and iteration) are known collectively as **control flow.** Consider a small script that checks logins for some resource. The basic steps for that script may look like this:\n",
    "\n",
    "1. Get username from a central database\n",
    "2. Ask for user's password given retry counter > 0\n",
    "3. Check user-password combo\n",
    "4. IF the combination is correct grant access ELSE decrease the retry counter and go to the second step\n",
    "\n",
    "This logic can be implemented in Python directly—a paean to Python's elegance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e596b510",
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "from getpass import getuser, getpass\n",
    "\n",
    "# Mock database password checker\n",
    "def db_check_pwd(_username, password):\n",
    "    if isinstance(_username, str) and isinstance(password, str):\n",
    "        # Simulate checking password\n",
    "        time.sleep(1)\n",
    "        return password == \"catsareamazing123\"\n",
    "    return False        \n",
    "\n",
    "retry_limit = 5\n",
    "username = getuser()\n",
    "\n",
    "while retry_limit:\n",
    "    password = getpass(f\"Password for {username}: \")\n",
    "    if db_check_pwd(username, password):\n",
    "        print(\"Access granted!\")\n",
    "        # Instead of breaking here you'd grant access to\n",
    "        # the resource of course.\n",
    "        break\n",
    "    else:\n",
    "        print(f\"Remaining tries: {retry_limit}\")\n",
    "        retry_limit -= 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b614ccbc",
   "metadata": {},
   "source": [
    "# Conditional statements (if/elif/else)\n",
    "\n",
    "`if` statements check an expression's truthiness then execute _or_ skip a block of code based on the result. In other words, `if` statements branch based on an expression which allows programmers to control where their program's flow based on the environment, input, options, et cetera.\n",
    "\n",
    "Understanding `if` statements is easier if you parse them as English first. IF _something is true_ THEN _do some action_. The \"then\" in terms of Python is just an indented block of code.\n",
    "\n",
    "I'll begin with a few silly examples to demonstrate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e1606cb7",
   "metadata": {},
   "outputs": [],
   "source": [
    "awesome_band = \"King Crimson\"\n",
    "# Retrieve a musician from stdin and convert to title case\n",
    "# as well as strip white space for better comparisons.\n",
    "yr_awesome_music = input(\"(One of) your favorite musicians? \").title().strip()\n",
    "\n",
    "if yr_awesome_music == awesome_band:\n",
    "    print(\"That's awesome! I love King Crimson too!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fda75fd1",
   "metadata": {},
   "source": [
    "We can \"translate\" the `if` statement to English to understand it better.\n",
    "\n",
    "**Translation:** IF the awesome musician you like is the same as (equal to) the awesome band I like (King Crimson) THEN print/say \"That's awesome! I love King Crimson too!\"\n",
    "\n",
    "The condition must be `True` for the block to execute.\n",
    "\n",
    "The `if` statement is rather rude though. If the musician you provide is different than the band I provided then nothing is printed at all!\n",
    "\n",
    "## `else`\n",
    "\n",
    "`else` statements add a default if the `if` statement doesn't match.\n",
    "\n",
    "To add onto the sentence from earlier: IF _something is true_ THEN _do some action_ ELSE _do this action instead_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2c4b9e90",
   "metadata": {},
   "outputs": [],
   "source": [
    "awesome_band = \"King Crimson\"\n",
    "# Retrieve a musician from stdin and convert to title case\n",
    "# as well as strip white space for better comparisons.\n",
    "yr_awesome_music = input(\"(One of) your favorite musicians? \").title().strip()\n",
    "\n",
    "if yr_awesome_music == awesome_band:\n",
    "    print(\"That's awesome! I love King Crimson too!\")\n",
    "else:\n",
    "    print(f\"I'm sure {yr_awesome_music} is cool too!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "907aa07e",
   "metadata": {},
   "source": [
    "Oops. That still sounds rude. No harm intended!\n",
    "\n",
    "Let's translate that to English too.\n",
    "\n",
    "**Translation:** IF the awesome musician you like is the same as (equal to) the awesome band I like (King Crimson) THEN print/say \"That's awesome! I love King Crimson too!\" ELSE say \"I'm sure (your musician here) is cool too!\"\n",
    "\n",
    "## `elif`\n",
    "\n",
    "I like more than one band. Let's add more conditions!\n",
    "\n",
    "`elif` (\"else if\") adds more conditions to an `if` statement. They're basically extra `if` statements that are part of the same `if` block. Using `if` instead of `elif` to add more conditions results a new `if` block and thus doesn't continue the logic.\n",
    "\n",
    "You can only have one `if` and one `else` per block but as many `elif` as you wish. Use `elif` to **continue an `if` statement.**\n",
    "\n",
    "Finally, adding the last missing piece to the sentence from earlier: IF _something is true_ THEN _do some action_ ELSE IF _some other statement is true_ THEN _do this other action_ ELSE _do this action instead_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f0e7b61c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Retrieve a musician from stdin and convert to title case\n",
    "# as well as strip white space for better comparisons.\n",
    "yr_awesome_music = input(\"(One of) your favorite musicians? \").title().strip()\n",
    "\n",
    "if yr_awesome_music == \"King Crimson\":\n",
    "    print(\"(Insert JoJoke here?!)\")\n",
    "elif yr_awesome_music == \"Sonic Youth\":\n",
    "    print(\"Ah yes, my favorite band where the guitarists shove screwdrivers\"\n",
    "          \"into their instruments to make pretty sounds.\")\n",
    "elif yr_awesome_music == \"Pixies\":\n",
    "    print(\"ALIENS?\")\n",
    "elif not yr_awesome_music:\n",
    "    print(\"Follow the instructions! 🤬😾\")\n",
    "else:\n",
    "    print(f\"I'm sure {yr_awesome_music} is cool too!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6743de7d",
   "metadata": {},
   "source": [
    "Each `elif` acts like an `if` statement that is part of the entire `if` structure. In other words, each `elif` continues the main `if`. I said this above, but I'm repeating it because this concept is important but sometimes confusing. Use `elif` when you have multiple conditions that continue from the first `if`.\n",
    "\n",
    "Next, notice that the last `elif` has a different condition than the preceding. `elif not yr_awesome_music` evaluates to `True` if the human at the keyboard input an empty answer. This condition is clearly different than the string equivalency expressions.\n",
    "\n",
    "`elif` and `if` only need an expression that evaluates to a boolean or something \"truthy\" or \"falsey\". The `elif` statements don't need to be similar or related in any way.\n",
    "\n",
    "Let's focus on the first sentence above a bit more. `if` statements can trigger based on expressions as long as they result in bools. That means:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "3fb59956",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It's TRUE!\n",
      "falsey_func is False.\n",
      "empty_string is...empty.\n",
      "Empty list: False\n",
      "Empty dict: False\n",
      "None: False\n",
      "0: False\n"
     ]
    }
   ],
   "source": [
    "truthy = True\n",
    "\n",
    "if truthy:\n",
    "    print(\"It's TRUE!\")\n",
    "    \n",
    "def falsey_func():\n",
    "    return False\n",
    "\n",
    "if falsey_func():\n",
    "    print(\"falsey_func is True.\")\n",
    "else:\n",
    "    print(\"falsey_func is False.\")\n",
    "    \n",
    "empty_string = \"\"\n",
    "\n",
    "if not empty_string:\n",
    "    print(\"empty_string is...empty.\")\n",
    "\n",
    "print(f\"Empty list: {bool([])}\")\n",
    "print(f\"Empty dict: {bool({})}\")\n",
    "print(f\"None: {bool(None)}\")\n",
    "print(f\"0: {bool(0)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd355098",
   "metadata": {},
   "source": [
    "`truthy` is already `True` so the `if` statement succeeds. You **don't** have to test if `truthy == True` because the value is a bool. Testing for truthiness is redundant; it's as if you wrote code like `if 5 > 3 == True` or `if True == True`.\n",
    "\n",
    "`falsey_func()` returns `False` so `else` executes. You don't have to check if `falsey_func() == True`.\n",
    "\n",
    "Empty strings and collections; `None`, 0, and likely others that I've forgotten coerce to `False` when treated as a boolean. Idiomatic Python (a.k.a. Pythonic code) opts for using these rational coercions rather than explicit checks.\n",
    "\n",
    "## Nesting and collections\n",
    "\n",
    "`if` statements may be nested to create tree-like structures like you saw in the homework."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "36bee6bd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I store my video games in Queens!\n"
     ]
    }
   ],
   "source": [
    "location = {\"celestial_body\": \"Earth\",\n",
    "            \"loc_1\": \"New York\",\n",
    "            \"loc_2\": \"Queens\"}\n",
    "\n",
    "if location[\"celestial_body\"] == \"Earth\":\n",
    "    if location[\"loc_1\"] == \"New York\":\n",
    "        if location[\"loc_2\"] == \"Queens\":\n",
    "            print(\"I store my video games in Queens!\")\n",
    "        elif location[\"loc_2\"] == \"Brooklyn\":\n",
    "            print(\"Brooklyn has awesome vegan doughnuts.\")\n",
    "        elif location[\"loc_2\"] == \"Manhattan\":\n",
    "            print(\"Chelsea is my favorite neighborhood in Manhattan.\")\n",
    "        elif location[\"loc_2\"] == \"Bronx\":\n",
    "            print(\"I haven't visited the Bronx that much\")\n",
    "        else:\n",
    "            print(f\"Is {location['loc_2']} out of N.Y.C.?\")\n",
    "    else:\n",
    "        print(f\"Do you take a lot of cat pictures in {location['loc_2']}/{location['loc_1']}?\")\n",
    "elif location[\"celestial_body\"] == \"Mars\":\n",
    "    print(\"The UAC's research facilities are located on Mars and Phobos.\")\n",
    "    if location[\"loc_1\"] == \"Tharsis\":\n",
    "        if location[\"loc_2\"] == \"Olympus Mons\":\n",
    "            print(\"Olympus Mons is a huge volcano. Stay safe!\")\n",
    "elif location[\"celestial_body\"] in [\"Saturn\", \"Neptune\"]:\n",
    "    print(f\"I have property in {location['celestial_body']}!\")\n",
    "else:\n",
    "    print(f\"I'll have to visit {location['celestial_body']}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b43b6e0a",
   "metadata": {},
   "source": [
    "### Questions\n",
    "1. Change the `location` `dict` so that Olympus Mons quote is displayed.\n",
    "2. Explain the last `elif`.\n",
    "\n",
    "# Iteration\n",
    "\n",
    "Loops repeat an action until some condition is met. Like `if` statements, `while` loops evaluate an expression to decide whether to continue. `for` loops continue until an iterable is exhausted. Iterables are Python types that implement a `__next__()` method that returns the next element in a sequence until a possible end is reached.\n",
    "\n",
    "Iteration is one of the most practical constructs in any programming languages. Let's take a look at Python's `for` loop!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1d3f0765",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Espeon is awesome!\n",
      "Drampa is awesome!\n",
      "Psyduck is awesome!\n"
     ]
    }
   ],
   "source": [
    "cool_pokemon = [\"Espeon\", \"Drampa\", \"Psyduck\"]\n",
    "\n",
    "for pokemon in cool_pokemon:\n",
    "    print(f\"{pokemon} is awesome!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2afa0505",
   "metadata": {},
   "source": [
    "The for loop traverses cool_pokemon by way of an iterator and executes the block of code until the iterator is depleted.\n",
    "\n",
    "Unpacking a for loop looks something like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d73ecc0d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Espeon is awesome!\n",
      "Drampa is awesome!\n",
      "Psyduck is awesome!\n"
     ]
    }
   ],
   "source": [
    "pokemon_iter = iter(cool_pokemon)\n",
    "pokemon = next(pokemon_iter)\n",
    "print(f\"{pokemon} is awesome!\")\n",
    "pokemon = next(pokemon_iter)\n",
    "print(f\"{pokemon} is awesome!\")\n",
    "pokemon = next(pokemon_iter)\n",
    "print(f\"{pokemon} is awesome!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba378e6f",
   "metadata": {},
   "source": [
    "In other words, each reference to each element is assigned to `pokemon` in turn until the iterator is exhausted. Python knows when the iterator is exhausted because a [StopIteration](https://docs.python.org/3/library/exceptions.html#StopIteration) exception is raised.\n",
    "\n",
    "`while` loops test if an expression evaluates to `True` then executes a block of code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "24366848",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 3 5 7 9 11 13 15 17 "
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "\n",
    "while i <= 17:\n",
    "    if i % 2:\n",
    "        print(i, end=' ')\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c4fc9f2",
   "metadata": {},
   "source": [
    "Notice the difference between the two. `for` loops continutally retrieves elements from an iterator until exhausted or some other condition is reached. `while` loops execute as long as the expression evaluates as `True` but doesn't have to traverse a collection.\n",
    "\n",
    "You have to ensure that `while` conditions actually terminate or else your loop runs forever and contributes to global warming.\n",
    "\n",
    "`break` and `continue` provide ways to stop a loop early or skip an iteration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "52ae1806",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "24\n",
      "99\n",
      "Invalid age!\n",
      "\n",
      "And now continue\n",
      "\n",
      "8\n",
      "24\n",
      "99\n",
      "Invalid age!\n",
      "30\n",
      "25\n",
      "9\n",
      "Invalid age!\n",
      "Invalid age!\n"
     ]
    }
   ],
   "source": [
    "ages = [8, 24, 99, -1, 30, 25, 9, -50, 154]\n",
    "\n",
    "for age in ages:\n",
    "    if age < 0 or age > 120:\n",
    "        print(\"Invalid age!\")\n",
    "        break\n",
    "    else:\n",
    "        print(age)\n",
    "\n",
    "print(\"\\nAnd now continue\\n\")\n",
    "        \n",
    "for age in ages:\n",
    "    if age < 0 or age > 120:\n",
    "        print(\"Invalid age!\")\n",
    "        continue\n",
    "    else:\n",
    "        print(age)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "006c5da3",
   "metadata": {},
   "source": [
    "Admittedly, this example is nonsensical but I couldn't think of a simple and practical example of using `break` and `continue`.\n",
    "\n",
    "## Comprehensions\n",
    "\n",
    "Comprehensions are a neat aspect of functional programming built into Python. Essentially, a comprehension constructs a collection from another collection.\n",
    "\n",
    "Let's work with ages again. Say we have data that contains the ages above, but we want to preclude obviously wrong ages by setting them to `nan`. A comprehension is a simple tool to accomplish this without a longer `for` loop.\n",
    "\n",
    "As a small note, we'd use NumPy or pandas over loops or comprehensions for this task."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c754e24f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[8, 24, 99, 30, 25, 9]\n"
     ]
    }
   ],
   "source": [
    "cleaned_ages = [age for age in ages if age > 0 and age < 120]\n",
    "print(cleaned_ages)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cca76cf",
   "metadata": {},
   "source": [
    "A comprehension is cleaner than writing a `for` loop and appending to a new `list`. Essentially, we're transforming one collection into another collection without side effects such as modifying the original `list`.\n",
    "\n",
    "The syntax is fairly Spartan, but you can see how a comprehension is like a condensed `for` loop.\n",
    "\n",
    "One of the canonical examples is raising a list of numbers by an exponent."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "6d4fdd0d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 8, 27, 64, 125, 216, 343, 512, 729]\n"
     ]
    }
   ],
   "source": [
    "cubes = [i**3 for i in range(10)]\n",
    "print(cubes)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fef6696e",
   "metadata": {},
   "source": [
    "The syntax for comprehensions is essentially:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e0f557b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "[new_item for variable in collection if condition]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5084bfe",
   "metadata": {},
   "source": [
    "Comprehensions for other collections look about the same.\n",
    "\n",
    "## Gathering data with a loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "eed3acf4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Espeon has types: [{'slot': 1, 'type': {'name': 'psychic', 'url': 'https://pokeapi.co/api/v2/type/14/'}}]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAGAAAABgBAMAAAAQtmoLAAAAJ1BMVEUAAAAQEBAxQXNKc7R7SnuDYrSLIFK0e7TFIFLFxcXmpNXuve7///9jq7FLAAAAAXRSTlMAQObYZgAAAgVJREFUeJztls+K1EAQxruXeE/LSCDxYjwIe3PWB9jsFgQy5z2Ij+BpINAwvoCgb+ApMjBQOQ0MKqmXsyqZcRiQ6WrwZr5Dk8D3S339P8bMmjVr1j8SQJw/oSGOSIiG+yjC5XSIAowtKK6EsbSNA0wRlwmgiuo2eN/GdAJw532vByzunMs+hXt9+mSOjqlNF/Inp0/m3blVATbVAc1laAWA93HAA27PRMVjlYaAW/wTKukUwOMtHkMBNJ0i0+MSwfEMuAURaoCbJdCAzhHvN4kTzHTzTqyASEP5RgOY1S/5NuJDWb4yKuDrF04v/mWqAorPHxnYluXdW3m1mwDw7NuPngEucDc6ax8Aqg9Ee4ffy9dufK/X1/3QFUQvX2D3fPIn/jqQ4JoLvH9C7MYkNgskatr1vv/pch5WnmGoskABY50vZFAR+z7lKT/U1wuwnBV/h0QHnvI+uB0EEaBfCTAMQ7CCkXWNbcGrbyW1NIDJvF8zsRqmvquADfauwQgAT1IB7dmvAuzR3wKH0twomW8mv6sQL4+pv6ria2GDuAMHVa4AEr4WXC2rzwLwqgpmatDLgSe9XUBqw0C9q2QnyxQvhAwB046x43AqgfQSCE7EuAPynlsLKf9wuBBQSZNTOvbZrORBoUL2gZzJeaME9scHG0w02WgfNl0CuiBn6YLMmjXrf9Rvy+bd8r9wSz4AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<PIL.PngImagePlugin.PngImageFile image mode=P size=96x96 at 0x2577AAFCF08>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Espeon has types: [{'slot': 1, 'type': {'name': 'normal', 'url': 'https://pokeapi.co/api/v2/type/1/'}}, {'slot': 2, 'type': {'name': 'dragon', 'url': 'https://pokeapi.co/api/v2/type/16/'}}]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAGAAAABgBAMAAAAQtmoLAAAAMFBMVEX///8QEBAQUmIpe4tapKRgb1VybVyNVBuRo3y0zaS4t6O9OYPme5zu7u71rgf69VAz0GPSAAAAAXRSTlMAQObYZgAAA+BJREFUeJzt10Fr20gUAGBZtO5VWtiwGAxFEQsLhWUTs5Bj7cGk7NmQ9OTQ7BwEOge2lLLbUpRjSwKeQg9uQLADPveQQ/9AL6ZEC4J3bY899lbtezOSLMmy1F6WPWQITrDfp3nvzWjkGMb1uB7/zTAdx/6WeMdljDlWe2CXT7ucGw5TY6dVdH0IfQCu49nolzbgQ4zxK7HbMkUXYAEgJcBxClqmOPEATk6QQPRVOd1KPiz++fTlEc1z7DhY+ag5p8fJlz8eJ8lngBiWQRA4bjNwfr5MPiZJQlMA/IDir+0mYLLhnbcfk8sUfD9BsbOxalwtXNuh4z5891aDpYHiySbAsfvucIB9+e3dm5NfqeqlYRwGwQbA8YpX7mhwxu6xy/3gGYBP4KbYALqUwiGmJIQ4Y6cEYgALgXhSWzXthivxwvlJBEjEAYKIgHFYD9QEV2Im8Oc0A4sG4BcAvpwfBPiOHyswqwFqAoDJAaVzLs7vK+DJNgC/E5hM7ksN5sYm4KegP8F47M+cgLStVrCECcZDaN0MelKquGYAXL14ljFpBFkJAHM/OrJVaAGsr/QKLAF6R5KK/QYwVcV2FDPMvWYQ95dh+qZi7WDeC0sftQIpp2vAagSOc7v40Y1asFoHiefKsPiJ2wJe09F1ux1kOcUuGznbRbAtxPP1+BzgBDuG2QK6GXi/K1+X88EmjYT4swL60wywEWZUAXsNIGbMLbeIav5bWFUQZV0arAFz9DKeWUcVAJzrknfLoMMNd/QKnvN5GXSyNbjAZ0EJ4FNrbwGhrIKFjn+PSzYsdgmvxAWdHRVg9GhLUAU4BsW29jGawLQCOnhzYdWREoWczL46Lj25ZVSFvUVdDXdZcSeZ7liDUPKqUG2V8kLNMdQCvzjcVbV5slIE18+GWD5In+RDx1GPzzH3U2CVQF8vg7xg5TFW4QuoTqCahPGemuH0aQ7ShKA6AZ4nFB9KKR8MGD598rGleyQrO0MdWVLSC27uIhjb1GwpwyqgdbAJ0RPubJWUqgHB2sLhOqj40N2fnT5dzbEZpFl9x+6JLCnO2RgagMrKXAFsNNdgWQ8oK0MDqkHF8hxYNYCGyfZnKhu9wtFXAKazifJzrRkY7pgfq2wKwGsCP/qli6vRawLV4BSsrXQ2urDQ+3M1Iiqhekvng3t6exbRUUNGqu8hz1HWpHD9Bs3jY7UCUXquLbKia0U3X9wwrd3Lu1S7N/p0bBTjuV4Pqrq2Ctp+iEDq+FhN1lNgXv9vir4p5raulX7Ftt3Dv+y6hDJiW3Q04xclnIwu3OktN0XnA5WtXi19kVZwPa7H/3L8C615p70klIy/AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<PIL.PngImagePlugin.PngImageFile image mode=P size=96x96 at 0x2577AC180C8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Espeon has types: [{'slot': 1, 'type': {'name': 'water', 'url': 'https://pokeapi.co/api/v2/type/11/'}}]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAGAAAABgBAMAAAAQtmoLAAAAJFBMVEUAAAAQEBB7e3uDWgCUWhDetFLmpFL23ov/1Ur/5qT/7r3////nESqMAAAAAXRSTlMAQObYZgAAAZJJREFUeJztlTFOwzAUhh3wAWKVRBVMcAWrCGVqpSjqWhUDIpOl8NQLsLBVKpW5ATlAhJSNgcmX47mmtGLJ84jkr0OX9/X/HdcOY5FIJPJvuMRPoCDCBHGSBgpJ2DxLxBUxgnNWIkkqiEJVCYOU1HmG823rDOI81+atbd/RmBIDxsYnmA2pE4dMGc9mPaME6No+4LRSm7FZkwR78WXMq7W3xhA6cdDWolB/2q85UajtUpoaNVIlFJ5U0d9gpTuiALl87JagFIxJi6hAdv3yXl4DVZB9301ePhZU4bTfgYLG3SAsovDCcx4oLKCc0YTzn0YlaDBbPSxkO6HLARoASIeFRLkARReYUIjAYaiA0IixuUDAQwng/vDs5mdTuuCNEMFQhbk5Mho2fNccBDSacjjkSNi6rQgR3N41YWuoCAJf7fsgOeE5cVjtx7ER5ULO4Rc9XAhJDsbZcCHG5GSxN0hvUbwDlDe0UCRDOMP9wzN3LChGIbLUfU/cSU0pEcy/oItRP5KUhD0Jk5Tfj0QikchfvgEXzNn/mUzI+AAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<PIL.PngImagePlugin.PngImageFile image mode=P size=96x96 at 0x2577ACB4AC8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import io\n",
    "import matplotlib.pyplot as plt\n",
    "import time\n",
    "\n",
    "from IPython.display import display\n",
    "from PIL import Image\n",
    "from requests import session\n",
    "\n",
    "POKEAPI = \"https://pokeapi.co/api/v2/pokemon/{}\"\n",
    "\n",
    "with session() as session:\n",
    "    for pokemon in [196, 780, 54]:\n",
    "        # Ideally we'd check for errors. But eh, this is an example.\n",
    "        poke_data = session.get(POKEAPI.format(pokemon)).json()\n",
    "        \n",
    "        name = poke_data[\"name\"]\n",
    "        sprite_url = poke_data[\"sprites\"][\"front_default\"]\n",
    "        types = poke_data[\"types\"]\n",
    "        \n",
    "        # Lazy formatting because this is an example.\n",
    "        print(f\"Espeon has types: {types}\")\n",
    "        \n",
    "        # Draw sprite\n",
    "        sprite = session.get(sprite_url).content\n",
    "        with Image.open(io.BytesIO(sprite)) as im:\n",
    "            display(im)\n",
    "        \n",
    "        # Backoff to avoid hitting the servers too hard.\n",
    "        time.sleep(30)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cecf7290",
   "metadata": {},
   "source": [
    "A full solution would include error checking, caching the retrieved data, as well as saving the requested information to a file. Regardless, the above is still pretty cool, right?\n",
    "\n",
    "# Battle ship example\n",
    "\n",
    "I wrote a small example combining basically everything we learned plus next week's topic, functions. You may not understand every line of code, but you'll recognize most of the concepts shown and hopefully get the gist of the code as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b56c595",
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "from collections import namedtuple\n",
    "\n",
    "# Constants\n",
    "Y_MAX = 20\n",
    "X_MAX = 20\n",
    "EMPTY_CELL = '🌊'\n",
    "# Player ships\n",
    "PLAYER_ALIVE = '🚢'\n",
    "# Graphic to display for hit ships.\n",
    "PLAYER_DEAD = '💀'\n",
    "# Player bomb that missed enemy ships.\n",
    "BOMB = '💣'\n",
    "# Player bomb that hit an enemy.\n",
    "HIT_ENEMY = '💥'\n",
    "# Laughing cat emoji for enemy misses.\n",
    "ENEMY_MISS = '😹'\n",
    "\n",
    "# AiState = namedtuple(\"AiState\", [\"state\", \"direction\"])\n",
    "Shape = namedtuple(\"Shape\", ['y', 'x'])\n",
    "# Ideally this would be a class and the functions below would be methods.\n",
    "# But, you'll learn functions next week so this is a useful example.\n",
    "BattleShip = namedtuple(\"BattleShip\",\n",
    "                        [\"board\",\n",
    "                         \"size\",\n",
    "                         \"ships\",\n",
    "                         \"ai_state\"])\n",
    "\n",
    "def _create_blank_board(size=Shape(Y_MAX, X_MAX)):\n",
    "    \"\"\"Create a board with y rows and x columns.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    size: Shape\n",
    "        A Shape object consisting of columns, rows.\n",
    "        Must be positive.\n",
    "        \n",
    "    Returns\n",
    "    -------\n",
    "    list[list[str]]\n",
    "        A y by x board filled with EMPTY_CELL.\n",
    "    \"\"\"\n",
    "    # Fail on yucky incorrect inputs. 🤢\n",
    "    assert(size.y > 0 and size.x > 0)\n",
    "    \n",
    "    # This looks way crazier than the earlier comprehensions, right?\n",
    "    # The outer comprehension `[INNER for _y in range(x)] is executing the inner\n",
    "    # comprehension `[0 for _y in range(y)] x amount of times.\n",
    "    # A comprehension is much cleaner than a loop here even if it looks scarier.\n",
    "    return [[EMPTY_CELL for _y in range(size.y)]\n",
    "            for _x in range(size.x)]\n",
    "\n",
    "def _random_coords(board_size):\n",
    "    \"\"\"Return a set of coordinates within the limits of board_size.\n",
    "    \n",
    "    Paramaters\n",
    "    ----------\n",
    "    board_size: Shape\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    Random coordinates within board_size as a Shape.\n",
    "    \"\"\"\n",
    "    return Shape(random.randrange(0, board_size.y), random.randrange(0, board_size.x))\n",
    "\n",
    "def _make_ships(board_size, amount=5):\n",
    "    \"\"\"Create 'amount' of random coordinates within board_size.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    board_size: Shape\n",
    "        Valid coordinates range.\n",
    "    amount: integer\n",
    "        Number of ships to return. Must be > 0.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    List of randomly generated ships.\n",
    "    \"\"\"\n",
    "    # Fail if amount is 0 or negative.\n",
    "    assert(amount > 0)\n",
    "    return [_random_coords(board_size) for _ in range(amount)]\n",
    "\n",
    "def _running(battleship):\n",
    "    \"\"\"Check if both players are alive.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    battleship: BattleShip\n",
    "        Game instance\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    True if both players are alive. False otherwise.\n",
    "    \"\"\"\n",
    "    return battleship.ships[\"player\"] and battleship.ships[\"enemy\"]\n",
    "\n",
    "def new_board(size=Shape(Y_MAX, X_MAX)):\n",
    "    \"\"\"Create a new game instance.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    size: Shape\n",
    "        Size of game board.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    BattleShip instance.\n",
    "    \"\"\"\n",
    "    board = _create_blank_board(size)\n",
    "    ships = {\"player\": _make_ships(size),\n",
    "             \"enemy\": _make_ships(size)}\n",
    "    \n",
    "    for y, x in ships[\"player\"]:\n",
    "        board[y][x] = PLAYER_ALIVE\n",
    "    \n",
    "    return BattleShip(board, size, ships, set())\n",
    "\n",
    "def _display_game(battleship):\n",
    "    \"\"\"Print game instance.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    battleship: BattleShip\n",
    "    \"\"\"\n",
    "    print(f\"You have {len(battleship.ships['player'])} ship(s) remaining.\")\n",
    "    print(f\"The enemy has {len(battleship.ships['enemy'])} ship(s) remaining.\")\n",
    "    \n",
    "    for i, row in enumerate(battleship.board):\n",
    "        end = ''\n",
    "        # Add a space so that columns are aligned if i is a single digit\n",
    "        if i < 10:\n",
    "            end = ' '\n",
    "        # Print column number\n",
    "        print(i, end=end)\n",
    "        \n",
    "        for col in row:\n",
    "            print(col, end='')\n",
    "        print()\n",
    "        \n",
    "def _enemy_turn(battleship):\n",
    "    \"\"\"Basic enemy turn logic.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    battleship: BattleShip\n",
    "    \"\"\"\n",
    "    bomb = _random_coords(battleship.size)\n",
    "    \n",
    "    # ai_state contains already hit coordinates.\n",
    "    # I could use a while loop here to check if each bomb\n",
    "    # is unique, but that seems like a fun exercise for the class instead.\n",
    "    if bomb in battleship.ai_state:\n",
    "        print(\"The enemy's bomb hit a seagull. Poor seagull!\")\n",
    "    elif bomb in battleship.ships[\"player\"]:\n",
    "        print(f\"The enemy hit your ship at {bomb.y}, {bomb.x}!\")\n",
    "        battleship.ships[\"player\"].remove(bomb)\n",
    "        battleship.board[bomb.y][bomb.x] = PLAYER_DEAD\n",
    "    else:\n",
    "        battleship.board[bomb.y][bomb.x] = ENEMY_MISS\n",
    "        \n",
    "    battleship.ai_state.add(bomb)\n",
    "    \n",
    "def run_game(battleship):\n",
    "    while _running(battleship):\n",
    "        _display_game(battleship)\n",
    "        try:\n",
    "            coords = input(\"Where will you shoot your cannon? (y, x): \").split(',')\n",
    "            y = int(coords[0])\n",
    "            x = int(coords[1])\n",
    "            print(f\"Shooting at {y}, {x}.\")\n",
    "            \n",
    "            if (y, x) in battleship.ships[\"enemy\"]:\n",
    "                battleship.board[y][x] = HIT_ENEMY\n",
    "                battleship.ships[\"enemy\"].remove((y, x))\n",
    "            else:\n",
    "                battleship.board[y][x] = BOMB\n",
    "        except (ValueError, IndexError):\n",
    "            # ValueError is raised if a non-integer is provided (i.e. like j, 14).\n",
    "            # IndexError is raised if the provided value is out of bounds.\n",
    "            print(\"Your bomb was a dud! Make sure your coordinates are y, x.\")\n",
    "        finally:\n",
    "            # The enemy should always have a turn even if the player goofed their coordinates.\n",
    "            _enemy_turn(battleship)\n",
    "    \n",
    "    _display_game(battleship)\n",
    "    print(\"Game over!\")\n",
    "\n",
    "battleship_default = new_board()\n",
    "run_game(battleship_default)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf930923",
   "metadata": {},
   "source": [
    "# Questions\n",
    "\n",
    "1. Which of the two code samples is correct and why?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "02c55726",
   "metadata": {},
   "outputs": [],
   "source": [
    "favorite_animal = \"cat\"\n",
    "\n",
    "if favorite_animal == \"cat\":\n",
    "    pass\n",
    "\n",
    "if favorite_animal is \"cat\":\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db99292c",
   "metadata": {},
   "source": [
    "2. What's wrong with the following `while` loop?\n",
    "\n",
    "**Don't run this cell.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8a408473",
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 1\n",
    "\n",
    "while i < 100:\n",
    "    if i % 2 == 0:\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c2c62bb",
   "metadata": {},
   "source": [
    "3. What does the comprehension below do?\n",
    "4. Which of the two loops are idiomatic Python?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b21bd504",
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "numbers = [random.random() for _ in range(100)]\n",
    "\n",
    "# First\n",
    "numbers_sum = 0\n",
    "for number in numbers:\n",
    "    numbers_sum += number\n",
    "print(f\"Mean: {numbers_sum/len(numbers)}\")\n",
    "\n",
    "# Second\n",
    "numbers_sum = 0\n",
    "i = 0\n",
    "while i < len(numbers):\n",
    "    numbers_sum += numbers[i]\n",
    "    i += 1\n",
    "print(f\"Mean: {numbers_sum/len(numbers)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed441589",
   "metadata": {},
   "source": [
    "5. Write a guessing game in Python. This is essentially a much smaller version of Battle Ship, but it still tests a lot of what you know.\n",
    "\n",
    "* Generate a pseudorandom integer using [random](https://docs.python.org/3/library/random.html).\n",
    "* Retrieve a guess with Python using [input()](https://docs.python.org/3/library/functions.html#input). You can just crash if the input isn't an integer.\n",
    "* Print \"too high\" or \"too low\" based on the input.\n",
    "* Stop the loop if the input is correct.\n",
    "\n",
    "[Next: Functions](https://github.com/joshuamegnauth54/data765-intro-python-tutoring/blob/main/notebooks/04-functions.ipynb)"
   ]
  }
 ],
 "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}