Learn+Python+3+.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python Tutorial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello World\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "10.5\n"
     ]
    }
   ],
   "source": [
    "a = 10\n",
    "b = 10.5\n",
    "\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "print(type(a))\n",
    "print(type(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "c = \"hello_python\"\n",
    "print(type(c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5+3j)\n",
      "<class 'complex'>\n"
     ]
    }
   ],
   "source": [
    "d = 5 + 3j\n",
    "print(d)\n",
    "print(type(d))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = 100.5\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100.5\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "print(a)\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Working with Input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the name of your organisation\n",
      "Hello \n"
     ]
    }
   ],
   "source": [
    "name = input(\"Enter the name of your organisation\")\n",
    "print(\"Hello\",end=' ')\n",
    "print(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reading Numbers | Typecasting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a Number\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "could not convert string to float: ",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-9-b8fca47f411e>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0ma\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mfloat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0minput\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Enter a Number\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtype\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: could not convert string to float: "
     ]
    }
   ],
   "source": [
    "a = float(input(\"Enter a Number\"))\n",
    "print(a)\n",
    "print(a*a)\n",
    "\n",
    "print(type(a))\n",
    "print(\"The square of the number is \" + str(a*a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More about the Print Function\n",
    "\n",
    "- format \n",
    "- end and sep"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(\"Hello\",\"World\",\"I\",\"Love\",\"Python\",sep=\"+\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = 10\n",
    "b = 20\n",
    "print(a,end=',')\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = \"Indians\"\n",
    "b = \"Mangoes\"\n",
    "\n",
    "c = \"Russians\"\n",
    "d = \"Pizza\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(\"{0} love {1}\".format(c,d))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = 10\n",
    "b = 20\n",
    "\n",
    "print(\"You entered %d and %d and %d\"%(a,b,b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variables,Datatypes and Operators\n",
    "\n",
    "A type of identifier.\n",
    "\n",
    "Rules for naming identifiers:\n",
    "\n",
    "    The first character of the identifier must be a letter of the alphabet (uppercase ASCII or lowercase ASCII or Unicode character) or an underscore (_).\n",
    "\n",
    "    The rest of the identifier name can consist of letters (uppercase ASCII or lowercase ASCII or Unicode character), underscores (_) or digits (0-9).\n",
    "\n",
    "    Identifier names are case-sensitive. For example, myname and myName are not the same. Note the lowercase n in the former and the uppercase N in the latter.\n",
    "\n",
    "Examples of valid identifier names are i, name_2_3.\n",
    "\n",
    "Examples of invalid identifier names are 2things, this is spaced out, my-name and >a1b2_c3."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Airthmetic Operators (+,-,*,**,/,//,%) \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = 10\n",
    "b = 21\n",
    "\n",
    "print(a+b)\n",
    "print(a-b)\n",
    "print(a*b)\n",
    "print(\"%0.4f\"%(a/b))\n",
    "print(a//b)\n",
    "#Exponent/Power Function\n",
    "print(a**b)\n",
    "print(b%a)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multiple Variable Assignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a,b,c = 10,20,30.34"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 20 30.34\n"
     ]
    }
   ],
   "source": [
    "# This functions print the variables\n",
    "print(a,b,c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Whitespaces and Indendation\n",
    "\n",
    "\n",
    "- Whitespace is important in Python.\n",
    "\n",
    "- Actually, whitespace at the beginning of the line is important. This is called indentation.\n",
    "\n",
    "- Leading whitespace (spaces and tabs) at the beginning of the logical line is used to determine the indentation level of the logical line, which in turn is used to determine the grouping of statements.\n",
    "\n",
    "- This means that statements which go together must have the same indentation. Each such set of statements is called a block\n",
    "\n",
    "### Don't mix tabs and Spaces\n",
    "### Comments are Important for readability of your code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is \n",
      "a multiline string \n"
     ]
    }
   ],
   "source": [
    "\n",
    "# This is a single comment !\n",
    "\n",
    "\"\"\"This is a \n",
    "multiline \n",
    "comment \"\"\"\n",
    "\n",
    "myString = \"\"\"This is \n",
    "a multiline string \"\"\"\n",
    "\n",
    "print(myString)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operators - Arithmetic, Comparsion, Compound Assignment, Logical Operators\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "raining = True\n",
    "temperature = 30\n",
    "\n",
    "\n",
    "outing = raining and temperature <= 30\n",
    "print(outing)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## If Else Blocks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rainy\n",
      "Don't go outside\n",
      "It is raining heavilly\n"
     ]
    }
   ],
   "source": [
    "weather  = input()\n",
    "\n",
    "if weather==\"Rainy\":\n",
    "    print(\"Don't go outside\")\n",
    "    print(\"It is raining heavilly\")\n",
    "    \n",
    "elif weather==\"Cool\":\n",
    "    print(\"Lets play Cricket\")\n",
    "\n",
    "else:\n",
    "    print(\"Lets go for shopping\")\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loops in Python "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Step 1\n",
      "Step 2\n",
      "Step 3\n",
      "Step 4\n",
      "Step 5\n",
      "Step 6\n",
      "Step 7\n",
      "Step 8\n",
      "Step 9\n",
      "Step 10\n",
      "Loop Finished\n"
     ]
    }
   ],
   "source": [
    "n = 10\n",
    "i = 1\n",
    "\n",
    "while i<=n:\n",
    "    print(\"Step %d\"%i)\n",
    "    i = i + 1\n",
    "\n",
    "print(\"Loop Finished\")\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1,3,5,7,9,"
     ]
    }
   ],
   "source": [
    "for i in range(1,10,2):\n",
    "    print(i,end=\",\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3628800\n"
     ]
    }
   ],
   "source": [
    "no = 10\n",
    "ans = 1\n",
    "\n",
    "for i in range(1,11):\n",
    "    ans *= i\n",
    "    \n",
    "print(ans)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loops here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10,8,6,4,2,"
     ]
    }
   ],
   "source": [
    "for i in range(10,1,-2):\n",
    "    print(i,end=',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 5 5 5 5 \n",
      "5 4 4 4 5 \n",
      "5 4 3 4 5 \n",
      "5 4 4 4 5 \n",
      "5 5 5 5 5 \n"
     ]
    }
   ],
   "source": [
    "# 5 X 5 Matrix\n",
    "n = 5\n",
    "for x in range(n):\n",
    "    for y in range(n):\n",
    "        print(max(x+1,y+1,n-x,n-y),end=\" \")\n",
    "    print()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Break Continue and Pass Statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "Loop ends\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,10):\n",
    "    if i==5:\n",
    "        continue\n",
    "    print(i)\n",
    "\n",
    "print(\"Loop ends\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Write a Program which prints all primes number upto N !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Factorial\n"
     ]
    }
   ],
   "source": [
    "def helloFact():\n",
    "    print(\"Hello Factorial\")\n",
    "    \n",
    "helloFact()\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "120\n"
     ]
    }
   ],
   "source": [
    "def factorial(n):\n",
    "    ans = 1\n",
    "    for i in range(1,n+1):\n",
    "        ans *= i\n",
    "    return ans\n",
    "\n",
    "print(factorial(5))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1,2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,"
     ]
    }
   ],
   "source": [
    "def isPrime(n):\n",
    "    \n",
    "    for i in range(2,n):\n",
    "        if(n%i==0):\n",
    "            return False\n",
    "        \n",
    "    return True\n",
    "\n",
    "\n",
    "def printPrime(V):\n",
    "    \n",
    "    for i in range(1,V+1):\n",
    "        if(isPrime(i)):\n",
    "            print(i,end=',')\n",
    "            \n",
    "            \n",
    "printPrime(100)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Default Argument Values and Local Global Variables\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I Love JavaScript\n",
      "I Love Python\n",
      "C++\n"
     ]
    }
   ],
   "source": [
    "lang = \"C++\"\n",
    "def say(x=\"Python\"):\n",
    "    print(\"I Love \" +x)\n",
    "    \n",
    "say(\"JavaScript\")\n",
    "say()\n",
    "print(lang)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Recursive Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "720\n"
     ]
    }
   ],
   "source": [
    "def fact(n):\n",
    "    #Base Case\n",
    "    if(n==0):\n",
    "        return 1\n",
    "    #Rec Case\n",
    "    return n*fact(n-1)\n",
    "\n",
    "print(fact(6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Keywords Arguments\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I scored 10 in Python\n",
      "1010\n"
     ]
    }
   ],
   "source": [
    "def myFunc(score,lang,rollNo):\n",
    "    print(\"I scored %d in %s\"%(score,lang))\n",
    "    print(rollNo)\n",
    "    \n",
    "    \n",
    "myFunc(rollNo=1010,lang=\"Python\",score=10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "(3, 4, 10, 14)\n",
      "<class 'tuple'>\n",
      "{'shake': 'OreoShake', 'drink': 'lemonade', 'fruit': 'Mango'}\n",
      "<class 'dict'>\n",
      "shake OreoShake\n",
      "drink lemonade\n",
      "fruit Mango\n"
     ]
    }
   ],
   "source": [
    "def fun(a,b,*x,**y):\n",
    "    print(a)\n",
    "    print(b)\n",
    "    print(x)\n",
    "    print(type(x))\n",
    "    print(y)\n",
    "    print(type(y))\n",
    "    \n",
    "    for k in y:\n",
    "        print(k,y[k])\n",
    "    \n",
    "    \n",
    "fun(1,2,3,4,10,14,shake=\"OreoShake\",drink=\"lemonade\",fruit=\"Mango\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Datastructure"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Coding Blocks\n"
     ]
    }
   ],
   "source": [
    "a = \"Coding Blocks\"\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "d\n"
     ]
    }
   ],
   "source": [
    "print(a[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s\n"
     ]
    }
   ],
   "source": [
    "print(a[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n"
     ]
    }
   ],
   "source": [
    "print(len(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Code Blocks\n"
     ]
    }
   ],
   "source": [
    "# Strings are Not Mutable!\n",
    "a = \"Code Blocks\"\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C\n",
      "o\n",
      "d\n",
      "e\n",
      " \n",
      "B\n",
      "l\n",
      "o\n",
      "c\n",
      "k\n",
      "s\n"
     ]
    }
   ],
   "source": [
    "for i in range(len(a)):\n",
    "    print(a[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C\n",
      "o\n",
      "d\n",
      "e\n",
      " \n",
      "B\n",
      "l\n",
      "o\n",
      "c\n",
      "k\n",
      "s\n"
     ]
    }
   ],
   "source": [
    "for c in a:\n",
    "    print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MangoJuice\n"
     ]
    }
   ],
   "source": [
    "a = \"Mango\"\n",
    "b = \"Juice\"\n",
    "print(a + b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MangoMangoMangoMangoMango\n"
     ]
    }
   ],
   "source": [
    "print(a*5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'an'"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Range Slicing \n",
    "a[1:-2]\n",
    "a[ : ]\n",
    "a[-2:]\n",
    "a[1:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yes\n"
     ]
    }
   ],
   "source": [
    "# Membership - Substring is present in bigger string\n",
    "a = \"Coding Blocks\"\n",
    "b = \"Code\"\n",
    "if b not in a:\n",
    "    print(\"Yes\")\n",
    "else:\n",
    "    print(\"No\")\n",
    "\n",
    "    #'go' in a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My favourite fruit is Mango and it comes from I\n"
     ]
    }
   ],
   "source": [
    "# String Formating \n",
    "print(\"My favourite fruit is %s and it comes from %c\"%(\"Mango\",\"I\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is some\n",
      "paragram written\n",
      "here\n"
     ]
    }
   ],
   "source": [
    "# Triple Quotes\n",
    "para = \"\"\"This is some\n",
    "paragram written\n",
    "here\"\"\"\n",
    "print(para)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['This', 'is', 'some', 'paragram', 'written', 'here']\n",
      "<class 'list'>\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "l = para.split()\n",
    "print(l)\n",
    "print(type(l))\n",
    "print(type(l[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['This is some', 'paragram written', 'here']"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "para.splitlines()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mango\n"
     ]
    }
   ],
   "source": [
    "fruit = \"Mango\"\n",
    "fruit = fruit.upper()\n",
    "fruit = fruit.lower()\n",
    "print(fruit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18\n"
     ]
    }
   ],
   "source": [
    "shake = \"    Apple Shake   \"\n",
    "shake2 = shake\n",
    "print(len(shake))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Apple Shake\n",
      "11\n"
     ]
    }
   ],
   "source": [
    "shake = shake.lstrip() #Removes the leading white space\n",
    "shake = shake.rstrip() #Removes the ending white space\n",
    "print(shake)\n",
    "print(len(shake))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Apple Shake\n",
      "11\n"
     ]
    }
   ],
   "source": [
    "shake2 = shake2.strip() #Removes leading and trailing whites spaces \n",
    "print(shake2)\n",
    "print(len(shake2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = \"9318790\"\n",
    "a.isdigit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = \"HNo\"\n",
    "a.isalpha()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "a = \"12abcA\"\n",
    "b = \"    \"\n",
    "print(a.isalnum())\n",
    "print(a.islower())\n",
    "print(b.isspace())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Some More String Functions :)\n",
    "    Find Function\n",
    "    Replace\n",
    "    Count Function\n",
    "    Join Function\n",
    "    Title Function\n",
    "    Capitalize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "48\n",
      "48\n"
     ]
    }
   ],
   "source": [
    "a = \"I love having Apple Juice, and I like eat green Apple\"\n",
    "print(a.find(\"Apple\",30,len(a)))\n",
    "\n",
    "print(a.index(\"Apple\",30,len(a)))\n",
    "# Difference is find() return -1, index throws an exception"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I love having Mango Juice, and I like eat green Mango\n"
     ]
    }
   ],
   "source": [
    "a = a.replace(\"Apple\",\"Mango\")\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.count(\"Mango\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['I', 'love', 'having', 'Mango', 'Juice,', 'and', 'I', 'like', 'eat', 'green', 'Mango']\n"
     ]
    }
   ],
   "source": [
    "l = a.split()\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I_love_having_Mango_Juice,_and_I_like_eat_green_Mango\n"
     ]
    }
   ],
   "source": [
    "b = \"_\"\n",
    "b = b.join(l)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Chiranjeev Kumar'"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name_org = \"chiranjeev kumar\"\n",
    "name_org.title()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists in Python\n",
    "#### List is like array, heterogenous list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3.5, 'Hello']\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "myList = [ 1,2,3.5,\"Hello\"]\n",
    "print(myList)\n",
    "print(type(myList))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "l2 = list([1,2,3])\n",
    "print(l2)\n",
    "print(type(l2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "[1, 2, 3, 1, 2, 3]\n",
      "[1, 2, 3, 1, 2, 3, 1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "l3 = list(l2)\n",
    "print(l3)\n",
    "\n",
    "l3 = l3 + l2\n",
    "print(l3)\n",
    "\n",
    "l3.extend(l2)\n",
    "print(l3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "# List of Square of the numbers from 1 to 5\n",
    "l4 = [i*i for i in range(1,6)]\n",
    "print(l4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9]\n",
      "[9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "print(l4[0:3])\n",
    "print(l4[-3:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Insertion and Deletion\n",
    "append\n",
    "\n",
    "insert\n",
    "\n",
    "remove\n",
    "\n",
    "pop\n",
    "\n",
    "del"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, [1.0, 2.1], 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "l = [1,2]\n",
    "l.append(3)\n",
    "\n",
    "l.append([1.0,2.1])\n",
    "l += [4,5,6]\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 20, 3, [1.0, 2.1], 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "l.insert(2,20)\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'int' object is not subscriptable",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-106-3e8b8ff82182>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ml\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\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: 'int' object is not subscriptable"
     ]
    }
   ],
   "source": [
    "print(l[3][1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 20, 3, [1.0, 2.1], 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "del l[0]\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 20, 3, [1.0, 2.1], 4, 5]\n"
     ]
    }
   ],
   "source": [
    "l.pop()\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "l = ([1,2,3])\n",
    "l = l*4\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = [\"Apple\",\"mango\",\"guava\",80]\n",
    "80 in l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Apple\n",
      "mango\n",
      "guava\n",
      "80\n"
     ]
    }
   ],
   "source": [
    "for i in range(len(l)):\n",
    "    print(l[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Apple\n",
      "mango\n",
      "guava\n",
      "80\n"
     ]
    }
   ],
   "source": [
    "for x in l:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### More functions on lists : Searching & Sorting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "l = [4,3,2,16,18]\n",
    "print(max(l))\n",
    "print(min(l))\n",
    "#Linear Search \n",
    "print(l.index(16))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "l = sorted(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 4, 16, 18]\n"
     ]
    }
   ],
   "source": [
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 4, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "l = [4,5,1,3,2]\n",
    "l.sort(reverse=True)\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 4 3 5 7 8 10 11\n",
      "[1, 4, 16, 9, 25, 49, 64, 100, 121]\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "## Read a list of Numbers\n",
    "numbers = [int(number)*int(number) for number in input().split()]\n",
    "print(numbers)\n",
    "print(type(numbers))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 'Hello')\n"
     ]
    }
   ],
   "source": [
    "t = (1,2,3,\"Hello\")\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "#tuples are immutable\n",
    "#t[0] = 5\n",
    "print(t[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 'Hello']\n",
      "[5, 2, 3, 'Hello']\n"
     ]
    }
   ],
   "source": [
    "# Convert a tuple into a list\n",
    "\n",
    "l = list(t)\n",
    "print(l)\n",
    "\n",
    "l[0] = 5\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5, 2, 3, 'Hello')\n"
     ]
    }
   ],
   "source": [
    "t2 = tuple(l)\n",
    "print(t2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5, 2, 3, 'Hello', 1, 2, 3, 'Hello')\n",
      "(5, 2, 3, 'Hello', 5, 2, 3, 'Hello', 5, 2, 3, 'Hello')\n"
     ]
    }
   ],
   "source": [
    "#concatentation\n",
    "print(t2 + t)\n",
    "\n",
    "#Repetion\n",
    "t2 = t2*3\n",
    "print(t2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "t = (1,44,3,2)\n",
    "print(min(t))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#for deleting the tuple\n",
    "del t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 't' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-22-d7cd619b74b5>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmin\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mt\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 't' is not defined"
     ]
    }
   ],
   "source": [
    "print(min(t))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Mango': 100, 'Apple': 80}\n",
      "100\n",
      "{'Mango': 100, 'Apple': 80, 'Guava': 60}\n",
      "[10, 20]\n",
      "90\n"
     ]
    }
   ],
   "source": [
    "d = {\"Mango\":100,\"Apple\":80}\n",
    "print(d)\n",
    "#Look Up\n",
    "print(d[\"Mango\"])\n",
    "\n",
    "d[\"Guava\"] = 60\n",
    "print(d)\n",
    "\n",
    "d[\"Grape\"] = [10,20]\n",
    "print(d[\"Grape\"])\n",
    "\n",
    "d[\"Pineapple\"] = {\"Small\":90,\"Large\":150}\n",
    "\n",
    "print(d[\"Pineapple\"][\"Small\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['Mango', 'Apple', 'Guava', 'Grape', 'Pineapple'])\n"
     ]
    }
   ],
   "source": [
    "print(d.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_values([100, 80, 60, [10, 20], {'Small': 90, 'Large': 150}])\n"
     ]
    }
   ],
   "source": [
    "print(d.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'NoneType'>\n"
     ]
    }
   ],
   "source": [
    "print(type(d.get(\"Mangoes\")))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Doesn't exist\n"
     ]
    }
   ],
   "source": [
    "if \"Mangoes\" in d:\n",
    "    print(\"Price of Mango is %d\"%(d[\"Mango\"]))\n",
    "else:\n",
    "    print(\"Doesn't exist\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('Mango', 100), ('Apple', 80), ('Guava', 60), ('Grape', [10, 20])]\n"
     ]
    }
   ],
   "source": [
    "del d[\"Pineapple\"]\n",
    "l = list(d.items())\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Mango': 100, 'Apple': 80, 'Guava': 60, 'Grape': [10, 20], 'Strawberry': 95}\n"
     ]
    }
   ],
   "source": [
    "d2 = {\"Strawberry\":95}\n",
    "\n",
    "d.update(d2)\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "print(len(d))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "d.clear()\n",
    "print(len(d))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Apple': 100, 'Papaya': 120, 'Guava': 30, 'Banana': 50}\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "l1 = [\"Apple\",\"Papaya\",\"Guava\",\"Banana\"]\n",
    "l2 = [100,120,30,50]\n",
    "\n",
    "p = dict(zip(l1,l2))\n",
    "print(p)\n",
    "print(type(p))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n",
      "120\n",
      "30\n",
      "50\n"
     ]
    }
   ],
   "source": [
    "for k in p.values():\n",
    "    print(k)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 15}\n"
     ]
    }
   ],
   "source": [
    "s = set([15,1,2,3,4,3,1,1])\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "not present\n"
     ]
    }
   ],
   "source": [
    "if 14 in s:\n",
    "    print(\"present\")\n",
    "else:\n",
    "    print(\"not present\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 11, 5, 6}\n"
     ]
    }
   ],
   "source": [
    "s2 = {5,6,11,1,1}\n",
    "print(s2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 5, 6, 11, 50}\n"
     ]
    }
   ],
   "source": [
    "s2.add(50)\n",
    "print(s2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "s.clear()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 5, 6}\n"
     ]
    }
   ],
   "source": [
    "a1 = {1,2,3,4}\n",
    "a2 = {2,3,4,5,6}\n",
    "\n",
    "#Those element which are only in one of the sets\n",
    "print(a1^a2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# OOPs in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.Person'>\n"
     ]
    }
   ],
   "source": [
    "#A minimalistic Python Class\n",
    "\n",
    "\n",
    "class Person:\n",
    "    pass\n",
    "\n",
    "p = Person()\n",
    "print(type(p))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n",
      "My Name is  Prateek\n",
      "I am from  Coding Blocks\n",
      "I am  Indian\n",
      "In Secret Method of  Prateek\n",
      "My Name is  Arnav\n",
      "I am from  Micromax\n",
      "I am  Indian\n",
      "In Secret Method of  Arnav\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    #Class Variable, common for all objects of the same class\n",
    "    nationality = \"Indian\"\n",
    "    \n",
    "    def __init__(self,pname,clg):\n",
    "        self.name = pname\n",
    "        self.college = clg\n",
    "    \n",
    "    def sayHi(self,name):\n",
    "        print(\"Hello \"+name)\n",
    "        \n",
    "    def __secretMethod(self):\n",
    "        print(\"In Secret Method of \",self.name)\n",
    "    \n",
    "    def introduce(self):\n",
    "        print(\"My Name is \",self.name)\n",
    "        print(\"I am from \",self.college)\n",
    "        print(\"I am \",self.nationality)\n",
    "        self.__secretMethod()\n",
    "        \n",
    "        \n",
    "p = Person(\"Prateek\",\"Coding Blocks\")\n",
    "p.sayHi(\"World!\")\n",
    "p.introduce()\n",
    "#p.__secretMethod()\n",
    "\n",
    "p2 = Person(\"Arnav\",\"Micromax\")\n",
    "p2.introduce()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "German Shepherd\n",
      "['HighJump', 'Roll Over']\n",
      "Doing Secret Activity  German Shepherd\n",
      "Golden Retriever\n",
      "['LowJump', 'Roll Upside Down']\n",
      "Doing Secret Activity  Golden Retriever\n"
     ]
    }
   ],
   "source": [
    "#Instance Variables vs Class Variables\n",
    "\n",
    "class Dog:\n",
    "    \n",
    "    color = \"Brown\"\n",
    "    #Common for all data member of the class \n",
    "  \n",
    "    def __init__(self,breed):\n",
    "        \"\"\"This method accepts the breed of the dog and initialsies it\"\"\"\n",
    "        self.activities = []\n",
    "        self.breed = breed\n",
    "    \n",
    "    def addActivity(self,act):\n",
    "        self.activities.append(act)\n",
    "        \n",
    "    def __secretActivity(self):\n",
    "        print(\"Doing Secret Activity \",self.breed)\n",
    "        \n",
    "    def doActivity(self):\n",
    "        \"\"\"This is reg dog activities\"\"\"\n",
    "        print(self.breed)\n",
    "        print(self.activities)\n",
    "        self.__secretActivity()\n",
    "        \n",
    "        \n",
    "d1 = Dog(\"German Shepherd\")\n",
    "d2 = Dog(\"Golden Retriever\")\n",
    "\n",
    "d1.addActivity(\"HighJump\")\n",
    "d1.addActivity(\"Roll Over\")\n",
    "#d1.__secretActivity()\n",
    "\n",
    "d2.addActivity(\"LowJump\")\n",
    "d2.addActivity(\"Roll Upside Down\")\n",
    "#d2.__secretActivity()\n",
    "d1.doActivity()\n",
    "d2.doActivity()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Public vs Private method\n",
    "#Inheritance in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Init School Member: Mr.Alpha \n",
      "Init Teacher : Mr.Alpha\n",
      "Name :Mr.Alpha 30\n",
      "Salary : 45000\n",
      "Init School Member: Xyz \n",
      "Init Student Xyz\n",
      "Name :Xyz 20\n",
      "Marks 90\n"
     ]
    }
   ],
   "source": [
    "class SchoolMember:\n",
    "    def __init__(self,name,age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        print(\"Init School Member: %s \"%self.name)\n",
    "        \n",
    "    def introduce(self):\n",
    "        print(\"Name :%s %d\"%(self.name,self.age))\n",
    "        \n",
    "\n",
    "class Teacher(SchoolMember):\n",
    "       \n",
    "        def __init__(self,name,age,salary):\n",
    "            SchoolMember.__init__(self,name,age)\n",
    "            self.salary = salary\n",
    "            print(\"Init Teacher : %s\"%self.name)\n",
    "\n",
    "        def introduce(self):\n",
    "            SchoolMember.introduce(self)\n",
    "            print(\"Salary : %d\"%(self.salary))\n",
    "            \n",
    "class Student(SchoolMember):\n",
    "    '''Represents a school student'''\n",
    "    def __init__(self,name,age,marks):\n",
    "        SchoolMember.__init__(self,name,age)\n",
    "        self.marks = marks\n",
    "        print(\"Init Student %s\"%(self.name))\n",
    "        \n",
    "    def introduce(self):\n",
    "        SchoolMember.introduce(self)\n",
    "        print(\"Marks %d\"%(self.marks))\n",
    "    \n",
    "\n",
    "t = Teacher(\"Mr.Alpha\",30,45000)\n",
    "t.introduce()\n",
    "\n",
    "s = Student(\"Xyz\",20,90)\n",
    "s.introduce()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exception Handling in Python\n",
    " ## Try Except"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your name  Chiranjeev\n",
      "Try executed without any error\n",
      "Form Submitted Successfully\n",
      "It is always there\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    a  = input(\"Enter your name\")\n",
    "    if(len(a)<3):\n",
    "        raise Exception\n",
    "    \n",
    "except FileNotFoundError as e:\n",
    "    print(\"File doesnt exist. Please reupload\")\n",
    "    print(e)\n",
    "    \n",
    "except NameError as e:\n",
    "    print(\"b is not defined\")\n",
    "    print(e)\n",
    "    \n",
    "except Exception as e:\n",
    "    print(\"Please enter a valid name\")\n",
    "    print(e)\n",
    "    \n",
    "else:\n",
    "    print(\"Try executed without any error\")\n",
    "    print(\"Form Submitted Successfully\")\n",
    "    \n",
    "finally:\n",
    "    print(\"It is always there\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Some more built in functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9.0"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"1+10/2+abs(-3)\"\n",
    "\n",
    "eval(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7+3-3+4*5/2\n",
      "17.0\n"
     ]
    }
   ],
   "source": [
    "expression = input()\n",
    "print(eval(expression))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 'mango')\n",
      "(1, 'apple')\n",
      "(2, 'banana')\n"
     ]
    }
   ],
   "source": [
    "l = [\"mango\",\"apple\",\"banana\"]\n",
    "for x in enumerate(l):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "l = []\n",
    "print(all(l))\n",
    "print(any(l))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}