Learn2Code - Part 1 - Basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Jupyter Notebook Shortcuts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Esc** will take you into command mode where you can navigate around your notebook with arrow keys.   \n",
    "** While in command mode: **\n",
    "- A to insert a new cell above the current cell, B to insert a new cell below.\n",
    "- M to change the current cell to Markdown, Y to change it back to code\n",
    "- D + D (press the key twice) to delete the current cell\n",
    "- Enter will take you from command mode back into edit mode for the given cell.\n",
    "- Shift + Tab will show you the Docstring (documentation) for the the object you have just typed in a code cell - you can keep pressing this short cut to cycle through a few modes of documentation.\n",
    "- Ctrl + Shift + - will split the current cell into two from where your cursor is.\n",
    "- Esc + F Find and replace on your code but not the outputs.\n",
    "- Esc + O Toggle cell output.\n",
    "- Select Multiple Cells:\n",
    "    - Shift + J or Shift + Down selects the next sell in a downwards direction. You can also select sells in an upwards direction by using Shift + K or Shift + Up.\n",
    "    -Once cells are selected, you can then delete / copy / cut / paste / run them as a batch. This is helpful when you need to move parts of a notebook.\n",
    "    - You can also use Shift + M to merge multiple cells."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Python Statements\n",
    "\n",
    "In this lecture we will be doing a quick overview of Python Statements. This lecture will emphasize differences between Python and other languages such as C++. \n",
    "\n",
    "There are two reasons we take this approach for learning the context of Python Statements:\n",
    "\n",
    "    1.) If you are coming from a different language this will rapidly accelerate your understanding of Python.\n",
    "    2.) Learning about statements will allow you to be able to read other languages more easily in the future."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python vs Other Languages\n",
    "\n",
    "Let's create a simple statement that says:\n",
    "\"If a is greater than b, assign 2 to a and 4 to b\"\n",
    "\n",
    "Take a look at these two if statements (we will learn about building out if statements soon).\n",
    "\n",
    "**Version 1 (Other Languages)**\n",
    "\n",
    "    if (a>b){\n",
    "        a = 2;\n",
    "        b = 4;\n",
    "    }\n",
    "                        \n",
    "**Version 2 (Python)**   \n",
    "\n",
    "    if a>b:\n",
    "        a = 2\n",
    "        b = 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You'll notice that Python is less cluttered and much more readable than the first version. How does Python manage this?\n",
    "\n",
    "Let's walk through the main differences:\n",
    "\n",
    "Python gets rid of () and {} by incorporating two main factors: a *colon* and *whitespace*. The statement is ended with a colon, and whitespace is used (indentation) to describe what takes place in case of the statement.\n",
    "\n",
    "Another major difference is the lack of semicolons in Python. Semicolons are used to denote statement endings in many other languages, but in Python, the end of a line is the same as the end of a statement.\n",
    "\n",
    "Lastly, to end this brief overview of differences, let's take a closer look at indentation syntax in Python vs other languages:\n",
    "\n",
    "## Indentation\n",
    "\n",
    "Here is some pseudo-code to indicate the use of whitespace and indentation in Python:\n",
    "\n",
    "**Other Languages**\n",
    "\n",
    "    if (x)\n",
    "        if(y)\n",
    "            code-statement;\n",
    "    else\n",
    "        another-code-statement;\n",
    "        \n",
    "**Python**\n",
    "    \n",
    "    if x:\n",
    "        if y:\n",
    "            code-statement\n",
    "    else:\n",
    "        another-code-statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note how Python is so heavily driven by code indentation and whitespace. This means that code readability is a core part of the design of the Python language.\n",
    "\n",
    "Now let's start diving deeper by coding these sort of statements in Python!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Time to code!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# BASIC ELEMENTS OF PYTHON"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Types\n",
    " - Integers\n",
    " - Float\n",
    " - Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numbers and more in Python!\n",
    "\n",
    "In this lecture, we will learn about numbers in Python and how to use them.\n",
    "\n",
    "We'll learn about the following topics:\n",
    "\n",
    "    1.) Types of Numbers in Python\n",
    "    2.) Basic Arithmetic\n",
    "    3.) Object Assignment in Python\n",
    "\n",
    "## Types of numbers\n",
    "\n",
    "- Python has various \"types\" of numbers (numeric literals). We'll mainly focus on integers and floating point numbers.\n",
    "\n",
    "- Integers are just whole numbers, positive or negative. \n",
    "    - For example: 2 and -2 are examples of integers.\n",
    "\n",
    "- Floating point numbers in Python are notable because they have a decimal point in them, or use an exponential (e) to define the number. \n",
    "    - For example 2.0 and -2.1 are examples of floating point numbers. 4E2 (4 times 10 to the power of 2) is also an example of a floating point number in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is a table of the two main types we will spend most of our time working with some examples:\n",
    "\n",
    "<table>\n",
    "<tr>\n",
    "    <th>Examples</th> \n",
    "    <th>Number \"Type\"</th>\n",
    "</tr>\n",
    "\n",
    "<tr>\n",
    "    <td>1,2,-5,1000</td>\n",
    "    <td>Integers</td> \n",
    "</tr>\n",
    "\n",
    "<tr>\n",
    "    <td>1.2,-0.5,2e2,3E2</td> \n",
    "    <td>Floating-point numbers</td> \n",
    "</tr>\n",
    " </table>\n",
    "\n",
    " \n",
    " \n",
    "Now let's start with some basic arithmetic."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic Arithmetic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Addition\n",
    "2+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Subtraction\n",
    "2-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Multiplication\n",
    "2*2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Division\n",
    "3/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Floor Division\n",
    "3//2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Specifying one of the numbers as a float\n",
    "3.0/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Works for either number\n",
    "3/2.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- We could also \"cast\" the type using a function that basically turns integers into floats. This function, unsurprisingly, is called float()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# We can use this float() function to cast integers as floats:\n",
    "float(3)/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Powers\n",
    "2**3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Can also do roots this way\n",
    "4**0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Order of Operations followed in Python -- PEMDAS \n",
    "#[Paranthesis,Exponentiation,Multiplication,Addition,Subtraction]\n",
    "2 + 10 * 10 + 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Can use parenthesis to specify orders\n",
    "(2+10) * (10+3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variable Assignments\n",
    "\n",
    "Now that we've seen how to use numbers in Python as a calculator let's see how we can assign names and create variables.\n",
    "\n",
    "We use a single equals sign to assign labels to variables. Let's see a few examples of how we can do this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Let's create an object called \"a\" and assign it the number 5\n",
    "a = 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now if I call *a* in my Python script, Python will treat it as the number 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Adding the objects\n",
    "a+a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What happens on reassignment? Will Python let us write it over?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Reassignment\n",
    "a = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Check\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yes! Python allows you to write over assigned variable names. We can also use the variables themselves when doing the reassignment. Here is an example of what I mean:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Check\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Use A to redefine A\n",
    "a = a + a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Check \n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The names you use when creating these labels need to follow a few rules:\n",
    "\n",
    "    1. Names can not start with a number.\n",
    "    2. There can be no spaces in the name, use _ instead.\n",
    "    3. Can't use any of these symbols :'\",<>/?|\\()!@#$%^&*~-+\n",
    "    3. It's considered best practice (PEP8) that the names are lowercase.\n",
    "\n",
    "Using variable names can be a very useful way to keep track of different variables in Python. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Use object names to keep better track of what's going on in your code!\n",
    "my_income = 100\n",
    "\n",
    "tax_rate = 0.1\n",
    "\n",
    "my_taxes = my_income*tax_rate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Show my taxes!\n",
    "my_taxes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So what have we learned? We learned some of the basics of numbers in Python. We also learned how to do arithmetic and use Python as a basic calculator. We then wrapped it up with learning about Variable Assignment in Python.\n",
    "\n",
    "Up next we'll learn about User Input!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Scope of a variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Whenever an identifier is assigned to a value, that definition is made with a specific scope. \n",
    "- Top-level assignments are typically made in what is known as global scope. \n",
    "- Assignments made within the body of a function typically have scope that is local to that function call. Therefore, an assignment, x = 5, within a function has no effect on the identifier, x, in the broader scope.\n",
    "- LEGB Rule.\n",
    "\n",
    "    - L, Local — Names assigned in any way within a function (def or lambda)), and not declared global in that function.\n",
    "\n",
    "    - E, Enclosing-function locals — Name in the local scope of any and all statically enclosing functions (def or lambda), from inner to outer.\n",
    "\n",
    "    - G, Global (module) — Names assigned at the top-level of a module file, or by executing a global statement in a def within the file.\n",
    "\n",
    "    - B, Built-in (Python) — Names preassigned in the built-in names module : open,range,SyntaxError,..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def test1():\n",
    "    x = 10\n",
    "    print(x)\n",
    "test1()# prints x\n",
    "type(x)# gives an error as x is not foundin the scope"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# USER INPUT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#The input from console can be triggered with input() function\n",
    "a = input(\"Please enter the value for a:\")\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = 1\n",
    "b = 2.0\n",
    "c = \"abc\"\n",
    "d = input()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "type(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "type(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "type(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1.Accept 2 numbers from the user and:\n",
    "    - Print the biggest number\n",
    "    - print the difference\n",
    "    - The difference when b is subtracted from a\n",
    "    - The product of a and b\n",
    "    - The quotient when a is divided by b\n",
    "    - The remainder when a is divided by b\n",
    "    - The result of log10 a\n",
    "    - The result of a power b\n",
    "    - swap both the numbers and print both numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2.Write a program that asks the user to enter the width and length of a room. Once\n",
    "the values have been read, your program should compute and display the area of the\n",
    "room. The length and the width will be entered as floating point numbers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3.Create a program that reads the length and width of a farmer’s field from the user in\n",
    "feet. Display the area of the field in acres.There are 43,560 square feet in an acre."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4.In many jurisdictions a small deposit is added to drink containers to encourage people\n",
    "to recycle them. In one particular jurisdiction, drink containers holding one liter or\n",
    "less have a \\$0.10 deposit, and drink containers holding more than one liter have a\n",
    "$ 0.25 deposit.\n",
    "Write a program that reads the number of containers of each size from the user.\n",
    "Your program should continue by computing and displaying the refund that will be\n",
    "received for returning those containers. Format the output so that it includes a dollar\n",
    "sign and always displays exactly two decimal places.\n",
    "hint: print('Floating point numbers: %10.2f' %(13.144)) will print 13.14 - more will be discussed in print formatting lecture"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5.The program that you create for this exercise will begin by reading the cost of a meal\n",
    "ordered at a restaurant from the user. Then your program will compute the tax and\n",
    "tip for the meal. Use your local tax rate when computing the amount of tax owing.\n",
    "Compute the tip as 18 percent of the meal amount (without the tax). The output from\n",
    "your program should include the tax amount, the tip amount, and the grand total for\n",
    "the meal including both the tax and the tip. Format the output so that all of the values\n",
    "are displayed using two decimal places."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6.Write a program that reads a positive integer, n, from the user and then displays the\n",
    "sum of all of the integers from 1 to n. The sum of the first n positive integers can be\n",
    "computed using the formula:\n",
    "sum = (n) * (n + 1) / 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7.An online retailer sells two products: widgets and gizmos. Each widget weighs 75\n",
    "grams. Each gizmo weighs 112 grams. Write a program that reads the number of\n",
    "widgets and the number of gizmos in an order from the user. Then your program\n",
    "should compute and display the total weight of the order."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8.Pretend that you have just opened a new savings account that earns 4 percent interest\n",
    "per year. The interest that you earn is paid at the end of the year, and is added\n",
    "to the balance of the savings account. Write a program that begins by reading the\n",
    "amount of money deposited into the account from the user. Then your program should\n",
    "compute and display the amount in the savings account after 1, 2, and 3 years. Display\n",
    "each amount so that it is rounded to 2 decimal places."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "9.Consider the software that runs on a self-checkout machine. One task that it must be\n",
    "able to perform is to determine how much change to provide when the shopper pays\n",
    "for a purchase with cash.\n",
    "Write a program that begins by reading a number of cents from the user as an\n",
    "integer. Then your program should compute and display the denominations of the\n",
    "coins that should be used to give that amount of change to the shopper. The change\n",
    "should be given using as few coins as possible. Assume that the machine is loaded\n",
    "with pennies, nickels, dimes, quarters."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### - - More Exercises to come we are just beginning to learn :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Comparison Operators \n",
    "\n",
    "In this lecture we will be learning about Comparison Operators in Python. These operators will allow us to compare variables and output a Boolean value (True or False). \n",
    "\n",
    "If you have any sort of background in Math, these operators should be very straight forward.\n",
    "\n",
    "First we'll present a table of the comparison operators and then work through some examples:\n",
    "\n",
    "## Table of Comparison Operators\n",
    "\n",
    "<table class=\"table table-bordered\">\n",
    "<tr>\n",
    "<th style=\"width:10%\">Operator</th><th style=\"width:45%\">Description</th><th>Example</th>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>==</td>\n",
    "<td>If the values of two operands are equal, then the condition becomes true.</td>\n",
    "<td> (a == b) is not true.</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>!=</td>\n",
    "<td>If values of two operands are not equal, then condition becomes true.</td>\n",
    "<td>(a != b) is true</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>&lt;&gt;</td>\n",
    "<td>If values of two operands are not equal, then condition becomes true.</td>\n",
    "<td> (a &lt;&gt; b) is true. This is similar to != operator.</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>&gt;</td>\n",
    "<td>If the value of left operand is greater than the value of right operand, then condition becomes true.</td>\n",
    "<td> (a &gt; b) is not true.</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>&lt;</td>\n",
    "<td>If the value of left operand is less than the value of right operand, then condition becomes true.</td>\n",
    "<td> (a &lt; b) is true.</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>&gt;=</td>\n",
    "<td>If the value of left operand is greater than or equal to the value of right operand, then condition becomes true.</td>\n",
    "<td> (a &gt;= b) is not true. </td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>&lt;=</td>\n",
    "<td>If the value of left operand is less than or equal to the value of right operand, then condition becomes true.</td>\n",
    "<td> (a &lt;= b) is true. </td>\n",
    "</tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's now work through quick examples of each of these.\n",
    "\n",
    "#### Equal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 == 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 == 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Not Equal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 != 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 != 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 <> 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 <> 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Greater Than"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 > 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 > 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Less Than"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 < 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 < 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Greater Than or Equal to"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 >= 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 >= 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Less than or Equal to"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 <= 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 <= 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Great! Go over each comparison operator to make sure you understand what each one is saying. But hopefully this was straightforward for you**\n",
    "\n",
    "Next we will cover chained comparison operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# BRANCHING"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#if,elif,else Statements\n",
    "\n",
    "if Statements in Python allows us to tell the computer to perform alternative actions based on a certain set of results.\n",
    "\n",
    "Verbally, we can imagine we are telling the computer:\n",
    "\n",
    "\"Hey if this case happens, perform some action\"\n",
    "\n",
    "We can then expand the idea further with elif and else statements, which allow us to tell the computer:\n",
    "\n",
    "\"Hey if this case happens, perform some action. Else if another case happens, perform some other action. Else-- none of the above cases happened, perform this action\"\n",
    "\n",
    "Let's go ahead and look at the syntax format for if statements to get a better idea of this:\n",
    "\n",
    "    if case1:\n",
    "        perform action1\n",
    "    elif case2:\n",
    "        perform action2\n",
    "    else: \n",
    "        perform action 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## First Example\n",
    "\n",
    "Let's see a quick example of this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "if True:\n",
    "    print('It was true!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's add in some else logic:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = False\n",
    "\n",
    "if x:\n",
    "    print('x was True!')\n",
    "else:\n",
    "    print('I will be printed in any case where x is not true')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multiple Branches\n",
    "\n",
    "Let's get a fuller picture of how far if, elif, and else can take us!\n",
    "\n",
    "We write this out in a nested structure. Take note of how the if,elif,and else line up in the code. This can help you see what if is related to what elif or else statements.\n",
    "\n",
    "We'll reintroduce a comparison syntax for Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "loc = 'Bank'\n",
    "\n",
    "if loc == 'Auto Shop':\n",
    "    print('Welcome to the Auto Shop!')\n",
    "elif loc == 'Bank':\n",
    "    print('Welcome to the bank!')\n",
    "else:\n",
    "    print(\"Where are you?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note how the nested if statements are each checked until a True boolean causes the nested code below it to run. You should also note that you can put in as many elif statements as you want before you close off with an else.\n",
    "\n",
    "Let's create two more simple examples for the if,elif, and else statements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "person = 'Sammy'\n",
    "\n",
    "if person == 'Sammy':\n",
    "    print('Welcome Sammy!')\n",
    "else:\n",
    "    print(\"Welcome, what's your name?\" )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "person = 'George'\n",
    "\n",
    "if person == 'Sammy':\n",
    "    print('Welcome Sammy!')\n",
    "elif person =='George':\n",
    "    print(\"Welcome George!\")\n",
    "else:\n",
    "    print(\"Welcome, what's your name?\") "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indentation\n",
    "\n",
    "It is important to keep a good understanding of how indentation works in Python to maintain the structure and order of your code. We will touch on this topic again when we start building out functions!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Even or Odd?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Name that Shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Month Name to Number of Days"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Letter Grade to Grade Points "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Is it a Leap Year?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Roulette Payouts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## End of Branching... let's start the super loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ITERATION"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#range()\n",
    "\n",
    "In this short lecture we will be discussing the range function. We haven't developed a very deep level of knowledge of functions yet, but we can understand the basics of this simple (but extremely useful!) function.\n",
    "\n",
    "range() allows us to create a list of numbers ranging from a starting point *up to* an ending point. We can also specify step size. Lets walk through a few examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "range(0,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x =range(0,10)\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "start = 0 #Default\n",
    "stop = 20 \n",
    "x = range(start,stop)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great! Notice how it went *up to* 20, but doesn't actually produce 20. Just like in indexing. What about step size? We can specify that as a third argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = range(start,stop,2)\n",
    "#Show\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# for Loops\n",
    "\n",
    "A **for** loop acts as an iterator in Python, it goes through items that are in a *sequence* or any other iterable item. Objects that we've learned about that we can iterate over include strings,lists,tuples, and even built in iterables for dictionaries, such as the keys or values.\n",
    "\n",
    "We've already seen the **for** statement a little bit in past lectures but now lets formalize our understanding.\n",
    "\n",
    "Here's the general format for a **for** loop in Python:\n",
    "\n",
    "    for item in object:\n",
    "        statements to do stuff\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The variable name used for the item is completely up to the coder, so use your best judgment for choosing a name that makes sense and you will be able to understand when revisiting your code. This item name can then be referenced inside you loop, for example if you wanted to use if statements to perform checks.\n",
    "\n",
    "Let's go ahead and work through several example of **for** loops using a variety of data object types. we'll start simple and build more complexity later on.\n",
    "\n",
    "## Example 1  \n",
    "Iterating through a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# We'll learn how to automate this sort of list in the next lecture\n",
    "lst = [1,2,3,4,5,6,7,8,9,10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for num in lst:\n",
    "    print(num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for num in lst:\n",
    "    if num % 2 == 0:\n",
    "        print(num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could have also put in else statement in there:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for num in lst:\n",
    "    if num % 2 == 0:\n",
    "        print(num)\n",
    "    else:\n",
    "        print('Odd number')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 3\n",
    "Another common idea during a **for** loop is keeping some sort of running tally during the multiple loops. For example, lets create a for loop that sums up the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Start sum at zero\n",
    "list_sum = 0 \n",
    "\n",
    "for num in lst:\n",
    "    list_sum = list_sum + num\n",
    "\n",
    "print(list_sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# while loops\n",
    "\n",
    "The **while** statement in Python is one of most general ways to perform iteration. A **while** statement will repeatedly execute a single statement or group of statements as long as the condition is true. The reason it is called a 'loop' is because the code statements are looped through over and over again until the condition is no longer met.\n",
    "\n",
    "The general format of a while loop is:\n",
    "\n",
    "    while test:\n",
    "        code statement\n",
    "    else:\n",
    "        final code statements\n",
    "\n",
    "Let’s look at a few simple while loops in action. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = 0\n",
    "\n",
    "while x < 10:\n",
    "    print('x is currently: ',x)\n",
    "    print(' x is still less than 10, adding 1 to x')\n",
    "    x+=1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how many times the print statements occurred and how the while loop kept going until the True condition was met, which occurred once x==10. Its important to note that once this occurred the code stopped. Lets see how we could add an else statement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = 0\n",
    "\n",
    "while x < 10:\n",
    "    print('x is currently: ',x)\n",
    "    print(' x is still less than 10, adding 1 to x')\n",
    "    x+=1\n",
    "    \n",
    "else:\n",
    "    print('All Done!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# break, continue, pass\n",
    "\n",
    "We can use break, continue, and pass statements in our loops to add additional functionality for various cases. The three statements are defined by:\n",
    "\n",
    "    break: Breaks out of the current closest enclosing loop.\n",
    "    continue: Goes to the top of the closest enclosing loop.\n",
    "    pass: Does nothing at all.\n",
    "    \n",
    "    \n",
    "Thinking about **break** and **continue** statements, the general format of the while loop looks like this:\n",
    "\n",
    "    while test: \n",
    "        code statement\n",
    "        if test: \n",
    "            break\n",
    "        if test: \n",
    "            continue \n",
    "    else:\n",
    "\n",
    "**break** and **continue** statements can appear anywhere inside the loop’s body,but we will usually put them further nested in conjunction with an **if** statement to perform an action based on some condition.\n",
    "\n",
    "Lets go ahead and look at some examples!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = 0\n",
    "\n",
    "while x < 10:\n",
    "    print('x is currently: ',x)\n",
    "    print(' x is still less than 10, adding 1 to x')\n",
    "    x+=1\n",
    "    if x ==3:\n",
    "        print('x==3')\n",
    "    else:\n",
    "        print('continuing...')\n",
    "        continue"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note how we have a printed statement when x==3, and a continue being printed out as we continue through the outer while loop. Let's put in a break once x ==3 and see if the result makes sense:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = 0\n",
    "\n",
    "while x < 10:\n",
    "    print('x is currently: ',x)\n",
    "    print(' x is still less than 10, adding 1 to x')\n",
    "    x+=1\n",
    "    if x ==3:\n",
    "        print('Breaking because x==3')\n",
    "        break\n",
    "    else:\n",
    "        print('continuing...')\n",
    "        continue"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note how the other else statement wasn't reached and continuing was never printed!\n",
    "\n",
    "After these brief but simple examples, you should feel comfortable using while statements in you code.\n",
    "\n",
    "**A word of caution however! It is possible to create an infinitely running loop with while statements. For example:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# DO NOT RUN THIS CODE!!!! \n",
    "while True:\n",
    "    print('Uh Oh infinite Loop!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Print Formatting\n",
    "\n",
    "In this lecture we will briefly cover the various ways to format your print statements. As you code more and more, you will probably want to have print statements that can take in a variable into a printed string statement.\n",
    "\n",
    "The most basic example of a print statement is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a string\n"
     ]
    }
   ],
   "source": [
    "print('This is a string')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings\n",
    "You can use the %s to format strings into your print statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Place another string with a mod and s: something to print\n"
     ]
    }
   ],
   "source": [
    "s = 'something to print'\n",
    "print('Place another string with a mod and s: %s' %(s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Place another string with a mod and s: Hi\n"
     ]
    }
   ],
   "source": [
    "print('Place another string with a mod and s: %s' %('Hi'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##Floating Point Numbers\n",
    "Floating point numbers use the format %n1.n2f where the n1 is the total minimum number of digits the string should contain (these may be filled with whitespace if the entire number does not have this many digits. The n2 placeholder stands for how many numbers to show past the decimal point. Lets see some examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Floating point numbers: 13.14\n"
     ]
    }
   ],
   "source": [
    "print('Floating point numbers: %0.2f' %(13.144))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Floating point numbers: 13\n"
     ]
    }
   ],
   "source": [
    "print('Floating point numbers: %1.0f' %(13.144))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Floating point numbers: 13.14400\n"
     ]
    }
   ],
   "source": [
    "print('Floating point numbers: %1.5f' %(13.144))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Floating point numbers:      13.14\n"
     ]
    }
   ],
   "source": [
    "print('Floating point numbers: %10.2f' %(13.144))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Floating point numbers:                     13.14\n"
     ]
    }
   ],
   "source": [
    "print('Floating point numbers: %25.2f' %(13.144))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##Conversion Format methods.\n",
    "It should be noted that two methods %s and %r actually convert any python object to a string using two separate methods: str() and repr(). We will learn more about these functions later on in the course, but you should note you can actually pass almost any Python object with these two methods and it will work:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Here is a number: 123.1. Here is a string: hi\n"
     ]
    }
   ],
   "source": [
    "print('Here is a number: %s. Here is a string: %s' %(123.1,'hi'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Here is a number: 123.1. Here is a string: 'hi'\n"
     ]
    }
   ],
   "source": [
    "print('Here is a number: %r. Here is a string: %r' %(123.1,'hi'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##Multiple Formatting\n",
    "Pass a tuple to the modulo symbol to place multiple formats in your print statements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First: hi!, Second: 3.14, Third: 22\n"
     ]
    }
   ],
   "source": [
    "print('First: %s, Second: %1.2f, Third: %r' %('hi!',3.14,22))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#Using the string .format() method\n",
    "The best way to format objects into your strings for print statements is using the format method. The syntax is:\n",
    "\n",
    "    'String here {var1} then also {var2}'.format(var1='something1',var2='something2')\n",
    "    \n",
    "Lets see some examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a string with an insert\n"
     ]
    }
   ],
   "source": [
    "print('This is a string with an {p}'.format(p='insert'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "One: Hello!, Two: Hello!, Three: Hello!\n"
     ]
    }
   ],
   "source": [
    "# Multiple times:\n",
    "print('One: {p}, Two: {p}, Three: {p}'.format(p='Hello!'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Object 1: 1, Object 2: two, Object 3: 12.3\n"
     ]
    }
   ],
   "source": [
    "# Several Objects:\n",
    "print('Object 1: {a}, Object 2: {b}, Object 3: {c}'.format(a=1,b='two',c=12.3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That is the basics of string formatting! Remember that Python 3 uses a print() function, not the print statement!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "1.Times Table - Acccept a number from the user and print the multiplication table for the number"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2.Accept a number and print the number pyramid\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3.Inverse a number -  Accept a 4 digit number and inverese the number eg: 1234 will be displayed as 4321"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4.sum of all numbers - Accept a 4 digit number and display the sum of all digits in the number eg: 1234= 1+2+3+4 = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}