Working with Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Getting Started with Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hi, python is the hero of programming languages now a days. Everyone here is excited to learn python. But, the one who knows are not sure about it and know that they haven't learnt all in and out of this language yet. We learn python, its data types, then go to libraries like pandas, numpy, then to data visualisation, machine learning, python developement and everything we can. ### "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### While following \"Learn as much you can\" we get into the stage where we learn new, BUT, dont know what we learnt in pas. It's \"age path piche sapat\" thing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before starting learning Python, here are some tips of using Jupyter Notebook. (Shortcuts)\n",
    "\n",
    "1. Esc : To swithc to command mode\n",
    "2. Esc (1 - 6) : Make the cell as heading 1, 2, 3, 4, 5, 6\n",
    "3. Esc M : Make Markdown cell\n",
    "4. Esc Y : Change cell to code cell\n",
    "5. Esc A : To add cell above\n",
    "6. Exc B : To add cell below\n",
    "7. Shift M : Merge cells\n",
    "\n",
    "(Please use these to become comfortable with jupyter notebbok)\n",
    "\n",
    "PS: Want to know other shortcuts? Please dont Google. On menu bar, see a keyboard sign, click on it, you will get the shortcuts there.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's head toward's something amazing. First programe, \"HELLO WORLD !\", Yes, we are here."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hello, world !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello, World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Taking Input in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter name:Urvi\n",
      "Hi, Urvi\n"
     ]
    }
   ],
   "source": [
    "name = input(\"Enter name:\")\n",
    "print(\"Hi, \" + name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables in  python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variables aren't declared in python. Data type is chosen automatically according to the variable we define"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A line is commented using '#' . Multiple lines are commented using ''' comments '''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "a = 5\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "b = 'Hi, its Urvi Jain'\n",
    "print(type(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "5\n",
      "5.0\n"
     ]
    }
   ],
   "source": [
    "# Type Casting\n",
    "\n",
    "print(str(a))\n",
    "print(int(a))\n",
    "print(float(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "u = 'urvi'\n",
    "U = 'Urvi'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "urvi\n",
      "Urvi\n"
     ]
    }
   ],
   "source": [
    "print(u)\n",
    "print(U)\n",
    "\n",
    "#see, both are cprrect, i.e variable names are cae sentitive"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Different cases for variable name:\n",
    "    \n",
    "    camelCase\n",
    "    PascalCase\n",
    "    snake_case"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Many values to multiple variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "a,b,c = 'apple', 'banana', 'camel'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple banana camel\n",
      "apple\n",
      "banana\n",
      "camel\n"
     ]
    }
   ],
   "source": [
    "print(a,b,c)\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## One value to many variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = b = c = 'letters'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "letters letters letters\n"
     ]
    }
   ],
   "source": [
    "print(a,b,c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Unpacking of collection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cpp go r python\n"
     ]
    }
   ],
   "source": [
    "languages = ['cpp', 'go', 'r', 'python']\n",
    "a, b, c, d = languages\n",
    "print(a,b,c,d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Managing the output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi, my name is Urvi Jain\n"
     ]
    }
   ],
   "source": [
    "name = \"Urvi\"\n",
    "surname = \"Jain\"\n",
    "print(\"Hi, my name is\" , name, \"Jain\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Urvi Jain\n"
     ]
    }
   ],
   "source": [
    "print(name + \" \" + surname)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Note: you can't join string by + having one string and one integer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-15-1e68cfc89fac>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m28\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mstates\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"States in India\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mstates\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "a = 28\n",
    "states = \"States in India\"\n",
    "print(a + states)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "28 States in India\n"
     ]
    }
   ],
   "source": [
    "# The valid output formatting is:;\n",
    "\n",
    "print(a, states)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Global Variables in python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number is  3\n"
     ]
    }
   ],
   "source": [
    "x = 3\n",
    "\n",
    "def fun():\n",
    "    print(\"The number is \", x)\n",
    "\n",
    "fun()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number is  4\n"
     ]
    }
   ],
   "source": [
    "x = 3\n",
    "\n",
    "def fun():\n",
    "    x=4\n",
    "    print(\"The number is \", x)\n",
    "\n",
    "fun()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Outside 1 3\n",
      "In fun  10\n",
      "Outside 2 10\n",
      "In fun 2 10\n",
      "Outside 3 11\n"
     ]
    }
   ],
   "source": [
    "def fun():\n",
    "    global x\n",
    "    x = 10\n",
    "    print(\"In fun \", x)\n",
    "\n",
    "def fun2():\n",
    "    print(\"In fun 2\", x)\n",
    "\n",
    "\n",
    "print(\"Outside 1\" , x)\n",
    "fun()\n",
    "print(\"Outside 2\" , x)\n",
    "fun2()\n",
    "x = 11\n",
    "print(\"Outside 3\" , x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Outside 1 11\n",
      "In fun  10\n",
      "Outside 2 10\n",
      "In fun 2 10\n",
      "Outside 3 10\n"
     ]
    }
   ],
   "source": [
    "def fun():\n",
    "    global x\n",
    "    x = 10\n",
    "    print(\"In fun \", x)\n",
    "\n",
    "def fun2():\n",
    "    print(\"In fun 2\", x)\n",
    "\n",
    "\n",
    "print(\"Outside 1\" , x)\n",
    "fun()\n",
    "print(\"Outside 2\" , x)\n",
    "fun2()\n",
    "print(\"Outside 3\" , x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Data Types\n",
    "\n",
    "Text Type:\tstr\n",
    "\n",
    "Numeric Types:\tint, float, complex\n",
    "\n",
    "Sequence Types:\tlist, tuple, range\n",
    "\n",
    "Mapping Type:\tdict\n",
    "\n",
    "Set Types:\tset, frozenset\n",
    "\n",
    "Boolean Type:\tbool\n",
    "\n",
    "Binary Types:\tbytes, bytearray, memoryview\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "x=\"hi\"\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "x=20\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "x=20.3\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'complex'>\n"
     ]
    }
   ],
   "source": [
    "x=20j + 5\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'complex'>\n"
     ]
    }
   ],
   "source": [
    "x=20j\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "x=['a', 'b', 'c']\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "x=('a', 'b', 'c')\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'set'>\n"
     ]
    }
   ],
   "source": [
    "x={'a', 'b', 'c'}\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "x={1 :'a',2: 'b',3: 'c'}\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'range'>\n"
     ]
    }
   ],
   "source": [
    "x= range(9)\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'frozenset'>\n"
     ]
    }
   ],
   "source": [
    "x = frozenset({\"a\", \"b\", \"c\"})\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "x = True\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bytes'>\n"
     ]
    }
   ],
   "source": [
    "x = b\"hi\"\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bytearray'>\n"
     ]
    }
   ],
   "source": [
    "x = bytearray(5)\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'memoryview'>\n"
     ]
    }
   ],
   "source": [
    "x = memoryview(bytes(5))\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Working with numerical data types in python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n",
      "<class 'float'>\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "x = 3e3\n",
    "y = 1E4\n",
    "z = -3.14e10\n",
    "\n",
    "print(type(x))\n",
    "print(type(y))\n",
    "print(type(z))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(6+3j)\n"
     ]
    }
   ],
   "source": [
    "# Complex numbers:\n",
    "\n",
    "a = 1j + 2\n",
    "b = 2j + 4\n",
    "\n",
    "print(a+b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1+0j)\n"
     ]
    }
   ],
   "source": [
    "# conversion from int to complex:\n",
    "\n",
    "a = 1\n",
    "print(complex(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### NOTE: We can not convert complex number to other data type except string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3+1j)\n"
     ]
    }
   ],
   "source": [
    "a = 1j + 3\n",
    "print(str(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Random Numbers, working with random module, here giving just an idea of generating random numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "random.randint(a,b) returns random numbers between a and b inclusive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random\n",
    "random.randint(1,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.10531197275813775\n",
      "0.7076003254450288\n",
      "0.2022244803043629\n"
     ]
    }
   ],
   "source": [
    "print(random.random())\n",
    "print(random.random())\n",
    "print(random.random())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Working with python strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 'Urvi'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Urvi\n"
     ]
    }
   ],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "U\n"
     ]
    }
   ],
   "source": [
    "print(a[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "U\n",
      "r\n",
      "v\n",
      "i\n"
     ]
    }
   ],
   "source": [
    "for i in a:\n",
    "    print (i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "print(len(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"Hi, I am Urvi Jain and I am a Python Developer\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(\"I\" in s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(\"V\" in s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "it is there\n"
     ]
    }
   ],
   "source": [
    "if \"I\" in s:\n",
    "    print(\"it is there\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "it is not there\n"
     ]
    }
   ],
   "source": [
    "if \"V\" not in s:\n",
    "    print(\"it is not there\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Summary for Strings yet:\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. type string\n",
    "2. reading string through index\n",
    "3. looping through string\n",
    "4. len(string)\n",
    "5. if: in and not in\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### More String Functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bcde\n"
     ]
    }
   ],
   "source": [
    "a = 'abcdefghi'\n",
    "print(a[1:5])  # This includes (1,5] i.e indexing from 1, it do not include last mentioned number. \n",
    "# It takes (from,to-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fgh\n"
     ]
    }
   ],
   "source": [
    "print(a[-4:-1])  # Similary with negetive indexes, start to end-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ABCDEFGHI'"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'qwerty'"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = \"QWERTY\"\n",
    "p.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hi'"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "strip_it =\"   Hi   \"\n",
    "strip_it.strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ai'"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "strip_it.replace(\"H\", \"A\").strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['This', 'is', 'the', 'string']"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = \"This is the string\"\n",
    "a.split(\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Urvi Jain\n"
     ]
    }
   ],
   "source": [
    "# String Concatenation\n",
    "\n",
    "u = \"Urvi\"\n",
    "j = \" Jain\"\n",
    "\n",
    "print(u+j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is urvi, and I have 0 years of experience\n"
     ]
    }
   ],
   "source": [
    "exp = 0\n",
    "txt = \"My name is urvi, and I have {} years of experience\"\n",
    "print(txt.format(exp))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I bought 3 bananas for 12 rupees.\n"
     ]
    }
   ],
   "source": [
    "q = 3\n",
    "cost = 12\n",
    "bill = \"I bought {} bananas for {} rupees.\"\n",
    "print(bill.format(q, cost))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I bought 3 bananas for 12 rupees.\n"
     ]
    }
   ],
   "source": [
    "q = 3\n",
    "cost = 12\n",
    "bill = \"I bought {1} bananas for {0} rupees.\"\n",
    "print(bill.format(cost, q))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summary of String methods used yet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. type string\n",
    "2. reading string through index\n",
    "3. looping through string\n",
    "4. len(string)\n",
    "5. if: in and not in\n",
    "6. SLicing (from, end) : from to end-1\n",
    "7. .upper()\n",
    "8. .lower()\n",
    "9. .strip()\n",
    "10. .split('character')\n",
    "11. .replace(\"from\", \"to\")\n",
    "12. concatenate using '+'\n",
    "13. .format(variable_name), and string is written or printed with {} "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://www.w3schools.com/python/python_ref_string.asp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Boolean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(1 >2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(bool(\"hi\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Almost every value is True instead of:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False False False False False False False\n"
     ]
    }
   ],
   "source": [
    "print(bool(False), bool(None), bool(0), bool(\"\"), bool(()),bool([]), bool({}))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# isinstance is used to check if variable belong to that data type\n",
    "\n",
    "x = 10\n",
    "print(isinstance(x, int))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operators"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Arithmetic:\n",
    "\n",
    "+\tAddition\tx + y\t\n",
    "-\tSubtraction\tx - y\t\n",
    "*\tMultiplication\tx * y\t\n",
    "/\tDivision\tx / y\t\n",
    "%\tModulus\tx % y\t\n",
    "**\tExponentiation\tx ** y\t\n",
    "//\tFloor division\tx // y\n",
    "\n",
    "\n",
    "Assignment:\n",
    "\n",
    "=\tx = 5\tx = 5\t\n",
    "+=\tx += 3\tx = x + 3\t\n",
    "-=\tx -= 3\tx = x - 3\t\n",
    "*=\tx *= 3\tx = x * 3\t\n",
    "/=\tx /= 3\tx = x / 3\t\n",
    "%=\tx %= 3\tx = x % 3\t\n",
    "//=\tx //= 3\tx = x // 3\t\n",
    "**=\tx **= 3\tx = x ** 3\t\n",
    "&=\tx &= 3\tx = x & 3\t\n",
    "|=\tx |= 3\tx = x | 3\t\n",
    "^=\tx ^= 3\tx = x ^ 3\t\n",
    ">>=\tx >>= 3\tx = x >> 3\t\n",
    "<<=\tx <<= 3\tx = x << 3\n",
    "\n",
    "Comparision:\n",
    "\n",
    "==\tEqual\tx == y\t\n",
    "!=\tNot equal\tx != y\t\n",
    ">\tGreater than\tx > y\t\n",
    "<\tLess than\tx < y\t\n",
    ">=\tGreater than or equal to\tx >= y\t\n",
    "<=\tLess than or equal to\tx <= y\t\n",
    "\n",
    "\n",
    "Logical:\n",
    "\n",
    "and \tReturns True if both statements are true\tx < 5 and  x < 10\t\n",
    "or\tReturns True if one of the statements is true\tx < 5 or x < 4\t\n",
    "not\tReverse the result, returns False if the result is true\tnot(x < 5 and x < 10)\n",
    "\n",
    "\n",
    "Identity:\n",
    "\n",
    "is \tReturns True if both variables are the same object\tx is y\t\n",
    "is not\tReturns True if both variables are not the same object\tx is not y\n",
    "\n",
    "Membership:\n",
    "\n",
    "in \tReturns True if a sequence with the specified value is present in the object\tx in y\t\n",
    "not in\tReturns True if a sequence with the specified value is not present in the object\tx not in y\n",
    "\n",
    "Bitwise:\n",
    "\n",
    "& \tAND\tSets each bit to 1 if both bits are 1\n",
    "|\tOR\tSets each bit to 1 if one of two bits is 1\n",
    " ^\tXOR\tSets each bit to 1 if only one of two bits is 1\n",
    "~ \tNOT\tInverts all the bits\n",
    "<<\tZero fill left shift\tShift left by pushing zeros in from the right and let the leftmost bits fall off\n",
    ">>\tSigned right shift\tShift right by pushing copies of the leftmost bit in from the left, and let the rightmost bits fall off\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Lists"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Python lists are array type data type. \n",
    "It is used to store multiples values on the name of single variable.\n",
    "It is indexed\n",
    "Allows duplicates\n",
    "Mutble (Can be changed)\n",
    "Can store elements with different data types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "languages = ['Python', 'C++', 'Java', 'R', 'Go']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Python', 'C++', 'Java', 'R', 'Go']"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "languages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python'"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "languages[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python\n",
      "C++\n",
      "Java\n",
      "R\n",
      "Go\n"
     ]
    }
   ],
   "source": [
    "for i in languages:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "languages = [1, 'Python', 2, 'Java', 'Java']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b', 'c']"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can also use list constructor to make a list:\n",
    "\n",
    "letters = list((\"a\", \"b\", \"c\"))\n",
    "letters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "print(len(letters))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'c'"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "letters[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C is present\n"
     ]
    }
   ],
   "source": [
    "if 'c' in letters:\n",
    "    print(\"C is present\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "S isnt present\n"
     ]
    }
   ],
   "source": [
    "if 's' not in letters:\n",
    "    print(\"S isnt present\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'B', 'c']\n"
     ]
    }
   ],
   "source": [
    "letters[1] = 'B'\n",
    "print(letters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "letters = letters + ['d', 'e', 'f']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'B', 'c', 'd', 'e', 'f']"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "letters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "letters[-1:-5] = ['C', 'D', 'E', 'F']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'B', 'c', 'd', 'e', 'C', 'D', 'E', 'F', 'f']"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "letters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "keys = ['q', 'w', 'e' , 'r']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'e', 'r']"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "keys [:2] = 'a'\n",
    "keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 'Inserted element', 2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "keys = [1,2,3,4,5,6]\n",
    "keys.insert(1, \"Inserted element\")\n",
    "keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 'Inserted element', 2, 3, 4, 5, 6, 7]"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "keys.append(7)\n",
    "keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "keys1 = [8,9,10,11]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 'Inserted element', 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "keys.extend(keys1)\n",
    "keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 'Inserted element', 2, 3, 4, 5, 6, 8, 9, 10, 11]"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "keys.remove(7)\n",
    "keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "keys.pop(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "keys.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "del keys[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 4, 5, 6, 8, 9, 10]"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "names:  Phebe\n",
      "1\n",
      "names:  Chandeler\n",
      "2\n",
      "names:  Mon\n",
      "3\n",
      "names:  Joey\n",
      "4\n",
      "names:  Rach\n",
      "5\n",
      "names:  Ross\n"
     ]
    }
   ],
   "source": [
    "friends = ['Phebe', 'Chandeler', 'Mon', 'Joey', 'Rach', 'Ross']\n",
    "for i in range(len(friends)):\n",
    "    print(i)\n",
    "    print(\"names: \", friends[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Phebe\n",
      "Chandeler\n",
      "Mon\n",
      "Joey\n",
      "Rach\n",
      "Ross\n"
     ]
    }
   ],
   "source": [
    "i=0\n",
    "while i<len(friends):\n",
    "    print(friends[i])\n",
    "    i = i+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Phebe\n",
      "Chandeler\n",
      "Mon\n",
      "Joey\n",
      "Rach\n",
      "Ross\n"
     ]
    }
   ],
   "source": [
    "for i in friends:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apple', 'banana', 'mango']\n"
     ]
    }
   ],
   "source": [
    "# list comprehension\n",
    "\n",
    "fruits = [\"apple\", \"banana\", \"cherry\", \"kiwi\", \"mango\"]\n",
    "\n",
    "newlist = [x for x in fruits if \"a\" in x]\n",
    "\n",
    "print(newlist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Chandeler', 'Joey', 'Mon', 'Phebe', 'Rach', 'Ross']"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "friends.sort()\n",
    "friends"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Ross', 'Rach', 'Phebe', 'Mon', 'Joey', 'Chandeler']"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "friends.sort(reverse = True)\n",
    "friends"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[43, 12, 65, 75, 76, 76, 233]\n"
     ]
    }
   ],
   "source": [
    "# Sort the list based on how close the number is to 50:\n",
    "\n",
    "def fun(n):\n",
    "  return abs(n - 30)\n",
    "\n",
    "l = [12, 43, 65, 76, 233, 75, 76]\n",
    "l.sort(key = fun)\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Kiwi', 'Orange', 'banana', 'cherry']\n"
     ]
    }
   ],
   "source": [
    "# Someimes, in sorting, caseof starting etter can give bad results\n",
    "\n",
    "l = [\"banana\", \"Orange\", \"Kiwi\", \"cherry\"]\n",
    "l.sort()\n",
    "print(l)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['banana', 'cherry', 'Kiwi', 'Orange']\n"
     ]
    }
   ],
   "source": [
    "# Thus, we can have a key which ensure changing string t lower or upper before sorting\n",
    "\n",
    "thislist = [\"banana\", \"Orange\", \"Kiwi\", \"cherry\"]\n",
    "thislist.sort(key = str.lower)\n",
    "print(thislist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[34, 12, 43, 21, 22, 1]\n"
     ]
    }
   ],
   "source": [
    "a = [1,22,21,43,12,34]\n",
    "a.reverse()\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1,2,3]\n",
    "b = [4,5,6]\n",
    "for i in b:\n",
    "    a.append(i)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = b + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 5, 6, 4, 5, 6]"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = [1.2,3]\n",
    "d = [4,5,6]\n",
    "c.extend(d)\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://www.w3schools.com/python/python_lists_methods.asp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary of Lists"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "1. len(list_name)\n",
    "2. access by index\n",
    "3. can store different data types\n",
    "4. mutable\n",
    "5. follow negative indexing and slicing\n",
    "6. in and not in operators work on it.\n",
    "7. values can be reassigned easily using index as in arrays\n",
    "8. Reassingment can be done in group using slicing (:)\n",
    "9. We can also replace a slot by single elements through slicing\n",
    "10. .insert() (index, \"element\")\n",
    "11. .append() (to add at the end)\n",
    "12. list1.extend(list2)  to join two lists or a list and a tuple\n",
    "13. .remove() (remove an element)\n",
    "14. .pop() (to fetch by index, if not given argumet, pops last element)\n",
    "15. del list_name[index] also delets the element\n",
    "16. .clear() \n",
    "17. one can traverse a list by for, while and for (in range)\n",
    "18. list comprehension:    newlist = [expression for item in iterable if condition == True]\n",
    "19. .sort(), .sort(reverse = True)\n",
    "20. .reverse to reverse the list\n",
    "21. .copy to copy the list into other list\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples in python"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "immutable python data types\n",
    "ordered and declared with ()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rachel\n",
      "Joey\n",
      "Chandler\n",
      "Monica\n",
      "Phebe\n",
      "Ross\n"
     ]
    }
   ],
   "source": [
    "friends = ('Rachel', 'Joey', 'Chandler', 'Monica', 'Phebe', 'Ross')\n",
    "for i in friends:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rachel\n",
      "Joey\n",
      "Chandler\n",
      "Monica\n",
      "Phebe\n",
      "Ross\n"
     ]
    }
   ],
   "source": [
    "for i in range(len(friends)):\n",
    "    print(friends[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rachel\n",
      "Joey\n",
      "Chandler\n",
      "Monica\n",
      "Phebe\n",
      "Ross\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while(i < len(friends)):\n",
    "    print(friends[i])\n",
    "    i=i+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mike and Pheebe are friends\n"
     ]
    }
   ],
   "source": [
    "if 'Mike' not in friends:\n",
    "    print(\"Mike and Pheebe are friends\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "# to do any change into tuple, we need to change it to list first\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "friends=list(friends)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "friends[0] = 'Rach'\n",
    "friends = tuple (friends)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Rach', 'Joey', 'Chandler', 'Monica', 'Phebe', 'Ross')"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "friends"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(friends)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for any addition, sub, change, we need to convert it to list, then changes are to be done, then to tupl"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Unpacking of tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple\n",
      "banana\n",
      "chiku\n"
     ]
    }
   ],
   "source": [
    "fruits = (\"apple\", \"banana\", \"chiku\")\n",
    "(a, b, c) = fruits\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple\n",
      "banana\n",
      "['cherry', 'strawberry', 'raspberry']\n"
     ]
    }
   ],
   "source": [
    "fruits = (\"apple\", \"banana\", \"cherry\", \"strawberry\", \"raspberry\")\n",
    "\n",
    "(green, yellow, *red) = fruits\n",
    "\n",
    "print(green)\n",
    "print(yellow)\n",
    "print(red)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [],
   "source": [
    "friends = friends * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Rach',\n",
       " 'Joey',\n",
       " 'Chandler',\n",
       " 'Monica',\n",
       " 'Phebe',\n",
       " 'Ross',\n",
       " 'Rach',\n",
       " 'Joey',\n",
       " 'Chandler',\n",
       " 'Monica',\n",
       " 'Phebe',\n",
       " 'Ross')"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "friends"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 4, 5, 6)"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t1 = (1,2,3)\n",
    "t2 = (4,5,6)\n",
    "t3 = t1 + t2\n",
    "t3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://www.w3schools.com/python/python_tuples_methods.asp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Summary of Tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. len\n",
    "2. tuple to list to tuple\n",
    "3. multiply by tuple * 2 (any number)\n",
    "4. can unpack also\n",
    "5. can add with +\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sets in Python"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "UNORDERED and UNINDEXED\n",
    "Duplicates ARE NOT allowed\n",
    "Do not support indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Chandler', 'Joey', 'Monica', 'Phebe', 'Rachel', 'Ross'}"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "friends = {'Rachel', 'Joey', 'Chandler', 'Monica', 'Phebe', 'Ross'}\n",
    "friends"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'set' object does not support indexing",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-124-448c407be8a4>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfriends\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfriends\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;31m# wont work because it do not support indexing\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: 'set' object does not support indexing"
     ]
    }
   ],
   "source": [
    "for i in range(len(friends)):\n",
    "    print(friends[i])\n",
    "    \n",
    "# wont work because it do not support indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Phebe\n",
      "Monica\n",
      "Chandler\n",
      "Joey\n",
      "Rachel\n",
      "Ross\n"
     ]
    }
   ],
   "source": [
    "for i in friends:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = set ((1,2,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3}"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(1 in numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers.add(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4}"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5, 6}\n"
     ]
    }
   ],
   "source": [
    "set1 = {1,2,3}\n",
    "set2 = {4,5,6}\n",
    "\n",
    "set1.update(set2)\n",
    "\n",
    "print(set1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5, 6}\n"
     ]
    }
   ],
   "source": [
    "set1 = {1,2,3}\n",
    "tuple1 = (4,5,6)\n",
    "\n",
    "set1.update(tuple1)\n",
    "\n",
    "print(set1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 3, 4, 5, 6}"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1.remove(2)\n",
    "set1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "2",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-134-c3db8c08d9dc>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mset1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mremove\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m: 2"
     ]
    }
   ],
   "source": [
    "set1.remove(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [],
   "source": [
    "set1.discard(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1.pop()\n",
    "\n",
    "\n",
    "# this can give different result everytim because set is unordered and changes the order frequently"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [],
   "source": [
    "set1.clear()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "set()"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [],
   "source": [
    "del set1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'set1' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-140-d18f5a84d934>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mset1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'set1' is not defined"
     ]
    }
   ],
   "source": [
    "set1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 6}"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1 = {1,2,3,4}\n",
    "set2 = {4,5,6}\n",
    "set3 = set1.union(set2)\n",
    "set3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 6}"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1 = {1,2,3,4}\n",
    "set2 = {4,5,6}\n",
    "set1.update(set2)\n",
    "set1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{4, 5}"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1 = {1,2,3,4,5}\n",
    "set2 = {4,5,6}\n",
    "set1.intersection_update(set2)\n",
    "set1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 6}"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1 = {1,2,3,4,5}\n",
    "set2 = {4,5,6}\n",
    "set1.symmetric_difference_update(set2)\n",
    "set1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{4, 5}"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1 = {1,2,3,4,5}\n",
    "set2 = {4,5,6}\n",
    "set3 = set1.intersection(set2)\n",
    "set3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 6}"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1 = {1,2,3,4,5}\n",
    "set2 = {4,5,6}\n",
    "set3 = set1.symmetric_difference(set2)\n",
    "set3\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Summary of Sets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "https://www.w3schools.com/python/python_sets_methods.asp"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "1. Unordered, unindexed and repetition not allowed\n",
    "2. .add()\n",
    "3. len(set_name)\n",
    "4. set1.update(Set2) adds set2 after set1\n",
    "5. set1.update(set2) adds any iterable (tuple, list) at end\n",
    "6. .remove(element) removes the element\n",
    "7. .discard(element)   \n",
    "8. .pop() shows last element\n",
    "9. .clear()\n",
    "10. del set_name\n",
    "11. =set1.union(set2) : joins sets, remove repetition, returns set\n",
    "12. set1.update(set2) : insert set2 elements to set2\n",
    "13. set1.intersection_update(set2) : store only duplicate values \n",
    "14. =set1.intersection(set2) : store only duplicate values, returns set\n",
    "15. set1.symmetric_difference_update(set2) : keep all but no duplicate value\n",
    "16. =set1.symmetric_difference(set2) : returns values which are uncommon in both sets, not duplicate\n",
    "\n",
    "NOTE: remove shows an error if element do not exist, discard do not shows error\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Mon': 'Chandeler', 'Rach': 'Ross', 'Joey': 'Sandwiches', 'Phebe': 'Mike'}"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "friends = {'Mon' : 'Chandeler', 'Rach': 'Ross', 'Joey': 'Sandwiches', 'Phebe': 'Mike'}\n",
    "friends"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mon\n",
      "Rach\n",
      "Joey\n",
      "Phebe\n"
     ]
    }
   ],
   "source": [
    "for i in friends:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Sandwiches'"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "friends['Joey']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "print(len(friends))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Mon': 'Chandeler',\n",
       " 'Rach': 'Ross',\n",
       " 'Joey': 'Sandwiches',\n",
       " 'Phebe': 'Smelly Cat'}"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "friends['Phebe'] = 'Smelly Cat'\n",
    "friends"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Mon': 'Chandeler',\n",
       " 'Rach': 'Ross',\n",
       " 'Joey': ['Sandwiches', 'Pizza', 'Hugsy'],\n",
       " 'Phebe': 'Smelly Cat'}"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "friends['Joey'] = ['Sandwiches', 'Pizza', 'Hugsy']\n",
    "friends"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ross'"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=friends.get('Rach')\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['Mon', 'Rach', 'Joey', 'Phebe'])\n",
      "dict_values(['Chandeler', 'Ross', ['Sandwiches', 'Pizza', 'Hugsy'], 'Smelly Cat'])\n"
     ]
    }
   ],
   "source": [
    "k = friends.keys()\n",
    "v = friends.values()\n",
    "\n",
    "\n",
    "print(k)\n",
    "\n",
    "print(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_items([('Mon', 'Chandeler'), ('Rach', 'Ross'), ('Joey', ['Sandwiches', 'Pizza', 'Hugsy']), ('Phebe', 'Smelly Cat')])\n"
     ]
    }
   ],
   "source": [
    "print(friends.items())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hey Joey\n"
     ]
    }
   ],
   "source": [
    "if 'Joey' in friends:\n",
    "    print(\"Hey Joey\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Mon': 'Chandeler',\n",
       " 'Rach': 'Ross and Ema',\n",
       " 'Joey': ['Sandwiches', 'Pizza', 'Hugsy'],\n",
       " 'Phebe': 'Smelly Cat'}"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "friends.update({'Rach' : 'Ross and Ema'})\n",
    "friends"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Mon': 'Chandeler',\n",
       " 'Rach': 'Ross and Ema',\n",
       " 'Joey': ['Sandwiches', 'Pizza', 'Hugsy']}"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "friends.pop('Phebe')\n",
    "friends"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Mon': 'Chandeler',\n",
       " 'Rach': 'Ross and Ema',\n",
       " 'Joey': ['Sandwiches', 'Pizza', 'Hugsy'],\n",
       " 'Phebe': 'Mike'}"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "friends.update({'Phebe': 'Mike'})\n",
    "friends"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Mon': 'Chandeler',\n",
       " 'Rach': 'Ross and Ema',\n",
       " 'Joey': ['Sandwiches', 'Pizza', 'Hugsy']}"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "friends.popitem()\n",
    "friends\n",
    "\n",
    "# this removes last added item"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Chandeler\n",
      "Ross and Ema\n",
      "['Sandwiches', 'Pizza', 'Hugsy']\n"
     ]
    }
   ],
   "source": [
    "for i in friends.values():\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mon\n",
      "Rach\n",
      "Joey\n"
     ]
    }
   ],
   "source": [
    "for i in friends.keys():\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Mon': 'Chandeler',\n",
       " 'Rach': 'Ross and Ema',\n",
       " 'Joey': ['Sandwiches', 'Pizza', 'Hugsy']}"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "friends1 =friends.copy()\n",
    "friends1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Mon': 'Chandeler',\n",
       " 'Rach': 'Ross and Ema',\n",
       " 'Joey': ['Sandwiches', 'Pizza', 'Hugsy']}"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "friends2 = dict(friends)\n",
    "friends2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [],
   "source": [
    "child1 = {\n",
    "  \"name\" : \"Emil\",\n",
    "  \"year\" : 2004\n",
    "}\n",
    "child2 = {\n",
    "  \"name\" : \"Tobias\",\n",
    "  \"year\" : 2007\n",
    "}\n",
    "child3 = {\n",
    "  \"name\" : \"Linus\",\n",
    "  \"year\" : 2011\n",
    "}\n",
    "\n",
    "myfamily = {\n",
    "  \"child1\" : child1,\n",
    "  \"child2\" : child2,\n",
    "  \"child3\" : child3\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'child1': {'name': 'Emil', 'year': 2004},\n",
       " 'child2': {'name': 'Tobias', 'year': 2007},\n",
       " 'child3': {'name': 'Linus', 'year': 2011}}"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfamily"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [],
   "source": [
    "myfamily1 = {\n",
    "  \"child1\" : {\n",
    "    \"name\" : \"Emil\",\n",
    "    \"year\" : 2004\n",
    "  },\n",
    "  \"child2\" : {\n",
    "    \"name\" : \"Tobias\",\n",
    "    \"year\" : 2007\n",
    "  },\n",
    "  \"child3\" : {\n",
    "    \"name\" : \"Linus\",\n",
    "    \"year\" : 2011\n",
    "  }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'child1': {'name': 'Emil', 'year': 2004},\n",
       " 'child2': {'name': 'Tobias', 'year': 2007},\n",
       " 'child3': {'name': 'Linus', 'year': 2011}}"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfamily1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfamily1.clear()\n",
    "myfamily1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [],
   "source": [
    "del myfamily1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Summary of Dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. {a:b}\n",
    "2. for loop gives keys\n",
    "3. .keys()\n",
    "4. .values()\n",
    "5. .items()\n",
    "6. len(dict_name)\n",
    "7. d['key']   returns values\n",
    "8. .update({a:b})\n",
    "9. we can update easily by d['key']=value\n",
    "10. .pop(key)\n",
    "11. .popitem()  pop random item\n",
    "12. in and not in works\n",
    "13. .get(key) fetch value for that key //if the given key doesn't exist then it will return none\n",
    "14. dict[key] also fetch value for that key//if the given key doesn't exist then it will throw an error \n",
    "15. .copy()\n",
    "16. dict() constructor\n",
    "17. we can have a list as value for keys\n",
    "18. nested dicts are also possible\n",
    "19. .clear\n",
    "20. del dict_name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://www.w3schools.com/python/python_dictionaries_methods.asp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## If Else in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is S\n"
     ]
    }
   ],
   "source": [
    "a=1\n",
    "b=2\n",
    "if(a==b):\n",
    "    print(\"E\")\n",
    "elif(a>b):\n",
    "    print(\"a is G\")\n",
    "else:\n",
    "    print(\"a is S\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is S\n"
     ]
    }
   ],
   "source": [
    "print(\"a is S\") if a<b else print(\"a is G\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is S\n"
     ]
    }
   ],
   "source": [
    "if(a<b) : print(\"a is S\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=\n"
     ]
    }
   ],
   "source": [
    "a = 30\n",
    "b = 30\n",
    "print(\"A\") if a > b else print(\"=\") if a == b else print(\"B\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and and or also works in conditions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## While loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while(i<5):\n",
    "    print(i)\n",
    "    i=i+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i < 5:\n",
    "  print(i)\n",
    "  if i == 3:\n",
    "    break\n",
    "  i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "4\n",
      "5\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i < 6:\n",
    "  i += 1\n",
    "  if i == 3:\n",
    "    continue\n",
    "  print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## For loop in python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For loop is used in accessing sets, arrays, lists, dictionary and tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi\n"
     ]
    }
   ],
   "source": [
    "def hi():\n",
    "    print(\"hi\")\n",
    "hi()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi  vishal\n",
      "hi  Adi\n"
     ]
    }
   ],
   "source": [
    "def hi(name):\n",
    "    print(\"hi \", name)\n",
    "hi('vishal')\n",
    "hi('Adi')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi vishal hi Adi\n"
     ]
    }
   ],
   "source": [
    "def hi(*name):\n",
    "    print(\"hi\", name[0], \"hi\", name[1])\n",
    "hi('vishal', 'Adi')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi  Adi\n"
     ]
    }
   ],
   "source": [
    "def hi(name, friends):\n",
    "    print(\"hi \", name)\n",
    "\n",
    "hi('Adi', 'Joey')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My last name is Jain\n"
     ]
    }
   ],
   "source": [
    "# for unknown number of keyword arg:\n",
    "\n",
    "def my_function(**name):\n",
    "  print(\"My last name is \" + name[\"lname\"])\n",
    "\n",
    "my_function(fname = \"Urvi\", lname = \"Jain\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi  Adi\n",
      "hi  Vishal\n"
     ]
    }
   ],
   "source": [
    "def hi(name='Vishal'):\n",
    "    print(\"hi \", name)\n",
    "\n",
    "hi('Adi')\n",
    "hi()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hi():\n",
    "    pass\n",
    "hi()\n",
    "\n",
    "# pass is used when we dont have any definition for function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can also pass and return other data types like lists, sets, tuples, dict\n",
    "# Also, we can recurese a function same as other languages in python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lambda Function in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is a small anonymous function. One liner and one expression only"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16\n"
     ]
    }
   ],
   "source": [
    "x = lambda a : a ** 2\n",
    "print(x(4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16\n"
     ]
    }
   ],
   "source": [
    "x = lambda a : print(a ** 2)\n",
    "x(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n"
     ]
    }
   ],
   "source": [
    "x = lambda a,b : a * b\n",
    "print(x(4,5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classes and Objects in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "Hi\n"
     ]
    }
   ],
   "source": [
    "class x:\n",
    "    a=1\n",
    "    b='Hi'\n",
    "    \n",
    "obj_x = x()\n",
    "\n",
    "print(obj_x.a)\n",
    "print(obj_x.b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [],
   "source": [
    "# __init__ is used as a constructor, i.e to assign values to variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Monica \n",
      "Geller\n",
      "Hi, Monica Geller\n",
      "hi everyone\n"
     ]
    }
   ],
   "source": [
    "class Person():\n",
    "    def __init__(self, fname, lname):\n",
    "        self.fname = fname\n",
    "        self.lname = lname\n",
    "    \n",
    "    def say_hi(self):\n",
    "        print(\"Hi,\", self.fname+self.lname)\n",
    "    \n",
    "    def say_hi_e(self,e):\n",
    "        print(\"hi everyone\")\n",
    "        \n",
    "p1 = Person(\"Monica \", 'Geller')\n",
    "\n",
    "print(p1.fname)\n",
    "print(p1.lname)\n",
    "p1.say_hi()\n",
    "p1.say_hi_e(\"everyone\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inheritence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "John Doe\n",
      "Mike Olsen hi\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "  def __init__(self, fname, lname):\n",
    "    self.firstname = fname\n",
    "    self.lastname = lname\n",
    "\n",
    "  def printname(self):\n",
    "    print(self.firstname, self.lastname)\n",
    "\n",
    "\n",
    "class Student(Person):\n",
    "  def __init__(self, fname, lname, year):\n",
    "    super().__init__(fname, lname)\n",
    "    self.graduationyear = year\n",
    "  def printname(self):\n",
    "    print(self.firstname, self.lastname, \"hi\")\n",
    "\n",
    "#Use the Person class to create an object, and then execute the printname method:\n",
    "\n",
    "x = Person(\"John\", \"Doe\")\n",
    "x.printname()\n",
    "x = Student(\"Mike\", \"Olsen\", 2019)\n",
    "x.printname()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mike Olsen\n"
     ]
    }
   ],
   "source": [
    "# super() function will make the child class inherit all the methods and properties from its parent:\n",
    "\n",
    "\n",
    "class Person:\n",
    "  def __init__(self, fname, lname):\n",
    "    self.firstname = fname\n",
    "    self.lastname = lname\n",
    "\n",
    "  def printname(self):\n",
    "    print(self.firstname, self.lastname)\n",
    "\n",
    "class Student(Person):\n",
    "  def __init__(self, fname, lname):\n",
    "    super().__init__(fname, lname)\n",
    "\n",
    "x = Student(\"Mike\", \"Olsen\")\n",
    "x.printname()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2019\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "  def __init__(self, fname, lname):\n",
    "    self.firstname = fname\n",
    "    self.lastname = lname\n",
    "\n",
    "  def printname(self):\n",
    "    print(self.firstname, self.lastname)\n",
    "\n",
    "class Student(Person):\n",
    "  def __init__(self, fname, lname):\n",
    "    super().__init__(fname, lname)\n",
    "    self.graduationyear = 2019\n",
    "\n",
    "x = Student(\"Mike\", \"Olsen\")\n",
    "print(x.graduationyear)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome Mike Olsen to the class of 2019\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "  def __init__(self, fname, lname):\n",
    "    self.firstname = fname\n",
    "    self.lastname = lname\n",
    "\n",
    "  def printname(self):\n",
    "    print(self.firstname, self.lastname)\n",
    "\n",
    "class Student(Person):\n",
    "  def __init__(self, fname, lname, year):\n",
    "    super().__init__(fname, lname)\n",
    "    self.graduationyear = year\n",
    "\n",
    "  def welcome(self):\n",
    "    print(\"Welcome\", self.firstname, self.lastname, \"to the class of\", self.graduationyear)\n",
    "\n",
    "x = Student(\"Mike\", \"Olsen\", 2019)\n",
    "x.welcome()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "To make a list of Objects and to print the object in ascending order of any one of it's attribute ..lets say age in\n",
    "this example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "age :19 \n name :moni \n id :55\nage :22 \n name :shubh \n id :11\nage :55 \n name :abhi \n id :25\n"
     ]
    }
   ],
   "source": [
    "class Movie():\n",
    "    def __init__(self,id,name,age):\n",
    "        self.id=id\n",
    "        self.name=name\n",
    "        self.age=age\n",
    "n=int(input())\n",
    "ls=[]                 \n",
    "for i in range(n):\n",
    "   id=int(input())\n",
    "   name=input()\n",
    "   age=int(input())\n",
    "   ls.append(Movie(id,name,age))\n",
    "ls.sort(key=lambda x:x.age)\n",
    "for i in ls:\n",
    "    print(f\"age :{i.age} \\n name :{i.name} \\n id :{i.id}\")   \n",
    "    \n",
    "    ''' input:\n",
    "      3\n",
    "      11\n",
    "      shubh\n",
    "      22\n",
    "      55\n",
    "      moni\n",
    "      19\n",
    "      25\n",
    "      abhi\n",
    "      55 \n",
    "'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists, tuples, dictionaries, and sets are all iterable objects. They are iterable containers which you can get an iterator from.\n",
    "\n",
    "All these objects have a iter() method which is used to get an iterator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n"
     ]
    }
   ],
   "source": [
    "t = (\"a\", \"b\", \"c\")\n",
    "i = iter(t)\n",
    "\n",
    "print(next(i))\n",
    "print(next(i))\n",
    "print(next(i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "U\n",
      "r\n",
      "v\n",
      "i\n"
     ]
    }
   ],
   "source": [
    "t = \"Urvi\"\n",
    "i = iter(t)\n",
    "\n",
    "print(next(i))\n",
    "print(next(i))\n",
    "print(next(i))\n",
    "print(next(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modules in Python"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "We can create a file, make functions in them, then import the file(this will be our module), and use the functions of that file using file_name.function()\n",
    "Similar to function, we can even import variables, lists, tuples, sets, dict etc"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "we can also rename modules and make alias like\n",
    "\n",
    "import my_module as m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dir(my_module)\n",
    "\n",
    "# this prints every name listed in our module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['BooleanDtype',\n",
       " 'Categorical',\n",
       " 'CategoricalDtype',\n",
       " 'CategoricalIndex',\n",
       " 'DataFrame',\n",
       " 'DateOffset',\n",
       " 'DatetimeIndex',\n",
       " 'DatetimeTZDtype',\n",
       " 'ExcelFile',\n",
       " 'ExcelWriter',\n",
       " 'Float64Index',\n",
       " 'Grouper',\n",
       " 'HDFStore',\n",
       " 'Index',\n",
       " 'IndexSlice',\n",
       " 'Int16Dtype',\n",
       " 'Int32Dtype',\n",
       " 'Int64Dtype',\n",
       " 'Int64Index',\n",
       " 'Int8Dtype',\n",
       " 'Interval',\n",
       " 'IntervalDtype',\n",
       " 'IntervalIndex',\n",
       " 'MultiIndex',\n",
       " 'NA',\n",
       " 'NaT',\n",
       " 'NamedAgg',\n",
       " 'Panel',\n",
       " 'Period',\n",
       " 'PeriodDtype',\n",
       " 'PeriodIndex',\n",
       " 'RangeIndex',\n",
       " 'Series',\n",
       " 'SparseArray',\n",
       " 'SparseDataFrame',\n",
       " 'SparseDtype',\n",
       " 'SparseSeries',\n",
       " 'StringDtype',\n",
       " 'Timedelta',\n",
       " 'TimedeltaIndex',\n",
       " 'Timestamp',\n",
       " 'UInt16Dtype',\n",
       " 'UInt32Dtype',\n",
       " 'UInt64Dtype',\n",
       " 'UInt64Index',\n",
       " 'UInt8Dtype',\n",
       " '__Datetime',\n",
       " '__DatetimeSub',\n",
       " '__SparseArray',\n",
       " '__SparseArraySub',\n",
       " '__builtins__',\n",
       " '__cached__',\n",
       " '__doc__',\n",
       " '__docformat__',\n",
       " '__file__',\n",
       " '__git_version__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__numpy',\n",
       " '__package__',\n",
       " '__path__',\n",
       " '__spec__',\n",
       " '__version__',\n",
       " '_config',\n",
       " '_hashtable',\n",
       " '_is_numpy_dev',\n",
       " '_lib',\n",
       " '_libs',\n",
       " '_np_version_under1p16',\n",
       " '_np_version_under1p17',\n",
       " '_np_version_under1p18',\n",
       " '_testing',\n",
       " '_tslib',\n",
       " '_typing',\n",
       " '_version',\n",
       " 'api',\n",
       " 'array',\n",
       " 'arrays',\n",
       " 'bdate_range',\n",
       " 'compat',\n",
       " 'concat',\n",
       " 'core',\n",
       " 'crosstab',\n",
       " 'cut',\n",
       " 'date_range',\n",
       " 'datetime',\n",
       " 'describe_option',\n",
       " 'errors',\n",
       " 'eval',\n",
       " 'factorize',\n",
       " 'get_dummies',\n",
       " 'get_option',\n",
       " 'infer_freq',\n",
       " 'interval_range',\n",
       " 'io',\n",
       " 'isna',\n",
       " 'isnull',\n",
       " 'json_normalize',\n",
       " 'lreshape',\n",
       " 'melt',\n",
       " 'merge',\n",
       " 'merge_asof',\n",
       " 'merge_ordered',\n",
       " 'notna',\n",
       " 'notnull',\n",
       " 'np',\n",
       " 'offsets',\n",
       " 'option_context',\n",
       " 'options',\n",
       " 'pandas',\n",
       " 'period_range',\n",
       " 'pivot',\n",
       " 'pivot_table',\n",
       " 'plotting',\n",
       " 'qcut',\n",
       " 'read_clipboard',\n",
       " 'read_csv',\n",
       " 'read_excel',\n",
       " 'read_feather',\n",
       " 'read_fwf',\n",
       " 'read_gbq',\n",
       " 'read_hdf',\n",
       " 'read_html',\n",
       " 'read_json',\n",
       " 'read_orc',\n",
       " 'read_parquet',\n",
       " 'read_pickle',\n",
       " 'read_sas',\n",
       " 'read_spss',\n",
       " 'read_sql',\n",
       " 'read_sql_query',\n",
       " 'read_sql_table',\n",
       " 'read_stata',\n",
       " 'read_table',\n",
       " 'reset_option',\n",
       " 'set_eng_float_format',\n",
       " 'set_option',\n",
       " 'show_versions',\n",
       " 'test',\n",
       " 'testing',\n",
       " 'timedelta_range',\n",
       " 'to_datetime',\n",
       " 'to_numeric',\n",
       " 'to_pickle',\n",
       " 'to_timedelta',\n",
       " 'tseries',\n",
       " 'unique',\n",
       " 'util',\n",
       " 'value_counts',\n",
       " 'wide_to_long']"
      ]
     },
     "execution_count": 224,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(pd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dates in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-04-15 00:29:35.378744\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "\n",
    "x = datetime.datetime.now()\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021\n"
     ]
    }
   ],
   "source": [
    "print(x.year)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    }
   ],
   "source": [
    "print(x.day)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "print(x.month)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1998-12-30 00:00:00\n"
     ]
    }
   ],
   "source": [
    "x = datetime.datetime(1998, 12, 30)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "February\n"
     ]
    }
   ],
   "source": [
    "x = datetime.datetime(2020, 2, 12)\n",
    "\n",
    "print(x.strftime(\"%B\"))"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Directive\tDescription\tand example\n",
    "%a\tWeekday, short version\tWed\t\n",
    "%A\tWeekday, full version\tWednesday\t\n",
    "%w\tWeekday as a number 0-6, 0 is Sunday\t3\t\n",
    "%d\tDay of month 01-31\t31\t\n",
    "%b\tMonth name, short version\tDec\t\n",
    "%B\tMonth name, full version\tDecember\t\n",
    "%m\tMonth as a number 01-12\t12\t\n",
    "%y\tYear, short version, without century\t18\t\n",
    "%Y\tYear, full version\t2018\t\n",
    "%H\tHour 00-23\t17\t\n",
    "%I\tHour 00-12\t05\t\n",
    "%p\tAM/PM\tPM\t\n",
    "%M\tMinute 00-59\t41\t\n",
    "%S\tSecond 00-59\t08\t\n",
    "%f\tMicrosecond 000000-999999\t548513\t\n",
    "%z\tUTC offset\t+0100\t\n",
    "%Z\tTimezone\tCST\t\n",
    "%j\tDay number of year 001-366\t365\t\n",
    "%U\tWeek number of year, Sunday as the first day of week, 00-53\t52\t\n",
    "%W\tWeek number of year, Monday as the first day of week, 00-53\t52\t\n",
    "%c\tLocal version of date and time\tMon Dec 31 17:41:00 2018\t\n",
    "%x\tLocal version of date\t12/31/18\t\n",
    "%X\tLocal version of time\t17:41:00\t\n",
    "%%\tA % character\t%\t\n",
    "%G\tISO 8601 year\t2018\t\n",
    "%u\tISO 8601 weekday (1-7)\t1\t\n",
    "%V\tISO 8601 weeknumber (01-53)\t01\t\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Math module in python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Simple function to use:\n",
    "    \n",
    "https://www.w3schools.com/python/module_math.asp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.4142135623730951\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "print(math.sqrt(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.141592653589793\n"
     ]
    }
   ],
   "source": [
    "print(math.pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "a=[1,2,3]\n",
    "print(min(a))\n",
    "print(max(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 246,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    }
   ],
   "source": [
    "print(abs(-12))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "print(math.ceil(0.98))\n",
    "print(math.floor(0.93))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python JSON"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "From Json to python : LOADS\n",
    "From Python to JSON : DUMPS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22\n",
      "{'name': 'Urvi', 'age': 22, 'city': 'Dallas'}\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "\n",
    "x =  '{ \"name\":\"Urvi\", \"age\":22, \"city\":\"Dallas\"}'\n",
    "\n",
    "person = json.loads(x)\n",
    "\n",
    "print(person[\"age\"])\n",
    "print(person)\n",
    "print(type(person))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"name\": \"Urvi\", \"age\": 22, \"city\": \"Dallas\"}\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "# convert into JSON:\n",
    "y = json.dumps(person)\n",
    "\n",
    "# the result is a JSON string:\n",
    "print(y)\n",
    "print(type(y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exception Handling in Python"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "The try block test a block of code for errors.\n",
    "\n",
    "The except block handle the error.\n",
    "\n",
    "The finally block execute code, regardless of the result of the try- and except blocks.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "done\n"
     ]
    }
   ],
   "source": [
    "x=10\n",
    "\n",
    "try:\n",
    "  print(x)\n",
    "except:\n",
    "  print(\"An exception occurred\")\n",
    "finally:\n",
    "    print(\"done\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 261,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Division by 0 exception\n",
      "done\n"
     ]
    }
   ],
   "source": [
    "x=10\n",
    "\n",
    "try:\n",
    "  print(x/0)\n",
    "except:\n",
    "  print(\"Division by 0 exception\")\n",
    "finally:\n",
    "    print(\"done\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## File Handling in Python"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "The key function for working with files in Python is the open() function.\n",
    "\n",
    "The open() function takes two parameters; filename, and mode."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Four modes are:\n",
    "    \n",
    "\"r\" - Read - Default value. Opens a file for reading, error if the file does not exist\n",
    "\n",
    "\"a\" - Append - Opens a file for appending, creates the file if it does not exist\n",
    "\n",
    "\"w\" - Write - Opens a file for writing, creates the file if it does not exist\n",
    "\n",
    "\"x\" - Create - Creates the specified file, returns an error if the file exists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "metadata": {},
   "outputs": [],
   "source": [
    "# For reading, just mention name in open()\n",
    "\n",
    "# f=open(\"file_name.txt\")\n",
    "\n",
    "# for different purposes, we can specify the mode as well, after ',' in open()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 269,
   "metadata": {},
   "outputs": [],
   "source": [
    "# to read the file, we use .read()\n",
    "\n",
    "# f = open(\"name.txt\", r)\n",
    "\n",
    "# f.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "metadata": {},
   "outputs": [],
   "source": [
    "# f = open(\"filename\", x) \n",
    "# Creates file "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 271,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import os\n",
    "# os.remove(\"filename.txt\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summary of File Handling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. .read(5) #read 5 characters of starting only\n",
    "2. .readline() # read a line, need to call again and again for multiple number of lines\n",
    "3. for x in f : (loop through line)\n",
    "4. .open()\n",
    "5. .close()\n",
    "6. modes: r,w,a,x\n",
    "7. os module: os.remove(\"file_name\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### This revision notebook ends here, but python do not. Thus, numpy, arrays, pandas, regex, and other important must know modules these will be covered in different notebooks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# THE END"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "name": "python385jvsc74a57bd0d862c071e59930aca1a120f94be8023881e5d7e2745f60bf5eebc60b16b535cd",
   "display_name": "Python 3.8.5 64-bit ('base': conda)"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}