01. Learn_Variables_DataTypes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Basics\n",
    "<div class=\"alert alert-block alert-warning\">\n",
    "    <b>Learning outcomes:</b>\n",
    "    <br>\n",
    "    <ul>\n",
    "        <li>Write your first line of code.</li>\n",
    "        <li>Learn and apply the core Python variables, types and operators.</li>\n",
    "        <li>Variables, types and operators in loops and conditions to perform simple tasks.</li>\n",
    "        <li>Capture and respond efficiently to exceptions.</li>\n",
    "        <li>Use sets to extract unique data from lists.</li>\n",
    "    </ul>\n",
    "</div>\n",
    "\n",
    "You will have opened a new notebook in Jupyter Notebook:\n",
    "\n",
    "![Jupyter Notebook](images/jupyter-04.png)\n",
    "\n",
    "Note two things:\n",
    "\n",
    "- The dropdown menu item that says `code`\n",
    "- The layout of the text entry box below that (which starts with `In []:`)\n",
    "\n",
    "This specifies that this block is to be used for code. You can also use it for structured text blocks like this one by selecting `markdown` from the menu list. This tutorial won't teach `markdown`, but you can learn more [here](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).\n",
    "\n",
    "\n",
    "## Welcome to Python World!\n",
    "\n",
    "For now, let's start with \"Welcome to Python World!\".\n",
    "\n",
    "Type the below text into the code block in your notebook and hit `Ctrl-Enter` to execute the code:\n",
    "\n",
    "    print(\"Welcome to Python World!\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to Python World!\n"
     ]
    }
   ],
   "source": [
    "print(\"Welcome to Python World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You just ran your first program. See how Jupyter performs code highlighting for you, changing the colours of the text depending on the nature of the syntax used. `print` is a protected term and gets highlighted in green.\n",
    "\n",
    "This also demonstrates how useful Jupyter Notebook can be. You can treat this just like a document, saving the file, and storing the outputs of your program in the notebook. You could even email this to someone else and, if they have Jupyter Notebook, they could run the notebook and see what you have done.\n",
    "\n",
    "From here on out, we'll simply move through the Python coding tutorial and learn syntax and methods for coding.\n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variables, Booleans and None\n",
    "\n",
    "> ## Variables and Types\n",
    "        Storing and working with data in computer's memory.\n",
    "        Variable is name storage location in computer's memory for holding pieces of information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 100 # Create a Variable called 'a' that points to 1\n",
    "b = 200 # Create a Variable called 'b'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a # get the value that the variable points to"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "200"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b # get the value that the variable points to"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's draw a diagram of these variables.\n",
    "\n",
    "![Jupyter Notebook](images/variables1.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "140711099867040"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "140711099870240"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 200"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "200"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's draw a diagram of these variables.\n",
    "![Jupyter Notebook](images/variables2.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "140711099870240"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "140711099870240"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1\n",
    "b = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "140711099863872"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "140711099863872"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'c' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-19-4117832d7945>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mc\u001b[0m \u001b[1;31m#'c' is not defined\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'c' is not defined"
     ]
    }
   ],
   "source": [
    "c #'c' is not defined"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Variables are simple to understand, but there are a few details that we need to keep in mind:**\n",
    "\n",
    "**1. can be in alphabet with range of a to z**<br>\n",
    "**2. can be in range of A to Z**<br>\n",
    "**3. should not start with digits**<br>\n",
    "**4. should not be keywords**<br>\n",
    "**5. \"!,@,#,%,$\" cannot use special symbols**\n",
    "\n",
    "#Keywords:- break = 2\n",
    "#Identifiers:- is a name given to entities like class, functions, variables\n",
    "\n",
    "\n",
    "###### Valid Variable Name\n",
    "\n",
    "- can be in alphabet with range of a to z or A to Z\n",
    "   - * myVariable\n",
    "   - * myVariable45\n",
    "   - * _myVariable\n",
    "   \n",
    "\n",
    "###### Invalid Variable Name\n",
    "- should not start with digits\n",
    "- should not be keywords\n",
    "- cannot use special symbols !,@,#,$,%\n",
    "   - * 5myVariable\n",
    "   - * !myVariable\n",
    "  \n",
    "     \n",
    "\n",
    "## Keywords:- Not Allowed\n",
    "\n",
    "- global = 5 \n",
    "- break = 3     "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Case sensitive language"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "thing = 1\n",
    "THING = 2\n",
    "thIng = 3\n",
    "thing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "THING"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "thIng"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-2-f3cf1177a9b4>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-2-f3cf1177a9b4>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    if = 100 # Keywords - not allowed\u001b[0m\n\u001b[1;37m       ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "if = 100 # Keywords - not allowed "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23\n",
      "30\n",
      "54 43 42\n",
      "2 4.2 Hello\n",
      "same data same data same data\n"
     ]
    }
   ],
   "source": [
    "#Statements\n",
    "\n",
    "a = 1 #assigngment statement \n",
    "\n",
    "b = a\n",
    "\n",
    "\n",
    "#Multiple Statement\n",
    "a = 1 + 2 +3 + 4 + \\\n",
    "2 + 4 + 3 + 4\n",
    "    \n",
    "print(a)\n",
    "\n",
    "a = (2 + 5 + 3 + 3 +\n",
    "     2 + 5 + 6\n",
    "     + 4)\n",
    "print(a)\n",
    "\n",
    "\n",
    "#Multiple Assigngment statement\n",
    "a = 54; b = 43; c = 42;\n",
    "\n",
    "print(a,b,c)\n",
    "\n",
    "a, b, c = 2, 4.2, \"Hello\"\n",
    "\n",
    "print(a,b,c)\n",
    "\n",
    "a = b = c = \"same data\"\n",
    "\n",
    "print(a,b,c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Types:-"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numbers and more in Python!\n",
    "   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Types of numbers\n",
    "\n",
    "Python has various \"types\" of numbers (numeric literals). Will focus on **integers** and **floating** point numbers.\n",
    "\n",
    "Integers are just whole numbers, positive or negative. For example: 2 and -2 are examples of integers.\n",
    "\n",
    "Floating point numbers in Python are notable because they have a decimal point in them, or use an exponential (e) to define the number. For example 2.0 and -2.1 are examples of floating point numbers. 4E2 (4 times 10 to the power of 2) is also an example of a floating point number in Python.\n",
    "\n",
    "Here is a table of the two main types we will spend most of our time working with some examples:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table>\n",
    "<tr>\n",
    "    <th>Examples</th> \n",
    "    <th>Number \"Type\"</th>\n",
    "</tr>\n",
    "\n",
    "<tr>\n",
    "    <td>10, 20, -50, 1000</td>\n",
    "    <td>Integers</td> \n",
    "</tr>\n",
    "\n",
    "<tr>\n",
    "    <td>5.2, -0.5, 8e2</td> \n",
    "    <td>Floating-point numbers</td> \n",
    "</tr>\n",
    " </table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ## Booleans\n",
    "There are two Boolean values, **True** and **False**. In Python, and in many other programming languages, = is assigning and == is comparing. <br> a = 1 sets a to 1, and a == 1 checks if a equals 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "print(a == 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "a = 2\n",
    "print(a == 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "a == 1 is the same as (a == 1) == True, but a == 1 is more readable, so most of the time we shouldn't write == True anywhere."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "print(a == 1)\n",
    "print((a == 1) == True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "a = 2\n",
    "print(a == 1)\n",
    "print((a == 1) == True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ## None\n",
    "None is Python's \"nothing\" value. It behaves just like any other value, and it's often used as a default value for different kinds of things. Right now it might seem useless but we'll find a bunch of ways to use None later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "a = None\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operators\n",
    "\n",
    "- __Arithmetic Operators__\n",
    "- __Relational Operators or Comparison Operators__\n",
    "- __Logical operators__ \n",
    "- __Bitwise oeprators__ \n",
    "- __Assignment operators__\n",
    "- __Ternary Operator__\n",
    "- __Special operators__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arithmetic Operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "2\n",
      "8\n",
      "2.0\n",
      "2\n",
      "16\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "# + Addition\n",
    "# - Subtraction\n",
    "# * Multiplication\n",
    "# / Division\n",
    "# % Mod (the remainder after dividing)\n",
    "# // Divides and rounds down to the nearest intege \n",
    "# ** Exponentiation or Power Operator (note that ^ does not do this operation, as you might have seen in other languages)\n",
    "\n",
    "a = 4\n",
    "b = 2\n",
    "\n",
    "print(a + b)\n",
    "print(a - b)\n",
    "print(a * b)\n",
    "print(a / b)\n",
    "print(a // b)\n",
    "print(a ** b)\n",
    "print(a % b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Relational Operators or Comparison Operators\n",
    "\n",
    "![Jupyter Notebook](images/comp.jpg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a >  b is -----> False\n",
      "a >= b is -----> False\n",
      "a <  b is -----> True\n",
      "a <= b is -----> True\n",
      "\n",
      "a ==  b is ----> False\n",
      "a !=  b is ----> True\n"
     ]
    }
   ],
   "source": [
    "a = 10\n",
    "b = 20\n",
    "\n",
    "print(\"a >  b is ----->\",  a > b)\n",
    "print(\"a >= b is ----->\", a >= b)\n",
    "print(\"a <  b is ----->\",  a < b)\n",
    "print(\"a <= b is ----->\", a <= b)\n",
    "print()\n",
    "\n",
    "print(\"a ==  b is ---->\", a==b)\n",
    "print(\"a !=  b is ---->\", a!=b)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also combine multiple comparisons. This table assumes that a and b are Booleans.\n",
    "![Jupyter Notebook](images/comp1.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logical operators\n",
    "- We can apply for all types. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# and, or, not\n",
    "\n",
    "# and -> If both arguments are True then only result is True \n",
    "# or  -> If atleast one arugemnt is True then result is True \n",
    "# not -> complement \n",
    "\n",
    "a = 1\n",
    "b = 0\n",
    "\n",
    "print(a and b)\n",
    "\n",
    "print(a or b)\n",
    "\n",
    "print(not b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bitwise Operators\n",
    "- We can apply these operators bitwise.\n",
    "- These operators are applicable only for int and boolean types.\n",
    "- By mistake if we are trying to apply for any other type then we will get Error. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Jupyter Notebook](images/bit.jpg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  &, |, ^, ~, <<, >>\n",
    "\n",
    "#  &  ----- If both bits are 1 then only result is 1 otherwise result is 0\n",
    "#  |  ----- If atleast one bit is 1 then result is 1 otherwise result is 0 \n",
    "#  ^  ----- If  bits are different then only result is 1 otherwise result is 0 \n",
    "#  ~  ----- Bitwise complement operator i.e 1 means 0 and 0 means 1 \n",
    "#  >> ----- Bitwise Left shift Operator (/) ->2\n",
    "#  << ----- Bitwise Right shift Operator (*) ->2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 5\n",
    "b = 1\n",
    "\n",
    "a >> b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Assignment operators\n",
    "\n",
    " - We can use assignment operator to assign value to the variable. Eg:   x = 100   \n",
    " - We can combine asignment operator with some other operator to form compound assignment operator.   \n",
    " - Eg:   x += 10 (or) x = x+10  \n",
    " \n",
    "  - The following is the list of all possible compound assignment operators in Python  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "# +=\n",
    "# -=\n",
    "# *=\n",
    "# /=\n",
    "# %=\n",
    "# //=\n",
    "# **=\n",
    "# &=\n",
    "# |=\n",
    "# ^= "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n",
      "hellohellohello\n",
      "hellohellohelloworld\n"
     ]
    }
   ],
   "source": [
    "a = 5\n",
    "a += 2          # a = a + 2\n",
    "a -= 2          # a = a - 2\n",
    "a *= 2          # a = a * 2\n",
    "a /= 2          # a = a / 2\n",
    "\n",
    "# This is not limited to integers.\n",
    "\n",
    "a = 'hello'\n",
    "print(a)\n",
    "\n",
    "a *= 3\n",
    "print(a)\n",
    "\n",
    "a += 'world'\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b>Summary</b>\n",
    "    <br>\n",
    "    <ul>\n",
    "        <li>Variables have a name and a value. We can create or change variables with name = value.</li>\n",
    "        <li>thing += stuff does the same thing as thing = thing + stuff.</li>\n",
    "        <li>Use lowercase variable names and remember that programmers hate figuring out what x is.</li>\n",
    "        <li>= means assigning and == means comparing.</li>\n",
    "        <li>True and False are Booleans. Comparing values results in a Boolean.</li>\n",
    "        <li>None is a value that we'll find useful later. When error messages say NoneType object they mean None.</li>\n",
    "    </ul>       \n",
    "</div>"
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}