01.03b.numbers-and-variables.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ve780Pr1iiGJ"
   },
   "source": [
    "# [Numbers](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex), [Operators](https://www.tutorialspoint.com/python/python_basic_operators.htm), [Variables](https://python-textbok.readthedocs.io/en/1.0/Variables_and_Scope.html#variables), and [Data Types](https://realpython.com/python-data-types/)\n",
    "\n",
    "<hr>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "b24XCbCOA1vo"
   },
   "source": [
    "## Understanding How To Use A Notebook\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "tM4JUYPhA1vq"
   },
   "source": [
    "### <span style=\"color:red\"> ***Click Me*** </span>\n",
    "\n",
    "If you see this cell have a shadow around it, it means that this cell is focused."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "uyuKtwXWA1vt"
   },
   "source": [
    "### <span style=\"color:red\"> ***Double Click Me*** </span>\n",
    "\n",
    "If you see this cell have a shadow around it, that means that this cell is selected for edit.\n",
    "To get out of edit mode, click `shift` and `enter` at the same time.\n",
    "This will run the cell with the edits you made, if you made any at all and shift the focus to the cell below. \n",
    "\n",
    "You can also press `ESC` or `Escape` to switch from edit mode to focus mode. **Note** that you need to run the cell for any markdown style to take effect, do this by clicking `shift` and `enter` at the same time.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "9Mql3fI4A1vw"
   },
   "source": [
    "### <span style=\"color:red\"> ***Click Me Again*** </span>\n",
    "\n",
    "If you see this cell have a shadow around it, that means that this cell is focused. \n",
    "\n",
    "**When the cell is focused you can press keys on the keyboard to help you navigate the notebook cells easier.**\n",
    "\n",
    "**Once A Cell Is Selected You Can Press The Following Keys For Their Respective Actions:**\n",
    "- `up arrow` - shift focus to cell above\n",
    "- `down arrow` - shift focus to cell below\n",
    "\n",
    "\n",
    "- `Enter` - edit cell after cell is selected\n",
    "- `ctrl + Enter` - run **code cell** and keep focus on code cell. **(will not work with markdown cell)**.\n",
    "- `shift + Enter` - runs **any type of cell** and then shifts focus to the cell below.\n",
    "- `ctrl + shift + y` - redo cell action\n",
    "- `ctrl + shift + z` - undo cell action\n",
    "\n",
    "**For the key combinations below press `ctrl + m` first, and then after that click the other letter on the keyboard:**  \n",
    "- `ctrl+m a` - insert cell above the selected cell\n",
    "- `ctrl+m b` - insert cell below the selected cell\n",
    "\n",
    "\n",
    "- `ctrl+m m` - changes the cell type to a markdown cell, which allows you to write notes about code cells\n",
    "- `ctrl+m y` - changes the cell type to a code cell, which allows you to write and execute code.\n",
    "\n",
    "\n",
    "- `ctrl + m d` - will delete the selected cell. If you accidently delete a cell navigate to the *`Edit`* toolbar near the top of the screen and click `Undo Delete Cells`, or you can undo cell action by typing `ctrl + shift + z`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "F8dRDO4eA1vy"
   },
   "source": [
    "<hr>\n",
    "\n",
    "### This Is A ***`Markdown`*** Cell\n",
    "\n",
    "Use markdown cells to write notes about your code and experiments.\n",
    "\n",
    "Once focused click `Enter` to edit the markdown cell, once finished click `Shift` and `Enter` at the same time for the edits to take place.\n",
    "\n",
    "*Code cells look different than mark down cells.*\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "k9iMG7AGA1v3"
   },
   "outputs": [],
   "source": [
    "# This is a code cell"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "MiDOFw9aA1v9",
    "outputId": "25052e2e-010a-460a-bdf3-5d2e3bb94f3f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello!\n"
     ]
    }
   ],
   "source": [
    "# Once focused click `Enter` to edit the code cell\n",
    "\n",
    "print(\"Hello!\") # Press shift and enter to run cell to see output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "yVv5qc8KiiGP"
   },
   "source": [
    "# 1. Basic operators - Python as a Calculator\n",
    "<hr>\n",
    "\n",
    "The most basic operations in `python` are the same as the most basic operations of a calculator.\n",
    "\n",
    "<hr>\n",
    "\n",
    "<img src=\"https://media.giphy.com/media/DHqth0hVQoIzS/giphy.gif\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "W7GVdfBuiiGR"
   },
   "source": [
    "<br>\n",
    "<br>\n",
    "\n",
    "### Addition `+`\n",
    "<hr>\n",
    "\n",
    "Try adding together `numbers` and/or `strings` inside of a jupyter notebook cell\n",
    "<br>\n",
    "Notice how the behavior of `+` changes, depending on the `data type` of the objects being \"added.\"\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "aLDzmkMiiiGS",
    "scrolled": false
   },
   "source": [
    "```python\n",
    "2 + 3\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "WIYgVGzZiiGT",
    "outputId": "c8b19ac6-7c3c-4793-abff-540b56f8543b"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 1,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 + 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "JRkpwDzTiiGY"
   },
   "source": [
    "```python\n",
    "'2' + '3'\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "NX6PdNyfiiGZ",
    "outputId": "4bca2ae1-8fda-4bdd-8261-2eb2661cd051"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'23'"
      ]
     },
     "execution_count": 2,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'2' + '3'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "nujnjOikiiGc"
   },
   "source": [
    "#### Is `Python` like `Javascript`?\n",
    "Will this work? \n",
    "<br>\n",
    "try it out.\n",
    "```python\n",
    "'7' + 7\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "6CRbZdBtiiGc",
    "outputId": "749dbea5-964d-41a3-cd20-0450db44fbba"
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "must be str, not int",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-3-b8880d35ebe2>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;34m'7'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m7\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: must be str, not int"
     ]
    }
   ],
   "source": [
    "'7' + 7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "N4dafLo1iiGh"
   },
   "source": [
    "<br>\n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "BntYVCs8iiGi"
   },
   "source": [
    "### Subtraction `-`\n",
    "<hr>\n",
    "\n",
    "`-` is more straightforward than `+` in `python`, there is no concept of `subtraction` outside of the `numbers`.\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ntJ0mgP1iiGj"
   },
   "source": [
    "```python\n",
    "2 - 3\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "AV9sZWuBiiGk",
    "outputId": "9cee9e51-8178-45dd-cf0d-37f37b2b8732"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 4,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 - 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "dS0AxTAOiiGm"
   },
   "source": [
    "<br>\n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "mdUA4pvCiiGn"
   },
   "source": [
    "### Multiplication `*`\n",
    "<hr>\n",
    "\n",
    "Try multiplying together numbers and/or strings inside of a jupyter notebook cell. \n",
    "<br>\n",
    "Notice how the behavior of `*` changes, depending on the data type of the objects being \"multiplied.\"\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "mZreo_-ViiGo"
   },
   "source": [
    "```python\n",
    "2 * 2\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "se6QnPXdiiGp",
    "outputId": "57cf91d0-1046-4c30-a9c1-fe11094fac84"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 5,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "8uhIhLmKiiGr"
   },
   "source": [
    "```python \n",
    "'2' * 10\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "GEanwzqaiiGs",
    "outputId": "8fb99cce-82ab-4557-f9d4-cc83abda9f85"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2222222222'"
      ]
     },
     "execution_count": 6,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'2' * 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "bidhxAhUiiGx"
   },
   "source": [
    "<br>\n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "evFXlqBOiiGz"
   },
   "source": [
    "### Exponentiation `**`\n",
    "<hr>\n",
    "\n",
    "`**` is more straightforward than `*` in `python`, there is no concept of `Exponentiation` outside of the `numbers`.\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "IZ8S68SBiiG0"
   },
   "source": [
    "```python\n",
    "2 ** 3\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Fpo30qQriiG0",
    "outputId": "9d95ad02-d79e-4ce6-f625-3955618d627c"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1048576"
      ]
     },
     "execution_count": 8,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 ** 20"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Vf9eYjSNiiG3"
   },
   "source": [
    "<br>\n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "DZigf73ciiG3"
   },
   "source": [
    "### Division `/`\n",
    "<hr>\n",
    "\n",
    "We will do a deep dive on division below, as there is much more nuance here, because of the different classes of numbers, `int` and `float`\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "IuPpWgLxiiG4"
   },
   "source": [
    "```python \n",
    "8 / 2\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "jhveSguYiiG5",
    "outputId": "06a13975-e710-4026-9708-1641fc40d237"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0"
      ]
     },
     "execution_count": 9,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "8 / 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "JFQ_tPvViiG8"
   },
   "source": [
    "***\n",
    "<br>\n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "KaNIELXniiG9"
   },
   "source": [
    "# 2. Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "GBLPlDn4iiG9"
   },
   "source": [
    "### \"Declaring\" Variables\n",
    "<hr>\n",
    "\n",
    "We can save some `value`, the result of a `calculation`, or even the output of a `function` to a `variable`. This is particularly important for making your code `concise`, `readable`, and `efficient`.\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "bWjxB6_giiG-"
   },
   "source": [
    "```python\n",
    "a = 7\n",
    "a\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "bzcxPWPoiiG_",
    "outputId": "6bca86f0-f900-4029-c8ae-df6dc69de6ca"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 11,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 7\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "YKbeUSzNiiHE"
   },
   "source": [
    "<br>\n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "4FOyDyoEiiHE"
   },
   "source": [
    "### \"Unpacking\" Variables\n",
    "<hr>\n",
    "\n",
    "We can assign more than 1 variable at a time, in the future we will see how some functions return more than 1 value per function call, we can capture both outputs at once with this method.\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "J8wmXy67iiHF"
   },
   "source": [
    "```python\n",
    "b, c = 2, 3\n",
    "b\n",
    "c\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "XZL14RTTiiHG",
    "outputId": "bbd62092-0bc6-4c23-c359-53093c44480e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 12,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b, c = 2, 3\n",
    "b\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "EagPaYnMiiHI"
   },
   "source": [
    "Notice how when we reference more than 1 variable in a single cell, only the last one will be returned in the `output` cell. \n",
    "<br>\n",
    "The next section provides a solution to this behavior."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "YS0GcBOViiHJ"
   },
   "source": [
    "---\n",
    "<br>\n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "wNE9fYFFiiHL"
   },
   "source": [
    "# 3. Printing to Screen with `Print()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "g55vfV8NiiHM"
   },
   "source": [
    "*First* **Built-in Function** from the Python **Standard Library**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "2QABjikKiiHM"
   },
   "source": [
    "### `Print()` - simple\n",
    "<hr>\n",
    "\n",
    "You can have very simple `print()` statements, with only variables inside of the `()`. or even no values inside the `()` at all, which will just print a blank line.\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "OdX2it8eiiHP"
   },
   "source": [
    "```python\n",
    "print(a)\n",
    "print(b)\n",
    "print()\n",
    "print(a, b)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "n953qvj7iiHS",
    "outputId": "95697243-f984-4953-8b34-a01c0059db6b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "2\n",
      "\n",
      "7 2\n"
     ]
    }
   ],
   "source": [
    "print(a)\n",
    "print(b)\n",
    "print()\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "T5-q-4UXiiHU"
   },
   "source": [
    "<br>\n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "dBsLPWwqiiHW"
   },
   "source": [
    "### `Print()` - complex\n",
    "<hr>\n",
    "\n",
    "You can also combine data types inside of a `print()`, particularly `\"strings of characters\"` which must be within a set of `\"\"` or `''`, we will discuss `strings` further in the next Notebook.\n",
    "\n",
    "This is useful for providing context to a `print()`. You can do things like below, where the `,` gives you a space for free. \n",
    "<br>\n",
    "\n",
    "**`print()` function call:** \n",
    "```python\n",
    "print('Remaining tasks:', task_count)\n",
    "```\n",
    "\n",
    "**output:**\n",
    "<br> \n",
    "<p style='margin-left: 30px;'>Remaining Tasks: 18</p>\n",
    "\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Ygj2f45HiiHZ"
   },
   "source": [
    "```python\n",
    "print(\"a:\", a)\n",
    "print(\"b:\", b)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "v32dxMiUiiHb",
    "outputId": "67260c6f-d318-44fd-a81d-c9a729a3e96b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a: 7\n",
      "b: 2\n"
     ]
    }
   ],
   "source": [
    "print(\"a:\", a)\n",
    "print(\"b:\", b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Xm62RfNniiHe"
   },
   "source": [
    "```python \n",
    "print(\"-----------\")\n",
    "print(\"a:\", a, \"|\", \"b:\", b)\n",
    "print(\"-----------\")\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "yYum7MM6iiHf",
    "outputId": "0fd3b67e-a29f-4dad-da19-3b3c8e97de77"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-----------\n",
      "a: 7 | b: 2\n",
      "-----------\n"
     ]
    }
   ],
   "source": [
    "print(\"-----------\")\n",
    "print(\"a:\", a, \"|\", \"b:\", b)\n",
    "print(\"-----------\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "DBJuz1o4iiHi"
   },
   "source": [
    "<hr>\n",
    "<br>\n",
    "<center><h1 style = 'color:red'>-----------Numbers Exercise (1)-------------</h1></center>\n",
    "<br>\n",
    "<hr>\n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "eRJYrj_KiiHj"
   },
   "source": [
    "# 4. Data Types: `int` vs `float`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "eNPUwtj1iiHj"
   },
   "source": [
    "#### Some more **Built-In Functions**\n",
    "<hr>\n",
    "Data type is important in Data Science, it is important that you know the `Data Type` of whatever variable you're working on, as that will determine the transformations that are avaiable to you. Say adding an element to a list, seperating a string by whitespace, or adding numbers together.\n",
    "\n",
    "Keeping track of data type is especially important when dealing with the output of a function that you imported, particularly when you were not the author of the package where that function originated. An example would be the `.arange()` fucntion from the `numpy` package.\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "BhhdQp-aiiHk"
   },
   "source": [
    "### `type()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "wxHquqhtiiHl"
   },
   "source": [
    "```python\n",
    "print(type(7))\n",
    "print(type(7.0))\n",
    "print(type('value'))\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "mTKmue3oiiHl",
    "outputId": "2023cf73-43d1-42ef-e142-502a62241b40"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "print(type(7))\n",
    "print(type(7.0))\n",
    "print(type('value'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "VHD6tO2KiiHo"
   },
   "source": [
    "<br>\n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "MFRvKmlriiHo"
   },
   "source": [
    "### `int()`\n",
    "**Convert an appropriate datatype to `int`**\n",
    "<br>\n",
    "`7.0 -> int() -> 7`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "PkO27GNZiiHp"
   },
   "source": [
    "```python\n",
    "my_int = int(7.0)\n",
    "\n",
    "print('value:', my_int)\n",
    "print('type:', type(my_int))\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "UTLZ1jM4iiHp",
    "outputId": "f624457d-cd12-43b7-8b41-a9dcde1dd0ab"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "value: 7\n",
      "type: <class 'int'>\n"
     ]
    }
   ],
   "source": [
    "my_int = int(7.0)\n",
    "\n",
    "print('value:', my_int)\n",
    "print('type:', type(my_int))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "7c9amscaiiHr"
   },
   "source": [
    "<br>\n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "XcPH1E9QiiHu"
   },
   "source": [
    "### `float()`\n",
    "\n",
    "**Convert an appropriate datatype to `float`**\n",
    "<br>\n",
    "`7 -> float() -> 7.0`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "AE0Kf4SJiiHv",
    "scrolled": true
   },
   "source": [
    "```python\n",
    "my_float = float(7)\n",
    "\n",
    "print('value:', my_float)\n",
    "print('type:', type(my_float))\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "qfk-8zfciiHw",
    "outputId": "de9250bd-8cb5-4f6e-d243-fc08e148079c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "value: 7.0\n",
      "type: <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "my_float = float(7)\n",
    "\n",
    "print('value:', my_float)\n",
    "print('type:', type(my_float))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "oV9gsxqviiH0"
   },
   "source": [
    "#### Note that division of `int`s (integers) produces a `float`:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "collapsed": true,
    "id": "142Yi872iiH0"
   },
   "source": [
    "```python\n",
    "print(1 / 1)\n",
    "print(6 / 5)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "mVyLtmCziiH1",
    "outputId": "24b68423-06fb-46c7-9c73-f27d5d19fca6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n",
      "1.2\n"
     ]
    }
   ],
   "source": [
    "print(1 / 1)\n",
    "print(6 / 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Ri8ZeuSziiH3"
   },
   "source": [
    "<br>\n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "SMOMUpU4iiH4"
   },
   "source": [
    "### `help()`, Use It OFTEN."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "iecrmKSEiiH4"
   },
   "source": [
    "Jupyter Notebook has built-in documentation lookup, so instead of switching to a new tab with an infinite possibility for distractions, look up the definition of any function, `built-in` or otherwise —directly from a jupyter cell.\n",
    "\n",
    "```python\n",
    "help(some_func)\n",
    "\n",
    "some_func?\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "P87CKaBwiiH5",
    "outputId": "bc1246b1-0e3a-4a6a-c07a-7d4051782f9c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function print in module builtins:\n",
      "\n",
      "print(...)\n",
      "    print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n",
      "    \n",
      "    Prints the values to a stream, or to sys.stdout by default.\n",
      "    Optional keyword arguments:\n",
      "    file:  a file-like object (stream); defaults to the current sys.stdout.\n",
      "    sep:   string inserted between values, default a space.\n",
      "    end:   string appended after the last value, default a newline.\n",
      "    flush: whether to forcibly flush the stream.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(print)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Y5XC52lZjwOL"
   },
   "outputs": [],
   "source": [
    "print?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "n1cdhTUKiiH7"
   },
   "source": [
    "***\n",
    "<br>\n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "DPIOM6ACiiH7"
   },
   "source": [
    "# 5. Deep Dive: Division"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "4k4ok4DXiiH9"
   },
   "source": [
    "### [Float division](https://stackoverflow.com/questions/183853/what-is-the-difference-between-and-when-used-for-division) `/`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "nwDHEydciiH-"
   },
   "source": [
    "```python\n",
    "7 / 3\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "bviinuZqiiH-",
    "outputId": "5f75a864-7bc9-42b9-a9ce-edd373396e2c"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.3333333333333335"
      ]
     },
     "execution_count": 22,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "7 / 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "gT9SuwYiiiIC"
   },
   "source": [
    "<br>\n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "oivhGRXRiiIE"
   },
   "source": [
    "### [Integer division](https://stackoverflow.com/questions/183853/what-is-the-difference-between-and-when-used-for-division) `//`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "srpWDPjPiiIF"
   },
   "source": [
    "```python\n",
    "7 // 3\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "M7MZ-QbmiiIF",
    "outputId": "248ad143-7a18-4035-886d-fdc58e2d4c87"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 23,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "7 // 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "9ga26phniiIH"
   },
   "source": [
    "<br>\n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Zj17G7M5iiII"
   },
   "source": [
    "### [modulus](https://stackoverflow.com/questions/4432208/how-does-work-in-python) \"remainder\" `%`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "RxkC2kVYiiII"
   },
   "source": [
    "```python\n",
    "7 % 3\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "3kqxPZUoiiIJ",
    "outputId": "849e6920-b583-4e1f-f419-eec8d0972c61"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 24,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "7 % 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "__qv-dQRiiIL"
   },
   "source": [
    "<hr>\n",
    "<br>\n",
    "<br>\n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "I7PTieAriiIM"
   },
   "source": [
    "# 7. Operator precedence in calculations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "OmH9OIx5iiIN"
   },
   "source": [
    "[comment]: PEMDAS\n",
    "<img src=\"https://vignette.wikia.nocookie.net/math/images/c/c0/PEMDAS.png/revision/latest?cb=20120220215230&path-prefix=en\"\n",
    "width= \"350px;\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "_HiA9sS6iiIO"
   },
   "source": [
    "### Execution order depends on [PEMDAS](https://www.mathsisfun.com/operation-order-pemdas.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ZNS93oJhiiIO"
   },
   "source": [
    "```python\n",
    "without_parens = 1 + 2**2 * 3 / 6\n",
    "print(without_parens)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "YothDk8BiiIQ",
    "outputId": "71bc6a8b-919e-4079-9d1e-6ac465ea3e19"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.0\n"
     ]
    }
   ],
   "source": [
    "without_parens = 1 + 2**2 * 3 / 6\n",
    "print(without_parens)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "kknnprLMiiIW"
   },
   "source": [
    "<br>\n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "xP6EbaWWiiIW"
   },
   "source": [
    "### Use brackets if you want to EXPLICITLY change the execution order:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "collapsed": true,
    "id": "YleAkYiUiiIX"
   },
   "source": [
    "```python\n",
    "with_parens = (1 + 2**2) * 3 / 6\n",
    "print(with_parens)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Egbd1S8LiiIY",
    "outputId": "b8fdca8c-89db-40cb-e3f0-c504997d71a3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.5\n"
     ]
    }
   ],
   "source": [
    "with_parens = (1 + 2**2) * 3 / 6\n",
    "print(with_parens)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "4xL-lFiOiiIa"
   },
   "source": [
    "<hr>\n",
    "<br>\n",
    "<center><h1 style = 'color:red'>-----------Numbers Exercises (2)(3)-------------</h1></center>\n",
    "<br>\n",
    "<hr>\n",
    "<br>"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [
    "eNPUwtj1iiHj"
   ],
   "name": "01.03b.numbers-and-variables.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}