Week_02.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Comments & Data Types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    }
   ],
   "source": [
    "# this is a comment\n",
    "\n",
    "\"\"\"\n",
    "    this is a\n",
    "    multi-line\n",
    "    comment\n",
    "\"\"\"\n",
    "\n",
    "print('Hello') # this is also a comment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "# the following are all integers\n",
    "\n",
    "print(2)\n",
    "\n",
    "print(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10.953\n",
      "8.0\n"
     ]
    }
   ],
   "source": [
    "# the following are all floats\n",
    "\n",
    "print(10.953)\n",
    "\n",
    "print(8.0) # even this number is a float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# the following are booleans\n",
    "\n",
    "print(True)\n",
    "\n",
    "print(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "There's a snake in my boot!\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# the following are strings\n",
    "\n",
    "print('')\n",
    "\n",
    "print(\"There's a snake in my boot!\")\n",
    "\n",
    "print('True')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'sport' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-2-b0dc95ed88db>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mSport\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'baseball'\u001b[0m    \u001b[1;31m# capital 'S'\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msport\u001b[0m\u001b[1;33m)\u001b[0m          \u001b[1;31m# lowercase 's'\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'sport' is not defined"
     ]
    }
   ],
   "source": [
    "Sport = 'baseball'    # capital 'S'\n",
    "print(sport)          # lowercase 's'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 8.4\n"
     ]
    }
   ],
   "source": [
    "num1 = 5           # storing an integer into a variable\n",
    "\n",
    "num2 = 8.4         # storing a float into a variable\n",
    "\n",
    "print(num1, num2)  # you can print multiple items using commas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# storing a boolean into a variable\n",
    "\n",
    "switch = True\n",
    "\n",
    "print(switch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "John Smith 9\n"
     ]
    }
   ],
   "source": [
    "# storing strings into a variable\n",
    "\n",
    "name = 'John Smith'\n",
    "\n",
    "fav_number = '9'\n",
    "\n",
    "print(name, fav_number)       # will print 9 next to the name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13.4\n"
     ]
    }
   ],
   "source": [
    "# using two variables to create another variable\n",
    "\n",
    "result = num1 + num2\n",
    "\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14.4\n",
      "72.0\n"
     ]
    }
   ],
   "source": [
    "# adding, deleting, multiplying, dividing from a variable\n",
    "\n",
    "result += 1   # same as saying result = result + 1\n",
    "print(result)\n",
    "\n",
    "result *= num1   # same as saying result = result * num1\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "John\n",
      "Sam\n"
     ]
    }
   ],
   "source": [
    "# defining a variable and overwriting it's value\n",
    "\n",
    "name = 'John'\n",
    "print(name)\n",
    "\n",
    "name = 'Sam'\n",
    "print(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Working with Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "John Smith\n"
     ]
    }
   ],
   "source": [
    "# using the addition operator without variables\n",
    "\n",
    "name = 'John' + ' ' + 'Smith'\n",
    "\n",
    "print(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "John Smith\n"
     ]
    }
   ],
   "source": [
    "# using the addition operator with variables\n",
    "\n",
    "first_name = 'John'\n",
    "last_name = 'Smith'\n",
    "\n",
    "full_name = first_name + ' ' + last_name\n",
    "\n",
    "print(full_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello John\n",
      "Hello John, you are 28 years old!\n"
     ]
    }
   ],
   "source": [
    "# injecting variables using the format method\n",
    "\n",
    "name = 'John'\n",
    "\n",
    "print('Hello {}'.format(name))\n",
    "\n",
    "print('Hello {}, you are {} years old!'.format(name, 28))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello John\n"
     ]
    }
   ],
   "source": [
    "# using the new f strings\n",
    "\n",
    "name = 'John'\n",
    "\n",
    "print(f'Hello {name}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, John\n"
     ]
    }
   ],
   "source": [
    "# one major difference between versions 2 & 3\n",
    "\n",
    "name = 'John'\n",
    "\n",
    "print('Hello, %s' % name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, John Smith\n"
     ]
    }
   ],
   "source": [
    "# python 2 multiple variable formatting\n",
    "\n",
    "first_name = \"John\"\n",
    "last_name = \"Smith\"\n",
    "\n",
    "print(\"Hello, %s %s\" % (first_name, last_name))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H\n",
      "e\n",
      "o\n"
     ]
    }
   ],
   "source": [
    "# using indexes to print each element\n",
    "\n",
    "word = 'Hello'\n",
    "\n",
    "print(word[0])        # will output 'H'\n",
    "print(word[1])        # will output 'e'\n",
    "print(word[-1])       # will output 'o'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "He\n"
     ]
    }
   ],
   "source": [
    "print(word[0:2])      # will output 'He'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hlo\n"
     ]
    }
   ],
   "source": [
    "print( word[ 0 : 5 : 2 ] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Manipulating Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "John Smith\n"
     ]
    }
   ],
   "source": [
    "# using the title method to capitalize a string\n",
    "\n",
    "name = 'john smith'\n",
    "\n",
    "print(name.title())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello there.\n"
     ]
    }
   ],
   "source": [
    "# replacing an exclamation point with a period\n",
    "\n",
    "words = 'Hello there!'\n",
    "\n",
    "print(words.replace('!', '.'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "# finding the starting index of our searched term\n",
    "\n",
    "s = 'Look over that way'\n",
    "\n",
    "print(s.find('over'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "john\n"
     ]
    }
   ],
   "source": [
    "# removing white space with strip\n",
    "\n",
    "name = '   john   '\n",
    "\n",
    "print(name.strip( ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['These', 'words', 'are', 'separated', 'by', 'spaces']\n"
     ]
    }
   ],
   "source": [
    "# converting a string into a list of words\n",
    "\n",
    "s = 'These words are separated by spaces'\n",
    "\n",
    "print(s.split(' '))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Friday Project: Printing Receipts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "**************************************************\n",
      "\t\tCoding Temple, Inc.\n",
      "\t\t283 Franklin St.\n",
      "\t\tBoston, Ma\n",
      "==================================================\n",
      "\tProduct Name\tProduct Price\n",
      "\tBooks\t\t$49.95\n",
      "\tComputer\t$579.99\n",
      "\tMonitor\t\t$124.89\n",
      "==================================================\n",
      "\t\t\tTotal\n",
      "\t\t\t$754.83\n",
      "==================================================\n",
      "\n",
      "\tThanks for shopping with us today!\n",
      "\n",
      "**************************************************\n"
     ]
    }
   ],
   "source": [
    "# create a product and price for three items\n",
    "p1_name, p1_price = 'Books', 49.95\n",
    "p2_name, p2_price = 'Computer', 579.99\n",
    "p3_name, p3_price = 'Monitor', 124.89\n",
    "\n",
    "# create a company name and information\n",
    "company_name = 'coding temple, inc.'\n",
    "company_address = '283 Franklin St.'\n",
    "company_city = 'Boston, MA'\n",
    "\n",
    "# declare ending message\n",
    "message = 'Thanks for shopping with us today!'\n",
    "\n",
    "# create a top border\n",
    "print('*' * 50)\n",
    "\n",
    "# print company information first using format\n",
    "print('\\t\\t{}'.format(company_name.title()))\n",
    "print('\\t\\t{}'.format(company_address.title()))\n",
    "print('\\t\\t{}'.format(company_city.title()))\n",
    "\n",
    "# print a line between sections\n",
    "print('=' * 50)\n",
    "\n",
    "# print out header for section of items\n",
    "print('\\tProduct Name\\tProduct Price')\n",
    "\n",
    "# create a print statement for each item\n",
    "print('\\t{}\\t\\t${}'.format(p1_name.title(), p1_price))\n",
    "print('\\t{}\\t${}'.format(p2_name.title(), p2_price))\n",
    "print('\\t{}\\t\\t${}'.format(p3_name.title(), p3_price))\n",
    "\n",
    "# print a line between sections\n",
    "print('=' * 50)\n",
    "\n",
    "# print out header for section of total\n",
    "print('\\t\\t\\tTotal')\n",
    "\n",
    "# calculate total price and print out\n",
    "total = p1_price + p2_price + p3_price\n",
    "print('\\t\\t\\t${}'.format(total))\n",
    "\n",
    "# print a line between sections\n",
    "print('=' * 50)\n",
    "\n",
    "# output thank you message\n",
    "print('\\n\\t{}\\n'.format(message))\n",
    "\n",
    "# create a bottom border\n",
    "print('*' * 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Monday Exercises - Answers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "1. <b>Output:</b> Print our your name.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Connor P. Milliken\n"
     ]
    }
   ],
   "source": [
    "print(\"Connor P. Milliken\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "2. <b>Type Checking:</b> Try checking the type of a value by using the type() method. This will always print out what kind of data type you're checking. This is useful to check data types when you're unsure. As an example:\n",
    "</p>\n",
    "\n",
    "<p>\n",
    ">>> type(int)    # will output <class \"int\">\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tuesday Exercises - Answers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "1. <b>Variable Output:</b> Store the value 3 in a variable called \"x\" and the value 10 in a variable called \"y\". Save the result of x * y into a separate variabled called \"result\". Finally, output the information so it shows like the following:\n",
    "</p>\n",
    "\n",
    "<p>\n",
    ">>> 3 + 10 = 13\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 * 10 = 30\n"
     ]
    }
   ],
   "source": [
    "x = 3\n",
    "y = 10\n",
    "\n",
    "result = x  * y\n",
    "\n",
    "print(x, '*', y, '=', result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "2. <b>Area Calculation:</b> Calculate the area of a 245.54\" x 13.66\" rectangle. Print out the result. HINT: Area is width multiplied by height.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The area is 3354.0764\n"
     ]
    }
   ],
   "source": [
    "width = 245.54\n",
    "height = 13.66\n",
    "\n",
    "area = width * height\n",
    "\n",
    "print('The area is', area)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Wednesday Exercises - Answers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "1. <b>Variable Injection:</b> Create a print statement that injects an integer, float, boolean, and string all into one line. The output should look like \"23 4.5 False John\".\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23 4.5 False John\n"
     ]
    }
   ],
   "source": [
    "print(\"{} {} {} {}\".format(23, 4.5, False, \"John\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "2. <b>Fill in the Blanks:</b> Using the format method, fill in the blanks below by assinging your name and favorite activities into variables:\n",
    "</p>\n",
    "\n",
    "<p>\n",
    "\"{}'s favorite sport is {}.\"\n",
    "</p>\n",
    "\n",
    "<p>\n",
    "\"{} is working on {} programming!\"\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Connor's favorite sport is Baseball\n",
      "Connor is working on Python programming!\n"
     ]
    }
   ],
   "source": [
    "print(\"{}'s favorite sport is {}\".format(\"Connor\", \"Baseball\"))\n",
    "print(\"{} is working on {} programming!\".format(\"Connor\", \"Python\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Thursday Exercises - Answers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "1. <b>Uppercasing:</b> Try manipulating the string 'uppercase' so it prints out as all uppercase letters. You'll need to lookup a new method.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "UPPERCASE\n"
     ]
    }
   ],
   "source": [
    "s = 'uppercase'\n",
    "\n",
    "print(s.upper())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "2. <b>Strip Symbols:</b> Strip all dollar signs from the left side of this string \"$$John Smith\". Try it with .lstrip() and .strip(). To see a description of how to use the strip method further, try using the help function by typing the following:\n",
    "</p>\n",
    "\n",
    "<p>\n",
    ">>> help(\"\".strip)\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "John Smith\n"
     ]
    }
   ],
   "source": [
    "# help(\"\".strip)\n",
    "\n",
    "s = \"$$John Smith\"\n",
    "\n",
    "print(s.lstrip('$'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# End of Week Exercises - Answers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "1. <b>Side Borders:</b> In the Friday project, we ended up creating borders above and below the information printed out. Try adding a star border on the sides as well now.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "**************************************************\n",
      "*\t\tCoding Temple, Inc.\t\t *\n",
      "*\t\t283 Franklin St.\t\t *\n",
      "*\t\tBoston, Ma\t\t\t *\n",
      "*================================================*\n",
      "*\tProduct Name\tProduct Price\t\t *\n",
      "*\tBooks\t\t$49.95\t\t\t *\n",
      "*\tComputer\t$579.99\t\t\t *\n",
      "*\tMonitor\t\t$124.89\t\t\t *\n",
      "*================================================*\n",
      "*\t\t\tTotal\t\t\t *\n",
      "*\t\t\t$754.83\t\t\t *\n",
      "*================================================*\n",
      "*\t\t\t\t\t\t *\n",
      "*\tThanks for shopping with us today!\t *\n",
      "*\t\t\t\t\t\t *\n",
      "**************************************************\n"
     ]
    }
   ],
   "source": [
    "# create a product and price for three items\n",
    "p1_name, p1_price = 'Books', 49.95\n",
    "p2_name, p2_price = 'Computer', 579.99\n",
    "p3_name, p3_price = 'Monitor', 124.89\n",
    "\n",
    "# create a company name and information\n",
    "company_name = 'coding temple, inc.'\n",
    "company_address = '283 Franklin St.'\n",
    "company_city = 'Boston, MA'\n",
    "\n",
    "# declare ending message\n",
    "message = 'Thanks for shopping with us today!'\n",
    "\n",
    "# create a top border\n",
    "print('*' * 50)\n",
    "\n",
    "# print company information first using format\n",
    "print('*\\t\\t{}\\t\\t *'.format(company_name.title()))\n",
    "print('*\\t\\t{}\\t\\t *'.format(company_address.title()))\n",
    "print('*\\t\\t{}\\t\\t\\t *'.format(company_city.title()))\n",
    "\n",
    "# print a line between sections\n",
    "print('*' + '=' * 48 + '*')\n",
    "\n",
    "# print out header for section of items\n",
    "print('*\\tProduct Name\\tProduct Price\\t\\t *')\n",
    "\n",
    "# create a print statement for each item\n",
    "print('*\\t{}\\t\\t${}\\t\\t\\t *'.format(p1_name.title(), p1_price))\n",
    "print('*\\t{}\\t${}\\t\\t\\t *'.format(p2_name.title(), p2_price))\n",
    "print('*\\t{}\\t\\t${}\\t\\t\\t *'.format(p3_name.title(), p3_price))\n",
    "\n",
    "# print a line between sections\n",
    "print('*' + '=' * 48 + '*')\n",
    "\n",
    "# print out header for section of total\n",
    "print('*\\t\\t\\tTotal\\t\\t\\t *')\n",
    "\n",
    "# calculate total price and print out\n",
    "total = p1_price + p2_price + p3_price\n",
    "print('*\\t\\t\\t${}\\t\\t\\t *'.format(total))\n",
    "\n",
    "# print a line between sections\n",
    "print('*' + '=' * 48 + '*')\n",
    "\n",
    "# output thank you message\n",
    "print('*\\t\\t\\t\\t\\t\\t *\\n*\\t{}\\t *\\n*\\t\\t\\t\\t\\t\\t *'.format(message))\n",
    "\n",
    "# create a bottom border\n",
    "print('*' * 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "2. <b>Researching Methods:</b> We've gone over a few of the string manipulation methods that are widely used; however, there's many more, try looking up some and implementing them.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "3. <b>Reverse:</b> Declare a variable equal to \"Hello\". Reverse the string using slicing. Try looking it up if you struggle. Tip: You can define a start, stop, and step when slicing.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "olleH\n"
     ]
    }
   ],
   "source": [
    "s = \"Hello\"\n",
    "\n",
    "print(s[::-1])"
   ]
  }
 ],
 "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}