Intro to python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# This is my intro to Python Programming\n",
    "\n",
    "This will be a way for users to learn the basics of Python by trying the commands right here\n",
    "The topics covered:\n",
    "* Getting Started\n",
    "* Hello World\n",
    "* Variables\n",
    "* Operations\n",
    "* String and Console Input\n",
    "* String Methods\n",
    "* Functions\n",
    "* Conditionals and Control Flow\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How to use this iNotebook\n",
    "To run the code, you click on the cell, (that's the box surrounding the code), and press shift+enter. The output of the code will be displayed under the cell. To edit a code cell, click on it once. If it's a markdown cell, which is text like this, you'll need to double-click (though I have no idea why you'd need to edit the text)Other than that, all you need to do is read through the intro. Hope you enjoy!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hello World"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello World\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hello World is one of the first things a new programmer learns, and is a good way to start off. This statement uses the print function, which tells Python to print whatever is between the parenthesis. Notice that the words Hello World are in quotes, which tells the computer that this is a statement, and not a variable with a value (I'll explain more below)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "a = 10\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variables are basically letters or symbols with a numeric value, which means that they stand for a number. Variables help programmers because they can write programs using the variable, and then change the value of the variable, andn consequently the program, without having to change the whole program. Variables can be used in loops and with operations as well. We'll get more into that below."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## Operations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10+10 #Addition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10-10 #Subtraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10*10 #Multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10/10 #Division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10//10 #Floor Division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10%10 #Modulo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-10"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "-10 #Negation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abs(10) #Absolute value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10000000000"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10**10 #Exponents "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Little side note- You can see that I wrote words in common english after a hashtag. The hashtag lets the program know to skip anything after the hashtag in that line. This helps progrmmers explain more complicated programs, and put in notes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Remember, you can use variables in operations:\n",
    "(Just make sure you define the variable, or tell the computer what the variable stands for first)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n"
     ]
    }
   ],
   "source": [
    "a=10\n",
    "b=3 #Defining variables a and b\n",
    "print(a+b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Now let's try and create our first program!\n",
    "In this program, we're going to calculate the price of a meal after tax and tip. If you want, you can skip the instructions, and try to figure this one out yourself, or you can look at the cell below.\n",
    "(Sorry for the long explainations!)\n",
    "(Just scroll sideways to read them)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def MealCost(a, b, c):  \n",
    "#First, you have to define the program. This tells the computer that you are creating a multi-use program. \n",
    "#Let's name this program MealCost    \n",
    "    meal = a\n",
    "    tax = b/100\n",
    "    tip = c/100\n",
    "#The a, b, and c are the varaiables that the computer uses.\n",
    "#When you use the program, you'll subsitute a for the meal cost, b for tax, and c for tip, as seen in the next cell.\n",
    "#We are using these variables in other variables. a is the meal cost, b is divided by 100 to get the decimal value of the tax, this will be used later and c is divided by 100 to find the decimal value of the tip.  \n",
    "    meal = meal + meal * tax\n",
    "#Here we are resetting the value of meal to encompass tax as well. Yes, you can use the variable to reset itself. We take meal, and mutiply it by tax to get the value of the tax. Then we add the tax value to the previuos meal value, resetting the meal value to include the tax as well. \n",
    "    total = meal + meal*tip\n",
    "#We're doing the same here, except with tip. We're making a new value called total to do this.\n",
    "\n",
    "    print(\"%.2f\" % total)\n",
    "#This is printing total, but shortening it to only two decimal places. We'll learn how to do this later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "MealCost(44.50, 6.75, 15)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hopefully this worked for you. If it didn't work feel check what you did by the answer I have above. Remember, there's more tha one way to code anything. If it did, then CONGRATS! You can start trying to make other basic calculation programs that you can use over and over again."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings & Console Output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A string is another data type. It can contain letters, symbols, or numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "name = \"Christie\"\n",
    "age = \"14\"\n",
    "day = \"Sunday\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Name, age, and day are all variables that are assigned strings. Strings MUST be in quotes. If you remember, when using the print function, you can tell it to print a variable, or print a string, such as \"Christie\". "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(\"She said, \"It's a string\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above, you can see that using quotes in a string doesn't work because Python interprets the second quote as the end of the string. Then it doesn't know what to do with the rest of the text. However, the backslash fixes this problem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(\"She said, \\\"It's a string\\\"\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## String Methods\n",
    "String Methods are specific tasks that you can preform with a few simple commands. Some of these commands include:\n",
    "* len()\n",
    "* lower()\n",
    "* upper()\n",
    "* str()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " The command len() counts the number of characters in a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "len(\"This is a string\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The command lower() gets rid of all the capital letters in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\"Monty Python\".lower()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The command upper() gets replaces all lower case letters with upper case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\"monty python\".upper()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The command str() turns all non-strings into strings. For example, str(206) would become \"206\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "str(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Now try to combine this with the print and variable functions in this cell\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A function is a reusable piece of code that is designed for a specific use.  You can use built-in functions like print, or create your own. We did this with our MealCost program. Fuctions are defined with two componets:\n",
    "\n",
    "* The header, which includes the def keyword, the name of the fuction, and any parameters. If you look below, you can see the header we used in MealCost. We used the keyword def, we named our function MealCost, and we used parameters. Parameters are the inputs the computer will use in place of the variables when the function is actually used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def MealCost(a, b, c):"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Then we have the body, which describes the steps the function carries out. The body is indented as you can see below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def MealCost(a, b, c):  \n",
    "    meal = a\n",
    "    tax = b/100\n",
    "    tip = c/100\n",
    "    meal = meal + meal * tax \n",
    "    total = meal + meal*tip\n",
    "    print(\"%.2f\" % total)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After defining a function, you have to call it to use it. To do this, you type the function name, followed by parentheses. If you need to include parameters, you do so inside the parenthesis. Let's try calling the function MealCost."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "MealCost(44.50, 6.75, 15)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditionals and Control Flow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far, we've been working with single-minded programs; they can do one thing, like print something or multiply two numbers, but they can't make choices to do one thing over another. Control flow helps us do this. Control flow allows us to get different outputs based on what is happening in the rest of the program. Take a look at the example from Codecademy below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def clinic():\n",
    "    print(\"You've just entered the clinic!\")\n",
    "    print(\"Do you take the door on the left or the right?\")\n",
    "    answer = input(\"Type left or right and hit 'Enter'.\").lower()\n",
    "    if answer == \"left\" or answer == \"l\":\n",
    "        print(\"This is the Verbal Abuse Room, you heap of parrot droppings!\")\n",
    "    elif answer == \"right\" or answer == \"r\":\n",
    "        print(\"Of course this is the Argument Room, I've told you that already!\")\n",
    "    else:\n",
    "        print(\"You didn't pick left or right! Try again.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "clinic()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll take a better look at this later, but take a look at what we're telling the computer. If you get one answer, print this. If you get this other answer, print this. Else (if you don't get either answer), print this. That's the jist of control flow."
   ]
  }
 ],
 "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.5.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}