Chapter 8-Functions

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#FUNCTIONS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello!\n"
     ]
    }
   ],
   "source": [
    "#Defining a function\n",
    "\n",
    "def greet_user():\n",
    "    \"\"\"Display a simple greeting\"\"\"\n",
    "    print(\"Hello!\")\n",
    "    \n",
    "greet_user()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Smitha!\n"
     ]
    }
   ],
   "source": [
    "#Passing information to a function\n",
    "\n",
    "def greet_user(username):\n",
    "    \"\"\"Display a simple greeting\"\"\"\n",
    "    print(\"Hello, \"+username.title()+\"!\")\n",
    "\n",
    "greet_user('Smitha')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am learning about functions in this chapter.\n"
     ]
    }
   ],
   "source": [
    "#Exercise 8.1 Message\n",
    "\n",
    "def display_message():\n",
    "    \"\"\"Displays a simple sentence.\"\"\"\n",
    "    print(\"I am learning about functions in this chapter.\")\n",
    "    \n",
    "display_message()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "One of my favorite books is Alice In Wonderland!\n"
     ]
    }
   ],
   "source": [
    "#Exercise 8.2 Favorite Book\n",
    "\n",
    "def favorite_book(title):\n",
    "    \"\"\"Displays a sentence with argument stored in parameter.\"\"\"\n",
    "    print(\"One of my favorite books is \"+title.title()+\"!\")\n",
    "\n",
    "favorite_book('alice in wonderland')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "I have a Labrador Retriever.\n",
      "My Labrador Retriever's name is Zeus.\n"
     ]
    }
   ],
   "source": [
    "#Positional Arguments \n",
    "\n",
    "def describe_pet(animal_type, pet_name):\n",
    "    \"\"\"Display info about a pet\"\"\"\n",
    "    print(\"\\nI have a \"+animal_type.title()+\".\")\n",
    "    print(\"My \"+animal_type.title()+\"'s name is \"+pet_name.title()+\".\")\n",
    "\n",
    "describe_pet('labrador retriever','zeus')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "I have a Labrador Retriever.\n",
      "My Labrador Retriever's name is Zeus.\n",
      "\n",
      "I have a Hamster.\n",
      "My Hamster's name is Harry.\n"
     ]
    }
   ],
   "source": [
    "#Keyword Arguments\n",
    "\n",
    "\n",
    "def describe_pet(animal_type, pet_name):\n",
    "    \"\"\"Display info about a pet\"\"\"\n",
    "    print(\"\\nI have a \"+animal_type.title()+\".\")\n",
    "    print(\"My \"+animal_type.title()+\"'s name is \"+pet_name.title()+\".\")\n",
    "    \n",
    "describe_pet(animal_type='labrador retriever', pet_name='zeus')\n",
    "describe_pet( pet_name='harry', animal_type='hamster')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "I have a Dog.\n",
      "My Dog's name is Zeus.\n"
     ]
    }
   ],
   "source": [
    "#default value\n",
    "\n",
    "def describe_pet(pet_name, animal_type='dog'):\n",
    "    \"\"\"Display info about a pet\"\"\"\n",
    "    print(\"\\nI have a \"+animal_type.title()+\".\")\n",
    "    print(\"My \"+animal_type.title()+\"'s name is \"+pet_name.title()+\".\")\n",
    "    \n",
    "describe_pet(pet_name='zeus')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "I have a Dog.\n",
      "My Dog's name is Willie.\n"
     ]
    }
   ],
   "source": [
    "describe_pet('willie')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "The size of my shirt is: M\n",
      "The text to be displayed on the shirt is: Real Men Wear Pink.\n"
     ]
    }
   ],
   "source": [
    "#Exercises \n",
    "#Exercise 8.3 T-shirt\n",
    "#Using positional arguments\n",
    "\n",
    "def make_shirt(size, text):\n",
    "    \"\"\"Display size and text message displayed on a t-shirt\"\"\"\n",
    "    print(\"\\nThe size of my shirt is: \"+size.upper())\n",
    "    print(\"The text to be displayed on the shirt is: \"+text.title()+\".\")\n",
    "    \n",
    "make_shirt('m', 'real men wear pink')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "The size of my shirt is: M\n",
      "The text to be displayed on the shirt is: Real Men Wear Pink.\n"
     ]
    }
   ],
   "source": [
    "#Using keyword arguments\n",
    "\n",
    "def make_shirt(size, text):\n",
    "    \"\"\"Display size and text message displayed on a t-shirt\"\"\"\n",
    "    print(\"\\nThe size of my shirt is: \"+size.upper())\n",
    "    print(\"The text to be displayed on the shirt is: \"+text.title()+\".\")\n",
    "    \n",
    "make_shirt(text='real men wear pink',size='m')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "The size of my shirt is: L\n",
      "The text to be displayed on the shirt is: I Love Python.\n",
      "\n",
      "The size of my shirt is: M\n",
      "The text to be displayed on the shirt is: I Love Python.\n",
      "\n",
      "The size of my shirt is: S\n",
      "The text to be displayed on the shirt is: This Is Interesting.\n"
     ]
    }
   ],
   "source": [
    "#Exercise 8.4 Large Shirts\n",
    "\n",
    "def make_shirt(text='I love python', size='l'):\n",
    "    \"\"\"Display size and text message displayed on a t-shirt\"\"\"\n",
    "    print(\"\\nThe size of my shirt is: \"+size.upper())\n",
    "    print(\"The text to be displayed on the shirt is: \"+text.title()+\".\")\n",
    "\n",
    "make_shirt()\n",
    "make_shirt(size='m')\n",
    "make_shirt(size='s', text='this is interesting')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "New York is in United States.\n",
      "\n",
      "La is in United States.\n",
      "\n",
      "Florida is in United States.\n"
     ]
    }
   ],
   "source": [
    "#Exercise 8.5 Cities\n",
    "\n",
    "def describe_city(name_city, name_country='united states'):\n",
    "    \"\"\"Display a simple sentence about the city and its country.\"\"\"\n",
    "    print(\"\\n\"+name_city.title()+\" is in \"+name_country.title()+\".\")\n",
    "    \n",
    "describe_city('new york')\n",
    "describe_city('LA')\n",
    "describe_city('florida')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Smitha Achar'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Return Values\n",
    "\n",
    "def formatted_name(firstname, lastname):\n",
    "    \"\"\"Return a full name, neatly formatted.\"\"\"\n",
    "    full_name=firstname+' '+lastname\n",
    "    return full_name.title()\n",
    "\n",
    "formatted_name('smitha', 'achar')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Smitha Achar'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Making an Argument Optional\n",
    "\n",
    "\n",
    "def formatted_name(firstname, lastname, middlename=''):\n",
    "    \"\"\"Return a full name, neatly formatted.\"\"\"\n",
    "    if middlename:\n",
    "        full_name=firstname+' '+middlename+' '+lastname\n",
    "    else:\n",
    "        full_name=firstname+' '+lastname\n",
    "    return full_name.title()\n",
    "\n",
    "formatted_name('smitha', 'achar')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Arjun Singh Yadav'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "formatted_name('arjun', 'yadav', middlename='singh',)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Arjun Singh Yadav'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "formatted_name('arjun', 'yadav', 'singh')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'first': 'smitha', 'last': 'achar'}"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Returning a Dictionary\n",
    "\n",
    "def build_person(firstname, lastname):\n",
    "    \"\"\"Return a dictionary of information about a person.\"\"\"\n",
    "    person={'first':firstname, 'last':lastname}\n",
    "    return person\n",
    "\n",
    "build_person('smitha','achar')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'age': '24', 'first': 'smitha', 'last': 'achar'}"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def build_person(firstname, lastname, age=''):\n",
    "    \"\"\"Return a dictionary of information about a person.\"\"\"\n",
    "    person={'first':firstname, 'last':lastname}\n",
    "    if age:\n",
    "        person['age']=age\n",
    "    return person\n",
    "\n",
    "build_person('smitha','achar', age='24')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Please tell me your name: \n",
      "(enter q at anytime to quit)\n",
      "First name: smitha\n",
      "Last name: achar\n",
      "\n",
      "Hello, Smitha Achar!\n",
      "\n",
      "Please tell me your name: \n",
      "(enter q at anytime to quit)\n",
      "First name: q\n"
     ]
    }
   ],
   "source": [
    "#Using a Function with a while Loop\n",
    "\n",
    "def formatted_name(firstname, lastname):\n",
    "    \"\"\"Return a full name, neatly formatted.\"\"\"\n",
    "    full_name=firstname+' '+lastname\n",
    "    return full_name.title()\n",
    "\n",
    "while True:\n",
    "    print(\"\\nPlease tell me your name: \")\n",
    "    print(\"(enter q at anytime to quit)\")\n",
    "    \n",
    "    f_name=input(\"First name: \")\n",
    "    if f_name == 'q':\n",
    "        break\n",
    "        \n",
    "    l_name=input(\"Last name: \")\n",
    "    if l_name=='q':\n",
    "        break\n",
    "        \n",
    "    formatted_name=formatted_name(f_name,l_name)        \n",
    "    print(\"\\nHello, \"+formatted_name+\"!\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Santiago, Chile'"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Exercises\n",
    "#Exercise 8.6 City Names\n",
    "\n",
    "def city_country(city, country):\n",
    "    \"\"\"Display a city and country information\"\"\"\n",
    "    info=city+\", \"+country\n",
    "    return info.title()\n",
    "\n",
    "city_country('santiago', 'chile')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Dubai, United Arab Emirates'"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "city_country('dubai','united arab emirates')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Name': 'Rihanna', 'Title': 'Good Girl Gone Bad'}"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Exercise 8.7 Album \n",
    "\n",
    "def make_album(artist_name,album_title):\n",
    "    \"\"\"Display a dictionary of info about an artist and album.\"\"\"\n",
    "    artist={'Name':artist_name, 'Title':album_title}\n",
    "    return artist\n",
    "\n",
    "make_album('Rihanna','Good Girl Gone Bad')\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Name': 'Backstreet Boys', 'Title': 'Incomplete'}"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "make_album('Backstreet Boys', 'Incomplete')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Name': 'Beyonce', 'Title': 'Irreplaceable'}"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "make_album('Beyonce', 'Irreplaceable')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Name': 'Rihanna', 'Title': 'Good Girl Gone Bad', 'tracks': '20'}"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def make_album(artist_name,album_title,tracks=''):\n",
    "    \"\"\"Display a dictionary of info about an artist and album.\"\"\"\n",
    "    artist={'Name':artist_name, 'Title':album_title}\n",
    "    if tracks:\n",
    "        artist['tracks']= tracks\n",
    "    return artist\n",
    "make_album('Rihanna', 'Good Girl Gone Bad', '20')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Please enter details of artist:\n",
      "(enter q at anytime to quit)\n",
      "Artist name: rihanna\n",
      "Album title: good girl gone bad\n",
      "{'Name': 'rihanna', 'Title': 'good girl gone bad'}\n",
      "\n",
      "Please enter details of artist:\n",
      "(enter q at anytime to quit)\n",
      "Artist name: q\n"
     ]
    }
   ],
   "source": [
    "#Exercise 8.8 User Albums\n",
    "\n",
    "def make_album(artist_name,album_title):\n",
    "    \"\"\"Display a dictionary of info about an artist and album.\"\"\"\n",
    "    artist={'Name':artist_name, 'Title':album_title}\n",
    "    print(artist)\n",
    "\n",
    "while True:\n",
    "    print(\"\\nPlease enter details of artist:\")\n",
    "    print(\"(enter q at anytime to quit)\")\n",
    "    \n",
    "    artist_name=input(\"Artist name: \")\n",
    "    if artist_name=='q':\n",
    "        break\n",
    "        \n",
    "    album_title=input(\"Album title: \")\n",
    "    if album_title=='q':\n",
    "        break\n",
    "    make_album(artist_name, album_title)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Hannah!\n",
      "Hello, Ty!\n",
      "Hello, Margot!\n"
     ]
    }
   ],
   "source": [
    "#Passing a List\n",
    "\n",
    "def greet_users(names):\n",
    "    \"\"\"Print a simple greeting to every user on list.\"\"\"\n",
    "    for name in names:\n",
    "        msg=\"Hello, \"+ name.title()+\"!\"\n",
    "        print(msg)\n",
    "        \n",
    "names=['hannah','ty','margot']\n",
    "greet_users(names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Printint model: dodecahedron\n",
      "Printint model: robot pendant\n",
      "Printint model: iphone case\n",
      "\n",
      "The following models have been printed: \n",
      "dodecahedron\n",
      "robot pendant\n",
      "iphone case\n"
     ]
    }
   ],
   "source": [
    "#Modifying a list in a function\n",
    "#Below program carried out without the use of functions\n",
    "\n",
    "unprinted_designs=['iphone case', 'robot pendant', 'dodecahedron']\n",
    "completed_models=[]\n",
    "\n",
    "while unprinted_designs:\n",
    "    current_design=unprinted_designs.pop()\n",
    "    \n",
    "    print(\"Printint model: \"+current_design)\n",
    "    completed_models.append(current_design)\n",
    "    \n",
    "print(\"\\nThe following models have been printed: \")\n",
    "for completed_model in completed_models:\n",
    "    print(completed_model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Printing model: dodecahedron\n",
      "Printing model: robot pendant\n",
      "Printing model: iphone case\n",
      "\n",
      "The following models have been printed: \n",
      "dodecahedron\n",
      "robot pendant\n",
      "iphone case\n"
     ]
    }
   ],
   "source": [
    "#Using functions for the above program\n",
    "\n",
    "def print_models(unprinted_designs, completed_designs):\n",
    "    \"\"\"Simulate printing each design, until none are left.\n",
    "    Move each design to completed_models after printing\"\"\"\n",
    "    \n",
    "    while unprinted_designs:\n",
    "        current_design=unprinted_designs.pop()\n",
    "        \n",
    "        print(\"Printing model: \"+current_design)\n",
    "        completed_designs.append(current_design)\n",
    "        \n",
    "def show_completed_models(completed_models):\n",
    "    \"\"\"Show all models that were printed.\"\"\"\n",
    "    print(\"\\nThe following models have been printed: \")\n",
    "    for completed_model in completed_models:\n",
    "        print(completed_model)\n",
    "        \n",
    "unprinted_designs=['iphone case', 'robot pendant', 'dodecahedron']\n",
    "completed_models=[]\n",
    "\n",
    "print_models(unprinted_designs, completed_models)\n",
    "show_completed_models(completed_models)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rodrigo\n",
      "Albert\n",
      "Cirque De Sole\n"
     ]
    }
   ],
   "source": [
    "#Exercises \n",
    "#Exercise 8.9 Magicians\n",
    "\n",
    "names=['Rodrigo', 'Albert', 'Cirque De Sole']\n",
    "\n",
    "def show_magicians():\n",
    "    \"\"\"Prints a list of names of magicians\"\"\"\n",
    "    for name in names:\n",
    "        print(name)\n",
    "\n",
    "show_magicians()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The great Rodrigo.\n",
      "The great Albert.\n",
      "The great Cirque De Sole.\n",
      "Rodrigo\n",
      "Albert\n",
      "Cirque De Sole\n"
     ]
    }
   ],
   "source": [
    "#Exercise 8.10 Great Magicians\n",
    "\n",
    "names=['Rodrigo', 'Albert', 'Cirque De Sole']\n",
    "\n",
    "def show_magicians():\n",
    "    \"\"\"Prints a list of names of magicians\"\"\"\n",
    "    for name in names:\n",
    "        print(name)\n",
    "\n",
    "def make_great():\n",
    "    \"\"\"Modifies the list of magicians to add 'The Great' next to their name\"\"\"\n",
    "    for name in names:\n",
    "        print(\"The great \"+name+\".\")\n",
    "\n",
    "make_great()\n",
    "show_magicians()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('pepperoni',)\n",
      "('mushrooms', 'green peppers', 'extra cheese')\n"
     ]
    }
   ],
   "source": [
    "#Passing an Arbitary Number of Arguments\n",
    "\n",
    "def make_pizza(*toppings):\n",
    "    \"\"\"Print the list of toppings that have been requested.\"\"\"\n",
    "    print(toppings)\n",
    "    \n",
    "make_pizza('pepperoni')\n",
    "make_pizza('mushrooms', 'green peppers', 'extra cheese')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Making a pizza with the following toppings: \n",
      "- pepperoni\n",
      "\n",
      "Making a pizza with the following toppings: \n",
      "- mushrooms\n",
      "- green peppers\n",
      "- extra cheese\n"
     ]
    }
   ],
   "source": [
    "def make_pizza(*toppings):\n",
    "    \"\"\"Print the list of toppings that have been requested.\"\"\"\n",
    "    print(\"\\nMaking a pizza with the following toppings: \")\n",
    "    for topping in toppings:\n",
    "        print(\"- \"+topping)\n",
    "    \n",
    "make_pizza('pepperoni')\n",
    "make_pizza('mushrooms', 'green peppers', 'extra cheese')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Making a 16-inch pizza with the following toppings: \n",
      "- pepperoni\n",
      "\n",
      "Making a 12-inch pizza with the following toppings: \n",
      "- mushrooms\n",
      "- green peppers\n",
      "- extra cheese\n"
     ]
    }
   ],
   "source": [
    "#Making Positional and Arbitary Arguments\n",
    "\n",
    "def make_pizza(size, *toppings):\n",
    "    \"\"\"Summarize the size and list of toppings that have been requested.\"\"\"\n",
    "    print(\"\\nMaking a \"+str(size)+\"-inch pizza with the following toppings: \")\n",
    "    for topping in toppings:\n",
    "        print(\"- \"+topping)\n",
    "    \n",
    "make_pizza('16','pepperoni')\n",
    "make_pizza('12','mushrooms', 'green peppers', 'extra cheese')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'field': 'physics',\n",
       " 'first name': 'albert',\n",
       " 'last name': 'einstein',\n",
       " 'location': 'princeton'}"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Using Arbitary Keyword Arguments\n",
    "\n",
    "def build_profile(first, last, **user_info):\n",
    "    \"\"\"Build a dictionary containing information we know about a user.\"\"\"\n",
    "    profile={}\n",
    "    profile['first name']=first\n",
    "    profile['last name']=last\n",
    "    for key, value in user_info.items():\n",
    "        profile[key]=value\n",
    "    return profile\n",
    "\n",
    "build_profile('albert','einstein',location='princeton',field='physics')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The ingredient added in the sandwich is: bread\n",
      "\n",
      "The ingredient added in the sandwich is: lettuce\n",
      "\n",
      "The ingredient added in the sandwich is: tomato\n",
      "\n",
      "The ingredient added in the sandwich is: onion\n",
      "\n",
      "The ingredient added in the sandwich is: bread\n",
      "\n",
      "The ingredient added in the sandwich is: tomato\n",
      "\n",
      "The ingredient added in the sandwich is: cheese\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Exercises\n",
    "#Exercise 8.12 Sandwiches\n",
    "\n",
    "def sandwich(*ingredients):\n",
    "    \"\"\"Ingredients used to make a sandwich.\"\"\"\n",
    "    for ingredient in ingredients:\n",
    "        print(\"The ingredient added in the sandwich is: \"+ingredient+\"\\n\")\n",
    "        \n",
    "sandwich('bread', 'lettuce','tomato', 'onion')\n",
    "sandwich('bread','tomato')\n",
    "sandwich('cheese')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'first name': 'smitha',\n",
       " 'hobby': 'swimming',\n",
       " 'home': 'dubai',\n",
       " 'last name': 'achar',\n",
       " 'location': 'new york'}"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Exercise 8.13 User Profile\n",
    "\n",
    "\n",
    "def build_profile(first, last, **user_info):\n",
    "    \"\"\"Build a dictionary containing information we know about a user.\"\"\"\n",
    "    profile={}\n",
    "    profile['first name']=first\n",
    "    profile['last name']=last\n",
    "    for key, value in user_info.items():\n",
    "        profile[key]=value\n",
    "    return profile\n",
    "\n",
    "build_profile('smitha','achar',location='new york',hobby='swimming',home='dubai')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Manufacturer name': 'subaru',\n",
       " 'Model name': 'outback',\n",
       " 'color': 'blue',\n",
       " 'tow_package': True}"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Exercise 8.14 Cars\n",
    "\n",
    "def info_car(manufacturer,model_name,**car_details):\n",
    "    \"\"\"Build a dictionary containing information about a car\"\"\"\n",
    "    details={}\n",
    "    details['Manufacturer name']=manufacturer\n",
    "    details['Model name']=model_name\n",
    "    for key, value in car_details.items():\n",
    "        details[key]=value\n",
    "    return details\n",
    "\n",
    "info_car('subaru','outback',color='blue',tow_package=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is Smitha.\n"
     ]
    }
   ],
   "source": [
    "print(\"My name is Smitha.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Storing your functions in modules\n",
    "\n",
    "#make two files pizza.py and making_pizza.py and save in the same directory. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Making a 16-inch pizza with the following toppings:\n",
      "-pepperoni\n"
     ]
    }
   ],
   "source": [
    "import pizza \n",
    "\n",
    "pizza.make_pizza(16,'pepperoni')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Making a 12-inch pizza with the following toppings:\n",
      "-mushrooms\n",
      "-green pepppers\n",
      "-extra cheese\n"
     ]
    }
   ],
   "source": [
    "#importing specific functions \n",
    "\n",
    "from pizza import make_pizza\n",
    "\n",
    "make_pizza(12,'mushrooms','green pepppers', 'extra cheese')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Making a 16-inch pizza with the following toppings:\n",
      "-pepperoni\n"
     ]
    }
   ],
   "source": [
    "#Using as to Give a Function an Alias\n",
    "\n",
    "from pizza import make_pizza as mp\n",
    "\n",
    "mp(16,'pepperoni')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Making a 16-inch pizza with the following toppings:\n",
      "-pepperoni\n"
     ]
    }
   ],
   "source": [
    "#Using as to Give a Module an Alias\n",
    "\n",
    "import pizza as p\n",
    "\n",
    "p.make_pizza(16,'pepperoni')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Making a 16-inch pizza with the following toppings:\n",
      "-pepperoni\n"
     ]
    }
   ],
   "source": [
    "#Importing all functions in a module\n",
    "\n",
    "from pizza import *\n",
    "\n",
    "make_pizza(16,'pepperoni')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#THE END"
   ]
  }
 ],
 "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}