Section 1-12.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Day 1 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Printing, Commenting, Debugging, String Manipulation & Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Day 1 - Python Print Function \n",
      "The function is declared like this: \n",
      "print('What to print')\n"
     ]
    }
   ],
   "source": [
    "print(\"Day 1 - Python Print Function \\nThe function is declared like this: \\nprint('What to print')\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String Concatenation\n"
     ]
    }
   ],
   "source": [
    "print(\"String \" + \"Concatenation\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Python Input Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What is your name? Abhijeet\n",
      "Hello Abhijeet\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello \" + input(\"What is your name? \"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter here hello world\n",
      "Word length is 11\n"
     ]
    }
   ],
   "source": [
    "print(\"Word length is \" + str(len(input(\"Enter here \"))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Project band name generator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to the Band Name Generator\n",
      "Whats name of the city you grew up in?\n",
      "Mumbai\n",
      "Whats your pet's name?\n",
      "Tom\n",
      "Your band name could be  Mumbai Tom\n"
     ]
    }
   ],
   "source": [
    "print(\"Welcome to the Band Name Generator\")\n",
    "city = input(\"Whats name of the city you grew up in?\\n\")\n",
    "pet = input(\"Whats your pet's name?\\n\")\n",
    "print(\"Your band name could be \",city,pet)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Day 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Data Types, Numbers, Operations, Type Conversion, f-Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Data Types**\n",
    "- *String*  \n",
    "    Anything enclosed under \" \" or ' '\n",
    "- *Integer*  \n",
    "    No quotes. Number can be written separating with _\n",
    "- *Float*  \n",
    "    Similarly, only difference is it has decimal value.\n",
    "    Also if the decimal place shifts left or right ie Float Point Number\n",
    "- *Boolean*  \n",
    "    True or False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Converion**  \n",
    "- str()  \n",
    "- int()  \n",
    "- float()  \n",
    "- bool()  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Sum of 2-digit number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a 2-digit number: 12\n",
      "Sum ->  3\n"
     ]
    }
   ],
   "source": [
    "number = input(\"Enter a 2-digit number: \")\n",
    "type(number)  # String\n",
    "digit0 = int(number[0])  # Convert to integer\n",
    "digit1 = int(number[1])  # Convert to integer\n",
    "print(\"Sum -> \", digit0 + digit1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Mathematical Operations**\n",
    "- ' + '  \n",
    "- ' - '  \n",
    "- ' * '  \n",
    "- /   Float o/p  \n",
    "- //  Integer o/p (Floor division)  \n",
    "- **  Power  \n",
    "---\n",
    "**Priority PEMDASLR**  \n",
    "1 ( )  \n",
    "2 * /  \n",
    "3 + -  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### BMI Calculator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your weight in kg: 68\n",
      "Enter your height in cm: 172\n",
      "BMI ->  23\n"
     ]
    }
   ],
   "source": [
    "weight = float(input(\"Enter your weight in kg: \"))\n",
    "height = float(input(\"Enter your height in cm: \"))\n",
    "bmi = weight / (height/100)**2\n",
    "print(\"BMI -> \",round(bmi))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```round(num, no_of_place)\n",
    "``` -> Rounds of num to a no of decimal place  \n",
    "Earlier for printing integer in print, we did say \n",
    "```int(num)```  \n",
    "***f-String*** deals with all data types - int, float, bool.  \n",
    "It converts to string. Use -> ***print(f\"\")***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mohan divided 23 for o/p 2.3 which is True\n"
     ]
    }
   ],
   "source": [
    "str = \"Mohan\"\n",
    "num = 23\n",
    "dec = 2.3\n",
    "val = True\n",
    "print(f\"{str} divided {num} for o/p {dec} which is {val}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Your life in weeks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your age: 20\n",
      "You have 25550 days, 3640 weeks and 840 months left\n"
     ]
    }
   ],
   "source": [
    "age = int(input(\"Enter your age: \"))\n",
    "# Lets say you live upto 90\n",
    "years = 90 - age\n",
    "day = years * 365\n",
    "week = years * 52\n",
    "month = years * 12\n",
    "print(f\"You have {day} days, {week} weeks and {month} months left\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Project Tip Calculator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Round function leaves 12.5 as it is, buy if we need to print 12.50 use *format()*\n",
    "```\"{:.2f}\".format(bill)```  \n",
    "More about format:  \n",
    "```'Sam has {1:d} red balls and {0:d} yellow balls'.format(12, 31)```  Sam has 31 red balls and 12 yellow balls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to tip calculator\n",
      "What is the total bill? Rs.150\n",
      "What percentage tip would you like to give? 12\n",
      "How many people to split the bill? 5\n",
      "Each person should pay Rs.33.60\n"
     ]
    }
   ],
   "source": [
    "print(\"Welcome to tip calculator\")\n",
    "bill = float(input(\"What is the total bill? Rs.\"))\n",
    "tip_per = int(input(\"What percentage tip would you like to give? \"))\n",
    "pay = bill + (tip_per*bill/100)\n",
    "people = int(input(\"How many people to split the bill? \"))\n",
    "print(f\"Each person should pay Rs.{0:.2f}\".format(pay/people))\n",
    "print(f\"Each person should pay Rs.{pay/people:.2f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Day 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Conditional Statements, Logical Operators, Code Blocks & Scope"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Operator | Meaning |\n",
    "| :-: | :-: |\n",
    "| > | Greater than |\n",
    "| < | Less than |\n",
    "| >= | Greater than equal to |\n",
    "| <= | Less than equal to |\n",
    "| == | Equal to |\n",
    "| != | Not equal to |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Nested if / else"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to the rollercoaster\n",
      "What is your height in cm: 172\n",
      "You can ride the rollercoaster\n",
      "What is your age: 56\n",
      "Adult tickets are $12\n",
      "Do you want a photo taken? (yes=1, no=0): 1\n",
      "Please pay $15\n"
     ]
    }
   ],
   "source": [
    "print(\"Welcome to the rollercoaster\")\n",
    "ht = int(input(\"What is your height in cm: \"))\n",
    "if(ht >= 120):\n",
    "    x=0;\n",
    "    print(\"You can ride the rollercoaster\")\n",
    "    age = int(input(\"What is your age: \"))\n",
    "    if(age < 12):\n",
    "        x=5\n",
    "        print(\"Child tickets are $5\")\n",
    "    elif(age <= 18):\n",
    "        x=7\n",
    "        print(\"Youth tickets are $7\")\n",
    "    elif(45 < age < 55):\n",
    "        x=0\n",
    "        print(\"Everything is going to be okay. Have a free ride on us\")\n",
    "    else:\n",
    "        x=12\n",
    "        print(\"Adult tickets are $12\")\n",
    "    photo = int(input(\"Do you want a photo taken? (yes=1, no=0): \"))\n",
    "    if(photo):\n",
    "        x += 3\n",
    "    print(f\"Please pay ${x}\")\n",
    "else:\n",
    "    print(\"Sorry, you have to grow taller before you can ride\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### BMI Calculator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter height in cm: 172\n",
      "Enter weight in kg: 62\n",
      "Your BMI is 20.96\n",
      "Normal weight\n"
     ]
    }
   ],
   "source": [
    "height = int(input(\"Enter height in cm: \"))\n",
    "weight = int(input(\"Enter weight in kg: \"))\n",
    "bmi = weight / (height/100)**2\n",
    "print(f\"Your BMI is {bmi:.2f}\")\n",
    "if(bmi <= 18.5):\n",
    "    print(\"Underweight\")\n",
    "elif(bmi <= 25):\n",
    "    print(\"Normal weight\")\n",
    "elif(bmi <= 30):\n",
    "    print(\"Overweight\")\n",
    "elif(bmi <= 35):\n",
    "    print(\"Obese\")\n",
    "else:\n",
    "    print(\"Clinically obese\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Leap Year"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a year: 2204\n",
      "This is a leap year\n"
     ]
    }
   ],
   "source": [
    "year = int(input(\"Enter a year: \"))\n",
    "if(year%4 != 0):\n",
    "    print(\"This is not a leap year\")\n",
    "elif(year%100 != 0):\n",
    "    print(\"This is a leap year\")\n",
    "elif(year%400 == 0):\n",
    "    print(\"This is a leap year\")\n",
    "else:\n",
    "    print(\"This is not a leap year\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Pizza Order 🍕"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to Python pizza deliveries!\n",
      "What size pizza do you want? S,M or L L\n",
      "Do you want pepperoni? Y or N Y\n",
      "Do you want extra cheese? Y or N N\n",
      "Your final bill is 28\n"
     ]
    }
   ],
   "source": [
    "print(\"Welcome to Python pizza deliveries!\")\n",
    "size = input(\"What size pizza do you want? S,M or L \")\n",
    "addPepperoni = input(\"Do you want pepperoni? Y or N \")\n",
    "addExtraCheese = input(\"Do you want extra cheese? Y or N \")\n",
    "# Small Pizza: $15\n",
    "# Medium Pizza: $20\n",
    "# Large Pizza: $25\n",
    "# Pepperoni for Small Pizza: +$2\n",
    "# Pepperoni for Medium or Large Pizza: +$3\n",
    "# Extra cheese for any size pizza: + $1\n",
    "bill = 0\n",
    "if(size == 'L'):\n",
    "    bill += 25\n",
    "elif(size == 'M'):\n",
    "    bill += 20\n",
    "else:\n",
    "    bill += 15\n",
    "if(addPepperoni == 'Y' and size == 'S'):\n",
    "    bill += 2\n",
    "elif(addPepperoni == 'Y'):\n",
    "    bill += 3\n",
    "if(addExtraCheese == 'Y'):\n",
    "    bill += 1\n",
    "print(f\"Your final bill is ${bill}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Logical Operators***  \n",
    "- and  \n",
    "- or \n",
    "- not"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Love calculator 💙"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to Python Love Calculator!\n",
      "What is your name? David Beckham\n",
      "What is their name? Victoria Beckham\n",
      "Your score is 45, you are alright together.\n"
     ]
    }
   ],
   "source": [
    "print(\"Welcome to the Love Calculator!\")\n",
    "name1 = input(\"What is your name? \").lower()\n",
    "name2 = input(\"What is their name? \").lower()\n",
    "secret = name1 + name2\n",
    "count1 = 0\n",
    "for i in \"true\":\n",
    "    count1 += secret.count(i)\n",
    "count2 = 0\n",
    "for i in \"love\":\n",
    "    count2 += secret.count(i)\n",
    "score = int(str(count1) + str(count2))\n",
    "if(score > 90 or score < 10):\n",
    "    print(f\"Your score is {score}, you go together like coke and mentos.\")\n",
    "elif(40 < score < 50):\n",
    "    print(f\"Your score is {score}, you are alright together.\")\n",
    "else:\n",
    "    print(f\"Your score is {score}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Treasure Island"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " _                                     _     _                 _ \n",
      "| |                                   (_)   | |               | |\n",
      "| |_ _ __ ___  __ _ ___ _   _ _ __ ___ _ ___| | __ _ _ __   __| |\n",
      "| __| '__/ _ \\/ _` / __| | | | '__/ _ \\ / __| |/ _` | '_ \\ / _` |\n",
      "| |_| | |  __/ (_| \\__ \\ |_| | | |  __/ \\__ \\ | (_| | | | | (_| |\n",
      " \\__|_|  \\___|\\__,_|___/\\__,_|_|  \\___|_|___/_|\\__,_|_| |_|\\__,_|\n",
      "\n",
      "Welcome to Treasure Island.\n",
      "Your mission is to find the treasure.\n",
      "You are at  cross road. Where do you want to go? Type 'left or 'right'\n",
      "left\n",
      "You came to a lake. There  is an island in the middle of lake. Type 'wait to wait for a boat. Type 'swim' to swim across.\n",
      "wait\n",
      "You arrived at the island unharmed. There is a house with 3 doors. Red, yellow and blue. Which colour do you choose?\n",
      "yellow\n",
      "Hurray! You win\n"
     ]
    }
   ],
   "source": [
    "print('''\n",
    " _                                     _     _                 _ \n",
    "| |                                   (_)   | |               | |\n",
    "| |_ _ __ ___  __ _ ___ _   _ _ __ ___ _ ___| | __ _ _ __   __| |\n",
    "| __| '__/ _ \\/ _` / __| | | | '__/ _ \\ / __| |/ _` | '_ \\ / _` |\n",
    "| |_| | |  __/ (_| \\__ \\ |_| | | |  __/ \\__ \\ | (_| | | | | (_| |\n",
    " \\__|_|  \\___|\\__,_|___/\\__,_|_|  \\___|_|___/_|\\__,_|_| |_|\\__,_|\n",
    "''')\n",
    "print(\"Welcome to Treasure Island.\")\n",
    "print(\"Your mission is to find the treasure.\") \n",
    "opt1 = input(\"You are at  cross road. Where do you want to go? Type 'left or 'right'\\n\").lower()\n",
    "if(opt1 == 'left'):\n",
    "    opt2 = input(\"You came to a lake. There  is an island in the middle of lake. Type 'wait to wait for a boat. Type 'swim' to swim across.\\n\").lower()\n",
    "    if(opt2 == 'wait'):\n",
    "        opt3 = input(\"You arrived at the island unharmed. There is a house with 3 doors. Red, yellow and blue. Which colour do you choose?\\n\").lower()\n",
    "        if(opt3 == 'yellow'):\n",
    "            print(\"Hurray! You win\")\n",
    "        elif(opt3 == 'red'):\n",
    "            print(\"You were burned by fire. Game over.\")\n",
    "        elif(opt3 == 'blue'):\n",
    "            print(\"You were eaten by beasts. Game over.\")\n",
    "        else:\n",
    "            print(\"Game over.\")\n",
    "    else:\n",
    "        print(\"You were attacked by trout. Game over.\")\n",
    "\n",
    "else:\n",
    "    print(\"You fall into a hole. Game over.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Day 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Randomisation and Python Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Create your own Module***  \n",
    "> In the same directory as of `main.py`. Create `cutomMoule.py`.  \n",
    "> \n",
    "> `customModule.py`  \n",
    "```python\n",
    "customValue = 2000.0713\n",
    "```  \n",
    "> `main.py`  \n",
    " ```python\n",
    "import customModule \n",
    "print(customModule.customValue) #2000.0713\n",
    "```  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.6084639821375077\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "# Creates random integer between [1,10]\n",
    "random_integer = random.randint(1,10)\n",
    "# Creates random decimal between [0,1)\n",
    "random_float = random.random()\n",
    "# Creates random decimal between [0,5)\n",
    "print(random_float*5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Heads\n"
     ]
    }
   ],
   "source": [
    "# Flip coin\n",
    "toss = random.randint(0,1)\n",
    "if(toss==0):\n",
    "    print(\"Tails\")\n",
    "else:\n",
    "    print(\"Heads\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Python list** is a *datastructure* ie organising & storing data in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Banker Roulette - Who will pay the bill?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Give me everybody's names, separated by a comma. Ben,James,Krystine\n",
      "James is going to buy the meal today!\n"
     ]
    }
   ],
   "source": [
    "names_string = input(\"Give me everybody's names, separated by a comma. \")\n",
    "names = names_string.split(',')\n",
    "key = random.randint(0,len(names)-1)\n",
    "print(f\"{names[key]} is going to buy the meal today!\")\n",
    "# Shortcut, use random.choice(names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Treasure Map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['⬜️', '⬜️', '⬜️']\n",
      "['⬜️', '⬜️', '⬜️']\n",
      "['⬜️', '⬜️', '⬜️']\n",
      "Where do you want to put the treasure? 22\n",
      "['⬜️', '⬜️', '⬜️']\n",
      "['⬜️', 'X', '⬜️']\n",
      "['⬜️', '⬜️', '⬜️']\n"
     ]
    }
   ],
   "source": [
    "row1 = [\"⬜️\",\"⬜️\",\"⬜️\"]\n",
    "row2 = [\"⬜️\",\"⬜️\",\"⬜️\"]\n",
    "row3 = [\"⬜️\",\"⬜️\",\"⬜️\"]\n",
    "map = [row1, row2, row3]\n",
    "print(f\"{row1}\\n{row2}\\n{row3}\")\n",
    "position = input(\"Where do you want to put the treasure? \")\n",
    "row = int(position[0])-1\n",
    "column = int(position[1])-1\n",
    "map[row][column] = 'X'\n",
    "print(f\"{row1}\\n{row2}\\n{row3}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Project Rock Paper Scissors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What do you choose? 0-Rock, 1-Paper, 2-Scissors: 1\n",
      "Player choose:\n",
      "\n",
      "    _______\n",
      "---'   ____)____\n",
      "          ______)\n",
      "          _______)\n",
      "         _______)\n",
      "---.__________)\n",
      "\n",
      "Computer choose:\n",
      "\n",
      "    _______\n",
      "---'   ____)\n",
      "      (_____)\n",
      "      (_____)\n",
      "      (____)\n",
      "---.__(___)\n",
      "\n",
      "You won\n"
     ]
    }
   ],
   "source": [
    "rock = '''\n",
    "    _______\n",
    "---'   ____)\n",
    "      (_____)\n",
    "      (_____)\n",
    "      (____)\n",
    "---.__(___)\n",
    "'''\n",
    "\n",
    "paper = '''\n",
    "    _______\n",
    "---'   ____)____\n",
    "          ______)\n",
    "          _______)\n",
    "         _______)\n",
    "---.__________)\n",
    "'''\n",
    "\n",
    "scissors = '''\n",
    "    _______\n",
    "---'   ____)____\n",
    "          ______)\n",
    "       __________)\n",
    "      (____)\n",
    "---.__(___)\n",
    "'''\n",
    "\n",
    "player = int(input(\"What do you choose? 0-Rock, 1-Paper, 2-Scissors: \"))\n",
    "tool = [rock, paper, scissors]\n",
    "print(f\"Player choose:\\n{tool[player]}\")\n",
    "computer = random.randint(0,2)\n",
    "print(f\"Computer choose:\\n{tool[computer]}\")\n",
    "if(player == computer):\n",
    "    print(\"Draw\")\n",
    "elif((player == 0 and computer == 2) or (player == 1 and computer == 0) or (player == 2 and computer == 1)):\n",
    "    print(\"You won\")\n",
    "else:\n",
    "    print(\"You loose\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Day 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### For loops, Range and Code Blocks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input a list of student heights 180 124 165 173 189 169 146\n",
      "164\n"
     ]
    }
   ],
   "source": [
    "# Average Height\n",
    "student_heights = (input(\"Input a list of student heights \")).split()\n",
    "for n in range(0, len(student_heights)):\n",
    "    student_heights[n] = int(student_heights[n])\n",
    "totalHeight= 0\n",
    "totalInput = 0\n",
    "for height in student_heights:\n",
    "    totalHeight += height\n",
    "    totalInput += 1\n",
    "print(round(totalHeight/totalInput))\n",
    "\n",
    "# Simplify version using sum() and len()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input a list of student scores 78 65 89 86 55 91 64 89\n",
      "The highest score in the class is: 91\n"
     ]
    }
   ],
   "source": [
    "# Highest Score\n",
    "student_scores = input(\"Input a list of student scores \").split()\n",
    "for n in range(0, len(student_scores)):\n",
    "    student_scores[n] = int(student_scores[n])\n",
    "maxScore = 0\n",
    "for score in student_scores:\n",
    "    if score > maxScore:\n",
    "        maxScore = score\n",
    "print(f\"The highest score in the class is: {maxScore}\")\n",
    "\n",
    "# Simplify version using max() or min()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Range Function**\n",
    "```python\n",
    "for number in range(start,end,step):\n",
    "    print(number)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2550\n"
     ]
    }
   ],
   "source": [
    "# Sum of even numbers 1-100\n",
    "sum = 0\n",
    "for i in range(1,101):\n",
    "    if i%2 == 0:\n",
    "        sum += i\n",
    "print(sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "Fizz\n",
      "4\n",
      "Buzz\n",
      "Fizz\n",
      "7\n",
      "8\n",
      "Fizz\n",
      "Buzz\n",
      "11\n",
      "Fizz\n",
      "13\n",
      "14\n",
      "FizzBuzz\n"
     ]
    }
   ],
   "source": [
    "# Fizz Buzz\n",
    "for i in range(1,16):\n",
    "    if (i%3==0 and i%5==0):\n",
    "        print('FizzBuzz')\n",
    "    elif (i%3 == 0):\n",
    "        print('Fizz')\n",
    "    elif(i%5 == 0):\n",
    "        print('Buzz')\n",
    "    else: print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Project Password Generator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The ***join( )*** method takes all items in an iterable and joins them into one string.  \n",
    "A string must be specified as the separator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to the PyPassword Generator!\n",
      "How many letters would you like in your password?\n",
      "12\n",
      "How many symbols would you like?\n",
      "3\n",
      "How many numbers would you like?\n",
      "4\n",
      "Your password is: 'W%dx*6%gqHH1tq#A1Bz'\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']\n",
    "numbers = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']\n",
    "symbols = ['!', '#', '$', '%', '&', '(', ')', '*', '+']\n",
    "\n",
    "print(\"Welcome to the PyPassword Generator!\")\n",
    "nr_letters= int(input(\"How many letters would you like in your password?\\n\")) \n",
    "nr_symbols = int(input(f\"How many symbols would you like?\\n\"))\n",
    "nr_numbers = int(input(f\"How many numbers would you like?\\n\"))\n",
    "\n",
    "passwordList = []\n",
    "passwordList += random.choices(letters, k=nr_letters)\n",
    "passwordList += random.choices(numbers, k=nr_symbols)\n",
    "passwordList += random.choices(symbols, k=nr_numbers)\n",
    "random.shuffle(passwordList) \n",
    "password = ''.join(passwordList)\n",
    "print(f\"Your password is: '{password}'\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Day 6 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Functions, Code Blocks & While Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "def myFunction():\n",
    "    print(\"Add functionalities\");\n",
    "myFunction()  \n",
    "\n",
    "while (something_is_true):\n",
    "    #Do something repeatedly\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Day 7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***enumerate( )***\n",
    "```python\n",
    "for index,value in enumerate(\"String\"):\n",
    "    print(f\"{index} -> {value}\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Project Hangman"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Clear window for Python IDLE\n",
    "```python\n",
    "import subprocess\n",
    "subprocess.call(\"cls\", shell=True)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Guess a letter: n\n",
      "\n",
      "  +---+\n",
      "  |   |\n",
      "  O   |\n",
      "      |\n",
      "      |\n",
      "      |\n",
      "=========\n",
      "\n",
      "baboon\n",
      "You Win\n"
     ]
    }
   ],
   "source": [
    "###### import random\n",
    "from IPython.display import clear_output\n",
    "word_list = [\"aardvark\", \"baboon\", \"camel\"]\n",
    "stages = ['''\n",
    "  +---+\n",
    "  |   |\n",
    "  O   |\n",
    " /|\\  |\n",
    " / \\  |\n",
    "      |\n",
    "=========\n",
    "''', '''\n",
    "  +---+\n",
    "  |   |\n",
    "  O   |\n",
    " /|\\  |\n",
    " /    |\n",
    "      |\n",
    "=========\n",
    "''', '''\n",
    "  +---+\n",
    "  |   |\n",
    "  O   |\n",
    " /|\\  |\n",
    "      |\n",
    "      |\n",
    "=========\n",
    "''', '''\n",
    "  +---+\n",
    "  |   |\n",
    "  O   |\n",
    " /|   |\n",
    "      |\n",
    "      |\n",
    "=========''', '''\n",
    "  +---+\n",
    "  |   |\n",
    "  O   |\n",
    "  |   |\n",
    "      |\n",
    "      |\n",
    "=========\n",
    "''', '''\n",
    "  +---+\n",
    "  |   |\n",
    "  O   |\n",
    "      |\n",
    "      |\n",
    "      |\n",
    "=========\n",
    "''', '''\n",
    "  +---+\n",
    "  |   |\n",
    "      |\n",
    "      |\n",
    "      |\n",
    "      |\n",
    "=========\n",
    "''']\n",
    "\n",
    "chosen_word  = random.choice(word_list)\n",
    "lives = 6\n",
    "display = ['_']*len(chosen_word)\n",
    "while(lives and '_' in display):\n",
    "    clear_output(wait=True)\n",
    "    guess = input(\"Guess a letter: \").lower()\n",
    "    if guess in display:\n",
    "        print(f\"You already guessed {guess}\")\n",
    "    for position,letter in enumerate(chosen_word):\n",
    "        if guess == letter:\n",
    "            display[position] = letter\n",
    "    if guess not in chosen_word:\n",
    "        lives -= 1\n",
    "        print(f\"You guessed {guess}, thats not in the word. You loose a life\")\n",
    "    print(stages[lives])\n",
    "    print(''.join(display))\n",
    "if('_' in display):\n",
    "    print(f\"You Loose \\t It was {chosen_word}\")\n",
    "else:\n",
    "    print(\"You Win\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Day 8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Function with Inputs, Arguments & Parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `Argument` is actual piece of data being passed over to function.  \n",
    "- Whereas `Parameter` is name of that data, used as reference inside function.\n",
    "```python\n",
    "def functionWithInput(parameter):\n",
    "    print(f\"This is {parameter} \")\n",
    "functionWithInput(\"argument\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "def greet(name,location):\n",
    "    print(f\"{name} -> {location}\")\n",
    "```\n",
    "> - Postional Argument\n",
    "```python \n",
    "greet('Abhijeet','Mumbai')```\n",
    "> - Keyword Argument\n",
    "```python\n",
    "greet(location = 'Mumbai', name = 'Abhijeet')```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Height of wall: 3\n",
      "Width of wall: 9\n",
      "You'll need 6 cans of paint.\n"
     ]
    }
   ],
   "source": [
    "# Paint Area Calculator\n",
    "\n",
    "from math import ceil\n",
    "def paint_calc(height, width, cover):\n",
    "    canRequired = ceil(height*width/coverage)\n",
    "    print(f\"You'll need {canRequired} cans of paint.\")\n",
    "test_h = int(input(\"Height of wall: \"))\n",
    "test_w = int(input(\"Width of wall: \"))\n",
    "coverage = 5\n",
    "paint_calc(height=test_h, width=test_w, cover=coverage)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Check this number: 5\n",
      "5 is a prime number\n"
     ]
    }
   ],
   "source": [
    "# Prime Number Checker\n",
    "\n",
    "def prime_checker(number):\n",
    "    prime = True\n",
    "    for n in range(1,number):\n",
    "        if number%n == 0:\n",
    "            prime = False\n",
    "    if(prime):\n",
    "        print(f\"{number} is a prime number\")\n",
    "    else:\n",
    "        print(f\"{number} not a prime number\")\n",
    "n = int(input(\"Check this number: \"))\n",
    "prime_checker(number = n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Project Caesar Cipher"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type 'encode' to encrypt, type 'decode' to decrypt:\n",
      "encode\n",
      "Type your message:\n",
      "secret message 1\n",
      "Type the shift number:\n",
      "1025\n",
      "The encoded text is 'dpncpe xpddlrp 1'\n",
      "Type 'yes' if you want to go again. Otherwise 'no'.\n",
      "yes\n",
      "Type 'encode' to encrypt, type 'decode' to decrypt:\n",
      "decode\n",
      "Type your message:\n",
      "dpncpe xpddlrp 1\n",
      "Type the shift number:\n",
      "1025\n",
      "The decoded text is 'secret message 1'\n",
      "Type 'yes' if you want to go again. Otherwise 'no'.\n",
      "no\n"
     ]
    }
   ],
   "source": [
    "alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']\n",
    "\n",
    "def caesar(text, shift, direction):\n",
    "    new_text = ['']*len(text)\n",
    "    if(direction == 'decode'):\n",
    "        shift *= -1\n",
    "    for (position, letter) in enumerate(text):\n",
    "        if letter in alphabet:\n",
    "            new_text[position] = alphabet[(alphabet.index(letter) + shift)%len(alphabet)]\n",
    "        else:\n",
    "            new_text[position] = letter\n",
    "    print(f\"The {direction}d text is '{''.join(new_text)}'\")\n",
    "\n",
    "resume = 'yes'\n",
    "while(resume == 'yes'):\n",
    "    direction = input(\"Type 'encode' to encrypt, type 'decode' to decrypt:\\n\")\n",
    "    text = input(\"Type your message:\\n\").lower()\n",
    "    shift = int(input(\"Type the shift number:\\n\"))\n",
    "    caesar(text, shift, direction)\n",
    "    resume = input(\"Type 'yes' if you want to go again. Otherwise 'no'.\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Day 9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Dictionaries & Nesting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "myDictionary = {\n",
    "   \"key1\" : \"value1\",\n",
    "    2 : \"value2\"\n",
    "}\n",
    "myDictionary[\"key3\"] = \"value3\"\n",
    "```\n",
    "Note : Value is string here, but if we define a function say add, then we can assgin `{'+' : add}`\n",
    "> Nesting  \n",
    "```python \n",
    "{\"key1\" : {Dict}, \"key2\" : [List]}```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Harry': 'Exceeds Expectations', 'Ron': 'Acceptable', 'Hermione': 'Outstanding', 'Draco': 'Acceptable', 'Neville': 'Fail'}\n"
     ]
    }
   ],
   "source": [
    "# Grading Program\n",
    "\n",
    "student_scores = {\n",
    "  \"Harry\": 81,\n",
    "  \"Ron\": 78,\n",
    "  \"Hermione\": 99, \n",
    "  \"Draco\": 74,\n",
    "  \"Neville\": 62,\n",
    "}\n",
    "student_grades = {}\n",
    "for i in student_scores:\n",
    "    if student_scores[i] > 90 :\n",
    "        student_grades[i] = \"Outstanding\"\n",
    "    elif student_scores[i] > 80 :\n",
    "        student_grades[i] = \"Exceeds Expectations\"\n",
    "    elif student_scores[i] > 70 :\n",
    "        student_grades[i] = \"Acceptable\"\n",
    "    else :\n",
    "        student_grades[i] = \"Fail\"\n",
    "print(student_grades)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You've been to Russia 2 times.\n",
      "You've been to Moscow Saint Petersburg\n",
      "[{'country': 'France', 'visits': 12, 'cities': ['Paris', 'Lille', 'Dijon']}, {'country': 'Germany', 'visits': 5, 'cities': ['Berlin', 'Hamburg', 'Stuttgart']}, {'country': 'Russia', 'visits': 2, 'cities': ['Moscow', 'Saint Petersburg']}]\n"
     ]
    }
   ],
   "source": [
    "travel_log = [\n",
    "{\n",
    "  \"country\": \"France\",\n",
    "  \"visits\": 12,\n",
    "  \"cities\": [\"Paris\", \"Lille\", \"Dijon\"]\n",
    "},\n",
    "{\n",
    "  \"country\": \"Germany\",\n",
    "  \"visits\": 5,\n",
    "  \"cities\": [\"Berlin\", \"Hamburg\", \"Stuttgart\"]\n",
    "},\n",
    "]\n",
    "def add_new_country(countryName, timesVisited, citiesVisited):\n",
    "    travel_log.append({\n",
    "        \"country\" : countryName,\n",
    "        \"visits\": timesVisited,\n",
    "        \"cities\": citiesVisited\n",
    "    })\n",
    "    print(f\"You've been to {countryName} {timesVisited} times.\")\n",
    "    print(f\"You've been to {' '.join(citiesVisited)}.\")\n",
    "add_new_country(\"Russia\", 2, [\"Moscow\", \"Saint Petersburg\"])\n",
    "print(travel_log)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Project Secret Auction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The winner is Neymar with a bid of $321\n"
     ]
    }
   ],
   "source": [
    "from IPython.display import clear_output\n",
    "\n",
    "print(\"Welcome to Python Secret Auction\")\n",
    "auction = []\n",
    "def addBid(name, bid):\n",
    "    auction.append({\n",
    "        \"name\" : name,\n",
    "        \"bid\" : bid\n",
    "    })\n",
    "resume = \"yes\"\n",
    "while resume == \"yes\":\n",
    "    name = input(\"What's your name? \")\n",
    "    bid = int(input(\"What's your bid? $\"))\n",
    "    addBid(name, bid)\n",
    "    resume = input(\"Add another bid? 'yes' or 'no': \")\n",
    "    clear_output()\n",
    "max = 0\n",
    "name = ''\n",
    "for value in auction:\n",
    "    if value[\"bid\"] > max:\n",
    "        max = value[\"bid\"]\n",
    "        name = value[\"name\"]\n",
    "print(f\"The winner is {name} with a bid of ${max}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Day 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Function with Outputs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ***title( )*** -> Convert to title case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a year: 2020\n",
      "Enter a month: 2\n",
      "29\n"
     ]
    }
   ],
   "source": [
    "def is_leap(year):\n",
    "    if year%4 != 0:\n",
    "        return False\n",
    "    elif year%100 != 0:\n",
    "        return True\n",
    "    elif year%400 == 0:\n",
    "        return True\n",
    "    return False\n",
    "\n",
    "def days_in_month(year, month):\n",
    "    month_days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]\n",
    "    if month == 2 and is_leap(year):\n",
    "        return 29\n",
    "    return month_days[month-1]\n",
    "\n",
    "year = int(input(\"Enter a year: \"))\n",
    "month = int(input(\"Enter a month: \"))\n",
    "days = days_in_month(year, month)\n",
    "print(days)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Docstrings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mark Henry\n"
     ]
    }
   ],
   "source": [
    "def printTitle(fName, lName):\n",
    "    \"\"\"\n",
    "    Return the title case for name.\n",
    "    \"\"\"\n",
    "    print((fName + \" \" + lName).title())\n",
    "printTitle(\"mArK\",\"HeNrY\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Project Calculator Program"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " _____________________\n",
      "|  _________________  |\n",
      "| | Pythonista   0. | |  .----------------.  .----------------.  .----------------.  .----------------. \n",
      "| |_________________| | | .--------------. || .--------------. || .--------------. || .--------------. |\n",
      "|  ___ ___ ___   ___  | | |     ______   | || |      __      | || |   _____      | || |     ______   | |\n",
      "| | 7 | 8 | 9 | | + | | | |   .' ___  |  | || |     /  \\     | || |  |_   _|     | || |   .' ___  |  | |\n",
      "| |___|___|___| |___| | | |  / .'   \\_|  | || |    / /\\ \\    | || |    | |       | || |  / .'   \\_|  | |\n",
      "| | 4 | 5 | 6 | | - | | | |  | |         | || |   / ____ \\   | || |    | |   _   | || |  | |         | |\n",
      "| |___|___|___| |___| | | |  \\ `.___.'\\  | || | _/ /    \\ \\_ | || |   _| |__/ |  | || |  \\ `.___.'\\  | |\n",
      "| | 1 | 2 | 3 | | x | | | |   `._____.'  | || ||____|  |____|| || |  |________|  | || |   `._____.'  | |\n",
      "| |___|___|___| |___| | | |              | || |              | || |              | || |              | |\n",
      "| | . | 0 | = | | / | | | '--------------' || '--------------' || '--------------' || '--------------' |\n",
      "| |___|___|___| |___| |  '----------------'  '----------------'  '----------------'  '----------------' \n",
      "|_____________________|\n",
      "\n",
      "What's the first number?: 1\n",
      "+\n",
      "-\n",
      "*\n",
      "/\n",
      "What's the next number?: 1\n",
      "Choose an operation from above: +\n",
      "1 + 1 = 2\n",
      "Type 'y' to continue calculating with 2 or 'r' to restart: y\n",
      "What's the next number?: 1\n",
      "Choose an operation from above: +\n",
      "2 + 1 = 3\n",
      "Type 'y' to continue calculating with 3 or 'r' to restart: r\n",
      "What's the first number?: 2\n",
      "+\n",
      "-\n",
      "*\n",
      "/\n",
      "What's the next number?: +2\n",
      "Choose an operation from above: +\n",
      "2 + 2 = 4\n",
      "Type 'y' to continue calculating with 4 or 'r' to restart: n\n"
     ]
    }
   ],
   "source": [
    "logo = \"\"\"\n",
    " _____________________\n",
    "|  _________________  |\n",
    "| | Pythonista   0. | |  .----------------.  .----------------.  .----------------.  .----------------. \n",
    "| |_________________| | | .--------------. || .--------------. || .--------------. || .--------------. |\n",
    "|  ___ ___ ___   ___  | | |     ______   | || |      __      | || |   _____      | || |     ______   | |\n",
    "| | 7 | 8 | 9 | | + | | | |   .' ___  |  | || |     /  \\     | || |  |_   _|     | || |   .' ___  |  | |\n",
    "| |___|___|___| |___| | | |  / .'   \\_|  | || |    / /\\ \\    | || |    | |       | || |  / .'   \\_|  | |\n",
    "| | 4 | 5 | 6 | | - | | | |  | |         | || |   / ____ \\   | || |    | |   _   | || |  | |         | |\n",
    "| |___|___|___| |___| | | |  \\ `.___.'\\  | || | _/ /    \\ \\_ | || |   _| |__/ |  | || |  \\ `.___.'\\  | |\n",
    "| | 1 | 2 | 3 | | x | | | |   `._____.'  | || ||____|  |____|| || |  |________|  | || |   `._____.'  | |\n",
    "| |___|___|___| |___| | | |              | || |              | || |              | || |              | |\n",
    "| | . | 0 | = | | / | | | '--------------' || '--------------' || '--------------' || '--------------' |\n",
    "| |___|___|___| |___| |  '----------------'  '----------------'  '----------------'  '----------------' \n",
    "|_____________________|\n",
    "\"\"\"\n",
    "print(logo)\n",
    "\n",
    "def add(n1,n2):\n",
    "    return n1+n2\n",
    "def subtract(n1,n2):\n",
    "    return n1-n2\n",
    "def multiply(n1,n2):\n",
    "    return n1*n2\n",
    "def divide(n1,n2):\n",
    "    return n1/n2\n",
    "operator = {\n",
    "    '+' : add,\n",
    "    '-' : subtract,\n",
    "    '*' : multiply,\n",
    "    '/' : divide\n",
    "}\n",
    "def start():\n",
    "    num1 = float(input(\"What's the first number?: \"))\n",
    "    for symbol in operator:\n",
    "        print(symbol)\n",
    "    return num1\n",
    "num1 = start()\n",
    "resume = 'y' \n",
    "while resume == 'y' or resume == 'r':\n",
    "    num2 = float(input(\"What's the next number?: \"))\n",
    "    symbol = input(\"Choose an operation from above: \")\n",
    "    function = operator[symbol]\n",
    "    answer = function(num1,num2)\n",
    "    print(f\"{num1} {symbol} {num2} = {answer}\")\n",
    "    resume = input(f\"Type 'y' to continue calculating with {answer} or 'r' to restart: \")\n",
    "    num1 =  answer\n",
    "    if resume == 'r':\n",
    "        num1 = start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Day 11"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Capstone Project Blackjack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      ".------.            _     _            _    _            _    \n",
      "|A_  _ |.          | |   | |          | |  (_)          | |   \n",
      "|( \\/ ).-----.     | |__ | | __ _  ___| | ___  __ _  ___| | __\n",
      "| \\  /|K /\\  |     | '_ \\| |/ _` |/ __| |/ / |/ _` |/ __| |/ /\n",
      "|  \\/ | /  \\ |     | |_) | | (_| | (__|   <| | (_| | (__|   < \n",
      "`-----| \\  / |     |_.__/|_|\\__,_|\\___|_|\\_\\ |\\__,_|\\___|_|\\_\\\n",
      "      |  \\/ K|                            _/ |                \n",
      "      `------'                           |__/           \n",
      "\n",
      "\tYour cards: [10, 5], current score: 15\n",
      "\tComputers's first card: 4\n",
      "Type 'y' to get another card, type 'n' to pass: y\n",
      "\tYour cards: [10, 5, 8], current score: 23\n",
      "\tComputers's first card: 4\n",
      "Your final hand: [10, 5, 8], final score: 23\n",
      "Computer's final hand: [4, 10, 1, 4], final score: 19\n",
      "You went over. You lose 😭\n",
      "Do you want to play a game of Blackjack? Type 'y' or 'n': n\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "from IPython.display import clear_output\n",
    "logo = \"\"\"\n",
    ".------.            _     _            _    _            _    \n",
    "|A_  _ |.          | |   | |          | |  (_)          | |   \n",
    "|( \\/ ).-----.     | |__ | | __ _  ___| | ___  __ _  ___| | __\n",
    "| \\  /|K /\\  |     | '_ \\| |/ _` |/ __| |/ / |/ _` |/ __| |/ /\n",
    "|  \\/ | /  \\ |     | |_) | | (_| | (__|   <| | (_| | (__|   < \n",
    "`-----| \\  / |     |_.__/|_|\\__,_|\\___|_|\\_\\ |\\__,_|\\___|_|\\_\\\\\n",
    "      |  \\/ K|                            _/ |                \n",
    "      `------'                           |__/           \n",
    "\"\"\"\n",
    "\n",
    "cards = [11, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10, 10]\n",
    "def displayStats(you, computer):\n",
    "    print(f\"\\tYour cards: {you}, current score: {sum(you)}\")\n",
    "    print(f\"\\tComputers's first card: {computer[0]}\")\n",
    "def drawCard(card):\n",
    "    newCard = random.choice(cards)\n",
    "    if newCard == 11 and sum(cards)+newCard>21:\n",
    "        newCard = 1\n",
    "    card.append(newCard)\n",
    "def blackJack(card):\n",
    "    return (card[0] + card[1]) == 21\n",
    "def result(yourCards, computerCards):\n",
    "    print(f\"Your final hand: {yourCards}, final score: {sum(yourCards)}\")\n",
    "    while (sum(computerCards) <= 16):\n",
    "        drawCard(computerCards)\n",
    "    print(f\"Computer's final hand: {computerCards}, final score: {sum(computerCards)}\")\n",
    "    if blackJack(computerCards):\n",
    "        return print(\"Lose, Opponent with a Blackjack 😭\")\n",
    "    if blackJack(yourCards):\n",
    "        return print(\"Win with a Blackjack 😎\")\n",
    "    if sum(yourCards) > 21:\n",
    "        return print(\"You went over. You lose 😭\")\n",
    "    elif sum(computerCards) > 21:\n",
    "        return print(\"Opponent went over. You win 😁\")\n",
    "    elif sum(yourCards) == sum(computerCards):\n",
    "        return print(\"Draw 😁\")\n",
    "    elif sum(yourCards) > sum(computerCards):\n",
    "        return print(\"You win 😁\")\n",
    "    else:\n",
    "        return print(\"You lose 😤\")\n",
    "play = 'y'\n",
    "while(play == 'y'):\n",
    "    clear_output()\n",
    "    print(logo)\n",
    "    yourCards = random.choices(cards, k=2)\n",
    "    computerCards = random.choices(cards, k=2)\n",
    "    displayStats(yourCards,computerCards)\n",
    "    move = 'y'\n",
    "    if blackJack(yourCards):\n",
    "        move = 'n'\n",
    "    while (sum(yourCards)<=21 and move=='y'):\n",
    "        move = input(\"Type 'y' to get another card, type 'n' to pass: \")\n",
    "        if(move == 'y'):\n",
    "            drawCard(yourCards)\n",
    "            displayStats(yourCards,computerCards)\n",
    "    result(yourCards,computerCards)\n",
    "    play = input(\"Do you want to play a game of Blackjack? Type 'y' or 'n': \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Day 12"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Namespaces: Local vs. Global Scope"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Local Scope***  \n",
    "- New variables and functions inside another function is accesible within that function.  \n",
    "\n",
    "***Global Scope***  \n",
    "- New variables defined at top-level is accesible within and outside function. \n",
    "- Dictionary can be accessed or edited within functions also, unike variables.\n",
    "\n",
    "```python\n",
    "player_health = 10\n",
    "def game():\n",
    "    def drinkPotion():\n",
    "        potion = +5\n",
    "        print(player_health) # Global variable accessible\n",
    "        print(potion) # Local variable only accessible to defined function\n",
    "```\n",
    "\n",
    "- No `Block Scope` in python.\n",
    "- if, for or while loop, any sort of block code thats indented. Still has same scope as enclosing function.\n",
    "```python\n",
    "enemies = ['Sekelton','Zombie','Alien']\n",
    "if True:\n",
    "    enemy = enemies[0]\n",
    "print(enemy) # Accessible\n",
    "```\n",
    "***Modifying Global Scope***\n",
    "```python\n",
    "enemies = 1\n",
    "def increaseEnemy():\n",
    "    enemies += 1 \n",
    "    # This will show error as we don't have access to global variable 'enemies' yet. Instead what is being done here  is, a local variable 'enemies' is being incremented, which is not possible as it's value is not initialized.\n",
    "    global enemies \n",
    "    enemies += 1 \n",
    "    # Now funcition knows 'enemies' is a global variable.\n",
    "    # However it's not recommended to use this method.\n",
    "    # Instead use 'reutrn'\n",
    "    return enemies+1\n",
    "enemies = increaseEnemy()\n",
    "print(enemies) # 2\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "  / _ \\_   _  ___  ___ ___  /__   \\ |__   ___    /\\ \\ \\_   _ _ __ ___ | |__   ___ _ __ \n",
      " / /_\\/ | | |/ _ \\/ __/ __|   / /\\/ '_ \\ / _ \\  /  \\/ / | | | '_ ` _ \\| '_ \\ / _ \\ '__|\n",
      "/ /_\\| |_| |  __/\\__ \\__ \\  / /  | | | |  __/ / /\\  /| |_| | | | | | | |_) |  __/ |   \n",
      "\\____/ \\__,_|\\___||___/___/  \\/   |_| |_|\\___| \\_\\ \\/  \\__,_|_| |_| |_|_.__/ \\___|_|  \n",
      "\n",
      "Welcome to the Number Guessing Game!\n",
      "I'm thinking of a number between 1 and 100.\n",
      "Pssst, the correct answer is 61\n",
      "Choose a difficulty. Type 'easy' or 'hard': hard\n",
      "You have 5 attempts remaining to guess the number.\n",
      "Make a guess: 645\n",
      "Too high.\n",
      "Guess again.\n",
      "You have 4 attempts remaining to guess the number.\n",
      "Make a guess: 64\n",
      "Too high.\n",
      "Guess again.\n",
      "You have 3 attempts remaining to guess the number.\n",
      "Make a guess: 61\n",
      "You got it! The answer was 61.\n",
      "Do you want to play Guess The Number? Type 'y' or 'n': n\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "from IPython.display import clear_output\n",
    "logo = \"\"\"\n",
    "  / _ \\_   _  ___  ___ ___  /__   \\ |__   ___    /\\ \\ \\_   _ _ __ ___ | |__   ___ _ __ \n",
    " / /_\\/ | | |/ _ \\/ __/ __|   / /\\/ '_ \\ / _ \\  /  \\/ / | | | '_ ` _ \\| '_ \\ / _ \\ '__|\n",
    "/ /_\\| |_| |  __/\\__ \\__ \\  / /  | | | |  __/ / /\\  /| |_| | | | | | | |_) |  __/ |   \n",
    "\\____/ \\__,_|\\___||___/___/  \\/   |_| |_|\\___| \\_\\ \\/  \\__,_|_| |_| |_|_.__/ \\___|_|  \n",
    "\"\"\"\n",
    "play = 'y'\n",
    "while play == 'y':\n",
    "    clear_output()\n",
    "    print(logo)\n",
    "    print(\"Welcome to the Number Guessing Game!\")\n",
    "    print(\"I'm thinking of a number between 1 and 100.\")\n",
    "    key = random.choice(range(101))\n",
    "#     print(f\"Pssst, the correct answer is {key}\")\n",
    "    level = input(\"Choose a difficulty. Type 'easy' or 'hard': \")\n",
    "    attempt = 10\n",
    "    if level=='hard':\n",
    "        attempt = 5\n",
    "    gameContinue = True\n",
    "    while attempt > 0 and gameContinue:\n",
    "        print(f\"You have {attempt} attempts remaining to guess the number.\")\n",
    "        guess = int(input(\"Make a guess: \"))\n",
    "        attempt -= 1\n",
    "        if guess < key:\n",
    "            print(\"Too low.\")\n",
    "        elif guess > key:\n",
    "            print(\"Too high.\")\n",
    "        else:\n",
    "            print(f\"You got it! The answer was {key}.\")\n",
    "            gameContinue = False\n",
    "        if attempt > 0 and gameContinue:\n",
    "            print(\"Guess again.\")\n",
    "        elif attempt < 1 and gameContinue:\n",
    "            print(\"You've run out of guesses, you lose.\")\n",
    "    play = input(\"Do you want to play Guess The Number? Type 'y' or 'n': \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}