10_Batteries Included.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    }
   ],
   "source": [
    "# how modules work and how to explore them and learn what they have to offer\n",
    "# Any Python program can be imported as a module\n",
    "# I created a file name hello.py in D:/ and contents are\n",
    "print(\"hello\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.path.append('D:/')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n"
     ]
    }
   ],
   "source": [
    "import hello\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n",
      "Hello, world! inside the function\n"
     ]
    }
   ],
   "source": [
    "# while my prog is running and i want to make changes in hello module, and want to reflect changes in importing program \n",
    "#  while it is runnin\n",
    "import importlib\n",
    "hello = importlib.reload(hello)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world! inside the function\n"
     ]
    }
   ],
   "source": [
    "# Defining a function in module\n",
    "hello.hello1()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<module 'hello' from 'D:\\\\hello.py'>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hello"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "import hello"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world! inside the function\n"
     ]
    }
   ],
   "source": [
    "hello.hello1()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hello.__name__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# hello4.py should written in separate py file and import it\n",
    "def hello():\n",
    "    print(\"Hello, world!\")\n",
    "def test():\n",
    "    hello()\n",
    "if __name__ == '__main__': test()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Making Your Modules Available\n",
    "# Previous cases, we altered system paths\n",
    "# Ideal case would be sys.path\n",
    "# Refer Python Packaging User Guide, available at packaging.python.org"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['C:\\\\Users\\\\Abhi',\n",
      " 'D:\\\\Anaconda3\\\\python37.zip',\n",
      " 'D:\\\\Anaconda3\\\\DLLs',\n",
      " 'D:\\\\Anaconda3\\\\lib',\n",
      " 'D:\\\\Anaconda3',\n",
      " '',\n",
      " 'D:\\\\Anaconda3\\\\lib\\\\site-packages',\n",
      " 'D:\\\\Anaconda3\\\\lib\\\\site-packages\\\\win32',\n",
      " 'D:\\\\Anaconda3\\\\lib\\\\site-packages\\\\win32\\\\lib',\n",
      " 'D:\\\\Anaconda3\\\\lib\\\\site-packages\\\\Pythonwin',\n",
      " 'D:\\\\Anaconda3\\\\lib\\\\site-packages\\\\IPython\\\\extensions',\n",
      " 'C:\\\\Users\\\\Abhi\\\\.ipython',\n",
      " 'D:/']\n"
     ]
    }
   ],
   "source": [
    "# Putting Your Module in the Right Place\n",
    "# checking interpreter search path\n",
    "import sys, pprint\n",
    "pprint.pprint(sys.path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Packages\n",
    "# To structure your modules, you can group them into packages. A package is basically just another type of module\n",
    "# The interesting thing about them is that they can contain other modules\n",
    "# While a module is stored in a file (with the file name extension .py), a package is a directory\n",
    "# To make Python treat it as a package, it must contain a file named __init__.py\n",
    "# The contents of this file will be the contents of the package, if you import it as if it were a plain module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# What is in module?\n",
    "# The most direct way of probing a module is to investigate it in the Python interpreter\n",
    "import copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Error', 'copy', 'deepcopy', 'dispatch_table', 'error']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# To find out what a module contains, you can use the dir function, which lists all the attributes of an object\n",
    "[n for n in dir(copy) if not n.startswith('_')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__all__',\n",
       " '__builtins__',\n",
       " '__cached__',\n",
       " '__doc__',\n",
       " '__file__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__spec__',\n",
       " '_copy_dispatch',\n",
       " '_copy_immutable',\n",
       " '_deepcopy_atomic',\n",
       " '_deepcopy_dict',\n",
       " '_deepcopy_dispatch',\n",
       " '_deepcopy_list',\n",
       " '_deepcopy_method',\n",
       " '_deepcopy_tuple',\n",
       " '_keep_alive',\n",
       " '_reconstruct']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[n for n in dir(copy) if  n.startswith('_')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Error', 'copy', 'deepcopy']"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# whats in __all__\n",
    "copy.__all__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function copy in module copy:\n",
      "\n",
      "copy(x)\n",
      "    Shallow copy operation on arbitrary Python objects.\n",
      "    \n",
      "    See the module's __doc__ string for more info.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Getting Help with help\n",
    "help(copy.copy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shallow copy operation on arbitrary Python objects.\n",
      "\n",
      "    See the module's __doc__ string for more info.\n",
      "    \n"
     ]
    }
   ],
   "source": [
    "print(copy.copy.__doc__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "range(stop) -> range object\n",
      "range(start, stop[, step]) -> range object\n",
      "\n",
      "Return an object that produces a sequence of integers from start (inclusive)\n",
      "to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.\n",
      "start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.\n",
      "These are exactly the valid indices for a list of 4 elements.\n",
      "When step is given, it specifies the increment (or decrement).\n"
     ]
    }
   ],
   "source": [
    "# Documentation\n",
    "print(range.__doc__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generic (shallow and deep) copying operations.\n",
      "\n",
      "Interface summary:\n",
      "\n",
      "        import copy\n",
      "\n",
      "        x = copy.copy(y)        # make a shallow copy of y\n",
      "        x = copy.deepcopy(y)    # make a deep copy of y\n",
      "\n",
      "For module specific errors, copy.Error is raised.\n",
      "\n",
      "The difference between shallow and deep copying is only relevant for\n",
      "compound objects (objects that contain other objects, like lists or\n",
      "class instances).\n",
      "\n",
      "- A shallow copy constructs a new compound object and then (to the\n",
      "  extent possible) inserts *the same objects* into it that the\n",
      "  original contains.\n",
      "\n",
      "- A deep copy constructs a new compound object and then, recursively,\n",
      "  inserts *copies* into it of the objects found in the original.\n",
      "\n",
      "Two problems often exist with deep copy operations that don't exist\n",
      "with shallow copy operations:\n",
      "\n",
      " a) recursive objects (compound objects that, directly or indirectly,\n",
      "    contain a reference to themselves) may cause a recursive loop\n",
      "\n",
      " b) because deep copy copies *everything* it may copy too much, e.g.\n",
      "    administrative data structures that should be shared even between\n",
      "    copies\n",
      "\n",
      "Python's deep copy operation avoids these problems by:\n",
      "\n",
      " a) keeping a table of objects already copied during the current\n",
      "    copying pass\n",
      "\n",
      " b) letting user-defined classes override the copying operation or the\n",
      "    set of components copied\n",
      "\n",
      "This version does not copy types like module, class, function, method,\n",
      "nor stack trace, stack frame, nor file, socket, window, nor array, nor\n",
      "any similar types.\n",
      "\n",
      "Classes can use the same interfaces to control copying that they use\n",
      "to control pickling: they can define methods called __getinitargs__(),\n",
      "__getstate__() and __setstate__().  See the documentation for module\n",
      "\"pickle\" for information on these methods.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(copy.__doc__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "D:\\Anaconda3\\lib\\copy.py\n"
     ]
    }
   ],
   "source": [
    "# and the source code\n",
    "print(copy.__file__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['DirEntry',\n",
       " 'F_OK',\n",
       " 'MutableMapping',\n",
       " 'O_APPEND',\n",
       " 'O_BINARY',\n",
       " 'O_CREAT',\n",
       " 'O_EXCL',\n",
       " 'O_NOINHERIT',\n",
       " 'O_RANDOM',\n",
       " 'O_RDONLY',\n",
       " 'O_RDWR',\n",
       " 'O_SEQUENTIAL',\n",
       " 'O_SHORT_LIVED',\n",
       " 'O_TEMPORARY',\n",
       " 'O_TEXT',\n",
       " 'O_TRUNC',\n",
       " 'O_WRONLY',\n",
       " 'P_DETACH',\n",
       " 'P_NOWAIT',\n",
       " 'P_NOWAITO',\n",
       " 'P_OVERLAY',\n",
       " 'P_WAIT',\n",
       " 'PathLike',\n",
       " 'R_OK',\n",
       " 'SEEK_CUR',\n",
       " 'SEEK_END',\n",
       " 'SEEK_SET',\n",
       " 'TMP_MAX',\n",
       " 'W_OK',\n",
       " 'X_OK',\n",
       " '_Environ',\n",
       " '__all__',\n",
       " '__builtins__',\n",
       " '__cached__',\n",
       " '__doc__',\n",
       " '__file__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__spec__',\n",
       " '_execvpe',\n",
       " '_exists',\n",
       " '_exit',\n",
       " '_fspath',\n",
       " '_get_exports_list',\n",
       " '_putenv',\n",
       " '_unsetenv',\n",
       " '_wrap_close',\n",
       " 'abc',\n",
       " 'abort',\n",
       " 'access',\n",
       " 'altsep',\n",
       " 'chdir',\n",
       " 'chmod',\n",
       " 'close',\n",
       " 'closerange',\n",
       " 'cpu_count',\n",
       " 'curdir',\n",
       " 'defpath',\n",
       " 'device_encoding',\n",
       " 'devnull',\n",
       " 'dup',\n",
       " 'dup2',\n",
       " 'environ',\n",
       " 'error',\n",
       " 'execl',\n",
       " 'execle',\n",
       " 'execlp',\n",
       " 'execlpe',\n",
       " 'execv',\n",
       " 'execve',\n",
       " 'execvp',\n",
       " 'execvpe',\n",
       " 'extsep',\n",
       " 'fdopen',\n",
       " 'fsdecode',\n",
       " 'fsencode',\n",
       " 'fspath',\n",
       " 'fstat',\n",
       " 'fsync',\n",
       " 'ftruncate',\n",
       " 'get_exec_path',\n",
       " 'get_handle_inheritable',\n",
       " 'get_inheritable',\n",
       " 'get_terminal_size',\n",
       " 'getcwd',\n",
       " 'getcwdb',\n",
       " 'getenv',\n",
       " 'getlogin',\n",
       " 'getpid',\n",
       " 'getppid',\n",
       " 'isatty',\n",
       " 'kill',\n",
       " 'linesep',\n",
       " 'link',\n",
       " 'listdir',\n",
       " 'lseek',\n",
       " 'lstat',\n",
       " 'makedirs',\n",
       " 'mkdir',\n",
       " 'name',\n",
       " 'open',\n",
       " 'pardir',\n",
       " 'path',\n",
       " 'pathsep',\n",
       " 'pipe',\n",
       " 'popen',\n",
       " 'putenv',\n",
       " 'read',\n",
       " 'readlink',\n",
       " 'remove',\n",
       " 'removedirs',\n",
       " 'rename',\n",
       " 'renames',\n",
       " 'replace',\n",
       " 'rmdir',\n",
       " 'scandir',\n",
       " 'sep',\n",
       " 'set_handle_inheritable',\n",
       " 'set_inheritable',\n",
       " 'spawnl',\n",
       " 'spawnle',\n",
       " 'spawnv',\n",
       " 'spawnve',\n",
       " 'st',\n",
       " 'startfile',\n",
       " 'stat',\n",
       " 'stat_result',\n",
       " 'statvfs_result',\n",
       " 'strerror',\n",
       " 'supports_bytes_environ',\n",
       " 'supports_dir_fd',\n",
       " 'supports_effective_ids',\n",
       " 'supports_fd',\n",
       " 'supports_follow_symlinks',\n",
       " 'symlink',\n",
       " 'sys',\n",
       " 'system',\n",
       " 'terminal_size',\n",
       " 'times',\n",
       " 'times_result',\n",
       " 'truncate',\n",
       " 'umask',\n",
       " 'uname_result',\n",
       " 'unlink',\n",
       " 'urandom',\n",
       " 'utime',\n",
       " 'waitpid',\n",
       " 'walk',\n",
       " 'write']"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Assignment explore os package\n",
    "import os\n",
    "[n for n in dir(os) ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.startfile(r'C:\\Windows\\System32\\notepad.exe')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.startfile(r'c:\\Program Files\\Mozilla Firefox\\firefox.exe')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import webbrowser\n",
    "webbrowser.open('http://www.python.org')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# sets\n",
    "set(range(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 6, 7, 8, 10}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = (10,1,2,1,1,1,2,3,4,5,5,6,7,4,8)\n",
    "set(a)                     # and sorted as well"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 6, 7, 8, 10}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# can use without set keyword \n",
    "{10,1,2,1,1,1,2,3,4,5,5,6,7,4,8}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'abhishek', 'anubha', 'anuraj'}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{\"abhishek\",\"anuraj\",\"anubha\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Set operations\n",
    "ab = {1,2,3}\n",
    "bc = {4,5,1}\n",
    "ab.union(bc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{1}"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#intersection\n",
    "c = ab & bc\n",
    "print(c)\n",
    "#\n",
    "ab.intersection(bc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# subset\n",
    "c.issubset(ab)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c.issubset(bc)   # or c <== a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# or \n",
    "c <= ab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# superset\n",
    "print(ab.issuperset(c))\n",
    "ab >= c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{2, 3}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{2, 3}"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#set Difference\n",
    "print(ab.difference(bc))\n",
    "# or\n",
    "ab-bc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{4, 5}"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bc-ab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{2, 3, 4, 5}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{2, 3, 4, 5}"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#symmetric difference\n",
    "print(ab.symmetric_difference(bc))\n",
    "# or\n",
    "ab^bc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 3, 4, 5}"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# or we can say that for symmetric difference\n",
    "(ab-bc).union(bc-ab)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{0, 1, 2, 3, 4},\n",
       " {1, 2, 3, 4, 5},\n",
       " {2, 3, 4, 5, 6},\n",
       " {3, 4, 5, 6, 7},\n",
       " {4, 5, 6, 7, 8},\n",
       " {5, 6, 7, 8, 9},\n",
       " {6, 7, 8, 9, 10},\n",
       " {7, 8, 9, 10, 11},\n",
       " {8, 9, 10, 11, 12},\n",
       " {9, 10, 11, 12, 13}]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# taking union of multiple sets\n",
    "# my_sets is list contains multiple sets\n",
    "my_sets = []\n",
    "for i in range(10):\n",
    "    my_sets.append(set(range(i, i+5)))\n",
    "my_sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# taking union using reduce\n",
    "import functools \n",
    "functools.reduce(set.union, my_sets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum of the list elements is : 17\n"
     ]
    }
   ],
   "source": [
    "lis = [ 1 , 3, 5, 6, 2, ] \n",
    "  \n",
    "# using reduce to compute sum of list \n",
    "print (\"The sum of the list elements is : \",end=\"\") \n",
    "print (functools.reduce(lambda a,b : a+b,lis)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unhashable type: 'set'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-1-f8edc43f4822>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0ma\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mset\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[0mb\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mset\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0ma\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0madd\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mb\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: unhashable type: 'set'"
     ]
    }
   ],
   "source": [
    "# Sets are immutable\n",
    "# and only contains immutable\n",
    "a = set()\n",
    "b = set()\n",
    "a.add(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Heaps: a kind of priority queue\n",
    "# A priority queue lets you add objects in an arbitrary order and at any time find the smallest element.\n",
    "# It does so much more efficiently than, say, using min on a list\n",
    "# the module is : heapq ( q for queue) \n",
    "#  heappush(heap, x) Pushes x onto the heap\n",
    "#  heappop(heap) Pops off the smallest element in the heap\n",
    "#  heapify(heap) Enforces the heap property on an arbitrary list\n",
    "#  heapreplace(heap, x) Pops off the smallest element and pushes\n",
    "#  nlargest(n, iter) Returns the n largest elements of iter\n",
    "#  nsmallest(n, iter) Returns the n smallest elements of iter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "after shuffle [2, 7, 4, 0, 3, 1, 6, 8, 9, 5]\n"
     ]
    }
   ],
   "source": [
    "from heapq import *\n",
    "from random import shuffle\n",
    "data = list(range(10))\n",
    "print(data)\n",
    "shuffle(data)\n",
    "print(\"after shuffle\", data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 7, 4, 0, 3, 1, 6, 8, 9, 5]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0, 2, 1, 7, 3, 4, 6, 8, 9, 5]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(data)\n",
    "heap = []\n",
    "for n in data:\n",
    "    heappush(heap, n)\n",
    "heap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 0.5, 1, 7, 2, 4, 6, 8, 9, 5, 3]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "heappush(heap, 0.5)\n",
    "heap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The order of the elements isn’t as arbitrary as it seems. They aren’t in strictly sorted order, but there is one\n",
    "#  guarantee made: the element at position i is always greater than the one in position i // 2\n",
    "# This is the basis for the underlying heap algorithm. This is called the heap property"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "heappop(heap)  # first element of the heap is always the smallest element, better than min ( no need to search entire list)\n",
    "# pops out first element. i.e. the smallest element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "heappop(heap)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "heappop(heap)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 4, 7, 9, 5, 6, 8]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "heap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 5, 3, 2, 7, 9, 8, 4, 6]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# heapify: The heapify function takes an arbitrary list and makes it a legal heap\n",
    "heap = [5, 8, 0, 3, 6, 7, 9, 1, 4, 2]\n",
    "heapify(heap)\n",
    "heap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# heapreplace: t pops the smallest element off the heap and then pushes a new element onto it\n",
    "# This is a bit more efficient than a heappop followed by a heappush\n",
    "heapreplace(heap,0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.5, 1, 5, 3, 2, 7, 9, 8, 4, 6]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "heap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[9, 8, 7]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nlargest(3,heap)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.5, 1, 2, 3]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nsmallest(4,heap)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "deque([6, 0, 1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Deques\n",
    "from collections import deque\n",
    "q = deque(range(5))\n",
    "q.append(5)\n",
    "q.appendleft(6)\n",
    "q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q.popleft()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "deque([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "deque([4, 0, 1, 2, 3])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q.rotate(1) #(Right Shift one place)\n",
    "q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "q.rotate(2)  #Right Shift two places"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "deque([2, 3, 4, 0, 1])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "deque([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q.rotate(-3)    #left rotate by 3\n",
    "q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('India Standard Time', 'India Daylight Time')"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# time module\n",
    "import time\n",
    "time.tzname"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=1, tm_isdst=0)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "time.gmtime(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1590308691.9538593"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#  time.time() returns the number of seconds that have passed since the epoch.\n",
    "time.time()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Sun May 24 13:56:16 2020'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from time import ctime\n",
    "t = time.time()\n",
    "ctime(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "The time tuple\n",
    "Index \tField \tValues\n",
    "0 \t4-digit year \t2008\n",
    "1 \tMonth \t1 to 12\n",
    "2 \tDay \t1 to 31\n",
    "3 \tHour \t0 to 23\n",
    "4 \tMinute \t0 to 59\n",
    "5 \tSecond \t0 to 61 (60 or 61 are leap-seconds)\n",
    "6 \tDay of Week \t0 to 6 (0 is Monday)\n",
    "7 \tDay of year \t1 to 366 (Julian day)\n",
    "8 \tDaylight savings \t-1, 0, 1, -1 means library determines DST\n",
    "Summer months generally experience more daylight hours than winter months. Because of this, some areas observe \n",
    "daylight savings time (DST) during the spring and summer to make better use of those daylight hours. \n",
    "1 daylight savings\n",
    "0 std time\n",
    "-1 unknown\n",
    "\n",
    "\n",
    "when dealing with Python time, you’re considering a period of time identified by a starting point. \n",
    "In computing, you call this starting point the epoch.\n",
    "\n",
    "The epoch, then, is the starting point against which you can measure the passage of time.\n",
    "\n",
    "For example, if you define the epoch to be midnight on January 1, 1970 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Local current time : time.struct_time(tm_year=2020, tm_mon=5, tm_mday=24, tm_hour=13, tm_min=51, tm_sec=7, tm_wday=6, tm_yday=145, tm_isdst=0)\n"
     ]
    }
   ],
   "source": [
    "# local time\n",
    "localtime = time.localtime(time.time())\n",
    "print (\"Local current time :\", localtime)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Local current time : Sun May 24 13:52:42 2020\n"
     ]
    }
   ],
   "source": [
    "# Getting formatted time\n",
    "localtime = time.asctime( time.localtime(time.time()) )\n",
    "print (\"Local current time :\", localtime)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Here is the calendar:\n",
      "      May 2020\n",
      "Mo Tu We Th Fr Sa Su\n",
      "             1  2  3\n",
      " 4  5  6  7  8  9 10\n",
      "11 12 13 14 15 16 17\n",
      "18 19 20 21 22 23 24\n",
      "25 26 27 28 29 30 31\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Getting calendar for a month\n",
    "import calendar\n",
    "\n",
    "cal = calendar.month(2020, 5)\n",
    "print(\"Here is the calendar:\")\n",
    "print(cal)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "time.struct_time(tm_year=2019, tm_mon=2, tm_mday=26, tm_hour=7, tm_min=6, tm_sec=55, tm_wday=1, tm_yday=57, tm_isdst=0)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Python time as object\n",
    "from time import struct_time\n",
    "time_tuple = (2019, 2, 26, 7, 6, 55, 1, 57, 0)\n",
    "time_obj = struct_time(time_tuple)\n",
    "time_obj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "57"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# day of year\n",
    "day_of_year = time_obj.tm_yday\n",
    "day_of_year"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "145\n"
     ]
    }
   ],
   "source": [
    "# current\n",
    "import datetime\n",
    "today = datetime.datetime.now()\n",
    "day_of_year = (today - datetime.datetime(today.year, 1, 1)).days + 1\n",
    "print(day_of_year)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2020-05-24 14:03:02.841936\n"
     ]
    }
   ],
   "source": [
    "print(today)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'datetime.datetime' object has no attribute 'tm_yday'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-22-8b6b759e8e06>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mtoday\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtm_yday\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: 'datetime.datetime' object has no attribute 'tm_yday'"
     ]
    }
   ],
   "source": []
  },
  {
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}