Python Basic  to Expert Mode.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Add Padding Around String"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = 'Chapter 1'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "           Chapter 1\n",
      "Chapter 1           \n",
      "*****Chapter 1******\n"
     ]
    }
   ],
   "source": [
    "print(format(text, '>20'))#add spaces to left\n",
    "print(format(text, '<20'))#add spaces to left\n",
    "print(format(text, '*^20'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[('warplanes',), ('armor',), ('infantory',)],\n",
       " [('warplanes', 'warplanes'),\n",
       "  ('warplanes', 'armor'),\n",
       "  ('warplanes', 'infantory'),\n",
       "  ('armor', 'armor'),\n",
       "  ('armor', 'infantory'),\n",
       "  ('infantory', 'infantory')],\n",
       " [('warplanes', 'warplanes', 'warplanes'),\n",
       "  ('warplanes', 'warplanes', 'armor'),\n",
       "  ('warplanes', 'warplanes', 'infantory'),\n",
       "  ('warplanes', 'armor', 'armor'),\n",
       "  ('warplanes', 'armor', 'infantory'),\n",
       "  ('warplanes', 'infantory', 'infantory'),\n",
       "  ('armor', 'armor', 'armor'),\n",
       "  ('armor', 'armor', 'infantory'),\n",
       "  ('armor', 'infantory', 'infantory'),\n",
       "  ('infantory', 'infantory', 'infantory')]]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Import combinations with replacements from itertools\n",
    "from itertools import combinations_with_replacement\n",
    "#create a list of objects to combine\n",
    "list_of_objects = ['warplanes', 'armor', 'infantory']\n",
    "#create an empty list object to hold the results of the loop\n",
    "combinations = []\n",
    "#create a loop for every item in the length of list_of_objects, that,\n",
    "for i in list(range(len(list_of_objects))):\n",
    "    #finds every combination(with replacement) for each object in the list\n",
    "    combinations.append(list(combinations_with_replacement(list_of_objects, i +1)))\n",
    "combinations    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('warplanes',),\n",
       " ('armor',),\n",
       " ('infantory',),\n",
       " ('warplanes', 'warplanes'),\n",
       " ('warplanes', 'armor'),\n",
       " ('warplanes', 'infantory'),\n",
       " ('armor', 'armor'),\n",
       " ('armor', 'infantory'),\n",
       " ('infantory', 'infantory'),\n",
       " ('warplanes', 'warplanes', 'warplanes'),\n",
       " ('warplanes', 'warplanes', 'armor'),\n",
       " ('warplanes', 'warplanes', 'infantory'),\n",
       " ('warplanes', 'armor', 'armor'),\n",
       " ('warplanes', 'armor', 'infantory'),\n",
       " ('warplanes', 'infantory', 'infantory'),\n",
       " ('armor', 'armor', 'armor'),\n",
       " ('armor', 'armor', 'infantory'),\n",
       " ('armor', 'infantory', 'infantory'),\n",
       " ('infantory', 'infantory', 'infantory')]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "combinations = [i for row in combinations for i in row]\n",
    "combinations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "x = [\"apple\", \"banana\"]\n",
    "print(\"banana\" not in x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'banana'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruits = ['apple', 'banana', 'cherry']\n",
    "\n",
    "fruits.pop(1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apple', 'cherry']\n"
     ]
    }
   ],
   "source": [
    "fruits = ['apple', 'banana', 'cherry']\n",
    "\n",
    "fruits.remove(\"banana\")\n",
    "print(fruits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['BMW', 'Ford', 'Volvo']\n"
     ]
    }
   ],
   "source": [
    "cars = ['Ford', 'BMW', 'Volvo']\n",
    "\n",
    "cars.sort()\n",
    "print(cars)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['VW', 'BMW', 'Ford', 'Mitsubishi']\n"
     ]
    }
   ],
   "source": [
    "def myFunc(e):\n",
    "  return len(e)\n",
    "\n",
    "cars = ['Ford', 'Mitsubishi', 'BMW', 'VW']\n",
    "\n",
    "cars.sort(key=myFunc)\n",
    "\n",
    "print(cars)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{'car': 'Suzuki', 'year': 2001}, {'car': 'Benz', 'year': 2002}, {'car': 'Ford', 'year': 2005}, {'car': 'BMW', 'year': 2007}]\n"
     ]
    }
   ],
   "source": [
    "def myFun(e):\n",
    "    return e['year']\n",
    "\n",
    "cars = [\n",
    "    {'car': 'Ford', 'year':2005},\n",
    "    {'car': 'Suzuki', 'year':2001},\n",
    "    {'car': 'BMW', 'year':2007},\n",
    "    {'car': 'Benz', 'year':2002},\n",
    "]\n",
    "cars.sort(key=myFun)\n",
    "print(cars)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Mitsubhi', 'Ford', 'BMW', 'VW']\n"
     ]
    }
   ],
   "source": [
    "def myFunc(e):\n",
    "    return len(e)\n",
    "cars = ['Ford', 'Mitsubhi', 'BMW', 'VW']\n",
    "cars.sort(reverse=True, key=myFunc)\n",
    "print(cars)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple\n",
      "banana\n",
      "cherry\n"
     ]
    }
   ],
   "source": [
    "thistuple = (\"apple\", \"banana\", \"cherry\")\n",
    "for i in thistuple:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('apple', 'banana', 'cherry')\n"
     ]
    }
   ],
   "source": [
    "thistuple = tuple((\"apple\", \"banana\", \"cherry\"))\n",
    "print(thistuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "thistuple = (5,5,5,5,5,5,5,5)\n",
    "x = thistuple.count(5)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "thistuple = (5,5,5,6,5,5,5,5)\n",
    "x = thistuple.index(6)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "8\n",
      "16\n"
     ]
    }
   ],
   "source": [
    "def fun(n):\n",
    "    return lambda a : a * n\n",
    "myDouble = fun(2)\n",
    "print(myDouble(3))\n",
    "print(myDouble(4))\n",
    "print(myDouble(8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "class MyClass:\n",
    "    x=5\n",
    "p1 = MyClass()\n",
    "print(p1.x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jhon\n",
      "36\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self, name, age):\n",
    "        self.name=name\n",
    "        self.age=age\n",
    "p1 = Person(\"Jhon\", 36)\n",
    "\n",
    "print(p1.name)\n",
    "print(p1.age)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, my name is Jhon\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self, name, age):\n",
    "        self.name=name\n",
    "        self.age=age\n",
    "    def myFun(self):\n",
    "        print(\"Hello, my name is \" + self.name)\n",
    "p1=Person(\"Jhon\",36)\n",
    "p1.myFun()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple\n",
      "banana\n",
      "carrot\n"
     ]
    }
   ],
   "source": [
    "myList = {\"apple\", \"banana\", \"carrot\"}\n",
    "myit = iter(myList)\n",
    "print(next(myit))\n",
    "print(next(myit))\n",
    "print(next(myit))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b\n",
      "a\n",
      "n\n",
      "a\n",
      "n\n",
      "a\n"
     ]
    }
   ],
   "source": [
    "mystr = \"banana\"\n",
    "myit = iter(mystr)\n",
    "\n",
    "print(next(myit))\n",
    "print(next(myit))\n",
    "print(next(myit))\n",
    "print(next(myit))\n",
    "print(next(myit))\n",
    "print(next(myit))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      " Recursion Example Results\n",
      "0\n",
      "0\n",
      "0\n",
      "0\n",
      "0\n",
      "0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Recursion function\n",
    "def tri_resources(k):\n",
    "    if(k>0):\n",
    "        result = k * tri_resources(k-1)\n",
    "        print(result)\n",
    "    else:\n",
    "        result=0\n",
    "    return result\n",
    "print(\"\\n\\n Recursion Example Results\")\n",
    "tri_resources(6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "class MyNumbers:\n",
    "    def __iter__(self):\n",
    "        self.a=1\n",
    "        return self\n",
    "    def __next__(self):\n",
    "        x = self.a\n",
    "        self.a +=1\n",
    "        return x\n",
    "p1 = MyNumbers()\n",
    "myiter = iter(p1)\n",
    " \n",
    "print(next(myiter))\n",
    "print(next(myiter))\n",
    "print(next(myiter))\n",
    "print(next(myiter))\n",
    "print(next(myiter))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2019\n",
      "2\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "\n",
    "x = datetime.datetime.now()\n",
    "print(x.year)\n",
    "print(x.month)\n",
    "print(x.strftime(\"%z\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Applying combinations for a list of objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import combinations_with_replacement\n",
    "list_of_objects = ['warplanes','armor','infantry']\n",
    "combinations = []\n",
    "for i in list(range(len(list_of_objects))):\n",
    "    combinations.append(list(combinations_with_replacement(list_of_objects, i+1)))\n",
    "combinations    \n",
    "\n",
    "combinations = [i for row in combinations for i in row]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[410, 80, 110, 33, 530]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "casualties = [420, 90, 120, 43, 540]\n",
    "def myFun(x):\n",
    "    return x-10\n",
    "list(map(myFun, casualties))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[492, 103, 402, 930, 823, 209]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "survivor = [482, 93, 392, 920, 813, 199]\n",
    "updated = []\n",
    "for x in survivor:\n",
    "    updated.append(x+10)\n",
    "updated    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[430, 100, 130, 53, 550]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map((lambda x : x+10), casualties))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Applying functions to list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['gorkha rifles',\n",
       " 'garhwal rifles',\n",
       " 'brigade of the guards',\n",
       " 'bihar regiment',\n",
       " 'parachute regiment',\n",
       " 'punjab regiment']"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "regimentNames = ['Gorkha Rifles', 'Garhwal Rifles','Brigade of the Guards', 'Bihar Regiment', 'Parachute Regiment', 'Punjab Regiment']\n",
    "regimentNamesInCapital = []\n",
    "for i in regimentNames:\n",
    "    regimentNamesInCapital.append(i.lower())\n",
    "regimentNamesInCapital    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['gorkha rifles',\n",
       " 'garhwal rifles',\n",
       " 'brigade of the guards',\n",
       " 'bihar regiment',\n",
       " 'parachute regiment',\n",
       " 'punjab regiment']"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "capitalizer = lambda x: x.lower()\n",
    "regimentNamesCapitilized_m = list(map(capitalizer, regimentNames))\n",
    "regimentNamesCapitilized_m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['GORKHA RIFLES',\n",
       " 'GARHWAL RIFLES',\n",
       " 'BRIGADE OF THE GUARDS',\n",
       " 'BIHAR REGIMENT',\n",
       " 'PARACHUTE REGIMENT',\n",
       " 'PUNJAB REGIMENT']"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "regimentNamesCapitalized_l = [x.upper() for x in regimentNames];\n",
    "regimentNamesCapitalized_l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Basic operations with Numpy Array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10480\n",
      "2096.0\n",
      "233\n",
      "4352\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "civilian_deaths = np.array([4352, 233, 3245, 256,2394])\n",
    "\n",
    "print(civilian_deaths.sum())\n",
    "print(civilian_deaths.mean())\n",
    "print(civilian_deaths.min())\n",
    "print(civilian_deaths.max())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "variableName = 'This is a string.'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "one, two, three = [1,2,3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "three"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "firstLetter, secondLetter, thirdLetter, fourthLetter = 'Bark'\n",
    "secondLetter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['p', 'a', 'm']"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a, *b = 'spam'\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Brute Force D20 Roll Simulator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Try again\n",
      "You rolled a 45\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "rolling = True\n",
    "while rolling:\n",
    "    x = random.randint(0,9)\n",
    "    y = random.randint(0,9)\n",
    "    if x<9 and 0<y<9:\n",
    "        print('You rolled a {0}{1}'.format(x,y))\n",
    "        rolling = False\n",
    "    else:\n",
    "        print('Try again')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cartesian Product"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3), (3, 1), (3, 2), (3, 3)]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "x = [1,2,3]\n",
    "y = [1,2,3]\n",
    "[(i,j) for i in x for j in y]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 1)\n",
      "(1, 2)\n",
      "(1, 3)\n",
      "(2, 1)\n",
      "(2, 2)\n",
      "(2, 3)\n",
      "(3, 1)\n",
      "(3, 2)\n",
      "(3, 3)\n"
     ]
    }
   ],
   "source": [
    "import itertools\n",
    "for i in itertools.product([1,2,3], [1,2,3]):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List chaining"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import chain"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "allies = ['Spain', 'Germany', 'Namibia', 'Austria']\n",
    "enemies = ['Mexico', 'United Kingdom', 'France']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Spain\n",
      "Germany\n",
      "Namibia\n",
      "Austria\n",
      "Mexico\n",
      "United Kingdom\n",
      "France\n"
     ]
    }
   ],
   "source": [
    "for country in chain(allies, enemies):\n",
    "    print(country)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NLTK"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "incoming_reports = [\"We are attacking on their left flank but are losing many men.\", \n",
    "               \"We cannot see the enemy army. Nothing else to report.\", \n",
    "               \"We are ready to attack but are waiting for your orders.\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['We',\n",
       "  'are',\n",
       "  'attacking',\n",
       "  'on',\n",
       "  'their',\n",
       "  'left',\n",
       "  'flank',\n",
       "  'but',\n",
       "  'are',\n",
       "  'losing',\n",
       "  'many',\n",
       "  'men',\n",
       "  '.'],\n",
       " ['We',\n",
       "  'can',\n",
       "  'not',\n",
       "  'see',\n",
       "  'the',\n",
       "  'enemy',\n",
       "  'army',\n",
       "  '.',\n",
       "  'Nothing',\n",
       "  'else',\n",
       "  'to',\n",
       "  'report',\n",
       "  '.'],\n",
       " ['We',\n",
       "  'are',\n",
       "  'ready',\n",
       "  'to',\n",
       "  'attack',\n",
       "  'but',\n",
       "  'are',\n",
       "  'waiting',\n",
       "  'for',\n",
       "  'your',\n",
       "  'orders',\n",
       "  '.']]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Method using nltk methods\n",
    "from nltk.tokenize import word_tokenize\n",
    "tokenized_reports = [word_tokenize(report) for report in incoming_reports]\n",
    "tokenized_reports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['We',\n",
       "  'are',\n",
       "  'attacking',\n",
       "  'on',\n",
       "  'their',\n",
       "  'left',\n",
       "  'flank',\n",
       "  'but',\n",
       "  'are',\n",
       "  'losing',\n",
       "  'many',\n",
       "  'men'],\n",
       " ['We',\n",
       "  'can',\n",
       "  'not',\n",
       "  'see',\n",
       "  'the',\n",
       "  'enemy',\n",
       "  'army',\n",
       "  'Nothing',\n",
       "  'else',\n",
       "  'to',\n",
       "  'report'],\n",
       " ['We',\n",
       "  'are',\n",
       "  'ready',\n",
       "  'to',\n",
       "  'attack',\n",
       "  'but',\n",
       "  'are',\n",
       "  'waiting',\n",
       "  'for',\n",
       "  'your',\n",
       "  'orders']]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#method using manuall\n",
    "import re\n",
    "import string\n",
    "regex = re.compile('[%s]' % re.escape(string.punctuation))\n",
    "tokenized_report_no_punctuation = []\n",
    "for review in tokenized_reports:\n",
    "    new_review = []\n",
    "    for token in review:\n",
    "        new_token = regex.sub(u'', token)\n",
    "        if not new_token == u'':\n",
    "            new_review.append(new_token)\n",
    "    tokenized_report_no_punctuation.append(new_review)\n",
    "tokenized_report_no_punctuation   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['We', 'attacking', 'left', 'flank', 'losing', 'many', 'men'],\n",
       " ['We', 'see', 'enemy', 'army', 'Nothing', 'else', 'report'],\n",
       " ['We', 'ready', 'attack', 'waiting', 'orders']]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from nltk.corpus import stopwords\n",
    "\n",
    "tokenized_reports_no_stopwords = []\n",
    "for report in tokenized_report_no_punctuation:\n",
    "    new_term_vector = []\n",
    "    for word in report:\n",
    "        if not word in stopwords.words('english'):\n",
    "            new_term_vector.append(word)\n",
    "    tokenized_reports_no_stopwords.append(new_term_vector)\n",
    "            \n",
    "tokenized_reports_no_stopwords"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Compare Two Dictionaries "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Spain'}"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#make two dictionaries\n",
    "importers = {'El Salvador' : 1234,\n",
    "             'Nicaragua' : 152,\n",
    "             'Spain' : 252\n",
    "            }\n",
    "\n",
    "exporters = {'Spain' : 252,\n",
    "             'Germany' : 251,\n",
    "             'Italy' : 1563\n",
    "             }\n",
    "importers.keys() & exporters.keys()#For finding the duplicate values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'El Salvador', 'Nicaragua'}"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "importers.keys() - exporters.keys()#For finding the difference key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{('Spain', 252)}"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "importers.items() & exporters.items()#For finding the common items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1 = [1,2,3,4,5,6]\n",
    "list2 = [7,8,9,10,11]\n",
    "list1+list2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Concurrent processing\n",
    "The concurrent.futures module provides a high-level interface for asynchronously executing callables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "from concurrent import futures\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = range(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "def some_function(value):\n",
    "    return value**value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Exception in thread Thread-6:\n",
      "Traceback (most recent call last):\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\threading.py\", line 916, in _bootstrap_inner\n",
      "    self.run()\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\threading.py\", line 864, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\concurrent\\futures\\process.py\", line 295, in _queue_management_worker\n",
      "    shutdown_worker()\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\concurrent\\futures\\process.py\", line 253, in shutdown_worker\n",
      "    call_queue.put_nowait(None)\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\multiprocessing\\queues.py\", line 129, in put_nowait\n",
      "    return self.put(obj, False)\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\multiprocessing\\queues.py\", line 83, in put\n",
      "    raise Full\n",
      "queue.Full\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# With a pool of workers\n",
    "with futures.ProcessPoolExecutor() as executor:\n",
    "    # Map the function to the data\n",
    "    result = executor.map(some_function, data)   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "#The above concept is creating a problem try to solve it when ever your free"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Continue and break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "running = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It's four! changing the running to false\n"
     ]
    }
   ],
   "source": [
    "while running:\n",
    "    s = random.randint(0,5)\n",
    "    if s < 3:\n",
    "        print(\"It is too small, starting over.\")\n",
    "        continue\n",
    "    if s == 4:\n",
    "        running = False\n",
    "        print(\"It's four! changing the running to false\")\n",
    "    if s == 5:\n",
    "        print('It is 5! Breaking Loop!')\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# HTML "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "import html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = 'This item costs &#166;400 or &#169;4.'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This item costs ¦400 or ©4.'"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "html.unescape(text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This item costs &amp;#166;400 or &amp;#169;4.'"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "html.escape(text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Converting String to Datetime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime\n",
    "from dateutil.parser import parse\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2011, 3, 7, 0, 0)"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "war_start = '2011-03-07'\n",
    "datetime.strptime(war_start,'%Y-%m-%d')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[datetime.datetime(2010, 7, 3, 0, 0),\n",
       " datetime.datetime(2011, 8, 4, 0, 0),\n",
       " datetime.datetime(2012, 9, 5, 0, 0),\n",
       " datetime.datetime(2013, 10, 6, 0, 0),\n",
       " datetime.datetime(2014, 11, 7, 0, 0)]"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "attack_Dates = ['7/3/2010','8/4/2011','9/5/2012','10/6/2013','11/7/2014']\n",
    "[datetime.strptime(D,'%m/%d/%Y') for D in attack_Dates]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[datetime.datetime(1998, 4, 25, 0, 0),\n",
       " datetime.datetime(1995, 8, 3, 0, 0),\n",
       " datetime.datetime(1970, 5, 1, 0, 0)]"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "birthday = ['25/4/1998', '3/8/1995', '1/5/1970']\n",
    "[datetime.strptime(x,'%d/%m/%Y') for x in birthday]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2011, 3, 7, 0, 0)"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "parse(war_start)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[datetime.datetime(2011, 7, 3, 0, 0),\n",
       " datetime.datetime(2011, 7, 3, 0, 0),\n",
       " datetime.datetime(2011, 7, 3, 0, 0),\n",
       " datetime.datetime(2011, 7, 3, 0, 0),\n",
       " datetime.datetime(2011, 7, 3, 0, 0)]"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[parse(war_start, dayfirst=True) for x in attack_Dates]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = {'date': ['2014-05-01 18:47:05.069722', '2014-05-01 18:47:05.119994', '2014-05-02 18:47:05.178768', '2014-05-02 18:47:05.230071', '2014-05-02 18:47:05.230071', '2014-05-02 18:47:05.280592', '2014-05-03 18:47:05.332662', '2014-05-03 18:47:05.385109', '2014-05-04 18:47:05.436523', '2014-05-04 18:47:05.486877'], \n",
    "        'value': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]}\n",
    "df = pd.DataFrame(data, columns = ['date', 'value'])\n",
    "df1=pd.to_datetime(df['date'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating, Writing and deleting the file and reading "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a file if it doesn't already exist\n",
    "with open('file.txt', 'xt') as f:\n",
    "    # Write to the file\n",
    "    f.write('This file now exsits!')\n",
    "    # Close the connection to the file\n",
    "    f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a file if it doesn't already exist\n",
    "with open('file.txt', 'rt') as f:\n",
    "    # Write to the file\n",
    "    f.read()\n",
    "    # Close the connection to the file\n",
    "    f.close()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'date': ['2014-05-01 18:47:05.069722',\n",
       "  '2014-05-01 18:47:05.119994',\n",
       "  '2014-05-02 18:47:05.178768',\n",
       "  '2014-05-02 18:47:05.230071',\n",
       "  '2014-05-02 18:47:05.230071',\n",
       "  '2014-05-02 18:47:05.280592',\n",
       "  '2014-05-03 18:47:05.332662',\n",
       "  '2014-05-03 18:47:05.385109',\n",
       "  '2014-05-04 18:47:05.436523',\n",
       "  '2014-05-04 18:47:05.486877'],\n",
       " 'value': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]}"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os \n",
    "os.remove('file.txt')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### A List is a data structure that holds an ordered collection of items\n",
    "#### i.e. you can store a sequence of items in a list.\n",
    "#### Lists are mutable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['USA', 'UK', 'France', 'New Zealand', 'Australia', 'Canada', 'Poland']"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "allies = ['USA','UK','France','New Zealand',\n",
    "          'Australia','Canada','Poland']\n",
    "allies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['USA',\n",
       " 'UK',\n",
       " 'France',\n",
       " 'New Zealand',\n",
       " 'Australia',\n",
       " 'Canada',\n",
       " 'Poland',\n",
       " 'china']"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "allies.append('china');\n",
    "allies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Australia',\n",
       " 'Canada',\n",
       " 'France',\n",
       " 'New Zealand',\n",
       " 'Poland',\n",
       " 'UK',\n",
       " 'USA',\n",
       " 'china']"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "allies.sort()\n",
    "allies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['china',\n",
       " 'USA',\n",
       " 'UK',\n",
       " 'Poland',\n",
       " 'New Zealand',\n",
       " 'France',\n",
       " 'Canada',\n",
       " 'Australia']"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "allies.reverse();\n",
    "allies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['china', 'USA', 'UK', 'Poland', 'France', 'Canada', 'Australia']"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del allies[4]\n",
    "allies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tuples\n",
    "Tuples are immutable, and usually contain an heterogeneous sequence of elements that are accessed via unpacking."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Texas', 'California', 'Maryland')"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "usa = ('Texas', 'California', 'Maryland')\n",
    "usa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('canada', 'mexico', ('Texas', 'California', 'Maryland'))"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "countries = ('canada', 'mexico', usa)#usa tuple is inside countries tuple\n",
    "countries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Texas', 'California', 'Maryland')"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "countries[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Maryland'"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "countries[2][2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries\n",
    "“A dictionary is like an address-book where you can find the address or contact details of a person by knowing only his/her name i.e. we associate keys (name) with values (details). Note that the key must be unique just like you cannot find out the correct information if you have two persons with the exact same name.” - A Byte Of Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'charan': 'charan@gmail.com',\n",
       " 'kiran': 'kiran@gmail.com',\n",
       " 'vijaya': 'vijaya@gmail.com',\n",
       " 'ramdhan': 'ramdhan@gmail.com'}"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "staff = {'charan' : 'charan@gmail.com',\n",
    "        'kiran':'kiran@gmail.com',\n",
    "        'vijaya' : 'vijaya@gmail.com'}\n",
    "staff['ramdhan'] = 'ramdhan@gmail.com'\n",
    "staff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "del staff['kiran']\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'charan': 'charan@gmail.com',\n",
       " 'vijaya': 'vijaya@gmail.com',\n",
       " 'ramdhan': 'ramdhan@gmail.com'}"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "staff"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sets\n",
    "sets are unordered collections of simple objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "BRI = set(['brazil', 'russia', 'india'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'india' in BRI"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "BRI.add('china')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "BRI.remove('china')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'brazil', 'india', 'russia'}"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "BRI"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "BRIC = BRI.copy()\n",
    "BRIC.add('china')\n",
    "BRIC.issuperset(BRI)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "BRI.remove('russia')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'brazil', 'india'}"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "BRI & BRIC"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Date And Time Basics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime\n",
    "from datetime import timedelta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2019, 2, 11, 14, 50, 54, 771319)"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "now = datetime.now()\n",
    "now"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2019"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "now.year"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "now.month"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "now.day"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "now.hour"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "now.minute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "54"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "now.second"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.timedelta(1)"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "delta = datetime(2011,1,7) - datetime(2011,1,6)\n",
    "delta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "delta.days"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "delta.seconds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "start = datetime(2011, 1, 7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2011, 1, 19, 0, 0)"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "start + timedelta(12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [],
   "source": [
    "ages = {'John': 21,\n",
    "        'Mike': 52,\n",
    "        'Sarah': 12,\n",
    "        'Bob': 43\n",
    "       }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(12, 'Sarah')"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min(zip(ages.values(), ages.keys()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_of_lists = [['Amy','Betty','Cathryn','Dana'], \n",
    "                 ['Elizabeth','Fay','Gora'], \n",
    "                  ['Heidi','Jane','Kayley']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Amy',\n",
       " 'Betty',\n",
       " 'Cathryn',\n",
       " 'Dana',\n",
       " 'Elizabeth',\n",
       " 'Fay',\n",
       " 'Gora',\n",
       " 'Heidi',\n",
       " 'Jane',\n",
       " 'Kayley']"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "flattend_list = [i for row in list_of_lists for i in row]\n",
    "flattend_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions Vs Generators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Abe'"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def function(names):\n",
    "    for name in names:\n",
    "        return name\n",
    "students = function(['Abe', 'Bob', 'Christina', 'Derek'])     \n",
    "students"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "kiran\n",
      "charan\n",
      "ramdhan\n"
     ]
    }
   ],
   "source": [
    "for i in ['kiran', 'charan', 'ramdhan']:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Abe\n",
      "Bob\n",
      "Christina\n"
     ]
    }
   ],
   "source": [
    "def generator(names):\n",
    "    for name in names:\n",
    "        yield name\n",
    "students = generator(['Abe', 'Bob', 'Christina', 'Derek']) \n",
    "print(next(students))\n",
    "print(next(students))\n",
    "print(next(students))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Random Number generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.35068511897230165"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "np.random.normal()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.13760849,  0.3847269 ,  0.51097406, -0.02300925])"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.normal(size=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([91, 94, 65])"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.randint(low=1, high=100, size=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [],
   "source": [
    "students = ['Abe', 'Bob', 'Christina', 'Derek', 'Eleanor']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [],
   "source": [
    "lowercase_names = (student.lower() for student in students)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<generator object <genexpr> at 0x0000021437AA2678>"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lowercase_names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abe'"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(lowercase_names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'bob'"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(lowercase_names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'christina'"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(lowercase_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hard Wrapping Text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [],
   "source": [
    "import textwrap as tw"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [],
   "source": [
    "excerpt = 'Then there was the bad weather. It would come in one day when the fall was over. We would have to shut the windows in the night against the rain and the cold wind would strip the leaves from the trees in the Place Contrescarpe. The leaves lay sodden in the rain and the wind drove the rain against the big green autobus at the terminal and the Café des Amateurs was crowded and the windows misted over from the heat and the smoke inside.'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Then there was the bad weather. It would come in one day when the fall was over. We would have to shut the windows in the night against the rain and the cold wind would strip the leaves from the trees in the Place Contrescarpe. The leaves lay sodden in the rain and the wind drove the rain against the big green autobus at the terminal and the Café des Amateurs was crowded and the windows misted over from the heat and the smoke inside.\n"
     ]
    }
   ],
   "source": [
    "print(tw.indent(excerpt,' '))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Default Dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [],
   "source": [
    "import collections"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [],
   "source": [
    "arrests = collections.defaultdict(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [],
   "source": [
    "arrests['Satyam'] = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arrests['motors']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defaultdict(int, {'Satyam': 10, 'motors': 0})"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arrests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "arrays must all be same length",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-144-a5eefb4d5f9f>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mpandas\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0mpd\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mdata\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m{\u001b[0m\u001b[1;34m'score'\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'ground'\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'adele'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'lords'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mdf\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mpd\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mDataFrame\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      4\u001b[0m \u001b[0mdf\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\ProgramData\\Anaconda3\\lib\\site-packages\\pandas\\core\\frame.py\u001b[0m in \u001b[0;36m__init__\u001b[1;34m(self, data, index, columns, dtype, copy)\u001b[0m\n\u001b[0;32m    346\u001b[0m                                  dtype=dtype, copy=copy)\n\u001b[0;32m    347\u001b[0m         \u001b[1;32melif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdict\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 348\u001b[1;33m             \u001b[0mmgr\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_init_dict\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mindex\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcolumns\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mdtype\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    349\u001b[0m         \u001b[1;32melif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mma\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mMaskedArray\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    350\u001b[0m             \u001b[1;32mimport\u001b[0m \u001b[0mnumpy\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mma\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmrecords\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0mmrecords\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\ProgramData\\Anaconda3\\lib\\site-packages\\pandas\\core\\frame.py\u001b[0m in \u001b[0;36m_init_dict\u001b[1;34m(self, data, index, columns, dtype)\u001b[0m\n\u001b[0;32m    457\u001b[0m             \u001b[0marrays\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mk\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mk\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mkeys\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    458\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 459\u001b[1;33m         \u001b[1;32mreturn\u001b[0m \u001b[0m_arrays_to_mgr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0marrays\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdata_names\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mindex\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcolumns\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mdtype\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    460\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    461\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0m_init_ndarray\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvalues\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mindex\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcolumns\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcopy\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mFalse\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\ProgramData\\Anaconda3\\lib\\site-packages\\pandas\\core\\frame.py\u001b[0m in \u001b[0;36m_arrays_to_mgr\u001b[1;34m(arrays, arr_names, index, columns, dtype)\u001b[0m\n\u001b[0;32m   7313\u001b[0m     \u001b[1;31m# figure out the index, if necessary\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   7314\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0mindex\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 7315\u001b[1;33m         \u001b[0mindex\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mextract_index\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0marrays\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   7316\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   7317\u001b[0m     \u001b[1;31m# don't force copy because getting jammed in an ndarray anyway\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\ProgramData\\Anaconda3\\lib\\site-packages\\pandas\\core\\frame.py\u001b[0m in \u001b[0;36mextract_index\u001b[1;34m(data)\u001b[0m\n\u001b[0;32m   7359\u001b[0m             \u001b[0mlengths\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mlist\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mset\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mraw_lengths\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   7360\u001b[0m             \u001b[1;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlengths\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m>\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 7361\u001b[1;33m                 \u001b[1;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'arrays must all be same length'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   7362\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   7363\u001b[0m             \u001b[1;32mif\u001b[0m \u001b[0mhave_dicts\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: arrays must all be same length"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "data = {'score':[1,2,3,4,5]}\n",
    "df = pd.DataFrame(data)\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Does any cells equal 3? No!\n"
     ]
    }
   ],
   "source": [
    "if(df.score==3).all():\n",
    "    print('Does any cells equal 3? Yes!')\n",
    "else:\n",
    "    print('Does any cells equal 3? No!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Iterate an Ifelse over a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Invalid\n",
      "Invalid\n",
      "Invalid\n",
      "Invalid\n"
     ]
    }
   ],
   "source": [
    "word_list = ['Egyptian', 'Europe', 'England', 'America']\n",
    "vowels = ['A', 'E', 'I', 'O', 'U']\n",
    "for word in word_list:\n",
    "    if any([word.startswith(e) for e in vowels]):\n",
    "        print('Is valid')\n",
    "    else:\n",
    "        print(\"Invalid\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [],
   "source": [
    "names = ['James', 'Bob', 'Sarah', 'Marco', 'Nancy', 'Sally']\n",
    "ages = [42, 13, 14, 25, 63, 23]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "James 42\n",
      "Bob 13\n",
      "Sarah 14\n",
      "Marco 25\n",
      "Nancy 63\n",
      "Sally 23\n"
     ]
    }
   ],
   "source": [
    "for name, age in zip(names,ages):\n",
    "    print(name, age)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Sachin': 20, 'dravid': 30, 'sewagh': 35}"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dictionary = {'Sachin':20,'dravid':30,'sewagh':35}\n",
    "dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Sachin', 20)"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min(zip(dictionary.keys(),dictionary.values()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lambda function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "1048577\n",
      "1606938044258990275541962092341162602522202993782792835301377\n"
     ]
    }
   ],
   "source": [
    "var = [lambda x: x**2 +1,\n",
    "       lambda x: x**20 +1,\n",
    "       lambda x: x**200 +1]\n",
    "for i in var:\n",
    "    print(i(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Looping over two list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ramdhan is father of  Kiran\n",
      "Devoji is father of  Ramdhan\n",
      "Dasram is father of  Santosh\n"
     ]
    }
   ],
   "source": [
    "list = ['Ramdhan', 'Devoji', 'Dasram']\n",
    "list1 = ['Kiran', 'Ramdhan', 'Santosh']\n",
    "for ls, ls1 in zip(list,list1):\n",
    "    print(ls, \"is father of \", ls1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('51st Regiment', ['1st Squad', '2nd Squad', '3rd Squad']),\n",
       " ('51st Regiment', ['1st Squad', '2nd Squad', '3rd Squad']),\n",
       " ('51st Regiment', ['1st Squad', '2nd Squad', '3rd Squad']),\n",
       " ('15th Regiment', ['1st Squad', '2nd Squad', '3rd Squad']),\n",
       " ('15th Regiment', ['1st Squad', '2nd Squad', '3rd Squad']),\n",
       " ('15th Regiment', ['1st Squad', '2nd Squad', '3rd Squad']),\n",
       " ('12th Regiment', ['1st Squad', '2nd Squad', '3rd Squad']),\n",
       " ('12th Regiment', ['1st Squad', '2nd Squad', '3rd Squad']),\n",
       " ('12th Regiment', ['1st Squad', '2nd Squad', '3rd Squad'])]"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squads = [\"1st Squad\", '2nd Squad', '3rd Squad']\n",
    "regiments = [\"51st Regiment\", '15th Regiment', '12th Regiment']\n",
    "[(regiment,squads) for regiment in regiments for squad in squads]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Parallel Processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from multiprocessing import Pool\n",
    "from multiprocessing.dummy import Pool as ThreadPool "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = range(299)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def some_funtion(datum):\n",
    "    return datum**datum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 1.04 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "results = []\n",
    "for datum in data:\n",
    "    results.append(some_funtion(datum))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 115 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "pool = ThreadPool()\n",
    "results = pool.map(some_funtion,data)\n",
    "pool.close()\n",
    "pool.join()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Partial Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import partial\n",
    "def multiple(x,y,z):\n",
    "    return x*y*z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "double = partial(multiple, z=3,y=2)\n",
    "double(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Priority Queue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Walk Dog\n",
      "Wash Dog\n",
      "clean Dishes\n"
     ]
    }
   ],
   "source": [
    "# Priority Queue object\n",
    "import heapq\n",
    "class priority_queue:\n",
    "    def __init__(self):\n",
    "        self._queue=[]\n",
    "        self._index=0\n",
    "    def add_task(self, item, priority):\n",
    "        heapq.heappush(self._queue,(-priority, self._index,item))\n",
    "        self._index+=1\n",
    "    def next_task(self):\n",
    "        return heapq.heappop(self._queue)[-1]\n",
    "task_list = priority_queue()\n",
    "task_list.add_task('clean Dishes', 1)\n",
    "task_list.add_task('Wash Dog', 2)\n",
    "task_list.add_task('Walk Dog', 3)\n",
    "print(task_list.next_task())\n",
    "print(task_list.next_task())\n",
    "print(task_list.next_task())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Queues and stack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import deque"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "queue = deque(range(10), maxlen=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "queue.append('A')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "deque([1, 2, 3, 4, 5, 6, 7, 8, 9, 'A'])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "queue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "deque(['A', 'A', 1, 2, 3, 4, 5, 6, 7, 8])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "queue.appendleft('A')\n",
    "queue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "queue.count('A')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'A'"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "queue.popleft()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "deque([1, 'A', 'A', 'A', 'A', 'A', 'A', 'A', 2, 'A'], maxlen=10)\n"
     ]
    },
    {
     "ename": "IndexError",
     "evalue": "deque already at its maximum size",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-57-7e9318da0d24>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mqueue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mqueue\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0minsert\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m'A'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m: deque already at its maximum size"
     ]
    }
   ],
   "source": [
    "print(queue)\n",
    "print(queue.insert(1,'A'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "deque(['A', 2, 'A', 'A', 'A', 'A', 'A', 'A', 'A', 1])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "queue.reverse()\n",
    "queue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "queue.clear()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "deque([])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "queue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "720"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def factorial(n):\n",
    "    if n<=1:\n",
    "        return n\n",
    "    return n*factorial(n-1)\n",
    "n=int(input())\n",
    "factorial(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# selecting item from list using filter "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5345, 6436, 3453, 2352, 5212, 6232, 2124, 3425, 1200, 1000, 1211)"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "regimentSize = (5345, 6436, 3453, 2352, 5212, 6232, 2124, 3425, 1200, 1000, 1211); regimentSize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2352, 2124, 1200, 1000, 1211]\n"
     ]
    }
   ],
   "source": [
    "small_regiment = list(filter((lambda x : x<2500), regimentSize))\n",
    "print(small_regiment)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5345\n",
      "6436\n",
      "3453\n",
      "2352\n",
      "5212\n",
      "6232\n",
      "2124\n",
      "3425\n",
      "1200\n",
      "1000\n",
      "1211\n"
     ]
    }
   ],
   "source": [
    "small_regiment = []\n",
    "for x in regimentSize:\n",
    "    if x<2500:\n",
    "        small_regiment.append(x)\n",
    "    print(x)        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "commander_names = [\"Alan Brooke\", \"George Marshall\", \"Frank Jack Fletcher\", \"Conrad Helfrich\", \"Albert Kesselring\"] \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Alan Brooke',\n",
       " 'Frank Jack Fletcher',\n",
       " 'Conrad Helfrich',\n",
       " 'Albert Kesselring',\n",
       " 'George Marshall']"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(commander_names, key = lambda x:x.split(' ')[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Alan Brooke',\n",
       " 'George Marshall',\n",
       " 'Conrad Helfrich',\n",
       " 'Albert Kesselring',\n",
       " 'Frank Jack Fletcher']"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(commander_names, key = lambda x:len(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Alan Brooke',\n",
       " 'Albert Kesselring',\n",
       " 'Conrad Helfrich',\n",
       " 'Frank Jack Fletcher',\n",
       " 'George Marshall']"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(commander_names, key = lambda x:x.split(' '))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# String Formatting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This is 1 dead bird!'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'This is %d %s bird!' %(1, 'dead')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1 more burger'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'%(number)d more %(food)s' %{'number' : 1, 'food' : 'burger'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'My laptop runs win32'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'My {1[kind]} runs {0.platform}'. format(sys, {'kind':'laptop'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "string = 'Strings are defined as ordered collections of characters.'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Strings are defined as ordered collections of characters.'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string[:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Str'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string[0:3]\n",
    "string[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Sisr'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string[0:10:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'.sretcarahc fo snoitcelloc deredro sa denifed era sgnirtS'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Try, Catch and Except"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "scores = ['Kiran kumar']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Worked! ['Kiran kumar']\n",
      "End program\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    print('Worked!', scores)\n",
    "except Exception as e:\n",
    "    print('Error:', e)\n",
    "finally:\n",
    "    print('End program')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Unpacking A tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "family = [('kiran','kumar'),('ramdhan','naik'),('charan','nayak'),('vijaya','bhai')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "kumar\n",
      "naik\n",
      "nayak\n",
      "bhai\n"
     ]
    }
   ],
   "source": [
    "for first,_ in family:\n",
    "    print(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AlphaBrave\n",
      "AlphaBravo\n"
     ]
    }
   ],
   "source": [
    "argument_dict = {'a':'Alpha', 'b':'Brave'}\n",
    "argument_list = ['Alpha', 'Bravo']\n",
    "def simple_function(a,b):\n",
    "    return a+b\n",
    "print(simple_function(**argument_dict))\n",
    "print(simple_function(*argument_list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "data1=[]\n",
    "data = [1,2,3,4,5]\n",
    "for i in data:\n",
    "    data1.append(i)\n",
    "print(data1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import namedtuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "subaru\n",
      "Forrester\n",
      "4\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "vehicle = namedtuple('vehicle', 'make model wheels manual')\n",
    "forrest = vehicle('Forrester','subaru', 4, True)\n",
    "print(forrest.model)\n",
    "print(forrest.make)\n",
    "print(forrest.wheels)\n",
    "print(forrest.manual)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "class Regiment(object):\n",
    "\n",
    "    def __init__(self, date=datetime.datetime.now()):\n",
    "        self.date = date\n",
    "\n",
    "    def __repr__(self):\n",
    "        return date\n",
    "\n",
    "    def __str__(self):\n",
    "        return str(date)  \n",
    "    print(type(repr(date)))\n",
    "    print(type(str(date)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2019-02-12 15:26:19.814276\n",
      "datetime.datetime(2019, 2, 12, 15, 26, 19, 814276)\n"
     ]
    }
   ],
   "source": [
    "a = datetime.datetime.now()\n",
    "b = datetime.datetime.now()\n",
    "print(str(a))\n",
    "print(repr(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello kiran\n"
     ]
    }
   ],
   "source": [
    "class ClassName:\n",
    "    def createName(self,name):\n",
    "        self.name=name\n",
    "    def displayName(self):\n",
    "        return self.name\n",
    "    def saying(self):\n",
    "        print('Hello',self.name)\n",
    "first=ClassName()\n",
    "second=ClassName()\n",
    "first.createName('kiran')\n",
    "second.createName('charan')\n",
    "first.displayName()\n",
    "second.displayName()\n",
    "first.saying()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It is lower 2\n",
      "It is higher 9\n",
      "It is lower 1\n",
      "It is lower 0\n",
      "It is lower 5\n",
      "It is lower 1\n",
      "It is lower 1\n",
      "It is higher 9\n",
      "correct\n"
     ]
    }
   ],
   "source": [
    "deaths = 6\n",
    "running = True\n",
    "while running:\n",
    "    guess=random.randint(0,10)\n",
    "    if guess == deaths:\n",
    "        print(\"correct\")\n",
    "        running = False\n",
    "    elif guess>deaths:\n",
    "        print(\"It is higher\", guess)\n",
    "    else:\n",
    "        print(\"It is lower\", guess)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Platoon</th>\n",
       "      <th>Casualties</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>A</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>A</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>A</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>A</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>A</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>A</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>B</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>B</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>B</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>B</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>B</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>C</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>C</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>C</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>C</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>C</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Platoon  Casualties\n",
       "0        A           1\n",
       "1        A           4\n",
       "2        A           5\n",
       "3        A           7\n",
       "4        A           5\n",
       "5        A           5\n",
       "6        B           6\n",
       "7        B           1\n",
       "8        B           4\n",
       "9        B           5\n",
       "10       B           6\n",
       "11       C           7\n",
       "12       C           4\n",
       "13       C           6\n",
       "14       C           4\n",
       "15       C           6"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "data = {'Platoon': ['A','A','A','A','A','A','B','B','B','B','B','C','C','C','C','C'],\n",
    "       'Casualties': [1,4,5,7,5,5,6,1,4,5,6,7,4,6,4,6]}\n",
    "df = pd.DataFrame(data)\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0     NaN\n",
       "1     2.5\n",
       "2     4.5\n",
       "3     6.0\n",
       "4     6.0\n",
       "5     5.0\n",
       "6     NaN\n",
       "7     3.5\n",
       "8     2.5\n",
       "9     4.5\n",
       "10    5.5\n",
       "11    NaN\n",
       "12    5.5\n",
       "13    5.0\n",
       "14    5.0\n",
       "15    5.0\n",
       "Name: Casualties, dtype: float64"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.groupby('Platoon')['Casualties'].apply(lambda x:x.rolling(center=False,window=2).mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter lower range: 7\n",
      "Enter upper range: 27\n",
      "7\n",
      "11\n",
      "13\n",
      "17\n",
      "19\n",
      "23\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter lower range: 7\n",
      "Enter upper range: 27\n",
      "7\n",
      "11\n",
      "13\n",
      "17\n",
      "19\n",
      "23\n"
     ]
    }
   ],
   "source": [
    "lower = int(input(\"Enter lower range: \"))  \n",
    "upper = int(input(\"Enter upper range: \"))  \n",
    "  \n",
    "for num in range(lower,upper + 1):  \n",
    "   if num > 1:  \n",
    "       for i in range(2,num):  \n",
    "           if (num % i) == 0:  \n",
    "               break  \n",
    "       else:  \n",
    "           print(num)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}