03-Variables.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "# Variables\n",
    "\n",
    "- Definition\n",
    "- Namespace\n",
    "- Code Style\n",
    "- Variable types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## Vocab\n",
    "\n",
    "- **Variable**: The name given to something in programming that stores some information\n",
    "- **Definition**/**Assignment**/**Declaration**: To create a variable using the assignment operator `=`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Programming With Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Programming: a way to ask computer to store values (variables), and do things with them (operations).`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# This is a comment. You can write a comment by using a `#`\n",
    "my_variable = 12 \n",
    "\n",
    "my_other_variable = 13 # Comments can be 'inline', like this one"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "### Defining Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "<div class=\"alert alert-success\">\n",
    "In programming, variables are things that store values. Variables are defined with <code>name = value</code>.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "my_var = 1  # `my_var` is a variable\n",
    "\n",
    "# This defines another variable\n",
    "other_var = 'variables are cool'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# once you create a variable it's stored in your namespace\n",
    "other_var"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "### Variable Analogy: A Party Cup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![party cup](img/partycup.jpeg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "A cup has a general purpose. \n",
    "\n",
    "It's good for some things (storing things, particularly liquids) and not for others."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "If we were to compare this to programming...imagine a cup at a party:\n",
    "- the party cup would be the variable type\n",
    "- It would be designed to store liquids\n",
    "- When defined, we would specify its contents and write our name on the cup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Things we could do with this variable:\n",
    "- pour more liquid into the same cup\n",
    "- pour another cup with the same liquid\n",
    "- pour another cup with a different liquid\n",
    "- pour liquid between cups (changing both's \"values\")\n",
    "\n",
    "Regardless, this *type* of variable (party cup) has a purpose (store liquids). The *specific liquids* (values) differ between cups. But the operations are all specific to the fact that it is a cup."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "jp-MarkdownHeadingCollapsed": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## Not all equal signs are created equal\n",
    "\n",
    "In mathematics: `=` refers to equality (as a statement of truth).\n",
    "\n",
    "In coding: `=` refers to assignment. `==` refers to equality\n",
    "\n",
    "In your head, when you are reading code like \n",
    "\n",
    "`x=3` \n",
    "\n",
    "you should say it to yourself as:\n",
    "\n",
    "\"we assign the value 3 to the variable x\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Math: What is x?\n",
    "\n",
    "$y = 10x + 2$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Code: What is x?\n",
    "\n",
    "`x = x + 1`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Clicker Question #1\n",
    "\n",
    "After executing the following code, what will be the value of `my_var`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "my_var = 2 \n",
    "\n",
    "my_var = my_var + 1\n",
    "\n",
    "print(my_var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "- A) 2\n",
    "- B) 3\n",
    "- C) \"my_var + 1\"\n",
    "- D) This code will fail"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Clicker Question #2\n",
    "\n",
    "After executing the following code, what will be the value of `diff_var`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "diff_var = my_variabel - my_var\n",
    "\n",
    "print(diff_var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "- A) 4\n",
    "- B) 9\n",
    "- C) \"my_variable - my_var\"\n",
    "- D) This code will fail"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Assignment Notes\n",
    "\n",
    "- In programming `=` means assignment\n",
    "- There can be more than one assignment in a single line\n",
    "- Anything to the right of the `=` is evaluated before assignment\n",
    "    - This process proceeds from right to left"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## Declaring Variables Cheat Sheet\n",
    "\n",
    "- Names are always on the left of the `=`, values are always on the right\n",
    "- Names are case sensitive\n",
    "- Variables must start with letters (or underscores)\n",
    "    - After that, they can include numbers\n",
    "    - They cannot include special characters (like &, *, #, etc)\n",
    "- Python doesn't care what you name your variables\n",
    "    - Humans do care. Pick names that describe the data / value that they store"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Reserved Words\n",
    "\n",
    "There are 33 words that are not allowed to be used for variable assignment in Python 3.6."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "<table type=\"text/css\">\n",
    "  <tr>\n",
    "      <td><code>False</code></td>\n",
    "      <td><code>None</code></td>\n",
    "      <td><code>True</code></td>\n",
    "      <td><code>and</code></td>\n",
    "      <td><code>as</code></td>\n",
    "      <td><code>assert</code></td>\n",
    "      <td><code>break</code></td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "      <td><code>class</code></td>\n",
    "      <td><code>continue</code></td>\n",
    "      <td><code>def</code></td>\n",
    "      <td><code>del</code></td>\n",
    "      <td><code>elif</code></td>\n",
    "      <td><code>else</code></td>\n",
    "      <td><code>except</code></td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "      <td><code>finally</code></td>\n",
    "      <td><code>for</code></td>\n",
    "      <td><code>from</code></td>\n",
    "      <td><code>global</code></td>\n",
    "      <td><code>if</code></td>\n",
    "      <td><code>import</code></td>\n",
    "      <td><code>in</code></td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "      <td><code>is</code></td>\n",
    "      <td><code>lambda</code></td>\n",
    "      <td><code>nonlocal</code></td>\n",
    "      <td><code>not</code></td>\n",
    "      <td><code>or</code></td>\n",
    "      <td><code>pass</code></td>\n",
    "      <td><code>raise</code></td>\n",
    "  </tr>    \n",
    "  <tr>\n",
    "      <td><code>return</code></td>\n",
    "      <td><code>try</code></td>\n",
    "      <td><code>while</code></td>\n",
    "      <td><code>with</code></td>\n",
    "      <td><code>yield</code></td>\n",
    "  </tr>    \n",
    "</table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# you will get an error if you try to assign a variable to one of these words\n",
    "try = 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## Kernels"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "<div class=\"alert alert-success\">\n",
    "The <b>kernel</b> is the thing that executes your code. It is what connects the notebook (as you see it) with the part of your computer that runs code. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "Your kernel also stores your **namespace** - all the variables and code that you have declared (executed). \n",
    "\n",
    "It can be useful to clear and re-launch the kernel. You can do this from the 'kernel' drop down menu, at the top, optionally also clearing all ouputs. Note that this will erase any variables that are stored in memory. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## Namespace"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<div class=\"alert alert-success\">\n",
    "The <b>namespace</b> is the 'place' where all your currently defined code is declared - all the things you have stored in active memory. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "whos?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "editable": true,
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# You can list everything declared in the namespace with '%whos'\n",
    "%whos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## Code Style\n",
    "\n",
    "Code style considerations *do NOT affect the functionality* of your code, but *DO affect readability*.\n",
    "\n",
    "Get in good habits now!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "For variable assignment: \n",
    "- we use a single space around assignment operator `=`\n",
    "- we use **snake_case** for variable names (All lowercase, underscores between words)\n",
    "- use informative variable names...something that tells you a bit about what's being stored"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- Ideal: `my_variable = 6`\n",
    "- Avoid: `MyVariable=6`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## Variable Types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<div class=\"alert alert-success\">\n",
    "Every variable has a <b>type</b>, which refers to the kind of variable that it is, and how the computer stores that data.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Declare a variable\n",
    "variable_name = 1\n",
    "\n",
    "# You can always ask Python 'what type is this variable' using:\n",
    "type(variable_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "### Numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "-"
    },
    "tags": []
   },
   "source": [
    "<div class=\"alert alert-success\">\n",
    "<b>Integers</b> store whole numbers. <b>Floats</b> store signed, decimal-point numbers\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_integer = 1\n",
    "my_float = 2.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# integers and floats can be signed\n",
    "another_int = -4\n",
    "another_float = -2.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# checking the type of a variable\n",
    "type(another_float)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "### String"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "<div class=\"alert alert-success\">\n",
    "<b>Strings</b> store characters, as text. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_string = 'words, words, words'\n",
    "\n",
    "# Note that strings can be defined with either '' or \"\"\n",
    "and_another = \"and some more\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "editable": true,
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(my_string)\n",
    "type(my_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "#### Quotation Marks\n",
    "\n",
    "About those quotation marks..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_string = 'This is a single-quoted string.'\n",
    "my_string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "my_string = \"This is a double-quoted string.\"\n",
    "my_string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "Note that Python will put single quotes around it, even if you specify double quotes. \n",
    "\n",
    "A general principle is to pick something and be consistent. In this course, I'll do my best to only use single quotes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "notes"
    },
    "tags": []
   },
   "source": [
    "#### Aside: What if you want to print a quotation mark?\n",
    "- use double quotes outside with apostraphe inside quotes\n",
    "- use an escape `\\` (backslash) before character"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "notes"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# double quotes on outside; single quote inside\n",
    "my_string = \"i wan't to see a quote.\"\n",
    "my_string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "notes"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# backslash to \"escape\" quotation mark\n",
    "string_quote = \"And she said, \\\"Please teach me Python!\\\"\"\n",
    "string_quote"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "#### Clicker Question #3\n",
    "\n",
    "After executing the following code, what will the type of `var_a` be?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "var_a = -17.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "- A) String\n",
    "- B) Int\n",
    "- C) Float\n",
    "- D) Boolean\n",
    "- E) None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Clicker Question #4\n",
    "\n",
    "After executing the following code, what will the type of `var_b` be?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "var_b = '-17.5'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "- A) String\n",
    "- B) Int\n",
    "- C) Float\n",
    "- D) Boolean\n",
    "- E) None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Boolean"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "-"
    },
    "tags": []
   },
   "source": [
    "<div class=\"alert alert-success\">\n",
    "<b>Booleans</b> store <code>True</code> or <code>False</code>. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_bool = True\n",
    "another_bool = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "type(another_bool)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "<div class=\"alert alert-success\">\n",
    "<code>None</code> is a special type that stores <code>None</code>, used to denote a null or empty value.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "the_concept_of_nothing = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "type(the_concept_of_nothing)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Clicker Question #5\n",
    "\n",
    "After executing the following code, what will the type of the variable `m` be?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "-"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "n = 1\n",
    "a = 'm'\n",
    "m = n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "- A) String\n",
    "- B) Int\n",
    "- C) Float\n",
    "- D) Boolean\n",
    "- E) None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "#### Clicker Question #6\n",
    "\n",
    "After executing the following code, what will the type of the variable `m` be?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "m = 1\n",
    "a = m\n",
    "m = 'a'\n",
    "type(m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "- A) String\n",
    "- B) Int\n",
    "- C) Float\n",
    "- D) Boolean\n",
    "- E) None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "### Mutable vs Immutable\n",
    "\n",
    "The variable types we've talked about today are all **immutable**. This means they cannot be altered after they're created. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "immutable_string = 'COGS18 is the best!'\n",
    "immutable_string[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# cannot change part of the string after creation\n",
    "immutable_string[4] = '0'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Python does have **mutable** types. We'll talk about these later in the course, and these are where aliasing shines!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## Indentation\n",
    "\n",
    "Just a *brief* word on indentation.\n",
    "\n",
    "Python *does* care about whitespace. \n",
    "\n",
    "You will get an error if Python runs into unanticipated whitespace."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a = 1\n",
    "    b = a\n",
    "    \n",
    "    print(b) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "There *are* times when indentation will be required and expected. We'll discuss these in future lectures."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "\n",
    "<center><img src=\"img/doing_it_right.png\" width=\"900px\"></center>\n"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.8"
  },
  "rise": {
   "scroll": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}