Modules_and_Packages.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modules and Packages\n",
    "Modules are files that contain functions, variables or classes that can be used without redefining them. They're generally written in Python.\n",
    "\n",
    "Packages are directory or folders which conatin a number of modules or packages in them."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Few built-in Modules are:\n",
    "1. \\_\\_builtins\\_\\_\n",
    "0. \\_\\_file\\_\\_\n",
    "2. math\n",
    "3. cmath\n",
    "2. sys\n",
    "4. os\n",
    "5. itertools\n",
    "6. string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The basics of working with module are discussed using a file *prime_generator.py*\n",
    "\n",
    "Code:  \n",
    "```python\n",
    "from time import *\n",
    "from itertools import *\n",
    "from math import *\n",
    "\n",
    "def prime_gen(n):\n",
    "    num = 2\n",
    "    while num <= n:\n",
    "        k = 2\n",
    "        while k * k <= num:\n",
    "            if num % k == 0:\n",
    "                break\n",
    "            k += 1\n",
    "        else:\n",
    "            yield num\n",
    "    num += 1\n",
    "\n",
    "prime = 2\n",
    "prime_square = 4\n",
    "__primeval = 3\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    t = time()\n",
    "    for i in prime_gen(10 ** 2):\n",
    "        print(i)\n",
    "    print(time()-t)\n",
    "```\n",
    "\n",
    "Contents:\n",
    "1. prime_gen - function or generator \n",
    "2. prime - varaiable (constant when imported)\n",
    "3. prime_square - variable (constant when imported)\n",
    "4. \\_\\_primeval - private value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## import statement:\n",
    "The *import* keyword is used to import a module or package.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "import module_name\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 3 5 7 11 13 17 19 "
     ]
    }
   ],
   "source": [
    "import prime_generator\n",
    "\n",
    "for i in prime_generator.prime_gen(20):\n",
    "    print(i, end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## from statement:\n",
    "The *from* keyword is used to import a specific set of functions or classes from a module.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "from module_name import function_name\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 3 5 7 11 13 17 19 "
     ]
    }
   ],
   "source": [
    "from prime_generator import prime_gen\n",
    "\n",
    "for i in prime_gen(20):\n",
    "    print(i, end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing all the objects from the module:\n",
    "To import all the functions or objects, use * .\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "from module_name import *\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 3 5 7 11 13 17 19 "
     ]
    }
   ],
   "source": [
    "from prime_generator import *\n",
    "\n",
    "for i in prime_gen(20):\n",
    "    print(i, end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **as** Keyword:\n",
    "*as* Keyword is used to have a custom name for imported module or function.\n",
    "\n",
    "Syntax:  \n",
    "\n",
    "```python\n",
    "import moule_name as custom_name\n",
    "from module_name import function_name as custom_name\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 3 5 7 11 13 17 19 "
     ]
    }
   ],
   "source": [
    "import prime_generator as pg\n",
    "\n",
    "for i in pg.prime_gen(20):\n",
    "    print(i, end=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 3 5 7 11 13 17 19 "
     ]
    }
   ],
   "source": [
    "from prime_generator import prime_gen as pgf\n",
    "\n",
    "for i in pgf(20):\n",
    "    print(i, end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## \\_\\_name\\_\\_:\n",
    "It returns the name of the module without the extension. If called for main executing program (main module), it returns '\\_\\_main\\_\\_'\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "module_name.__name__\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "prime_generator\n",
      "__main__\n"
     ]
    }
   ],
   "source": [
    "import prime_generator as pg\n",
    "\n",
    "print(pg.__name__)\n",
    "print(__name__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## dir method:\n",
    "\n",
    "Returns the list of attributes (that are relevant) of an object or a module. By default, it gives the details of main module.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "dir([object])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__primeval', '__spec__', 'accumulate', 'acos', 'acosh', 'altzone', 'asctime', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'chain', 'comb', 'combinations', 'combinations_with_replacement', 'compress', 'copysign', 'cos', 'cosh', 'count', 'ctime', 'cycle', 'daylight', 'degrees', 'dist', 'dropwhile', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'filterfalse', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'get_clock_info', 'gmtime', 'groupby', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'islice', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'localtime', 'log', 'log10', 'log1p', 'log2', 'mktime', 'modf', 'monotonic', 'monotonic_ns', 'nan', 'nextafter', 'perf_counter', 'perf_counter_ns', 'perm', 'permutations', 'pi', 'pow', 'prime', 'prime_gen', 'prime_square', 'process_time', 'process_time_ns', 'prod', 'product', 'radians', 'remainder', 'repeat', 'sin', 'sinh', 'sleep', 'sqrt', 'starmap', 'strftime', 'strptime', 'struct_time', 'takewhile', 'tan', 'tanh', 'tau', 'tee', 'thread_time', 'thread_time_ns', 'time', 'time_ns', 'timezone', 'trunc', 'tzname', 'ulp', 'zip_longest']\n",
      "\n",
      "['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']\n",
      "\n",
      "['In', 'Out', '_', '__', '___', '__builtin__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', '_dh', '_i', '_i1', '_ih', '_ii', '_iii', '_oh', 'exit', 'get_ipython', 'prime_generator', 'quit']\n"
     ]
    }
   ],
   "source": [
    "import prime_generator\n",
    "\n",
    "print(dir(prime_generator))\n",
    "print()\n",
    "print(dir(prime_generator.prime_gen))\n",
    "print()\n",
    "print(dir())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## namespace:\n",
    "\n",
    "A container that has a list of names (objects) defined in a module. It is the place where python searches for objects defined and used in a function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Global, Local and Built-in Namespaces\n",
    "\n",
    "### Global:\n",
    "Namespace containing values defined throughout a file or module (globally)\n",
    "\n",
    "### Local:\n",
    "Namespace containing values defined in a part of a file or module (Locally)\n",
    "\n",
    "### Builtin:\n",
    "Namespace containing values common for all python file.\n",
    "\n",
    "## Order of Search:\n",
    "1. Local\n",
    "2. Global\n",
    "3. Builtin"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Packages:\n",
    "Directory or folder containing a number of modules and subpackages.\n",
    "\n",
    "It contains '\\_\\_init\\_\\_.py' file which defines the modules that can be imported from the package.\n",
    "\n",
    "### Importing a module from package:  \n",
    "```python\n",
    "import package_name.module_name\n",
    "import package_name.module_name as custom_name\n",
    "```\n",
    "\n",
    "### Import a specific object from a module:\n",
    "```python\n",
    "from package_name.module_name import object_name\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Builtins:\n",
    "\n",
    "\\_\\_builtins\\_\\_ module contains the list of methods and variables that are standard definitions in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ArithmeticError\n",
      "AssertionError\n",
      "AttributeError\n",
      "BaseException\n",
      "BlockingIOError\n",
      "BrokenPipeError\n",
      "BufferError\n",
      "BytesWarning\n",
      "ChildProcessError\n",
      "ConnectionAbortedError\n",
      "ConnectionError\n",
      "ConnectionRefusedError\n",
      "ConnectionResetError\n",
      "DeprecationWarning\n",
      "EOFError\n",
      "Ellipsis\n",
      "EnvironmentError\n",
      "Exception\n",
      "False\n",
      "FileExistsError\n",
      "FileNotFoundError\n",
      "FloatingPointError\n",
      "FutureWarning\n",
      "GeneratorExit\n",
      "IOError\n",
      "ImportError\n",
      "ImportWarning\n",
      "IndentationError\n",
      "IndexError\n",
      "InterruptedError\n",
      "IsADirectoryError\n",
      "KeyError\n",
      "KeyboardInterrupt\n",
      "LookupError\n",
      "MemoryError\n",
      "ModuleNotFoundError\n",
      "NameError\n",
      "None\n",
      "NotADirectoryError\n",
      "NotImplemented\n",
      "NotImplementedError\n",
      "OSError\n",
      "OverflowError\n",
      "PendingDeprecationWarning\n",
      "PermissionError\n",
      "ProcessLookupError\n",
      "RecursionError\n",
      "ReferenceError\n",
      "ResourceWarning\n",
      "RuntimeError\n",
      "RuntimeWarning\n",
      "StopAsyncIteration\n",
      "StopIteration\n",
      "SyntaxError\n",
      "SyntaxWarning\n",
      "SystemError\n",
      "SystemExit\n",
      "TabError\n",
      "TimeoutError\n",
      "True\n",
      "TypeError\n",
      "UnboundLocalError\n",
      "UnicodeDecodeError\n",
      "UnicodeEncodeError\n",
      "UnicodeError\n",
      "UnicodeTranslateError\n",
      "UnicodeWarning\n",
      "UserWarning\n",
      "ValueError\n",
      "Warning\n",
      "WindowsError\n",
      "ZeroDivisionError\n",
      "__IPYTHON__\n",
      "__build_class__\n",
      "__debug__\n",
      "__doc__\n",
      "__import__\n",
      "__loader__\n",
      "__name__\n",
      "__package__\n",
      "__spec__\n",
      "abs\n",
      "all\n",
      "any\n",
      "ascii\n",
      "bin\n",
      "bool\n",
      "breakpoint\n",
      "bytearray\n",
      "bytes\n",
      "callable\n",
      "chr\n",
      "classmethod\n",
      "compile\n",
      "complex\n",
      "copyright\n",
      "credits\n",
      "delattr\n",
      "dict\n",
      "dir\n",
      "display\n",
      "divmod\n",
      "enumerate\n",
      "eval\n",
      "exec\n",
      "filter\n",
      "float\n",
      "format\n",
      "frozenset\n",
      "get_ipython\n",
      "getattr\n",
      "globals\n",
      "hasattr\n",
      "hash\n",
      "help\n",
      "hex\n",
      "id\n",
      "input\n",
      "int\n",
      "isinstance\n",
      "issubclass\n",
      "iter\n",
      "len\n",
      "license\n",
      "list\n",
      "locals\n",
      "map\n",
      "max\n",
      "memoryview\n",
      "min\n",
      "next\n",
      "object\n",
      "oct\n",
      "open\n",
      "ord\n",
      "pow\n",
      "print\n",
      "property\n",
      "range\n",
      "repr\n",
      "reversed\n",
      "round\n",
      "set\n",
      "setattr\n",
      "slice\n",
      "sorted\n",
      "staticmethod\n",
      "str\n",
      "sum\n",
      "super\n",
      "tuple\n",
      "type\n",
      "vars\n",
      "zip\n"
     ]
    }
   ],
   "source": [
    "builtin = dir(__builtins__)\n",
    "for i in builtin:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## \\_\\_file\\_\\_ module:\n",
    "\n",
    "It contains the list of builtin variables and functions that can be used in the current file."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### contents:\n",
    "\\_\\_add\\_\\_  \n",
    "\\_\\_class\\_\\_  \n",
    "\\_\\_contains\\_\\_  \n",
    "\\_\\_delattr\\_\\_  \n",
    "\\_\\_dir\\_\\_  \n",
    "\\_\\_doc\\_\\_  \n",
    "\\_\\_eq\\_\\_  \n",
    "\\_\\_format\\_\\_  \n",
    "\\_\\_ge\\_\\_  \n",
    "\\_\\_getattribute\\_\\_  \n",
    "\\_\\_getitem\\_\\_  \n",
    "\\_\\_getnewargs\\_\\_  \n",
    "\\_\\_gt\\_\\_  \n",
    "\\_\\_hash\\_\\_  \n",
    "\\_\\_init\\_\\_  \n",
    "\\_\\_init_subclass\\_\\_  \n",
    "\\_\\_iter\\_\\_  \n",
    "\\_\\_le\\_\\_  \n",
    "\\_\\_len\\_\\_  \n",
    "\\_\\_lt\\_\\_  \n",
    "\\_\\_mod\\_\\_  \n",
    "\\_\\_mul\\_\\_  \n",
    "\\_\\_ne\\_\\_  \n",
    "\\_\\_new\\_\\_  \n",
    "\\_\\_reduce\\_\\_  \n",
    "\\_\\_reduce_ex\\_\\_  \n",
    "\\_\\_repr\\_\\_  \n",
    "\\_\\_rmod\\_\\_  \n",
    "\\_\\_rmul\\_\\_  \n",
    "\\_\\_setattr\\_\\_  \n",
    "\\_\\_sizeof\\_\\_  \n",
    "\\_\\_str\\_\\_  \n",
    "\\_\\_subclasshook\\_\\_  \n",
    "capitalize  \n",
    "casefold  \n",
    "center  \n",
    "count  \n",
    "encode  \n",
    "endswith  \n",
    "expandtabs  \n",
    "find  \n",
    "format  \n",
    "format_map  \n",
    "index  \n",
    "isalnum  \n",
    "isalpha  \n",
    "isascii  \n",
    "isdecimal  \n",
    "isdigit  \n",
    "isidentifier  \n",
    "islower  \n",
    "isnumeric  \n",
    "isprintable  \n",
    "isspace  \n",
    "istitle  \n",
    "isupper  \n",
    "join  \n",
    "ljust  \n",
    "lower  \n",
    "lstrip  \n",
    "maketrans  \n",
    "partition  \n",
    "replace  \n",
    "rfind  \n",
    "rindex  \n",
    "rjust  \n",
    "rpartition  \n",
    "rsplit  \n",
    "rstrip  \n",
    "split  \n",
    "splitlines  \n",
    "startswith  \n",
    "strip  \n",
    "swapcase  \n",
    "title  \n",
    "translate  \n",
    "upper  \n",
    "zfill  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Private in modules:\n",
    "\n",
    "Objects can be restricted to usage when running as a main module. They cannot be imported when importing the complete module using ' &#42; '.\n",
    "\n",
    "They start and end with double underscores, \\_\\_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "import prime_generator as pg\n",
    "\n",
    "print(pg.__primeval)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name '__primeval' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-3-1e464da0715f>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mfrom\u001b[0m \u001b[0mprime_generator\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[1;33m*\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0m__primeval\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name '__primeval' is not defined"
     ]
    }
   ],
   "source": [
    "from prime_generator import *\n",
    "\n",
    "print(__primeval)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## globals(), locals() and reload()\n",
    "\n",
    "globals - returns the list of objects that can be accessed globally from that point.\n",
    "\n",
    "locals - returns the list of objects that can be accessed locally from that point.\n",
    "\n",
    "reload - reloads the given module. (imported from impotlib module)\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "reload(module_name)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## math:\n",
    "This module contains list of all mathematical functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "__doc__\n",
      "__loader__\n",
      "__name__\n",
      "__package__\n",
      "__spec__\n",
      "acos\n",
      "acosh\n",
      "asin\n",
      "asinh\n",
      "atan\n",
      "atan2\n",
      "atanh\n",
      "ceil\n",
      "comb\n",
      "copysign\n",
      "cos\n",
      "cosh\n",
      "degrees\n",
      "dist\n",
      "e\n",
      "erf\n",
      "erfc\n",
      "exp\n",
      "expm1\n",
      "fabs\n",
      "factorial\n",
      "floor\n",
      "fmod\n",
      "frexp\n",
      "fsum\n",
      "gamma\n",
      "gcd\n",
      "hypot\n",
      "inf\n",
      "isclose\n",
      "isfinite\n",
      "isinf\n",
      "isnan\n",
      "isqrt\n",
      "ldexp\n",
      "lgamma\n",
      "log\n",
      "log10\n",
      "log1p\n",
      "log2\n",
      "modf\n",
      "nan\n",
      "perm\n",
      "pi\n",
      "pow\n",
      "prod\n",
      "radians\n",
      "remainder\n",
      "sin\n",
      "sinh\n",
      "sqrt\n",
      "tan\n",
      "tanh\n",
      "tau\n",
      "trunc\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "print(*dir(math), sep='\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.5707963267948966\n",
      "1.5707963267948966\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "print(math.pi/2)\n",
    "print(math.asin(1))\n",
    "# 1.570796... = pi/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22\n",
      "21\n"
     ]
    }
   ],
   "source": [
    "# 21.33 ceil - 22\n",
    "# 21.33 floor - 21\n",
    "# 21, 21.33, 22\n",
    "print(math.ceil(21.33))\n",
    "print(math.floor(21.33))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8.0"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.pow(2, 3) # 2 ** 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\mathit{^5P_2}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.perm(5, 2) # 5P2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\mathit{^5C_2}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.comb(5, 2) # 5C2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## cmath:\n",
    "Like math, used to work with complex numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "__doc__\n",
      "__loader__\n",
      "__name__\n",
      "__package__\n",
      "__spec__\n",
      "acos\n",
      "acosh\n",
      "asin\n",
      "asinh\n",
      "atan\n",
      "atanh\n",
      "cos\n",
      "cosh\n",
      "e\n",
      "exp\n",
      "inf\n",
      "infj\n",
      "isclose\n",
      "isfinite\n",
      "isinf\n",
      "isnan\n",
      "log\n",
      "log10\n",
      "nan\n",
      "nanj\n",
      "phase\n",
      "pi\n",
      "polar\n",
      "rect\n",
      "sin\n",
      "sinh\n",
      "sqrt\n",
      "tan\n",
      "tanh\n",
      "tau\n"
     ]
    }
   ],
   "source": [
    "import cmath\n",
    "\n",
    "print(*dir(cmath), sep='\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## sys:\n",
    "\n",
    "Work with program execution and system."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "__breakpointhook__\n",
      "__displayhook__\n",
      "__doc__\n",
      "__excepthook__\n",
      "__interactivehook__\n",
      "__loader__\n",
      "__name__\n",
      "__package__\n",
      "__spec__\n",
      "__stderr__\n",
      "__stdin__\n",
      "__stdout__\n",
      "__unraisablehook__\n",
      "_base_executable\n",
      "_clear_type_cache\n",
      "_current_frames\n",
      "_debugmallocstats\n",
      "_enablelegacywindowsfsencoding\n",
      "_framework\n",
      "_getframe\n",
      "_git\n",
      "_home\n",
      "_xoptions\n",
      "addaudithook\n",
      "api_version\n",
      "argv\n",
      "audit\n",
      "base_exec_prefix\n",
      "base_prefix\n",
      "breakpointhook\n",
      "builtin_module_names\n",
      "byteorder\n",
      "call_tracing\n",
      "callstats\n",
      "copyright\n",
      "displayhook\n",
      "dllhandle\n",
      "dont_write_bytecode\n",
      "exc_info\n",
      "excepthook\n",
      "exec_prefix\n",
      "executable\n",
      "exit\n",
      "flags\n",
      "float_info\n",
      "float_repr_style\n",
      "get_asyncgen_hooks\n",
      "get_coroutine_origin_tracking_depth\n",
      "getallocatedblocks\n",
      "getcheckinterval\n",
      "getdefaultencoding\n",
      "getfilesystemencodeerrors\n",
      "getfilesystemencoding\n",
      "getprofile\n",
      "getrecursionlimit\n",
      "getrefcount\n",
      "getsizeof\n",
      "getswitchinterval\n",
      "gettrace\n",
      "getwindowsversion\n",
      "hash_info\n",
      "hexversion\n",
      "implementation\n",
      "int_info\n",
      "intern\n",
      "is_finalizing\n",
      "maxsize\n",
      "maxunicode\n",
      "meta_path\n",
      "modules\n",
      "path\n",
      "path_hooks\n",
      "path_importer_cache\n",
      "platform\n",
      "prefix\n",
      "ps1\n",
      "ps2\n",
      "ps3\n",
      "pycache_prefix\n",
      "set_asyncgen_hooks\n",
      "set_coroutine_origin_tracking_depth\n",
      "setcheckinterval\n",
      "setprofile\n",
      "setrecursionlimit\n",
      "setswitchinterval\n",
      "settrace\n",
      "stderr\n",
      "stdin\n",
      "stdout\n",
      "thread_info\n",
      "unraisablehook\n",
      "version\n",
      "version_info\n",
      "warnoptions\n",
      "winver\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "\n",
    "print(*dir(sys), sep='\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## os:\n",
    "works with operating system"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "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",
      "_AddedDllDirectory\n",
      "_Environ\n",
      "__all__\n",
      "__builtins__\n",
      "__cached__\n",
      "__doc__\n",
      "__file__\n",
      "__loader__\n",
      "__name__\n",
      "__package__\n",
      "__spec__\n",
      "_check_methods\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",
      "add_dll_directory\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\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "print(*dir(os), sep='\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## itertools:\n",
    "\n",
    "A module containing iterators for efficient looping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "__doc__\n",
      "__loader__\n",
      "__name__\n",
      "__package__\n",
      "__spec__\n",
      "_grouper\n",
      "_tee\n",
      "_tee_dataobject\n",
      "accumulate\n",
      "chain\n",
      "combinations\n",
      "combinations_with_replacement\n",
      "compress\n",
      "count\n",
      "cycle\n",
      "dropwhile\n",
      "filterfalse\n",
      "groupby\n",
      "islice\n",
      "permutations\n",
      "product\n",
      "repeat\n",
      "starmap\n",
      "takewhile\n",
      "tee\n",
      "zip_longest\n"
     ]
    }
   ],
   "source": [
    "import itertools\n",
    "\n",
    "print(*dir(itertools), sep='\\n')"
   ]
  }
 ],
 "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.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}