Session -3-package_info.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5eb91c5c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Packages\n",
    "# how to read the package\n",
    "# how to understand the package\n",
    "# to get what are the methods/functions in the package"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d7e6e17",
   "metadata": {},
   "outputs": [],
   "source": [
    "# step-1:    import  <package_name>\n",
    "# step-2:    dir<package_name>  ====== > methods\n",
    "# step-3:    help(<package_name>.<method_name>)\n",
    "# step-4:    <package_name>.<method_name()>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93a1a25c",
   "metadata": {},
   "source": [
    "**keyword**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d91a136e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# step-1:  import <package_name>\n",
    "import keyword"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "df45bf55",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<module 'keyword' from 'C:\\\\Users\\\\omkar\\\\anaconda3\\\\lib\\\\keyword.py'>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "keyword\n",
    "\n",
    "# location :  'C:\\\\Users\\\\omkar\\\\anaconda3\\\\lib\\\\keyword.py'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "5226d2e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2  # module not found error\n",
    "\n",
    "# module/package\n",
    "# whenever package is not there you need to install manually\n",
    "\n",
    "# pip install <module_name>\n",
    "# import <module_name>   vs pip install <module_name>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "37453ecc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<module 'cv2' from 'C:\\\\Users\\\\omkar\\\\anaconda3\\\\lib\\\\site-packages\\\\cv2\\\\__init__.py'>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cv2\n",
    "\n",
    "# location : C:\\\\Users\\\\omkar\\\\anaconda3\\\\lib\\\\site-packages\\\\cv2\\\\__init__.py'>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "06056497",
   "metadata": {},
   "outputs": [
    {
     "ename": "ModuleNotFoundError",
     "evalue": "No module named 'tesnorflow'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
      "Cell \u001b[1;32mIn [3], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mtesnorflow\u001b[39;00m\n",
      "\u001b[1;31mModuleNotFoundError\u001b[0m: No module named 'tesnorflow'"
     ]
    }
   ],
   "source": [
    "import tesnorflow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "c323be37",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: opencv-python in c:\\users\\omkar\\anaconda3\\lib\\site-packages (4.8.0.74)\n",
      "Requirement already satisfied: numpy>=1.19.3 in c:\\users\\omkar\\anaconda3\\lib\\site-packages (from opencv-python) (1.23.5)\n"
     ]
    }
   ],
   "source": [
    "!pip install opencv-python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "59f360af",
   "metadata": {},
   "outputs": [],
   "source": [
    "# random\n",
    "# keyword\n",
    "# cv2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "59e22e34",
   "metadata": {},
   "outputs": [],
   "source": [
    "import keyword"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "ad360f6d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__all__',\n",
       " '__builtins__',\n",
       " '__cached__',\n",
       " '__doc__',\n",
       " '__file__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__spec__',\n",
       " 'iskeyword',\n",
       " 'issoftkeyword',\n",
       " 'kwlist',\n",
       " 'softkwlist']"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(keyword)\n",
    "\n",
    "# __ is not methods / subtask/functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "70782b79",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on list object:\n",
      "\n",
      "class list(object)\n",
      " |  list(iterable=(), /)\n",
      " |  \n",
      " |  Built-in mutable sequence.\n",
      " |  \n",
      " |  If no argument is given, the constructor creates a new empty list.\n",
      " |  The argument must be an iterable if specified.\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __add__(self, value, /)\n",
      " |      Return self+value.\n",
      " |  \n",
      " |  __contains__(self, key, /)\n",
      " |      Return key in self.\n",
      " |  \n",
      " |  __delitem__(self, key, /)\n",
      " |      Delete self[key].\n",
      " |  \n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __ge__(self, value, /)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __getitem__(...)\n",
      " |      x.__getitem__(y) <==> x[y]\n",
      " |  \n",
      " |  __gt__(self, value, /)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __iadd__(self, value, /)\n",
      " |      Implement self+=value.\n",
      " |  \n",
      " |  __imul__(self, value, /)\n",
      " |      Implement self*=value.\n",
      " |  \n",
      " |  __init__(self, /, *args, **kwargs)\n",
      " |      Initialize self.  See help(type(self)) for accurate signature.\n",
      " |  \n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |  \n",
      " |  __le__(self, value, /)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __len__(self, /)\n",
      " |      Return len(self).\n",
      " |  \n",
      " |  __lt__(self, value, /)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __mul__(self, value, /)\n",
      " |      Return self*value.\n",
      " |  \n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __reversed__(self, /)\n",
      " |      Return a reverse iterator over the list.\n",
      " |  \n",
      " |  __rmul__(self, value, /)\n",
      " |      Return value*self.\n",
      " |  \n",
      " |  __setitem__(self, key, value, /)\n",
      " |      Set self[key] to value.\n",
      " |  \n",
      " |  __sizeof__(self, /)\n",
      " |      Return the size of the list in memory, in bytes.\n",
      " |  \n",
      " |  append(self, object, /)\n",
      " |      Append object to the end of the list.\n",
      " |  \n",
      " |  clear(self, /)\n",
      " |      Remove all items from list.\n",
      " |  \n",
      " |  copy(self, /)\n",
      " |      Return a shallow copy of the list.\n",
      " |  \n",
      " |  count(self, value, /)\n",
      " |      Return number of occurrences of value.\n",
      " |  \n",
      " |  extend(self, iterable, /)\n",
      " |      Extend list by appending elements from the iterable.\n",
      " |  \n",
      " |  index(self, value, start=0, stop=9223372036854775807, /)\n",
      " |      Return first index of value.\n",
      " |      \n",
      " |      Raises ValueError if the value is not present.\n",
      " |  \n",
      " |  insert(self, index, object, /)\n",
      " |      Insert object before index.\n",
      " |  \n",
      " |  pop(self, index=-1, /)\n",
      " |      Remove and return item at index (default last).\n",
      " |      \n",
      " |      Raises IndexError if list is empty or index is out of range.\n",
      " |  \n",
      " |  remove(self, value, /)\n",
      " |      Remove first occurrence of value.\n",
      " |      \n",
      " |      Raises ValueError if the value is not present.\n",
      " |  \n",
      " |  reverse(self, /)\n",
      " |      Reverse *IN PLACE*.\n",
      " |  \n",
      " |  sort(self, /, *, key=None, reverse=False)\n",
      " |      Sort the list in ascending order and return None.\n",
      " |      \n",
      " |      The sort is in-place (i.e. the list itself is modified) and stable (i.e. the\n",
      " |      order of two equal elements is maintained).\n",
      " |      \n",
      " |      If a key function is given, apply it once to each list item and sort them,\n",
      " |      ascending or descending, according to their function values.\n",
      " |      \n",
      " |      The reverse flag can be set to sort in descending order.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods defined here:\n",
      " |  \n",
      " |  __class_getitem__(...) from builtins.type\n",
      " |      See PEP 585\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  __hash__ = None\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# kwlist   :  method\n",
    "\n",
    "help(keyword.kwlist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "136e7c61",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['False',\n",
       " 'None',\n",
       " 'True',\n",
       " 'and',\n",
       " 'as',\n",
       " 'assert',\n",
       " 'async',\n",
       " 'await',\n",
       " 'break',\n",
       " 'class',\n",
       " 'continue',\n",
       " 'def',\n",
       " 'del',\n",
       " 'elif',\n",
       " 'else',\n",
       " 'except',\n",
       " 'finally',\n",
       " 'for',\n",
       " 'from',\n",
       " 'global',\n",
       " 'if',\n",
       " 'import',\n",
       " 'in',\n",
       " 'is',\n",
       " 'lambda',\n",
       " 'nonlocal',\n",
       " 'not',\n",
       " 'or',\n",
       " 'pass',\n",
       " 'raise',\n",
       " 'return',\n",
       " 'try',\n",
       " 'while',\n",
       " 'with',\n",
       " 'yield']"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "keyword.kwlist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "ef1903a6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['False',\n",
       " 'None',\n",
       " 'True',\n",
       " 'and',\n",
       " 'as',\n",
       " 'assert',\n",
       " 'async',\n",
       " 'await',\n",
       " 'break',\n",
       " 'class',\n",
       " 'continue',\n",
       " 'def',\n",
       " 'del',\n",
       " 'elif',\n",
       " 'else',\n",
       " 'except',\n",
       " 'finally',\n",
       " 'for',\n",
       " 'from',\n",
       " 'global',\n",
       " 'if',\n",
       " 'import',\n",
       " 'in',\n",
       " 'is',\n",
       " 'lambda',\n",
       " 'nonlocal',\n",
       " 'not',\n",
       " 'or',\n",
       " 'pass',\n",
       " 'raise',\n",
       " 'return',\n",
       " 'try',\n",
       " 'while',\n",
       " 'with',\n",
       " 'yield']"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import keyword\n",
    "#dir(keyword)\n",
    "#help(keyword.kwlist)\n",
    "keyword.kwlist  # what it is returning\n",
    "# all the keywords in python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "6a6b10ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "#if or pass raise try with yield\n",
    "# dont use keywords as variables\n",
    "import keyword\n",
    "info=keyword.kwlist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "62d7d83f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "35"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(info)  # almost 35 keywords"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "79ecc46e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['False',\n",
       " 'None',\n",
       " 'True',\n",
       " 'and',\n",
       " 'as',\n",
       " 'assert',\n",
       " 'async',\n",
       " 'await',\n",
       " 'break',\n",
       " 'class',\n",
       " 'continue',\n",
       " 'def',\n",
       " 'del',\n",
       " 'elif',\n",
       " 'else',\n",
       " 'except',\n",
       " 'finally',\n",
       " 'for',\n",
       " 'from',\n",
       " 'global',\n",
       " 'if',\n",
       " 'import',\n",
       " 'in',\n",
       " 'is',\n",
       " 'lambda',\n",
       " 'nonlocal',\n",
       " 'not',\n",
       " 'or',\n",
       " 'pass',\n",
       " 'raise',\n",
       " 'return',\n",
       " 'try',\n",
       " 'while',\n",
       " 'with',\n",
       " 'yield']"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# import keyword\n",
    "# keyword.kwlist\n",
    "\n",
    "from keyword import kwlist\n",
    "kwlist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "f4ea32d5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.141592653589793"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# package name : math\n",
    "# method : pi = 3.14\n",
    "import math\n",
    "math.pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "e342fcb0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.141592653589793"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import pi\n",
    "pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e259b5b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# random\n",
    "# math\n",
    "# keyword"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "85248164",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.14"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "round(math.pi,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "0d41d156",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.157"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(1.156890,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "d17f327c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__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",
       " 'lcm',\n",
       " 'ldexp',\n",
       " 'lgamma',\n",
       " 'log',\n",
       " 'log10',\n",
       " 'log1p',\n",
       " 'log2',\n",
       " 'modf',\n",
       " 'nan',\n",
       " 'nextafter',\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",
       " 'ulp']"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(math)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "d46a35ba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.9880316240928618"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import sin\n",
    "sin(30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "798bd33e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function sin in module math:\n",
      "\n",
      "sin(x, /)\n",
      "    Return the sine of x (measured in radians).\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(math.sin)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82cc63d9",
   "metadata": {},
   "source": [
    "# Points\n",
    "\n",
    "- Variable can be small,capital and combination small and capital\n",
    "\n",
    "- numbers with combination of letters allowed when number as suffix\n",
    "\n",
    "- spl caharcters are not allowed except underscore\n",
    "\n",
    "- keywords are not allowed"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "416ce943",
   "metadata": {},
   "source": [
    "**Default Data types**\n",
    "\n",
    "- integer\n",
    "\n",
    "- float\n",
    "\n",
    "- boolean\n",
    "\n",
    "- string\n",
    "\n",
    "- complex conjugate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "26fefdbd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=100\n",
    "type(a)\n",
    "\n",
    "# in python no need to mention about type\n",
    "# default it will provide the type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "d71a7e24",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b=10.5\n",
    "type(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "337b1d89",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c=True\n",
    "type(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "c809c668",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d='python'   # string always in the quotes\n",
    "type(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "d623f2a1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e=\"python\"\n",
    "type(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a26054c",
   "metadata": {},
   "source": [
    "$integer$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "9898144d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1000"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num=1000\n",
    "num"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "c436de18",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5196c721",
   "metadata": {},
   "outputs": [],
   "source": [
    "numer system is one language\n",
    "\n",
    "1,2,3,4,5,6,7,.....\n",
    "\n",
    "binary\n",
    "octal\n",
    "hexa\n",
    "              decimal\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "001d7502",
   "metadata": {},
   "source": [
    "**binary**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fc39e00e",
   "metadata": {},
   "outputs": [],
   "source": [
    "bi ===== > two\n",
    "0 and 1\n",
    "\n",
    "represent by :  b   or B\n",
    "    \n",
    "example: 0b111  ====== > binary system\n",
    "    \n",
    "0B101  =========== Binary\n",
    "\n",
    "0B123  ==========  not valid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "1999fab9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#what is the value of 0b111\n",
    "0b1111\n",
    "# 8421==== > 8+4+2+1=15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "f8757676",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0b1010\n",
    "#8421 = 8 +2=10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "6a40b40a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0b10001\n",
    "# 16 8 4 2 1\n",
    "# 16+1=17"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "4d06025e",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'b1111' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn [38], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mb1111\u001b[49m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'b1111' is not defined"
     ]
    }
   ],
   "source": [
    "b1111"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0dc288c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "2^2   2^1   2^0\n",
    "4      2     1\n",
    "\n",
    "0      0     0  = 0\n",
    "0      0     1  = 1\n",
    "0      1     0  = 2\n",
    "0      1     1  = 2+1=3\n",
    "1      0     0  = 4\n",
    "1      0     1  = 4+1=5\n",
    "1      1     0  = 4+2=6\n",
    "1      1     1  = 4+2+1=7"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c5ae5d2",
   "metadata": {},
   "source": [
    "- binary means two digits are allowed : 0 and 1\n",
    "    \n",
    "- all binary numbers are combination of 0 and 1\n",
    "\n",
    "- binary number represnt by b or B\n",
    "\n",
    "- example: 0b111, 0B111\n",
    "    \n",
    "- python default provided decimal value only"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99626075",
   "metadata": {},
   "source": [
    "- octa means 8 digits are allowed : 0,1,2,3,4,5,6,7\n",
    "    \n",
    "- all octa numbers are combination of 0 to 7\n",
    "\n",
    "- octa number represnt by o or O\n",
    "\n",
    "- example: 0o156, 0O986\n",
    "    \n",
    "- python default provided decimal value only"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5f45004a",
   "metadata": {},
   "outputs": [],
   "source": [
    "binary =2     0   1\n",
    "\n",
    "0b\n",
    "111"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "69b3c7ef",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2610bc7a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e0e2391e",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}