PythonP2.ipynb

{
 "metadata": {
  "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.8.2"
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "python382jvsc74a57bd001e4a4ef43d7435a6845fd7336130797196ba9e9ad58f05806271349b7c58ab1",
   "display_name": "Python 3.8.2 64-bit"
  },
  "metadata": {
   "interpreter": {
    "hash": "01e4a4ef43d7435a6845fd7336130797196ba9e9ad58f05806271349b7c58ab1"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "source": [
    "# Python Bro"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "# Dictionaries\n",
    "- is a collection of key-value pair\n",
    "- key is connected to a value\n",
    "- u can use key to access the value associated with that key.\n",
    "- key value can be a number,a string, a list or even another dictionary\n",
    "- it is wrapped in curly braces i.e. {}"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "green\n5\n"
     ]
    }
   ],
   "source": [
    "# simple dictionary\n",
    "alien_0 ={'color':'green','points':5}\n",
    "print(alien_0['color'])\n",
    "print(alien_0['points'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "green\n"
     ]
    }
   ],
   "source": [
    "# accessing values in a dictionary\n",
    "alien_0={'color':'green'}\n",
    "print(alien_0['color'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "you just earned 5 points!\n"
     ]
    }
   ],
   "source": [
    "alien_0 ={'color':'green','points':5}\n",
    "new_points=alien_0['points']\n",
    "print(\"you just earned \"+ str(new_points)+\" points!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "{'color': 'green', 'points': 5, 'x_position': 0, 'y_position': 25}\n"
     ]
    }
   ],
   "source": [
    "# adding new key-value pairs\n",
    "alien_0 ={'color':'green','points':5}\n",
    "alien_0['x_position']=0\n",
    "alien_0['y_position']=25\n",
    "print(alien_0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "{'color': 'green', 'points': 5}\n"
     ]
    }
   ],
   "source": [
    "#starting with an empty dictionary\n",
    "alien_0={}\n",
    "alien_0['color']='green'\n",
    "alien_0['points']=5\n",
    "print(alien_0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "the alien is green.\nthe alien is now yellow.\n"
     ]
    }
   ],
   "source": [
    "#modifying values in a dicitonary\n",
    "alien_0={'color':'green'}\n",
    "print('the alien is '+ alien_0['color']+'.')\n",
    "\n",
    "alien_0['color']='yellow'\n",
    "print(\"the alien is now \"+ alien_0['color']+ '.');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "{'color': 'green', 'points': 5}\n{'points': 5}\n"
     ]
    }
   ],
   "source": [
    "# removing key-value pairs\n",
    "alien_0={'color':'green','points':5}\n",
    "print(alien_0)\n",
    "\n",
    "del alien_0['color']\n",
    "print(alien_0)\n",
    "\n",
    "# del alien_0['color'] tells python to deete the key 'points' from the dictionary alien_0 and to remove the value associated with that key as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Sarah's favorite labguage is C.\n"
     ]
    }
   ],
   "source": [
    "# a dicitonary of similar objects\n",
    "\n",
    "favroite_langugaes={\n",
    "    'jen':'python',\n",
    "    'sarah':'c',\n",
    "    'edward':'ruby',\n",
    "    'phil':'python'\n",
    "}\n",
    "\n",
    "print(\"Sarah's favorite labguage is \"+  favroite_langugaes['sarah'].title()+'.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "\nkey: username\nvalue :efermi\n\nkey: first\nvalue :enrico\n\nkey: last\nvalue :fermi\n"
     ]
    }
   ],
   "source": [
    "#looping through all the key-values pairs\n",
    "user_0={\n",
    "    'username':'efermi',\n",
    "    'first':'enrico',\n",
    "    'last':'fermi',\n",
    "}\n",
    "\n",
    "for key,value in user_0.items():\n",
    "    print(\"\\nkey: \"+key)\n",
    "    print('value :'+value)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Jen's favorite language is Python.\nSarah's favorite language is C.\nEdward's favorite language is Ruby.\nPhil's favorite language is Python.\n"
     ]
    }
   ],
   "source": [
    "favroite_langugaes={\n",
    "    'jen':'python',\n",
    "    'sarah':'c',\n",
    "    'edward':'ruby',\n",
    "    'phil':'python'\n",
    "}\n",
    "\n",
    "for name,language in favroite_langugaes.items():\n",
    "    print(name.title()+\"'s favorite language is \"+language.title()+'.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Name: jen\nName: sarah\nName: edward\nName: phil\n"
     ]
    }
   ],
   "source": [
    "#looping through all the keys in a dictionary\n",
    "favroite_langugaes={\n",
    "    'jen':'python',\n",
    "    'sarah':'c',\n",
    "    'edward':'ruby',\n",
    "    'phil':'python'\n",
    "}\n",
    "\n",
    "for name in favroite_langugaes.keys():\n",
    "    print(\"Name: \"+ name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Jen\nSarah\nHiSarah, I see your favorite language is C!\nEdward\nPhil\nHiPhil, I see your favorite language is Python!\n"
     ]
    }
   ],
   "source": [
    "favroite_langugaes={\n",
    "    'jen':'python',\n",
    "    'sarah':'c',\n",
    "    'edward':'ruby',\n",
    "    'phil':'python'\n",
    "}\n",
    "\n",
    "friends=['phil','sarah']\n",
    "for name in favroite_langugaes.keys():\n",
    "    print(name.title())\n",
    "\n",
    "    if name in friends:\n",
    "        print(\"Hi\"+name.title()+\", I see your favorite language is \"+ favroite_langugaes[name].title()+'!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Erin, please take a poll!\n"
     ]
    }
   ],
   "source": [
    "favroite_langugaes={\n",
    "    'jen':'python',\n",
    "    'sarah':'c',\n",
    "    'edward':'ruby',\n",
    "    'phil':'python'\n",
    "}\n",
    "\n",
    "if 'erin' not in favroite_langugaes.keys():\n",
    "    print(\"Erin, please take a poll!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Edward, thank you for taking the poll.\nJen, thank you for taking the poll.\nPhil, thank you for taking the poll.\nSarah, thank you for taking the poll.\n"
     ]
    }
   ],
   "source": [
    "# looping thriugh a dicitonary;s keys in order\n",
    "\n",
    "favroite_langugaes={\n",
    "    'jen':'python',\n",
    "    'sarah':'c',\n",
    "    'edward':'ruby',\n",
    "    'phil':'python'\n",
    "}\n",
    "\n",
    "for name in sorted(favroite_langugaes.keys()):\n",
    "    print(name.title()+\", thank you for taking the poll.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "The following language have been mentinoed:\nPython\nC\nRuby\nPython\n"
     ]
    }
   ],
   "source": [
    "# looping through all the values in a dicitonary\n",
    "\n",
    "favroite_langugaes={\n",
    "    'jen':'python',\n",
    "    'sarah':'c',\n",
    "    'edward':'ruby',\n",
    "    'phil':'python'\n",
    "}\n",
    "print(\"The following language have been mentinoed:\")\n",
    "for language in favroite_langugaes.values():\n",
    "    print(language.title())\n",
    "# here when the values are repeated the repeated values are not checked and is printed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "THe following language have been mentioned:\nPython\nC\nRuby\n"
     ]
    }
   ],
   "source": [
    "# to overcome the problem in above statement we use set\n",
    "# set is similar to list except that each item in a set must be unique\n",
    "\n",
    "favroite_langugaes={\n",
    "    'jen':'python',\n",
    "    'sarah':'c',\n",
    "    'edward':'ruby',\n",
    "    'phil':'python'\n",
    "}\n",
    "print('THe following language have been mentioned:')\n",
    "for language in set(favroite_langugaes.values()):\n",
    "    print(language.title())"
   ]
  },
  {
   "source": [
    "## Nesting\n",
    "- sometimes we want to store a set of dicitonaries in a list or a list of items as a value in a dcitionary. this is called nesting.\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "### A list of dictionaries\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[{'color': 'green', 'points': 5}, {'color': 'red', 'points': 15}, {'color': 'yellow', 'points': 10}]\n"
     ]
    }
   ],
   "source": [
    "alien_0={'color':'green','points':5}\n",
    "alien_1={'color':'yellow','points':10}\n",
    "alien_2={'color':\"red\",'points':15}\n",
    "alien=[alien_0,alien_2,alien_1]\n",
    "\n",
    "print(alien)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "{'color': 'green', 'points': 5, 'speed': 'slow'}\n{'color': 'green', 'points': 5, 'speed': 'slow'}\n{'color': 'green', 'points': 5, 'speed': 'slow'}\n{'color': 'green', 'points': 5, 'speed': 'slow'}\n{'color': 'green', 'points': 5, 'speed': 'slow'}\n....\nTotal no of aliens:30\n"
     ]
    }
   ],
   "source": [
    "aliens=[]\n",
    "for alien_number in range(30):\n",
    "    new_alien={'color':'green','points':5,'speed':'slow'}\n",
    "    aliens.append(new_alien)\n",
    "\n",
    "for alien in aliens[:5]:\n",
    "    print(alien)\n",
    "print('....')\n",
    "\n",
    "print('Total no of aliens:'+str(len(aliens)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "{'color': 'yellow', 'points': 10, 'speed': 'medium'}\n{'color': 'yellow', 'points': 10, 'speed': 'medium'}\n{'color': 'yellow', 'points': 10, 'speed': 'medium'}\n{'color': 'green', 'points': 5, 'speed': 'slow'}\n{'color': 'green', 'points': 5, 'speed': 'slow'}\n"
     ]
    }
   ],
   "source": [
    "aliens=[]\n",
    "\n",
    "for alien_number in range(0,30):\n",
    "    new_alien={'color':'green','points':5,'speed':'slow'}\n",
    "    aliens.append(new_alien)\n",
    "\n",
    "for alien in aliens[0:3]:\n",
    "    if alien['color']=='green':\n",
    "        alien['color']='yellow'\n",
    "        alien['points']=10\n",
    "        alien['speed']='medium'\n",
    "for alien in aliens[0:5]:\n",
    "    print(alien)\n"
   ]
  },
  {
   "source": [
    "### list in a dictionary"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "you ordered a thick-crust pizza with the following toppings:\nmushroom\nextra cheese\n"
     ]
    }
   ],
   "source": [
    "pizza={\n",
    "    'crust':'thick',\n",
    "    'toppings':['mushroom','extra cheese']\n",
    "}\n",
    "\n",
    "print('you ordered a '+ pizza['crust']+ '-crust pizza with the following toppings:')\n",
    "\n",
    "for topping in pizza['toppings']:\n",
    "    print(topping)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "\nJen's favorite language are:\n\t Python\n\t Ruby\n\nSarah's favorite language are:\n\t C\n\nEdward's favorite language are:\n\t Ruby\n\t Go\n\nPhil's favorite language are:\n\t Python\n\t Haskell\n"
     ]
    }
   ],
   "source": [
    "favorite_languages={\n",
    "    'jen':['python','ruby'],\n",
    "    'sarah':['c'],\n",
    "    'edward':['ruby','go'],\n",
    "    'phil':['python','haskell']\n",
    "}\n",
    "\n",
    "for name,languages in favorite_languages.items():\n",
    "    print('\\n'+name.title()+\"'s favorite language are:\")\n",
    "\n",
    "    for language in languages:\n",
    "        print(\"\\t \"+language.title())"
   ]
  },
  {
   "source": [
    "### dictionary in dictionary\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "\n Username:aeinstein\n\tFull Name: Albert Einstein\n\tLocation: Princeton\n\n Username:mcurie\n\tFull Name: Marie Curie\n\tLocation: Paris\n"
     ]
    }
   ],
   "source": [
    "users={\n",
    "    'aeinstein':{\n",
    "        'first':'albert',\n",
    "        'last':'einstein',\n",
    "        'location':'princeton'\n",
    "    },\n",
    "    'mcurie':{\n",
    "        'first':'marie',\n",
    "        'last':'curie',\n",
    "        'location':'paris'\n",
    "\n",
    "    }\n",
    "}\n",
    "\n",
    "for username,user_info in users.items():\n",
    "    print(\"\\n Username:\"+username)\n",
    "\n",
    "    full_name = user_info['first']+' '+user_info['last']\n",
    "    location=user_info['location']\n",
    "    print(\"\\tFull Name: \" + full_name.title())\n",
    "    print(\"\\tLocation: \"+location.title())"
   ]
  },
  {
   "source": [
    "## User Input and While Loops\n",
    "- Chapter 7"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Hello Everyone!\n"
     ]
    }
   ],
   "source": [
    "message=input(\"tell me something, and I will repeat it back to you: \");\n",
    "print(message)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Hello, Aayush!\n"
     ]
    }
   ],
   "source": [
    "name=input(\"Please enter your name: \")\n",
    "print(\"Hello, \"+name+'!')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "\nHello, Aayush!\n"
     ]
    }
   ],
   "source": [
    "prompt=\"If ypu tell us who you are, we can personaloze the message you see.\"\n",
    "prompt+=\"\\nWhat is your first name?\"\n",
    "\n",
    "name=input(prompt)\n",
    "print(\"\\nHello, \"+name+'!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "'21'"
      ]
     },
     "metadata": {},
     "execution_count": 6
    }
   ],
   "source": [
    "age=input(\"how old are you?\")\n",
    "age\n",
    "#returns age as string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "metadata": {},
     "execution_count": 7
    }
   ],
   "source": [
    "age=input(\"How old are you?\")\n",
    "age=int(age)\n",
    "age>=21\n",
    "#using int() to convert string age to numeric age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "You're tall enough to ride!\n"
     ]
    }
   ],
   "source": [
    "height=input(\"How tall are you,in inches?\")\n",
    "height=int(height)\n",
    "\n",
    "if height>=36:\n",
    "    print(\"You're tall enough to ride!\")\n",
    "else:\n",
    "    print(\"\\nYou'll be able to ride when you're a little older.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "metadata": {},
     "execution_count": 11
    }
   ],
   "source": [
    "## the modulo operator\n",
    "4%3\n",
    "5%3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "\n The number 21 is odd.\n"
     ]
    }
   ],
   "source": [
    "#even_or_odd.py\n",
    "number=input(\"Enter a number, and I'll tell you if it's even or odd: \")\n",
    "number=int(number)\n",
    "\n",
    "if number%2==0:\n",
    "    print(\"\\n The number \"+str(number)+\" is even.\")\n",
    "else:\n",
    "    print(\"\\n The number \"+ str(number)+\" is odd.\")"
   ]
  },
  {
   "source": [
    "### Introducing while loops\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "#### The while loop in action"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1\n2\n3\n4\n5\n"
     ]
    }
   ],
   "source": [
    "#couting.py\n",
    "current_number=1\n",
    "while current_number<=5:\n",
    "    print(current_number)\n",
    "    current_number+=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Hellp everyone!\n",
      "Hellp again\n",
      "quit\n"
     ]
    }
   ],
   "source": [
    "#parrot.py\n",
    "prompt=\"\\n Tell me something, and I will repeat it back to you:\"\n",
    "prompt+=\"\\n Enter 'quit' to end the program.\"\n",
    "\n",
    "message=\"\"\n",
    "while message!='quit':\n",
    "    message=input(prompt)\n",
    "    print(message)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "hello everyone!\n",
      "hello again\n"
     ]
    }
   ],
   "source": [
    "#using a flag\n",
    "active=True\n",
    "while active:\n",
    "    message=input(prompt)\n",
    "\n",
    "    if message=='quit':\n",
    "        active=False\n",
    "    else:\n",
    "        print(message)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "I'd love to go to Bhaktapur!\n",
      "I'd love to go to New York!\n",
      "I'd love to go to Sydney!\n",
      "I'd love to go to Quiy!\n"
     ]
    }
   ],
   "source": [
    "#using break to exit a loop\n",
    "#cities.py \n",
    "while True:\n",
    "    city=input(prompt)\n",
    "\n",
    "    if city=='quit':\n",
    "        break\n",
    "    else:\n",
    "        print(\"I'd love to go to \"+city.title()+\"!\")\n",
    "#break statement cause python to exit from the loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1\n3\n5\n7\n9\n"
     ]
    }
   ],
   "source": [
    "#using continue in a loop\n",
    "#counting.property\n",
    "\n",
    "current_number=0\n",
    "while current_number<10:\n",
    "    current_number+=1\n",
    "    if current_number%2==0:\n",
    "        continue\n",
    "\n",
    "    print(current_number)\n",
    "#continue statement tell python to ignore the rest of the loop and return to beginning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1\n2\n3\n4\n5\n"
     ]
    }
   ],
   "source": [
    "#avoding Infinte loops\n",
    "x=1\n",
    "while x<=5:\n",
    "    print(x)\n",
    "    x+=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=1\n",
    "while x<=5:\n",
    "    print(x)\n",
    "#this loops runs forever!"
   ]
  },
  {
   "source": [
    "### Using a while loop with lists and Dicitionaries"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Verifying user: Candace\nVerifying user: Brian\nVerifying user: Alice\n\n The following users have been confirmed:\nCandace\nBrian\nAlice\n"
     ]
    }
   ],
   "source": [
    "#moving items from one list to another\n",
    "#confirmed_users.py \n",
    "\n",
    "#start with users that meed to be verified,\n",
    "# and an empty list to hold confirmed users.\n",
    "\n",
    "unconfirmed_users=['alice','brian','candace']\n",
    "confirmed_users=[]\n",
    "\n",
    "#verify each user until there are no more unconfirmed users.\n",
    "#move each verified user into the list of confirmed users.break\n",
    "while unconfirmed_users:\n",
    "    current_user=unconfirmed_users.pop()\n",
    "\n",
    "    print(\"Verifying user: \"+current_user.title())\n",
    "    confirmed_users.append(current_user)\n",
    "\n",
    "#display all confirned users.\n",
    "print(\"\\n The following users have been confirmed:\")\n",
    "for confirmed_user in confirmed_users:\n",
    "    print(confirmed_user.title())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "['dog', 'cat', 'dog', 'goldfish', 'cat', 'rabbit', 'cat']\n['dog', 'dog', 'goldfish', 'rabbit']\n"
     ]
    }
   ],
   "source": [
    "#removing all instances of specific values fron a list\n",
    "pets=['dog','cat','dog','goldfish','cat','rabbit','cat']\n",
    "print(pets)\n",
    "\n",
    "while 'cat' in pets:\n",
    "    pets.remove('cat')\n",
    "print(pets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "\n---- Poll Results ----\nAayush would like to climb Everest\nPrasmit would like to climb Sagarmatha\n"
     ]
    }
   ],
   "source": [
    "#filling a dictionary with user input\n",
    "\n",
    "responses={}\n",
    "\n",
    "#set a flag to indicate that polling is active.\n",
    "polling_active=True\n",
    "while polling_active:\n",
    "    #prompt fir the person's name and response\n",
    "    name=input(\"\\n What is your name?\")\n",
    "    response=input(\"which mountain you would like to climb someday?\")\n",
    "\n",
    "    #store responses in the dictionary\n",
    "    responses[name]=response\n",
    "\n",
    "    # find out if anyone else is going to take the poll\n",
    "\n",
    "    repeat=input(\"Would you like to let another person respond?(yes/no) \")\n",
    "    if repeat=='no':\n",
    "        polling_active=False\n",
    "\n",
    "#Polling is complete.Show the results\n",
    "print(\"\\n---- Poll Results ----\")\n",
    "for name,response in responses.items():\n",
    "    print(name.title()+\" would like to climb \"+response.title())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Hello!\n"
     ]
    }
   ],
   "source": [
    "def greet_user():\n",
    "    \"\"\"Display a simple greeting.\"\"\"\n",
    "    print(\"Hello!\")\n",
    "\n",
    "greet_user()\n",
    "#def tells python that we're defining a function\n",
    "# greet_user is the name of function \n",
    "# \"\"\".....\"\"\" is a comment called docstring, which descibes what the function does.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Hello, Jesse!\n"
     ]
    }
   ],
   "source": [
    "#passing information to the function\n",
    "\n",
    "def greet_user(username):\n",
    "    \"\"\"Display a simple greeting.\"\"\"\n",
    "    print(\"Hello, \"+username.title()+\"!\")\n",
    "\n",
    "greet_user('jesse')\n",
    "\n",
    "# here we pass \"jesse\" as username.\n",
    "# here username is parameter, a piece of information in the function\n",
    "# jesse is an example of argument, which is passed to the function"
   ]
  },
  {
   "source": [
    "### Postional arguments\n",
    "\n",
    "- when we call a function , postion of each argument must match with a parameter. The simplest way to do this is a based on the order of arguments provided. Value matched this way are called postional arguments."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "\nI have a Hamster.\nMy Hamster's name is Harry.\n"
     ]
    }
   ],
   "source": [
    "\n",
    "#pets.py \n",
    "def describe_pet(animal_type,pet_name):\n",
    "    \"\"\"Display information about a pet.\"\"\"\n",
    "    print(\"\\nI have a \"+animal_type+\".\")\n",
    "    print(\"My \"+animal_type+\"'s name is \"+pet_name.title()+\".\")\n",
    "\n",
    "describe_pet(\"Hamster\",'harry')\n",
    "\n",
    "# Here when we call describe_pet we need to pass animal_type and pet_name ,in order. So we first pass hamster as animal_type and harry as pet_name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "\nI have a Hamster.\nMy Hamster's name is Harry.\n\nI have a dog.\nMy dog's name is Willie.\n"
     ]
    }
   ],
   "source": [
    "# multiple function calls\n",
    "def describe_pet(animal_type,pet_name):\n",
    "    \"\"\"Display information about the pet.\"\"\"\n",
    "    print(\"\\nI have a \"+animal_type+\".\")\n",
    "    print(\"My \"+animal_type+\"'s name is \"+pet_name.title()+\".\")\n",
    "\n",
    "describe_pet(\"Hamster\",\"harry\")\n",
    "describe_pet('dog','willie')\n",
    "\n",
    "# here we call function twice. First we pass hamster and harry as argument to describe_pet and secondly we pass dog and willie as arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "\nI have a Harry.\nMy Harry's name is Hamster.\n"
     ]
    }
   ],
   "source": [
    "# Orders matters in Postional Arguments\n",
    "\n",
    "def describe_pet(animal_type,pet_name):\n",
    "    \"\"\"Display information about the pet.\"\"\"\n",
    "    print(\"\\nI have a \"+animal_type+\".\")\n",
    "    print(\"My \"+animal_type+\"'s name is \"+pet_name.title()+\".\")\n",
    "\n",
    "describe_pet(\"Harry\",\"Hamster\")\n"
   ]
  },
  {
   "source": [
    "### Keyword Arguments\n",
    "- Its is a name-value pair that we pass to a function.\n",
    "- we directly associate the name and the value within the Arguments\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "\nI have a Hamster.\nMy Hamster's name is Harry.\n\nI have a hamster.\nMy hamster's name is Harry.\n"
     ]
    }
   ],
   "source": [
    "def describe_pet(animal_type,pet_name):\n",
    "    \"\"\"Display informatio about a pet.\"\"\"\n",
    "    print(\"\\nI have a \"+ animal_type+\".\")\n",
    "    print(\"My \"+animal_type+\"'s name is \"+ pet_name.title()+'.')\n",
    "\n",
    "describe_pet(animal_type=\"Hamster\",pet_name=\"harry\")\n",
    "describe_pet(pet_name=\"Harry\",animal_type='hamster')\n",
    "\n",
    "#Order of arguments doesn;t matter in keyword arguments\n"
   ]
  },
  {
   "source": [
    "### Defaut Values\n",
    "- when we write function we need to define default value for each parameter\n",
    "- If argument for a parameter is provided, Python uses argument value.Otherwise it uses default value\n",
    "- So when we define a deafult value for a parameter, we can exclude the corresponding argument we'd usually write in the function call.\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "\nI have a dog.\nMy dog's name is Willie.\n\nI have a Hamster.\nMy Hamster's name is Harry.\n"
     ]
    }
   ],
   "source": [
    "# default values\n",
    "\n",
    "def describe_pet(pet_name,animal_type='dog'):\n",
    "    \"\"\"Display information about a pet.\"\"\"\n",
    "\n",
    "    print(\"\\nI have a \"+ animal_type+\".\")\n",
    "    print(\"My \"+animal_type+\"'s name is \"+ pet_name.title()+'.')\n",
    "\n",
    "describe_pet(pet_name='willie')\n",
    "\n",
    "# Here animal_type=\"dog\" is a default value. SO, we can only provide pet_name\n",
    "\n",
    "describe_pet(pet_name='Harry',animal_type=\"Hamster\")\n",
    "\n",
    "# Here, we passed animal_type='hamster' so animal_type='hamster' will be used instead of default value .i.e animal_type='dog"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "\nI have a dog.\nMy dog's name is Willie.\n\nI have a dog.\nMy dog's name is Willie.\n\nI have a hamster.\nMy hamster's name is Harry.\n\nI have a hamster.\nMy hamster's name is Harry.\n\nI have a hamster.\nMy hamster's name is Harry.\n"
     ]
    }
   ],
   "source": [
    "# Equivalent Function Calls\n",
    "\n",
    "def describe_pet(pet_name,animal_type='dog'):\n",
    "    \"\"\"Display information about a pet.\"\"\"\n",
    "\n",
    "    print(\"\\nI have a \"+ animal_type+\".\")\n",
    "    print(\"My \"+animal_type+\"'s name is \"+ pet_name.title()+'.')\n",
    "\n",
    "# a dog named willie\n",
    "describe_pet('willie')\n",
    "describe_pet(pet_name='willie')\n",
    "\n",
    "# a hamster named harry\n",
    "describe_pet('harry','hamster')\n",
    "describe_pet(pet_name='harry',animal_type='hamster')\n",
    "describe_pet(animal_type='hamster',pet_name='harry')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "output_type": "error",
     "ename": "TypeError",
     "evalue": "describe_pet() missing 2 required positional arguments: 'pet_name' and 'animal_type'",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-18-b60fb25dc9b4>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      7\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"My \"\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0manimal_type\u001b[0m\u001b[1;33m+\u001b[0m\u001b[1;34m\"'s name is \"\u001b[0m\u001b[1;33m+\u001b[0m \u001b[0mpet_name\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtitle\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m+\u001b[0m\u001b[1;34m'.'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      8\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 9\u001b[1;33m \u001b[0mdescribe_pet\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: describe_pet() missing 2 required positional arguments: 'pet_name' and 'animal_type'"
     ]
    }
   ],
   "source": [
    "# Avoding argument errors\n",
    "\n",
    "def describe_pet(pet_name,animal_type):\n",
    "    \"\"\"Display information about a pet.\"\"\"\n",
    "\n",
    "    print(\"\\nI have a \"+ animal_type+\".\")\n",
    "    print(\"My \"+animal_type+\"'s name is \"+ pet_name.title()+'.')\n",
    "\n",
    "describe_pet()\n",
    "\n",
    "# Here we haven't provided arguments. Since our function have 2 parameter so we should have passed two argument which created an error."
   ]
  },
  {
   "source": [
    "### Return Values\n",
    "- Function doesn't have to display its output directly, it can process some data and then return a value or set of Values\n",
    "- return statement takes a value from inside a function and sends it back to the line that called the function."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Jimi Hendrix\n"
     ]
    }
   ],
   "source": [
    "# Returning a simple value\n",
    "def get_formatted_name(first_name,Last_name):\n",
    "    \"\"\"Return a full name,neatly formatted.\"\"\"\n",
    "    full_name=first_name.title()+\" \"+Last_name.title()\n",
    "    return full_name\n",
    "\n",
    "musician=get_formatted_name(\"jimi\",'hendrix')\n",
    "print(musician)\n",
    "\n",
    "# Here the function takes two parameter i.e. first_name and last_name .The fucntion combines the first_name and last_name and stores it in full_name .Then function returns full_name \n",
    "# When function return a value, while calling function we need to define a variable where return value is stored. In above case the return value will be saved in musician\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "John Lee Hooker\n"
     ]
    }
   ],
   "source": [
    "# making an argument optional\n",
    "\n",
    "def get_formatted_name(first_name,middle_name,last_name):\n",
    "    \"\"\"Return a full name,neatly formated,\"\"\"\n",
    "    full_name=first_name+\" \"+middle_name+' '+last_name\n",
    "    return full_name.title()\n",
    "\n",
    "musician=get_formatted_name('john','lee','hooker')\n",
    "print(musician)\n",
    "\n",
    "# Since middle name is optional so we can write above fucntion as"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "John Lee Hooker\nJimi Hendrix\n"
     ]
    }
   ],
   "source": [
    "def get_formatted_name(first_name,last_name,middle_name=''):\n",
    "    \"\"\"Return a full name,neatly formated,\"\"\"\n",
    "    if middle_name:\n",
    "        full_name=first_name+\" \"+middle_name+' '+last_name\n",
    "    else:\n",
    "        full_name=first_name+\" \"+last_name\n",
    "    return full_name.title()\n",
    "\n",
    "musician=get_formatted_name('john','hooker','lee')\n",
    "print(musician)\n",
    "musician=get_formatted_name('jimi','hendrix')\n",
    "print(musician)\n",
    "\n",
    "#Here we simply use if else condition to check if the person have middle name and set default value of middle_name to null"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "{'first': 'jimi', 'last': 'hendrix'}\n"
     ]
    }
   ],
   "source": [
    "# Returning a dictionary\n",
    "\n",
    "def build_person(first_name,last_name):\n",
    "    \"\"\"Return a dictionary of information about a person.\"\"\"\n",
    "    person={'first':first_name,'last':last_name}\n",
    "    return person\n",
    "\n",
    "musician=build_person('jimi','hendrix')\n",
    "print(musician)\n",
    "\n",
    "# here we simply pass first_name and last_name to the function. In fucntion we created person as a dictionary and store first_name in first and last_name in last and return person"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "{'first': 'jimi', 'last': 'hendrix', 'age': 27}\n"
     ]
    }
   ],
   "source": [
    "def build_person(first_name,last_name,age=''):\n",
    "    \"\"\"Return a dictinary of information about a person.\"\"\"\n",
    "    person={'first':first_name,'last':last_name}\n",
    "    if age:\n",
    "        person['age']=age\n",
    "    return person\n",
    "\n",
    "musician=build_person('jimi','hendrix',age=27)\n",
    "print(musician)\n",
    "\n",
    "# Here age is optional argument. If age is passed as argument we simply add it to the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Using a function with a while loop\n",
    "def build_person(first_name,last_name):\n",
    "    \"\"\"Return a dictionary of information about a person.\"\"\"\n",
    "    person={'first':first_name,'last':last_name}\n",
    "    return person\n",
    "\n",
    "while True:\n",
    "    f_name=input('First Name')\n",
    "    l_name=input('Last Name')\n",
    "\n",
    "    formatted_name=f_name.title()+' '+l_name.title()\n",
    "    print(\"\\nHello, \"+formatted_name+'!')\n",
    "\n",
    "# Here we simply used while loop which takes input from user and pass it to build_person. build_person returns a dictionary and it's printed\n",
    "# Here the problem is while loop is an infinite loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "\n",
      " Please tell me your name:\n",
      "(enter 'q' at any time to quit)\n",
      "\n",
      "Hello, Aayush Raut!\n",
      "\n",
      " Please tell me your name:\n",
      "(enter 'q' at any time to quit)\n",
      "\n",
      "Hello, Prasmit Neupane!\n",
      "\n",
      " Please tell me your name:\n",
      "(enter 'q' at any time to quit)\n",
      "\n",
      "Hello, Rabindra Baisnab!\n",
      "\n",
      " Please tell me your name:\n",
      "(enter 'q' at any time to quit)\n"
     ]
    }
   ],
   "source": [
    "def build_person(first_name,last_name):\n",
    "    \"\"\"Return a dictionary of information about a person.\"\"\"\n",
    "    person={'first':first_name,'last':last_name}\n",
    "    return person\n",
    "\n",
    "while True:\n",
    "    print(\"\\n Please tell me your name:\")\n",
    "    print(\"(enter 'q' at any time 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=f_name.title()+' '+l_name.title()\n",
    "    print(\"\\nHello, \"+formatted_name+'!')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Hello, Hannah!\nHello, Ty!\nHello, Margot!\n"
     ]
    }
   ],
   "source": [
    "# Passing a list\n",
    "def greet_users(names):\n",
    "    \"\"\"Print a simple greeting to each user in the list.\"\"\"\n",
    "    for name in names:\n",
    "        msg=\"Hello, \"+name.title()+'!'\n",
    "        print(msg)\n",
    "    \n",
    "usernames=['hannah','ty','margot']\n",
    "greet_users(usernames)\n",
    "\n",
    "# Here we simply created a list called usernames and pass that list as parameter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Printing model: dodecahedron\nPrinting model: robot pendant\nPrinting model: iphone case\n\n The following models have been printed:\ndodecahedron\nrobot pendant\niphone case\n"
     ]
    }
   ],
   "source": [
    "# modifying a list in a function\n",
    "\n",
    "# printing_models.py \n",
    "\n",
    "# start with some designs that need to be printed. \n",
    "unprinted_designs=['iphone case','robot pendant','dodecahedron']\n",
    "completed_models=[]\n",
    "\n",
    "# simulate priniting each design, until none are left. \n",
    "# moce each design to completed_models after printing,\n",
    "while unprinted_designs:\n",
    "    current_design=unprinted_designs.pop()\n",
    "\n",
    "    #simulate creating a 3D print from the design. \n",
    "    print(\"Printing model: \"+current_design)\n",
    "    completed_models.append(current_design)\n",
    "\n",
    "# Display all completed models. \n",
    "print(\"\\n The following models have been printed:\")\n",
    "for completed_model in completed_models:\n",
    "    print(completed_model)\n",
    "\n",
    "# This is a simple program using list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Printing model: iphone case\nPrinting model: robot pendant\nPrinting model: dodecahedron\n\n THe following models have been printed:\niphone case\nrobot pendant\ndodecahedron\n['iphone case', 'robot pendant', 'dodecahedron']\n"
     ]
    }
   ],
   "source": [
    "# the same above program using function can be written as:\n",
    "\n",
    "def print_models(unprinted_designs, completed_models):\n",
    "    \"\"\"Simulate printing each design, unit none are left.\n",
    "    Move each design to completed_models after printing.\"\"\"\n",
    "    while unprinted_designs:\n",
    "        current_design=unprinted_designs.pop(0)\n",
    "\n",
    "        # simulate creating a 3D print from the design. \n",
    "        print(\"Printing model: \"+current_design)\n",
    "        completed_models.append(current_design)\n",
    "\n",
    "   \n",
    "\n",
    "def show_completed_models(completed_models):\n",
    "    \"\"\"Show all the models that were printed:\"\"\"\n",
    "    print(\"\\n THe 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)\n",
    "\n",
    "#print(unprinted_designs)\n",
    "\n",
    "# passing list using [:] makes list unchanged\n",
    "# Here we made two function  one to move unprinted to completed_models and another function used to print completed_models\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "('pepperoni',)\n('mushrooms', 'green peppers', 'extra cheese')\n"
     ]
    }
   ],
   "source": [
    "# passing an arbitrary number of arguments\n",
    "\n",
    "def make_pizza(*toppings):\n",
    "    \"\"\"Print the list of toppings that hace been requested.\"\"\"\n",
    "    print(toppings)\n",
    "\n",
    "make_pizza('pepperoni')\n",
    "make_pizza('mushrooms','green peppers','extra cheese')\n",
    "\n",
    "# here asterisk in the parameter name *topping tells pyhton to make an empty tuple called toppings and pack whatever values it receives into this tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "\n Making a pizza with the following topppings:\n- pepperoni\n\n Making a pizza with the following topppings:\n- mushrooms\n- cheese\n- green peppers\n"
     ]
    }
   ],
   "source": [
    "def make_pizza(*toppings):\n",
    "    \"\"\"Summarize the pizza we are about to make.\"\"\"\n",
    "    print(\"\\n Making a pizza with the following topppings:\")\n",
    "    for topping in toppings:\n",
    "        print(\"- \"+topping)\n",
    "\n",
    "make_pizza('pepperoni')\n",
    "make_pizza('mushrooms','cheese','green peppers')\n",
    "\n",
    "# here  we simply loop through tuple i.e. toppings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "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-mushroom\n-green peppers\n-extra cheese\n"
     ]
    }
   ],
   "source": [
    "# Mixing positonal and arbitary arguments\n",
    "\n",
    "def make_pizza(size,*toppings):\n",
    "    \"\"\"Sumarize the pizza we are about to make.\"\"\"\n",
    "    print(\"\\n Making 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,'mushroom','green peppers','extra cheese')\n",
    "\n",
    "# Here we simply used both positional and arbitary arguments. while passing parameter is function we passed parameter in posional order and used the remaing parameter as arbitary argumets if there number of parameter was more than number of arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "{'first_name': 'albert', 'last_name': 'einstein', 'location': 'princeton', 'field': 'physics'}\n"
     ]
    }
   ],
   "source": [
    "# Using arbitary keyword arguments\n",
    "def build_profile(first,last,**user_info):\n",
    "    \"\"\"Build a dictionary containing everything we know about a user.\"\"\"\n",
    "    profile={}\n",
    "    profile['first_name']=first\n",
    "    profile['last_name']=last\n",
    "\n",
    "    for key,value in user_info.items():\n",
    "        profile[key]=value\n",
    "    return profile\n",
    "\n",
    "user_profile=build_profile('albert','einstein',location='princeton',field='physics')\n",
    "print(user_profile)\n",
    "# double asterisks is used to create empty dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "\n Making a 12-inch pizza with following toppings:\n- pepperoni\n\n Making a 16-inch pizza with following toppings:\n- mushrooms\n- green peppers\n- extra cheese\n"
     ]
    }
   ],
   "source": [
    "# importing an Entire Module\n",
    "import pizza\n",
    "\n",
    "pizza.make_pizza(12,'pepperoni')\n",
    "pizza.make_pizza(16,'mushrooms','green peppers','extra cheese')\n",
    "\n",
    "# import pizza tells python to open pizza.py and copy all the function from it into this program. So function defined in pizza.py will also be available here. \n",
    "\n",
    "# to call a function from an imported mudle ,we need to enter the name of module you imported,pizza, followed by the name of function, make_pizza, seperated by dot, .. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "\n Making a 16-inch pizza with following toppings:\n- pepperoni\n\n Making a 12-inch pizza with following toppings:\n- mushrooms\n- green peppers\n- extra cheese\n"
     ]
    }
   ],
   "source": [
    "# importing specific functions\n",
    "\n",
    "from pizza import make_pizza\n",
    "\n",
    "make_pizza(16,'pepperoni')\n",
    "make_pizza(12,'mushrooms','green peppers','extra cheese')\n",
    "\n",
    "# here we simply imported make_pizza function from pizza.py\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "\n Making a 16-inch pizza with following toppings:\n- pepperoni\n\n Making a 12-inch pizza with following toppings:\n- mushrooms\n- green peppers\n- extra cheese\n"
     ]
    }
   ],
   "source": [
    "# using as to give a function an Alias\n",
    "\n",
    "from pizza import make_pizza as mp \n",
    "mp(16,'pepperoni')\n",
    "mp(12,'mushrooms','green peppers','extra cheese')\n",
    "\n",
    "# we renamed make_pizza as mp ,so everytime we need to call a function we can simply call mp instead of make_pizza"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "\n Making a 16-inch pizza with following toppings:\n- pepperoni\n\n Making a 12-inch pizza with following toppings:\n- mushrooms\n- green peppers\n- extra cheese\n"
     ]
    }
   ],
   "source": [
    "# importing all function in a Module\n",
    "\n",
    "from pizza import *\n",
    "\n",
    "make_pizza(16,'pepperoni')\n",
    "make_pizza(12,'mushrooms','green peppers','extra cheese')\n",
    "\n",
    "# we can import all function in a module by using asterisk operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ]
}