1.01-lesson-python-intro/introduction-to-python3-notebook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"top\"></a>\n",
    "# Introduction to Python 3\n",
    "---\n",
    "\n",
    "## Table of Contents\n",
    "---\n",
    "* [Basic Syntax](#syntax)\n",
    "* [Variables](#variables)\n",
    "* [Data Types](#datatypes)\n",
    "  * [Numbers](#numbers)\n",
    "  * [String](#string)\n",
    "  * [List](#list)\n",
    "  * [Tuple](#tuple)\n",
    "  * [Dictionary](#dictionary)\n",
    "  * [Set](#set)\n",
    "  * [Boolean](#boolean)\n",
    "* [Operators](#operators)\n",
    "  * [Arithmetic](#arithmetic)\n",
    "  * [Comparison](#comparison)\n",
    "  * [Logical](#logical)\n",
    "  * [Truth Tables](#truth)\n",
    "* [Control Flow](#control_flow)\n",
    "  * [Conditionals](#conditionals)\n",
    "  * [Loops](#loops)\n",
    "    * [for loop](#for_loop)\n",
    "    * [List Comprehension](#list_comprehension)\n",
    "    * [while loop](#while_loop)\n",
    "    * [Nested loops](#nested_loops)\n",
    "---\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<a name=\"syntax\"></a>\n",
    "# Python Basic Syntax\n",
    "\n",
    "## Overview\n",
    "\n",
    "Python is an extremely readable and versatile programming language. Written in a relatively straight-forward style with immediate feedback on errors. Python offers simplicity and versatility, in terms of extensibility and supported paradigms.\n",
    "\n",
    "Many scripting and programming languages do not recognize the end of a line of code until it sees the termination character (in these cases, the semicolon). Thus, the actual physical lines of type taken up by the code are irrelevant.\n",
    "\n",
    "Unlike other languages, Python does **not** use an end of line character. Most of the time a simple <kbd>Enter</kbd> will do. Yet, Python is _very_ particular about indentation, spaces and lines in certain cases.\n",
    "\n",
    "It is important to understand how Python interprets:\n",
    "\n",
    "* End of Statement\n",
    "* Names and Capitalization\n",
    "* Comments\n",
    "* Block Structures\n",
    "* Tabs and Spaces\n",
    "\n",
    "For the official very detailed documentation on Python Syntax, see the [Style Guide for Python Code](https://www.python.org/dev/peps/pep-0008/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## End of Statements\n",
    "To end a statement in Python, you do not have to type in a semicolon or other special character; you simply press <kbd>Enter</kbd>. For example,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "message = 'Hello World!'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "this code will generate a syntax error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-29-5678d94a9659>, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-29-5678d94a9659>\"\u001b[0;36m, line \u001b[0;32m2\u001b[0m\n\u001b[0;31m    =\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "message\n",
    "=\n",
    "'Hello World!'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "In general, coding in Python is simplified by the lack of a required statement termination character. To maintain good readability, you are advised to limit the length of any single line of code to 79 characters. How do you break lines that are more than 79 characters?\n",
    "\n",
    "Although you might be tempted to split a statement into multiple lines simply by entering a carriage return, that is not the correction solution. For example, the following code snippet returns a run-time error in Python because a statement was split by using <kbd>Enter</kbd>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "EOL while scanning string literal (<ipython-input-30-e22d189496f1>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-30-e22d189496f1>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    message= 'This message will generate an error because\u001b[0m\n\u001b[0m                                                         ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m EOL while scanning string literal\n"
     ]
    }
   ],
   "source": [
    "message= 'This message will generate an error because\n",
    "  it was split by using the enter button on your\n",
    "  keyboard'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "You cannot split a statement into multiple lines in Python by pressing <kbd>Enter</kbd>. Instead, use the backslash (`\\`) to indicate that a statement is continued on the next line. \n",
    "\n",
    "In the revised version of the script, a blank space and a backslash indicate that the statement that was started on line 1 is continued on line 2. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This backslash acts like enter\n"
     ]
    }
   ],
   "source": [
    "message \\\n",
    "= \\\n",
    "'This \\\n",
    "backslash \\\n",
    "acts \\\n",
    "like \\\n",
    "enter'\n",
    "\n",
    "print(message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Line continuation is automatic when the split comes while a statement is inside parenthesis (` (` ), brackets (` [ `) or braces ( `{` ). This is convenient, but can also lead to errors if there is no closing parenthesis, bracket or brace. Python would interpret the rest of the script as one statement in that case.\n",
    "\n",
    "Python uses single quotes (`‘`) double quotes (`“`) and triple quotes (`“””`) to denote literal strings. Only the triple quoted strings (`“””`) also will automatically continue across the end of line statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "triple\n",
      "quotes\n",
      "will\n",
      "span\n",
      "multiple lines\n",
      "without\n",
      "errors\n"
     ]
    }
   ],
   "source": [
    "message\\\n",
    "=\\\n",
    "'''triple\n",
    "quotes\n",
    "will\n",
    "span\n",
    "multiple lines\n",
    "without\n",
    "errors'''\n",
    "print(message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes, more than one statement may be put on a single line. In Python a semicolon (`;`) can be used to separate multiple statements on the same line. For instance three statements can be written:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "y = 3; x = 5; print(x+y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "To the Python interpreter, this would be the same set of statements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "y = 3\n",
    "x = 5\n",
    "print(x+y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Names and Capitalization\n",
    "In Python names are used as identifiers of functions, classes, variables, etc…. Identifiers must start with a Letter (A-Z) or an underscore (“_”), followed by more letters or numbers.\n",
    "\n",
    "Python does not allow characters such as @, $, and % within identifier names.\n",
    "\n",
    "Python is case sensitive. So “selection” and “Selection” are two different identifiers. \n",
    "* Typically, **class names will begin with capital letters and other identifiers will be all lower case.** \n",
    "* It is also common practice to start private identifiers with an underscore.\n",
    "\n",
    "The body of a variable or procedure name should use mixed case and be as descriptive as necessary. Also, function names should begin with a verb, such as initNameArray or validateLayer.\n",
    "\n",
    "For frequently used or long terms, standard abbreviations are recommended to help keep name length reasonable. In general, variable names greater than 32 characters can be difficult to read. When using abbreviations, make sure they are consistent throughout the entire script. For example, randomly switching between Cnt and Count within a script may lead to confusion."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comments in Python\n",
    "Comments in Pythons are used to leave notes in the code to better explain what is happening. Comments are ignored by the interpreter during compile.\n",
    "\n",
    "Python comments are started with a hash (`#`) sign. The hash sign can be used at the start of a line, followed by a single line comment. This is considered a blank line by the interpreter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# My first comment\n",
    "# this is a second line to this comment\n",
    "# use multiple hash characters to make multiline comments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A hash sign can also be added at the end of a line of code. After the hash sign, add the comment. To Python this is considered an end of statement comment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello, World!\") # the second comment that I make"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember the following points:\n",
    "\n",
    "* Every important variable declaration should include an inline comment describing the use of the variable being declared.\n",
    "* Variables and procedures should be named clearly to ensure that inline comments are only needed for complex implementation details.\n",
    "* At the beginning of your program, you should include an overview that describes the program, enumerating objects, functions, and other system dependencies. Sometimes a piece of pseudocode describing the algorithm can be helpful.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Block Structure\n",
    "\n",
    "Most of the programming languages like C, C++, Java use braces `{ }` to define a block of code. Python does **not** use braces to denote block statement. **Python uses indentation.** Block statements are created using whitespace to the left of the lines within the block. Each following line within the block must have the same amount of white space.\n",
    "\n",
    "\n",
    "A code block (body of a function, loop etc.) starts with indentation and ends with the first unindented line. The amount of indentation is up to you, but it must be consistent throughout that block.\n",
    "\n",
    "A good example is an `if` block:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your answer is True.\n"
     ]
    }
   ],
   "source": [
    "if True:\n",
    "    print(\"Your answer is True.\")\n",
    "else:\n",
    "    print(\"Your answer is False.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, the following block generates an error −"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "unindent does not match any outer indentation level (<ipython-input-38-a0e66153fdd4>, line 6)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-38-a0e66153fdd4>\"\u001b[0;36m, line \u001b[0;32m6\u001b[0m\n\u001b[0;31m    print(\"correct\")\u001b[0m\n\u001b[0m                    ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m unindent does not match any outer indentation level\n"
     ]
    }
   ],
   "source": [
    "if True:\n",
    "    print(\"You are \")\n",
    "    print(\"correct\")\n",
    "else:\n",
    "    print(\"You are not\")\n",
    " print(\"correct\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You are \n",
      "correct\n",
      "Note: This line will always be printed since it is not part of the if... else block.\n"
     ]
    }
   ],
   "source": [
    "if True:\n",
    "    print(\"You are \")\n",
    "    print(\"correct\")\n",
    "else:\n",
    "    print(\"You are not\")\n",
    "print(\"Note: This line will always be printed since it is not part of the if... else block.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You may also see the use of the colon (`:`) in the statements above. The colon is used for compound code statements (suites in Python) such as if and while loops."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tabs and Spaces\n",
    "\n",
    "While Python can interpret both tabs and spaces as whitespace to the left of a statement, it is recommended that spaces are used. \n",
    "* Common practice is to use **4 spaces** to denote an indentation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "---\n",
    "<a name=\"variables\"></a>\n",
    "# Variables\n",
    "\n",
    "This section provides an overview of Python variables.\n",
    "\n",
    "## Overview\n",
    "\n",
    "A variable is a convenient placeholder that refers to a computer memory location where you can store program information that may change during the time your program is running. For example, you might create a variable called `clickCount` to store the number of times a user performs a certain operation.\n",
    "When a variable is stored in memory, the interpreter will allocate a certain amount of space for each variable type. \n",
    "* Where the variable is stored in computer memory is **not** important. \n",
    "* What is important is that you know that a variable has a type, and you refer to a variable by name to see or change its value.\n",
    "* Each variable has its own attributes/properties and methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Declaration\n",
    "\n",
    "In Python, variables are created the first time a value is assigned to them. \n",
    "\n",
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [],
   "source": [
    "number = 10\n",
    "string = \"This is a string\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You declare multiple variables by separating each variable name with a comma. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b = True, False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is the same as the multiple line declaration of:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = True\n",
    "b = False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Naming Restrictions\n",
    "Variable names follow the standard rules for naming anything in Python. A variable name:\n",
    "* Must begin with an alphabetic character (A -Z) or an underscore (_).\n",
    "* Cannot contain a period(`.`), `@`, `$`, or `%`.\n",
    "* Must be unique in the scope in which it is declared.\n",
    "* Python is **case sensitive**. \n",
    "  * So “selection” and “ Selection” are two different variables.\n",
    "* Best practices for all Python naming can be found in the [Style Guide for Python Naming Conventions](https://www.python.org/dev/peps/pep-0008/#naming-conventions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Assigning Values\n",
    "Values are assigned to variables creating an expression as follows: the variable is on the left side of the expression and the value you want to assign to the variable is on the right. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [],
   "source": [
    "B = 200"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same value can be assigned to multiple variables at the same time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = b = c = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And multiple variables can be assigned different values on a single line:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b, c = 1, 2, \"john\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is the same as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1\n",
    "b = 2\n",
    "c = \"john\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Scope & Lifetime\n",
    "\n",
    "### Scope\n",
    "Scope of a variable defines where that variable can be accessed in your code. For instance a global variable can be accessed from anywhere in your code. A local variable can only be accessed within the function it was declared in. Generally a variable’s scope is determined by where you declare it.\n",
    "\n",
    "When you declare a variable within a function, only code within that function can access or change the value of that variable. It has local scope and is a function-level variable. \n",
    "\n",
    "If you declare a variable outside a function, you make it recognizable to all the functions in your script. This is a global variable, and it has global scope.\n",
    "\n",
    "Here are few examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "global_var = True\n",
    "\n",
    "def function_one():\n",
    "    local_var = False\n",
    "    print(global_var)\n",
    "    print(local_var)\n",
    "\n",
    "function_one() # this calls and runs the function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'local_var' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-130-b7e83186d1ed>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mglobal_var\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# this works because global_var is accessible\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlocal_var\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# this gives an error because we are outside function_one\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'local_var' is not defined"
     ]
    }
   ],
   "source": [
    "print(global_var) # this works because global_var is accessible\n",
    "print(local_var)  # this gives an error because we are outside function_one"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is important to be careful when declaring variables. It is easy to create duplicate variable names that do not reference the correct values. \n",
    "\n",
    "For instance, do not declare a global variable this way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Inside the function, the var is Inside\n",
      "Outside the function, the var is Outside\n"
     ]
    }
   ],
   "source": [
    "g_var = 'Outside'\n",
    "\n",
    "def function2():\n",
    "    g_var = 'Inside'\n",
    "    print('Inside the function, the var is', g_var)\n",
    "\n",
    "function2()\n",
    "print('Outside the function, the var is', g_var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The example above will create a Global variable named g_var. When dropping in the function2 function, there will be a second local variable created named g_var with a different value. \n",
    "\n",
    "The proper way to work with a global variable is to be very explicit with the global statement in the local scope:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inside the function var is Inside\n",
      "outside the function var is Inside\n"
     ]
    }
   ],
   "source": [
    "g_var2 = \"Outside\"\n",
    "\n",
    "def function3():\n",
    "    global g_var2 # explicitly declare that the scope of this variable is global\n",
    "    g_var2 = \"Inside\"\n",
    "    print('inside the function var is', g_var2)\n",
    "    return;\n",
    "\n",
    "function3()\n",
    "print('outside the function var is', g_var2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lifetime\n",
    "\n",
    "The lifetime of a variable depends on how long it exists. The lifetime of a global variable extends from the time it is declared until the time the script is finished running. \n",
    "\n",
    "At function level, a variable exists only as long as you are in the function. When the function exits, the variable is destroyed. Local variables are ideal as temporary storage space when a function is executing. You can have local variables of the same name in several different functions because each is recognized only by the function in which it is declared."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<a name=\"datatypes\"></a>\n",
    "# Python Data Types\n",
    "\n",
    "This guide is an overview of Python Data Types.\n",
    "\n",
    "## Overview\n",
    "Python has seven standard Data Types:\n",
    "* [Numbers](#numbers)\n",
    "* [String](#string)\n",
    "* [List](#list)\n",
    "* [Tuple](#tuple)\n",
    "* [Dictionary](#dictionary)\n",
    "* [Set](#set)\n",
    "* [Boolean](#boolean)\n",
    "\n",
    "Python sets the variable type based on the value that is assigned to it. Unlike other languages, Python will change the variable type if the variable value is set to another value. For example:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "var = 123 # This will create a number integer assignment\n",
    "var = 'john' # the `var` variable is now a string type, even though the variable name is not changed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Most of the time Python will do variable conversion automatically. You can also use Python conversion functions [int(), long(), float(), complex()](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex) to convert data from one type to another. \n",
    "\n",
    "In addition, the `type()` method returns information about how your data is stored within a variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "<class 'int'>\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "message = \"Good morning\"\n",
    "num = 85\n",
    "pi = 3.14159\n",
    "\n",
    "print(type(message))  # This will return a string\n",
    "print(type(num))  # This will return an integer\n",
    "print(type(pi))  # This will return a float"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to top](#top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"numbers\"></a>\n",
    "## Numbers\n",
    "Python numbers variables are created by the standard Python method:\n",
    "\n",
    "|Type|Format|Description |\n",
    "|:---|:--- |:---|\n",
    "|int|a = 10 |Signed Integer |\n",
    "|long|a = 345L |(`L`) Long integers, they can also be represented in octal and hexadecimal |\n",
    "|float|a = 45.67 |(`.`) Floating point real values |\n",
    "|complex|a = 3.14J |(`J`) Contains integer in the range 0 to 255 |\t \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to top](#top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"string\"></a>\n",
    "## String\n",
    "Create string variables by enclosing characters in quotes. \n",
    "* Python uses single quotes `'` double quotes `\"` and triple quotes `\"\"\"` to denote literal strings. \n",
    "* Only the triple quoted strings \"\"\" also will automatically continue across the end of line statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a string that will span across multiple lines. \n",
      "Using newline characters\n",
      "and no spaces for the next lines. \n",
      "The end of lines within this string also count as a newline when printed\n"
     ]
    }
   ],
   "source": [
    "firstName = 'john'\n",
    "lastName = \"smith\"\n",
    "message = \"\"\"This is a string that will span across multiple lines. \n",
    "Using newline characters\n",
    "and no spaces for the next lines. \n",
    "The end of lines within this string also count as a newline when printed\"\"\"\n",
    "\n",
    "print(message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings can be accessed as a whole string, or a substring of the complete variable using brackets ‘`[]`’. Here are a couple examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H\n",
      "o\n",
      "yrann\n",
      "tyrann\n",
      "saurus\n"
     ]
    }
   ],
   "source": [
    "var1 = 'Hello World!'\n",
    "var2 = 'tyrannosaurus'\n",
    "\n",
    "print(var1[0]) # this will print the first character in the string an `H`\n",
    "print(var1[4]) # this will print the first character in the string an `o`\n",
    "print(var2[1:6]) # this will print the substring 'yrann`\n",
    "print(var2[:6]) # this will print the substring 'tyrann`\n",
    "print(var2[7:]) # this will print the substring 'saurus`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python can use a special syntax to format multiple strings and numbers. The string formatter is quickly covered here because it is seen often and it is important to recognize the syntax."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The item tyrannosaurus is repeated 3 times\n"
     ]
    }
   ],
   "source": [
    "print(\"The item {} is repeated {} times\".format(var2,y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `{}` are placeholders that are substituted by the variables element and count in the final string. This compact syntax is meant to keep the code more readable and compact.\n",
    "\n",
    "Python is currently transitioning to the format syntax above, but python can use an older syntax, which is being phased out, but is still seen in some example code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The item 5 is repeated 3 times\n"
     ]
    }
   ],
   "source": [
    "print(\"The item %i is repeated %i times\"% (x,y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to top](#top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Concatenation\n",
    "In Python, you can concatenate – or combine - strings. The new string that is created is referred to as a String object.\n",
    "\n",
    "In order to merge two strings into a single object, you may use the “`+`” operator. When writing code, that would look like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi there, john. Welcome to our world.\n"
     ]
    }
   ],
   "source": [
    "print(\"Hi there, \" + firstName + \". Welcome to our world.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One thing to note is that Python cannot concatenate a string and integer. These are considered two separate types of objects. So, if you want to merge the two, you will need to convert the integer to a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "red3\n"
     ]
    }
   ],
   "source": [
    "print(\"red\" + str(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to top](#top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Using String Formatters\n",
    "\n",
    "Python’s `str.format()` method of the string class allows you to do variable substitutions and value formatting. This lets you concatenate elements together within a string through positional formatting.\n",
    "\n",
    "This section will guide you through some of the common uses of formatters in Python, which can help make your code and program more readable and user friendly.\n",
    "\n",
    "Formatters work by putting in one or more replacement fields or placeholders — defined by a pair of curly braces `{}` — into a string and calling the `str.format()` method. You’ll pass into the method the value you want to concatenate with the string. This value will be passed through in the same place that your placeholder is positioned when you run the program.\n",
    "\n",
    "Let’s print out a string that uses a formatter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sammy has 5 balloons.\n"
     ]
    }
   ],
   "source": [
    "print(\"Sammy has {} balloons.\".format(5))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the example above, we constructed a string with a pair of curly braces as a placeholder:`\"Sammy has {} balloons.\"` We then added the `str.format()` method and passed the value of the integer 5 to that method. This places the value of 5 into the string where the curly braces were.\n",
    "\n",
    "We can also assign a variable to be equal to the value of a string that has formatter placeholders:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sammy loves open source.\n"
     ]
    }
   ],
   "source": [
    "open_string = \"Sammy loves {}.\"\n",
    "print(open_string.format(\"open source\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this second example, we concatenated the string \"open source\" with the larger string, replacing the curly braces in the original string.\n",
    "\n",
    "Formatters in Python allow you to use curly braces as placeholders for values that you’ll pass through with the `str.format()` method."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can include more parameters within the curly braces of our syntax. We’ll use the format code syntax `{field_name:conversion}`, where `field_name` specifies the index number of the argument to the `str.format()` method, and `conversion` refers to the conversion code of the data type that you’re using with the formatter.\n",
    "\n",
    "The conversion type refers to the the single-character type code that Python uses. The codes that we’ll be using here are `s` for string, `d` to display decimal integers (10-base), and `f` which we’ll use to display floats with decimal places. You can read more about the [Format-Specification Mini-Language](https://docs.python.org/3.6/library/string.html#format-specification-mini-language) through Python 3’s official documentation.\n",
    "\n",
    "Let’s look at an example where we have an integer passed through the method, but want to display it as a float by adding the `f` conversion type argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sammy ate 75.000000 percent of a pizza!\n"
     ]
    }
   ],
   "source": [
    "print(\"Sammy ate {0:f} percent of a {1}!\".format(75, \"pizza\"))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We used the syntax of `{field_name:conversion}` for the first curly brace replacement field to output a float. The second curly braces only uses the first parameter `{field_name}`.\n",
    "\n",
    "In the example above, there are a lot of numbers displaying after the decimal point, but you can limit those. When you are specifying f for float values, you can additionally specify the precision of that value by including a full stop . followed by the number of digits after the decimal you would like to include.\n",
    "\n",
    "If Sammy ate 75.765367% of the pizza, but we don’t need to have a high level of accuracy, we can limit the places after the decimal to 3 by adding .3 before the conversion type f:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sammy ate 75.765 percent of a pizza!\n"
     ]
    }
   ],
   "source": [
    "print(\"Sammy ate {0:.3f} percent of a pizza!\".format(75.765367))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we just want one decimal place, we can rewrite the string and method like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sammy ate 75.8 percent of a pizza!\n"
     ]
    }
   ],
   "source": [
    "print(\"Sammy ate {0:.1f} percent of a pizza!\".format(75.765367))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that modifying precision will cause the number to be rounded. If you would like no decimal places to be shown, you can write your formatter like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sammy ate 76 percent of a pizza!\n"
     ]
    }
   ],
   "source": [
    "print(\"Sammy ate {0:.0f} percent of a pizza!\".format(75.765367))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This will not convert your float to an integer, but instead limit the number of places shown after the decimal point.\n",
    "\n",
    "Because the placeholders are replacement fields, you can **pad** or create space around an element by increasing field size through additional parameters. This can be useful when we need to organize a lot of data visually.\n",
    "\n",
    "We can add a number to indicate field size (in terms of characters) after the colon : in the curly braces of our syntax:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sammy has    5 red balloons        !\n"
     ]
    }
   ],
   "source": [
    "print(\"Sammy has {0:4} red {1:16}!\".format(5, \"balloons\"))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the example above, we gave the number `5` a character field size of 4, and the string `balloon`s a character field size of `16` (because it is a long string).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Formatters can be seen in their best light when they are being used to organize a lot of data in a visual way. If we are showing databases to users, using formatters to increase field size and modify alignment can make your output more readable.\n",
    "\n",
    "We can specify a consistent field size number in order to have even columns, making sure that we accommodate the larger numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     3      9     27\n",
      "     4     16     64\n",
      "     5     25    125\n",
      "     6     36    216\n",
      "     7     49    343\n",
      "     8     64    512\n",
      "     9     81    729\n",
      "    10    100   1000\n",
      "    11    121   1331\n",
      "    12    144   1728\n"
     ]
    }
   ],
   "source": [
    "for i in range(3,13):\n",
    "    print(\"{:6d} {:6d} {:6d}\".format(i, i*i, i*i*i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See below for the non-formatted version:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 9 27\n",
      "4 16 64\n",
      "5 25 125\n",
      "6 36 216\n",
      "7 49 343\n",
      "8 64 512\n",
      "9 81 729\n",
      "10 100 1000\n",
      "11 121 1331\n",
      "12 144 1728\n"
     ]
    }
   ],
   "source": [
    "for i in range(3,13):\n",
    "    print(i, i*i, i*i*i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to top](#top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"slice_string\"></a>\n",
    "### Slicing Strings\n",
    "\n",
    "We can also call out a range of characters from the string. Say we would like to just print the word `Shark` from the phrase `Sammy Shark!`. We can do so by creating a slice, which is a sequence of characters within an original string. With slices, we can call multiple character values by creating a range of index numbers separated by a colon `[x:y]`:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shark\n"
     ]
    }
   ],
   "source": [
    "ss = \"Sammy Shark!\"\n",
    "\n",
    "print(ss[6:11])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When constructing a slice, as in `[6:11]`, the first index number is where the slice starts (inclusive), and the second index number is where the slice ends (**exclusive**), which is why in our example above the range has to be the index number that would occur just after the string ends.\n",
    "\n",
    "When slicing strings, we are creating a substring, which is essentially a string that exists within another string. When we call `ss[6:11]`, we are calling the substring `Shark` that exists within the string `Sammy Shark!`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want to include either end of a string, we can omit one of the numbers in the string[n:n] syntax. For example, if we want to print the first word of string ss — “Sammy” — we can do so by typing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sammy\n"
     ]
    }
   ],
   "source": [
    "print(ss[:5])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We did this by omitting the index number before the colon in the slice syntax, and only including the index number after the colon, which refers to the end of the substring.\n",
    "\n",
    "To print a substring that starts in the middle of a string and prints to the end, we can do so by including only the index number before the colon, like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hark!\n"
     ]
    }
   ],
   "source": [
    "print(ss[7:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Methods\n",
    "\n",
    "Python has quite a few methods that String objects can call to perform frequently occurring task (related to string). \n",
    "* For example, if you want to capitalize the first letter of a string, you can use `capitalize()` method.\n",
    "* For a list of String Methods, please refer to https://www.w3schools.com/python/python_ref_string.asp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to top](#top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"list\"></a>\n",
    "## List\n",
    "Lists are a very useful variable type in Python. A list can contain a collection of values. List variables are declared by using brackets `[ ]` following the variable name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = [] # This is a blank list variable\n",
    "B = [1, 23, 45, 67] # this list creates an initial list of 4 numbers.\n",
    "C = [2, 4, 'john'] # lists can contain different variable types."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All lists in Python are zero-based indexed. \n",
    "* When referencing a member or the length of a list, the number of list elements is always the number shown plus one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "Lazy Dog\n",
      "['Brown Fox', 'Lazy Dog']\n"
     ]
    }
   ],
   "source": [
    "mylist = ['Brown Fox', 'Lazy Dog', 'Flamingo', 'Hippo']\n",
    "B = len(mylist) # This will return the length of the list which is 3. The index is 0, 1, 2, 3.\n",
    "print(B)\n",
    "\n",
    "print(mylist[1]) # This will return the value at index 1, which is 'Lazy Dog'\n",
    "print(mylist[0:2]) # This will return the first 2 elements in the list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can assign data to a specific element of the list using an index into the list. The list index starts at zero. Data can be assigned to the elements of an array as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lazy Dog\n"
     ]
    }
   ],
   "source": [
    "mylist = [0, 1, 2, 3]\n",
    "mylist[0] = 'Brown Fox'\n",
    "mylist[1] = 'Lazy Dog'\n",
    "mylist[2] = 'Flamingo'\n",
    "mylist[3] = 'Hippo'\n",
    "\n",
    "print(mylist[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists aren’t limited to a single dimension. Although most people can’t comprehend more than three or four dimensions. You can declare multiple dimensions by separating an with commas. In the following example, the MyTable variable is a two-dimensional array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Brown\n",
      "Fox\n",
      "Lazy\n",
      "Dog\n",
      "---\n",
      "['Brown', 'Fox']\n",
      "['Lazy', 'Dog']\n",
      "3.5\n"
     ]
    }
   ],
   "source": [
    "MyTable = [[\"Brown\",\"Fox\"], [\"Lazy\",\"Dog\"],1.4,2,3.5]\n",
    "\n",
    "print(MyTable[0][0])\n",
    "print(MyTable[0][1])\n",
    "print(MyTable[1][0])\n",
    "print(MyTable[1][1])\n",
    "print(\"---\")\n",
    "print(MyTable[0])\n",
    "print(MyTable[1])\n",
    "print(MyTable[4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In a two-dimensional array, the first number is always the number of rows; the second number is the number of columns."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to top](#top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Methods\n",
    "\n",
    "Python has some list methods that you can use to perform frequency occurring task (related to list) with ease. \n",
    "* For example, if you want to add new item to the end of a list, you can use `append()` method.\n",
    "* For a list of List Methods, please refer to https://www.w3schools.com/python/python_ref_list.asp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to top](#top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"tuple\"></a>\n",
    "## Tuple\n",
    "Tuples are a group of values like a list and are manipulated in similar ways. But, tuples are fixed in size once they are assigned. In Python the fixed size is considered **immutable** as compared to a list that is dynamic and mutable. Tuples are defined by parenthesis `()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "myGroup = ('Brown Fox', 'Lazy Dog', 'Flamingo', 'Hippo')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here are some advantages of tuples over lists:\n",
    "\n",
    "* Tuples have no append or extend method.\n",
    "* Elements cannot be removed from a tuple.\n",
    "* You can find elements in a tuple, since this doesn’t change the tuple.\n",
    "* You can also use the `in` operator to check if an element exists in the tuple.\n",
    "* Tuples are faster than lists. If you’re defining a constant set of values and all you’re ever going to do with it is iterate through it, use a tuple instead of a list.\n",
    "* It makes your code safer if you “write-protect” data that does not need to be changed.\n",
    "\n",
    "It seems tuples are very restrictive, so why are they useful? \n",
    "* There are many data structures that require a fixed set of values. For instance a particular point in 3D space is a list of 3 numbers [34.5, 45.7, 0]. If this is set as tuple, then you can be assured the original 3 number structure stays as a point (34.5, 45.7, 0)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "Lazy Dog\n"
     ]
    }
   ],
   "source": [
    "print('Brown Fox' in myGroup) # test to see if 'Brown Fox' is in the tuple. This returns True.\n",
    "\n",
    "print(myGroup[1]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lazy\n",
      "3.5\n"
     ]
    }
   ],
   "source": [
    "MyTable_tuple = ([\"Brown\",\"Fox\"], [\"Lazy\",\"Dog\"],1.4,2,3.5) \n",
    "\n",
    "print(MyTable_tuple[1][0])\n",
    "print(MyTable_tuple[4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to top](#top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuple Methods\n",
    "\n",
    "Python has two built-in methods that you can use on tuples.\n",
    "\n",
    "* `count()` Returns the number of times a specified value occurs in a tuple\n",
    "* `index()`\tSearches the tuple for a specified value and returns the position of where it was found"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "thistuple = (1, 3, 7, 8, 7, 5, 4, 6, 8, 5)\n",
    "\n",
    "x = thistuple.count(5) #Return the number of times the value 5 appears in the tuple.\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 264,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "thistuple = (1, 3, 7, 8, 7, 5, 4, 6, 8, 5)\n",
    "\n",
    "x = thistuple.index(8)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to top](#top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"dictionary\"></a>\n",
    "## Dictionary\n",
    "Dictionaries in Python are lists of `Key`:`Value` pairs. \n",
    "* This is a very powerful datatype to hold a lot of related information that can be associated through keys. The main operation of a dictionary is to extract a value based on the key name. Unlike lists, where index numbers are used, dictionaries allow the use of a key to access its members. The keys behave in a way similar to indices in a list, except that list indices are numeric and keys are arbitrary strings. \n",
    "* Each key in a single Dictionary object must be unique. \n",
    "* Dictionaries can also be used to sort, iterate and compare data.\n",
    "\n",
    "Note that dictionaries are **unordered** - since the values in the dictionary are indexed by keys, they are not held in any particular order, unlike a list, where each item can be located by its position in the list.\n",
    "\n",
    "When do we use Dictionaries?\n",
    "* Dictionaries are used when some items need to be stored and recovered by name. For example, a dictionary can hold all of the environment variables defined by the system or all the values associated with a registry key.\n",
    "\n",
    "Dictionaries are created by using braces (`{}`) with pairs separated by a comma (`,`) and the key values associated with a colon(`:`). \n",
    "\n",
    "Here is a quick example on how dictionaries might be used:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating Dictionaries\n",
    "To create an empty dictionary, use a pair of braces `{}`\n",
    "\n",
    "`room_empty = {}`\n",
    "\n",
    "To construct an instance of a dictionary object with key:item pairs filled in, use one of the following methods.\n",
    "\n",
    "The dictionary room_num is created and filled in with each key:value pair, rather than as an empty dictionary. The key is a string or number, in the example below it is a person’s name, followed be a colon : as a separator from the associated value which can be any datatype, in this case an integer. Commas , seperate different key:value pairs in the dictionary:\n",
    "\n",
    "`room_num = {'john': 425, 'tom': 212, 'sally':325}`\n",
    "\n",
    "This dictionary is created from a list of tuples using the dict key word:\n",
    "\n",
    "`room_num1 = dict([('john', 425), ('tom', 212), ('sally', 325)])`\n",
    "\n",
    "The `dict` keyword can be used in other ways to construct dictionaries.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "212\n",
      "dict_keys(['john', 'tom', 'isaac'])\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "room_num = {'john': 425, 'tom': 212}\n",
    "room_num['john'] = 645  # set the value associated with the 'john' key to 645\n",
    "\n",
    "print (room_num['tom']) # print the value of the 'tom' key.\n",
    "\n",
    "room_num['isaac'] = 345 # Add a new key 'isaac' with the associated value\n",
    "\n",
    "print(room_num.keys()) # print out a list of keys in the dictionary\n",
    "print('isaac' in room_num) # test to see if 'issac' is in the dictionary.  This returns True."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding new items to a Dictionary\n",
    "To add a value to a Dictionary, specify the new key and set a value. Below, the code creates the dictionary `room_num` with two key:value pairs for John and Liz, then adds a third one for Isaac:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'John': 425, 'Liz': 212, 'Isaac': 345}\n"
     ]
    }
   ],
   "source": [
    "room_num = {'John': 425, 'Liz': 212}\n",
    "room_num['Isaac'] = 345\n",
    "print(room_num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Removing items from a Dictionary\n",
    "To remove a value from a dictionary, use the del method and specify the key to remove:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'John': 425, 'Liz': 212}\n"
     ]
    }
   ],
   "source": [
    "room_num = {'John': 425, 'Liz': 212, 'Isaac': 345}\n",
    "del room_num['Isaac']\n",
    "print(room_num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Counting Items in the Dictionary\n",
    "Use the `len()` property to obtain a count of the number of key:value pairs in the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "room_num = {'John': 425, 'Liz': 212, 'Isaac': 345}\n",
    "print(len(room_num))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get Values for Key\n",
    "The in syntax returns True if the specified key exists within the dictionary. For example you may want to know if Tom is included in a dictionary, in this case False:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Is Tom in the dictionary? False\n"
     ]
    }
   ],
   "source": [
    "room_num = {'John': 425, 'Liz': 212, 'Isaac': 345}\n",
    "var1 = 'Tom' in room_num\n",
    "print(\"Is Tom in the dictionary? \" + str(var1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or you may want to know if an Isaac is `not in` the dictionary. Below the answer will be also be False:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Is Isaac not in room_num? False\n"
     ]
    }
   ],
   "source": [
    "room_num = {'John': 425, 'Liz': 212, 'Isaac': 345}\n",
    "var1 = 'Isaac' not in room_num\n",
    "print(\"Is Isaac not in room_num? \" + str(var1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use the variable name and the key value in brackets `[]` to get the value associated with the key."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Isaac is in room number 345\n"
     ]
    }
   ],
   "source": [
    "room_num = {'John': 425, 'Liz': 212, 'Isaac': 345}\n",
    "var1 = room_num['Isaac']\n",
    "print(\"Isaac is in room number \" + str(var1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `.keys()` and `.values()` methods return an array containing all the keys or values from the dictionary. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['john', 'tom'])\n",
      "dict_values([425, 212])\n"
     ]
    }
   ],
   "source": [
    "room_num = {'john': 425, 'tom': 212}\n",
    "print(room_num.keys())\n",
    "print(room_num.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Looping through Dictionaries\n",
    "Dictionaries can be used to control loops. In addition both the keys and values can be extracted at the same time using the `.items()` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "John is in room 425\n",
      "Liz is in room 212\n",
      "Isaac is in room 345\n"
     ]
    }
   ],
   "source": [
    "room_num = {'John': 425, 'Liz': 212, 'Isaac': 345}\n",
    "\n",
    "for k, v in room_num.items():\n",
    "    print(k + ' is in room ' + str(v))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sorting Dictionaries\n",
    "On occasion, it may be important to sort your dictionary. Dictionaries and be sorted by key name or by values\n",
    "\n",
    "To sort a dictionary by key using the following `sorted()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Liz is in room 212\n",
      "John is in room 425\n",
      "Isaac is in room 345\n"
     ]
    }
   ],
   "source": [
    "room_num = {'John': 425, 'Liz': 212, 'Isaac': 345}\n",
    "\n",
    "for k, v in sorted(room_num.items(),reverse=True):\n",
    "    print(k + ' is in room ' + str(v))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Isaac', 'John', 'Liz']\n"
     ]
    }
   ],
   "source": [
    "room_num = {'John': 425, 'Liz': 212, 'Isaac': 345}\n",
    "print(sorted(room_num))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To sort by values use the `sorted()` method along with the `.values()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[212, 345, 425]\n"
     ]
    }
   ],
   "source": [
    "room_num = {'john': 425, 'tom': 212, 'isaac': 345}\n",
    "print(sorted(room_num.values()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also go through the dictionary backwards based on the keys by using the `sorted(, reverse=True)` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Liz is in room 212\n",
      "John is in room 425\n",
      "Isaac is in room 345\n"
     ]
    }
   ],
   "source": [
    "room_num = {'John': 425, 'Liz': 212, 'Isaac': 345}\n",
    "for k, v in sorted(room_num.items(),reverse=True):\n",
    "    print(k + ' is in room ' + str(v))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Dictionary object is not there to replace list iteration, but there are times when it makes more sense to index your array using English-like terms as opposed to numerical values. It can be much faster to locate an object in a dictionary than in a list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionary Methods\n",
    "\n",
    "Python has some methods that dictionary objects can call. \n",
    "* For example, dict1.clear() method removes all items from the dictionary dict1.\n",
    "* For a list of Dictionary Methods, please refer to https://www.w3schools.com/python/python_ref_dictionary.asp "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to top](#top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"set\"></a>\n",
    "## Set\n",
    "\n",
    "Python’s built-in set type has the following characteristics:\n",
    "* Sets are unordered.\n",
    "* Set elements are unique. Duplicate elements are not allowed.\n",
    "\n",
    "A set itself may be modified, but the elements contained in the set must be of an immutable type.\n",
    "Let’s see what all that means, and how you can work with sets in Python.\n",
    "\n",
    "A set can be created in two ways. First, you can define a set with the built-in set() function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'qux', 'bar', 'foo', 'baz'}\n"
     ]
    }
   ],
   "source": [
    "x = set(['foo', 'bar', 'baz', 'foo', 'qux'])\n",
    "print(x)\n",
    "# pay attention to foo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings are also iterable, so a string can be passed to set() as well. `set(s)` generates a set of the characters in s:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'q', 'u', 'x'}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = 'quux'\n",
    "set(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternately, a set can be defined with curly braces `{}`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'q', 'u', 'x'}\n"
     ]
    }
   ],
   "source": [
    "t = {'q', 'u', 'u', 'x'}\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A set can be empty. However, recall that Python interprets empty curly braces `{}` as an empty dictionary, so the only way to define an empty set is with the `set()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "set"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "empty1 = set()\n",
    "type(empty1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "empty_dictionary = {}\n",
    "type(empty_dictionary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The elements in a set can be objects of different types:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{42, 3.14159, 'foo', None}\n"
     ]
    }
   ],
   "source": [
    "variety = {42, 'foo', 3.14159, None}\n",
    "print(variety)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Don’t forget that elements of a set must be immutable. For example, a tuple may be included in a set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{42, 3.14159, 'foo', (1, 2, 3)}\n"
     ]
    }
   ],
   "source": [
    "okay = {42, 'foo', (1, 2, 3), 3.14159}\n",
    "print(okay)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But lists and dictionaries are mutable, so they *cannot* be set elements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unhashable type: 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-22-1559abcbd6bb>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0;34m{\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unhashable type: 'list'"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "{a}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unhashable type: 'dict'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-23-3a8f5e1b059c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0md\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m'a'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'b'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0;34m{\u001b[0m\u001b[0md\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unhashable type: 'dict'"
     ]
    }
   ],
   "source": [
    "d = {'a': 1, 'b': 2}\n",
    "{d}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to top](#top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"boolean\"></a>\n",
    "## Boolean\n",
    "\n",
    "The Boolean data type can be one of two values, either True or False. Booleans are used to represent the truth values that are associated with the logic branch of mathematics, which informs algorithms in computer science.\n",
    "\n",
    "Whenever you see the data type Boolean, it will start with a capitalized B because it is named for the mathematician George Boole. The values True and False will also always be with a capital T and F respectively, as they are special values in Python.\n",
    "\n",
    "Many operations in math give us answers that evaluate to either True or False.\n",
    "\n",
    "Like with numbers, we can store a Boolean value in a variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_bool = 5 > 8\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can then print the Boolean value with a call to the `print()` function:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(my_bool)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since 5 is not greater than 8, we will receive the following output: `False`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings can also be used with Boolean operators. They are case-sensitive."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sammy == sammy:  False\n",
      "Sammy == also_Sammy: True\n"
     ]
    }
   ],
   "source": [
    "Sammy = \"Sammy\"\n",
    "sammy = \"sammy\"\n",
    "also_Sammy = \"Sammy\"\n",
    "\n",
    "print(\"Sammy == sammy: \", Sammy == sammy)\n",
    "print(\"Sammy == also_Sammy:\", Sammy == also_Sammy)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also evaluate Boolean values with comparison operators:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "t != f:  True\n"
     ]
    }
   ],
   "source": [
    "t = True\n",
    "f = False\n",
    "\n",
    "print(\"t != f: \", t != f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to top](#top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<a name=\"operators\"></a>\n",
    "# Python Operators\n",
    "\n",
    "This guide discusses Python operators.\n",
    "\n",
    "## Overview\n",
    "Python has a full range of operators, including arithmetic operators, comparison operators, concatenation operators, and logical operators.\n",
    "\n",
    "## Operator Precedence\n",
    "* When several operations occur in an expression, each part is evaluated and resolved in a predetermined order called operator precedence. You can use parentheses to override the order of precedence and force some parts of an expression to be evaluated before others. Operations within parentheses are always performed before those outside. Within parentheses, however, standard operator precedence is maintained.\n",
    "\n",
    "* When expressions contain operators from more than one category, arithmetic operators are evaluated first, comparison operators are evaluated next, and logical operators are evaluated last. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14\n",
      "18\n",
      "14\n"
     ]
    }
   ],
   "source": [
    "x = 4 + 5 * 2\n",
    "print(x)\n",
    "\n",
    "x = (4 + 5) * 2        # wrong precedence\n",
    "print(x)\n",
    "\n",
    "x = 4 + (5 * 2)        # correct precedence\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to top](#top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"arithmetic\"></a>\n",
    "### Arithmetic\n",
    "Arithmetic operators are evaluated in the following order of precedence.\n",
    "\n",
    "|Description|Symbol|\n",
    "|-|-|\n",
    "|Exponentiation|`**`|\n",
    "|Unary negation|`-`|\n",
    "|Multiplication|`*`|\n",
    "|Division|`/`|\n",
    "|Modulus arithmetic|`%`|\n",
    "|Addition|`+`|\n",
    "|Subtraction|`-`|\n",
    "|String concatenation|`&`|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 256,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.3142577469661592\n"
     ]
    }
   ],
   "source": [
    "y = (math.sqrt(x ** 2 + (x - 1)) / (x - 3))   +   abs((2 * x) / (x ** (0.5 * x)))\n",
    "\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usually, one of the best things to do when lines of code are getting out of hand, is to break them up into smaller pieces. The equation becomes far more readable when spread out over multiple lines of code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.3142577469661592\n"
     ]
    }
   ],
   "source": [
    "A = x**2 + (x-1)\n",
    "B = x-3\n",
    "C = 2*x\n",
    "D = x**(0.5* x)\n",
    "y = (math.sqrt(A) / B) + abs(C / D)\n",
    "\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to top](#top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"comparison\"></a>\n",
    "### Comparison\n",
    "Comparison operators all have equal precedence; that is, they are evaluated in the left-to-right order in which they appear. \n",
    "\n",
    "|Description|Symbol|\n",
    "|-|-|\n",
    "|Less than|<|\n",
    "|Greater than|>|\n",
    "|Less than or equal to|<=|\n",
    "|Greater than or equal to|>=|\n",
    "|Equality|==|\n",
    "|Inequality|!=|\n",
    "|Object equivalence|is|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x == y: False\n",
      "x != y: True\n",
      "x < y: True\n",
      "x > y: False\n",
      "x <= y: True\n",
      "x >= y: False\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "y = 8\n",
    "\n",
    "print(\"x == y:\", x == y)\n",
    "print(\"x != y:\", x != y)\n",
    "print(\"x < y:\", x < y)\n",
    "print(\"x > y:\", x > y)\n",
    "print(\"x <= y:\", x <= y)\n",
    "print(\"x >= y:\", x >= y)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note the difference between the two operators = and ==.\n",
    "\n",
    "* `x = y `  # Sets x equal to y\n",
    "* `x == y`  # Evaluates whether x is equal to y\n",
    "\n",
    "The first, `=` is the assignment operator, which will set one value equal to another. The second, `==` is a comparison operator which will evaluate whether two values are equal."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to top](#top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"logical\"></a>\n",
    "### Logical\n",
    "Logical operators are evaluated in the following order of precedence.\n",
    "\n",
    "|Description|Symbol|\n",
    "|-|-|\n",
    "|Logical negation|not|\n",
    "|Logical conjunction|and|\n",
    "|Logical disjunction|or|\n",
    "|Logical exclusion|xor|\n",
    "|Logical equivalence|eqv|\n",
    "|Logical implication|imp|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 260,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Condition 1 met\n",
      "Condition 3 met\n"
     ]
    }
   ],
   "source": [
    "if 1 < 2 and 4 > 2:\n",
    "    print(\"Condition 1 met\")\n",
    "\n",
    "if 1 > 2 and 4 < 10:\n",
    "    print(\"Condition 2 not met\")\n",
    "\n",
    "if 4 < 10 or 1 < 2:\n",
    "    print(\"Condition 3 met\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 261,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Condition met\n"
     ]
    }
   ],
   "source": [
    "x = False\n",
    "if not x :\n",
    "    print(\"Condition met\")\n",
    "else:\n",
    "    print(\"Condition not met\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Considerations\n",
    "* When multiplication and division occur together in an expression, each operation is evaluated as it occurs from left to right. Likewise, when addition and subtraction occur together in an expression, each operation is evaluated in order of appearance from left to right.\n",
    "\n",
    "* The string concatenation (`&`) operator is not an arithmetic operator, but in precedence it falls after all arithmetic operators and before all comparison operators. \n",
    "  * This operator is an object reference comparison operator. It does not compare objects or their values; it checks only to determine if two object references refer to the same object."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to top](#top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"truth\"></a>\n",
    "### Truth Tables\n",
    "There is a lot to learn about the logic branch of mathematics, but we can selectively learn some of it to improve our algorithmic thinking when programming.\n",
    "\n",
    "Below are truth tables for the comparison operator ==, and each of the logic operators and, or, and not. While you may be able to reason them out, it can also be helpful to work to memorize them as that can make your programming decision-making process quicker.\n",
    "\n",
    "#### `==` Truth Table\n",
    "\n",
    "| x     \t| == \t| y     \t| Returns \t|\n",
    "|-------\t|----\t|-------\t|---------\t|\n",
    "| True  \t| == \t| True  \t| True    \t|\n",
    "| True  \t| == \t| False \t| False   \t|\n",
    "| False \t| == \t| True  \t| False   \t|\n",
    "| False \t| == \t| False \t| True    \t|\n",
    "\n",
    "#### `AND` Truth Table\n",
    "\n",
    "| x     \t| and \t| y     \t| Returns \t|\n",
    "|-------\t|-----\t|-------\t|---------\t|\n",
    "| True  \t| and \t| True  \t| True    \t|\n",
    "| True  \t| and \t| False \t| False   \t|\n",
    "| False \t| and \t| True  \t| False   \t|\n",
    "| False \t| and \t| False \t| False   \t|\n",
    "\n",
    "#### `OR` Truth Table\n",
    "\n",
    "| x     \t| or \t| y     \t| Returns \t|\n",
    "|-------\t|----\t|-------\t|---------\t|\n",
    "| True  \t| or \t| True  \t| True    \t|\n",
    "| True  \t| or \t| False \t| True    \t|\n",
    "| False \t| or \t| True  \t| True    \t|\n",
    "| False \t| or \t| False \t| False   \t|\n",
    "\n",
    "#### `NOT` Truth Table\n",
    "\n",
    "| not \t| x     \t| Returns \t|\n",
    "|-----\t|-------\t|---------\t|\n",
    "| not \t| True  \t| False   \t|\n",
    "| not \t| False \t| True    \t|\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to top](#top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"control_flow\"></a>\n",
    "\n",
    "---\n",
    "<a name=\"conditionals\"></a>\n",
    "# Control Flow Part 1: Python Conditionals \n",
    "This guide is an survey of Python conditional statements.\n",
    "\n",
    "## Overview\n",
    "You can control the flow of your script with conditional statements and looping statements. Using conditional statements, you can write Python code that makes decisions and repeats actions. The following conditional statements are available in Python:\n",
    "\n",
    "* <kbd>if</kbd> statement\n",
    "* <kbd>if…else</kbd> statement\n",
    "* <kbd>if…elif…elif…else</kbd> nested statement\n",
    "\n",
    "The <kbd>if</kbd> statement is used to evaluate whether a condition is True or False and, depending on the result, to specify one or more statements to run. Usually the condition is an expression that uses a comparison operator to compare one value or variable with another. \n",
    "\n",
    "* <kbd>if</kbd>… and <kbd>if…elif…else</kbd> statements can be nested to as many levels as you need.\n",
    "* Python programming language assumes any non-zero and non-null values as TRUE, and if it is either zero or null, then it is assumed as FALSE value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to top](#top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## if\n",
    "To run only one statement when a condition is True, use the single-line syntax for the <kbd>if</kbd>… statement. The following example shows the single-line syntax."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value of the variable is 350\n"
     ]
    }
   ],
   "source": [
    "myvar = 350\n",
    "if myvar == 350: print(\"The value of the variable is\", myvar)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To run more than one line of code, you must use the multiple-line (or block) syntax. The first line ends in a colon (`:`). As with all Python block syntax, the whitespaces to the left of the lines must be the same throughout the block. As an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value of the variable is 350\n",
      "The value of the 2nd variable is 450\n"
     ]
    }
   ],
   "source": [
    "myvar = 350\n",
    "\n",
    "if myvar == 350 :\n",
    "    print(\"The value of the variable is\", myvar)\n",
    "    myvar2 = 450\n",
    "    print(\"The value of the 2nd variable is\", myvar2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to top](#top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## if..else\n",
    "You can use an <kbd>if…else</kbd> statement to define two blocks of executable statements: one block to run if the condition is True, the other block to run if the condition is False…"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Green\n",
      "Black\n"
     ]
    }
   ],
   "source": [
    "myvar = 350\n",
    "\n",
    "if myvar == 0:\n",
    "    layerColour = 'Red'\n",
    "    objectColour = 'Blue'\n",
    "else:\n",
    "    layerColour = 'Green'\n",
    "    objectColour = 'Black'\n",
    "\n",
    "print(layerColour)\n",
    "print(objectColour)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to top](#top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## if..elif..elif..else\n",
    "A variation on the <kbd>if…else</kbd> statement allows you to choose from several alternatives. Adding <kbd>elif</kbd> clauses expands the functionality of the <kbd>if…else</kbd> statement so you can control program flow based on multiple different possibilities. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is the third 2\n"
     ]
    }
   ],
   "source": [
    "var1 = 2\n",
    "if var1 == 0:\n",
    "    print(\"This is the first \" + str(var1))\n",
    "elif var1 == 1:\n",
    "    print(\"This is the second \" + str(var1))\n",
    "elif var1 == 2:\n",
    "    print(\"This is the third \" + str(var1))\n",
    "else:\n",
    "    print(\"Value out of range!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can add as many <kbd>elif</kbd> clauses as you need to provide alternative choices. However, there can only be a single <kbd>else</kbd> clause.\n",
    "\n",
    "The <kbd>elif</kbd> statement takes the place of the Switch…Case statement in other programming languages."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to top](#top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nested if\n",
    "There may be a situation when you want to check for another condition after a condition resolves to true. In such a situation, you can use the nested if construct.\n",
    "\n",
    "In a nested if construct, you can have an <kbd>if…elif…else</kbd> clause inside another <kbd>if…elif…else</kbd> clause."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Expression value is less than 200\n",
      "Which is 100\n",
      "Good bye!\n"
     ]
    }
   ],
   "source": [
    "var = 100\n",
    "if var < 200:\n",
    "    print(\"Expression value is less than 200\")\n",
    "    if var == 150:\n",
    "        print(\"Which is 150\")\n",
    "    elif var == 100:\n",
    "        print(\"Which is 100\")\n",
    "    elif var == 50:\n",
    "        print(\"Which is 50\")\n",
    "    elif var < 50:\n",
    "        print(\"Expression value is less than 50\")\n",
    "else:\n",
    "    print(\"Could not find true expression\")\n",
    "\n",
    "print(\"Good bye!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to top](#top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<a name=\"loops\"></a>\n",
    "# Control Flow Part 2: Python Loops \n",
    "This guide is an overview of looping through Python code.\n",
    "\n",
    "## Overview\n",
    "Looping allows you to run a group of statements repeatedly. Some loops repeat statements until a condition is False; others repeat statements until a condition is True. There are also loops that repeat statements a specific number of times.\n",
    "\n",
    "The following looping statements are available in Python:\n",
    "\n",
    "* for - Uses a counter or loops through a each item in a list a specified number of times.\n",
    "* while - Loops while a condition is True.\n",
    "* Nested loops - Repeats a group of statements for each item in a collection or each element of an array.\n",
    "\n",
    "Loop statements use a very specific syntax. \n",
    "* Unlike other languages, Python does not use an end statement for its loop syntax. The initial Loop statement is followed by a colon : symbol. \n",
    "* Then the next line will be indented by 4 spaces. It is these spaces to the left of the line that is key.\n",
    "* Each subsequent line in the loop also needs to be indented by 4 or more spaces. If a line is not indented it is considered outside the loop and will also terminate any additional lines considered in the loop. \n",
    "  * A common mistake is to remove the spaces and therefore prematurely end the loop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to top](#top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"for_loop\"></a>\n",
    "## `for` Loop\n",
    "You can use <kbd>for</kbd> statements to run a block of statements for a specific number of times.\n",
    "\n",
    "Using Python to loop through each item in any type of list based structure is very easy. Python <kbd>for</kbd> loops, use a counter variable whose value increases or decreases with each repetition of the loop.\n",
    "\n",
    "The following example causes a procedure to execute 4 times. The <kbd>for</kbd> statement specifies the counter variable x and its start and end values. Python automatically increments the counter (x) variable by 1 after coming to end of the execution block."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We're now looping 0\n",
      "We're now looping 1\n",
      "We're now looping 2\n"
     ]
    }
   ],
   "source": [
    "for x in range(0, 3):\n",
    "    print(\"We're now looping \" + str(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python can use any iterable method as a the for loop counter. In the case above we are using `range()`. Other iterable objects can be lists or a string. You can also create you own iterable objects if needed.\n",
    "\n",
    "Sometimes it is required to increase or decrease the counter variable by the value you specify. In the following example, the counter variable `j` is incremented by 2 each time the loop repeats. When the loop is finished, the total is the sum of 0, 2, 4, 6 and 8."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We're now looping 0\n",
      "We're now looping 2\n",
      "We're now looping 4\n",
      "We're now looping 6\n",
      "We're now looping 8\n"
     ]
    }
   ],
   "source": [
    "for j in range(0, 10, 2):\n",
    "    print(\"We're now looping \" + str(j))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To decrease the counter variable, use a negative range value. You must specify an end value that is less than the start value. In the following example, the counter variable j is decreased by 2 each time the loop repeats. When the loop is finished, total is the sum of 10, 8, 6, 4, and 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We're now looping 10\n",
      "We're now looping 8\n",
      "We're now looping 6\n",
      "We're now looping 4\n",
      "We're now looping 2\n"
     ]
    }
   ],
   "source": [
    "for j in range(10, 0, -2):\n",
    "    print(\"We're now looping \" + str(j))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can exit any for statement before the counter reaches its end value by using the <kbd>break</kbd> statement. Because you usually want to exit only in certain situations, such as when an error occurs, you could also use the <kbd>if</kbd> statement in the _True_ statement block. If the condition is _False_, the loop runs as usual."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B\n",
      "i\n",
      "g\n",
      " \n",
      "D\n",
      "a\n",
      "t\n",
      "a\n",
      " \n",
      "a\n",
      "n\n",
      "d\n",
      " \n",
      "T\n",
      "e\n",
      "c\n",
      "The end\n"
     ]
    }
   ],
   "source": [
    "# Use of break statement inside loop\n",
    "for val in \"Big Data and Technologies\":\n",
    "    if val == \"h\":\n",
    "        break\n",
    "    print(val)\n",
    "\n",
    "print(\"The end\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B\n",
      "i\n",
      "g\n",
      " \n",
      "D\n",
      "a\n",
      "t\n",
      "a\n",
      " \n",
      "a\n",
      "n\n",
      "d\n",
      " \n",
      "T\n",
      "e\n",
      "c\n",
      "n\n",
      "o\n",
      "l\n",
      "o\n",
      "g\n",
      "i\n",
      "e\n",
      "s\n",
      "The end\n"
     ]
    }
   ],
   "source": [
    "# Program to show the use of continue statement inside loops\n",
    "\n",
    "for val in \"Big Data and Technologies\":\n",
    "    if val == \"h\":\n",
    "        continue\n",
    "    print(val)\n",
    "\n",
    "print(\"The end\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "gallahad the pure\n",
      "robin the brave\n"
     ]
    }
   ],
   "source": [
    "# Loop through a dictionary\n",
    "knights = {'gallahad': 'the pure', 'robin': 'the brave'}\n",
    "\n",
    "for k, v in knights.items():\n",
    "    print(k, v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 tic\n",
      "1 tac\n",
      "2 toe\n"
     ]
    }
   ],
   "source": [
    "# Loop through a list\n",
    "for i, v in enumerate(['tic', 'tac', 'toe']):\n",
    "    print(i, v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What is your name?  It is lancelot.\n",
      "What is your quest?  It is the holy grail.\n",
      "What is your favorite color?  It is blue.\n",
      "[('name', 'lancelot'), ('quest', 'the holy grail'), ('favorite color', 'blue')]\n"
     ]
    }
   ],
   "source": [
    "questions = ['name', 'quest', 'favorite color']\n",
    "answers = ['lancelot', 'the holy grail', 'blue']\n",
    "\n",
    "for q, a in zip(questions, answers):\n",
    "    print('What is your {0}?  It is {1}.'.format(q, a))\n",
    "\n",
    "print(list(zip(questions, answers)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 246,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['h']\n",
      "['h', 'e']\n",
      "['h', 'e', 'l']\n",
      "['h', 'e', 'l', 'l']\n",
      "['h', 'e', 'l', 'l', 'o']\n"
     ]
    }
   ],
   "source": [
    "my_list = []\n",
    "\n",
    "my_string = \"hello\"\n",
    "\n",
    "#using a for loop to append items to a list\n",
    "for char in my_string:\n",
    "    my_list.append(char)\n",
    "    print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to top](#top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"list_comprehension\"></a>\n",
    "### List Comprehension\n",
    "\n",
    "List comprehensions provide a concise way to create lists. Common applications are to make new lists where each element is the result of some operations applied to each member of another sequence or iterable, or to create a subsequence of those elements that satisfy a certain condition.\n",
    "\n",
    "For example, assume we want to create a list of squares, like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
     ]
    }
   ],
   "source": [
    "squares = []\n",
    "\n",
    "for x in range(10):\n",
    "    squares.append(x**2)\n",
    "\n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or, equivalently:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
     ]
    }
   ],
   "source": [
    "squares = [x**2 for x in range(10)]\n",
    "\n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A list comprehension consists of brackets containing an expression followed by a for clause, then zero or more for or if clauses. The result will be a new list resulting from evaluating the expression in the context of the for and if clauses which follow it. For example, this listcomp combines the elements of two lists if they are not equal:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]"
      ]
     },
     "execution_count": 239,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and it’s equivalent to:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]\n"
     ]
    }
   ],
   "source": [
    "combs = []\n",
    "\n",
    "for x in [1,2,3]:\n",
    "    for y in [3,1,4]:\n",
    "        if x != y:\n",
    "            combs.append((x, y))\n",
    "print(combs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to top](#top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"while_loop\"></a>\n",
    "## `while` Loop\n",
    "Use the while loop to check a condition before each execution of the loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "8\n",
      "16\n",
      "32\n",
      "The End.\n"
     ]
    }
   ],
   "source": [
    "var1 = 2\n",
    "while var1 < 32:\n",
    "    var1 = var1 * 2\n",
    "    print(var1)\n",
    "\n",
    "print(\"The End.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`while` loops are not used as much as for loops. But `while` loops are used often in in cases the following way, polling for specific input or a loop that will execute forever until a condition is met:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter 'hello':23\n",
      "Please enter 'hello':de\n",
      "Please enter 'hello':hello\n"
     ]
    }
   ],
   "source": [
    "while True:\n",
    "    n = input(\"Please enter 'hello':\")\n",
    "    if n.strip() == 'hello':\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# This is an infinite loop, this loop never terminates!\n",
    "# It has been commented out to prevent accidental runs!\n",
    "# Stop running this cell as soon as possible!!!!\n",
    "\n",
    "just_a_var = 1\n",
    "# while just_a_var:\n",
    "#     print('Looping forever and ever...')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to top](#top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"nested_loops\"></a>\n",
    "## Nested Loops\n",
    "Python allows for loops to be nested inside one another. **Any type of loop can be nested within any other type of loop.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20 is an even number.\n",
      "19 is an odd number.\n",
      "18 is an even number.\n",
      "17 is an odd number.\n",
      "16 is an even number.\n",
      "15 is an odd number.\n",
      "14 is an even number.\n",
      "13 is an odd number.\n",
      "12 is an even number.\n",
      "11 is an odd number.\n",
      "10 is an even number.\n",
      "9 is an odd number.\n",
      "8 is an even number.\n",
      "7 is an odd number.\n",
      "6 is an even number.\n",
      "5 is an odd number.\n",
      "4 is an even number.\n",
      "3 is an odd number.\n",
      "2 is an even number.\n"
     ]
    }
   ],
   "source": [
    "for x in range(20, 1,-1):\n",
    "    if x % 2 == 0:\n",
    "        print(str(x) + \" is an even number.\")\n",
    "    else:\n",
    "        print(str(x) + \" is an odd number.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Second Statement 1\n",
      "Third Statement 0\n",
      "Second Statement 1\n",
      "Third Statement 1\n",
      "First Statement 1\n",
      "Second Statement 2\n",
      "Third Statement 2\n",
      "First Statement 1\n",
      "First Statement 2\n",
      "Second Statement 3\n",
      "Third Statement 3\n",
      "First Statement 1\n",
      "First Statement 2\n",
      "First Statement 3\n",
      "Second Statement 4\n",
      "Third Statement 4\n",
      "First Statement 1\n",
      "First Statement 2\n",
      "First Statement 3\n",
      "First Statement 4\n",
      "Second Statement 5\n",
      "Third Statement 5\n"
     ]
    }
   ],
   "source": [
    "line = 0 \n",
    "\n",
    "while line <= 5 :\n",
    "    pos = 1\n",
    "    while pos < line:\n",
    "        print(\"First Statement\", pos)\n",
    "        pos += 1\n",
    "    else:\n",
    "        print(\"Second Statement \" + str(pos))\n",
    "\n",
    "    print(\"Third Statement \" + str(line))\n",
    "    line += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "non_flat = [ [1,2,3], [4,5,6], [7,8] ]\n",
    "flattened = []\n",
    "\n",
    "for x in non_flat:\n",
    "    if len(x) > 2:\n",
    "        for y in x:\n",
    "            flattened.append(y)\n",
    "\n",
    "print(flattened)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can re-write that as a nested list comprehension:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 249,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 249,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[ y for x in non_flat if len(x) > 2 for y in x ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to top](#top)"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}