28_1001_Operators.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "54a4c389",
   "metadata": {},
   "source": [
    "# Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24a4e39a",
   "metadata": {},
   "source": [
    "## Arithmatic Operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "37396c4b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "5\n",
      "25\n",
      "1.5\n",
      "1\n",
      "3.0\n",
      "3\n",
      "1\n",
      "0\n",
      "4\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "# Addition\n",
    "print(2+3)\n",
    "print(10-5)\n",
    "print(5*5)\n",
    "print(3/2)  # Division (floating point)\n",
    "print(3//2) # Floor Division (integer Division), return only first part before decimal, its floor value that why its called floor division\n",
    "print(6/2)\n",
    "print(6//2)\n",
    "print(5%2) # Modulous Operator, use to know/check \"Remainder\" after division\n",
    "print(10%2) \n",
    "print(2**2) # Power Calculation- Square\n",
    "print(2**3) # Power Calculation - Q\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40fe58f0",
   "metadata": {},
   "source": [
    "## Relational Operator"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35b511a5",
   "metadata": {},
   "source": [
    "- Try to identify relationship between operant, like asking something\n",
    "- Comparision"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "67acbe87",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n",
      "True\n",
      "True\n",
      "True\n",
      "False\n",
      "True\n",
      "True\n",
      "False\n",
      "False\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Comparision:\n",
    "\n",
    "print(4 > 2)  # is 4 > 2 ? \n",
    "print(4 < 2)  # is 4 < 2 ?\n",
    "print(4 == 2) # Equality, check where its equal or not; need to use double quaal (==) sign, because single equal used to assign value\n",
    "print(5 == 5)\n",
    "print(4 >= 2) # Check double condition, where 4 is >= 2 ? first check whether its > then check whether its equal, return True if any true\n",
    "print(4 >=4)\n",
    "print(4 >= 5)\n",
    "print(4 <=4)\n",
    "print(4 <=5)\n",
    "print(4 <=2)\n",
    "print(4 !=4) # Not Equal to Comparision, false becasue 4 & 4 are equal while it checking whether it is not equal!, return opposit then equal to!\n",
    "print(4 !=5) # 4 & 5 are not equal, return True\n",
    "print(4 !=3) # 4 & 3 are not equal, return True"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "245ca622",
   "metadata": {},
   "source": [
    "## Logical/ Boolean Operator"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a612e5e3",
   "metadata": {},
   "source": [
    "- Where relational operators use heavily \n",
    "- (And ; OR ; Not) - Boolean"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f659f476",
   "metadata": {},
   "source": [
    "### AND - Operator"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b94f656",
   "metadata": {},
   "source": [
    "- When left & right operant (value) both are True then return \"True\" otherwise return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "efb5a958",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(False and False) # Return False, because both are not true, rather both are false\n",
    "print(False and True) # Return False, because both are not true, any of them are false\n",
    "print(True and False) # Return False, because both are not true, any of them are false\n",
    "print(True and True) # Return True, because both are true"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b9be5c3",
   "metadata": {},
   "source": [
    "### OR - Operator"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da7e7bf2",
   "metadata": {},
   "source": [
    "- Any True out of Two, return True, otherwise false"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "7409f1b1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(False or False)\n",
    "print(False or True)\n",
    "print(True or False)\n",
    "print(True or True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c04af83",
   "metadata": {},
   "source": [
    "## Not Operator"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82870e20",
   "metadata": {},
   "source": [
    "- and, or & not are python built-in-keyword\n",
    "- or, and not : This keyword can not be used a variable\n",
    "- Not: this will make true statement to false & vise-versa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "6757fad7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not True  # convert True into false, like conversion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "7f598265",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not False"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d2f307d",
   "metadata": {},
   "source": [
    "##### Relational operator highly used with logical operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "2367ca09",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check the grade for the marks with some conditions\n",
    "marks = 78\n",
    "\n",
    "# Conditon : A grade is > 75- 90, check the grade\n",
    "\n",
    "# Checking A grade:\n",
    "marks > 75 and marks < 95"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "5448617d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check the grade for the marks with some conditions\n",
    "marks = 65\n",
    "\n",
    "# Conditon : A grade is > 75- 90, check the grade\n",
    "\n",
    "# Checking A grade: it returns false, because the and the condition is False\n",
    "marks > 75 and marks < 95    # Condition for 1st operant is True; whereas condition for 2nd Operant is False, \n",
    "\n",
    "# 65 is < 95 but not > 75 that why its return False- because as per 'and' rule both condition must be TRUE, any false, will return false"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "0c7aad28",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# grade for the marks with some conditions\n",
    "marks = 98\n",
    "\n",
    "# Conditon : A grade is > 75- 90, check the grade\n",
    "\n",
    "# Checking A grade: it returns false, because the and the condition is False\n",
    "marks > 75 and marks < 95    # 98 is not less then 95, so its return False "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "cf3b1278",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "marks = 85\n",
    "(marks > 75) and (marks <91)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0348b44",
   "metadata": {},
   "source": [
    "### Assignment Operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "82a13f31",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    }
   ],
   "source": [
    "# simple assignment\n",
    "num = 10\n",
    "\n",
    "# Case 1: Add 10 with num then again re-store in same variable\n",
    "num = num + 5\n",
    "print(num)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "9c8261ee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Case 1: Optimization case 1 (addition case)\n",
    "num = 10\n",
    "num += 5  # alternaive method, minimize extension\n",
    "num\n",
    "\n",
    "# Notes: + = ( it mean first add then assigned in same variable by assignment operator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "5520c7f3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Case 1: Optimization case 1 (Substraction case)\n",
    "num = 10\n",
    "num -= 5\n",
    "num"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "b84e7e21",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "49"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Case 1: Optimization case 1 (Square case)\n",
    "num = 7\n",
    "num **= 2  # first square then assign ; all arithmetic operation can be performed here\n",
    "num"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b0b6142",
   "metadata": {},
   "source": [
    "### Special Operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "d38bd8b6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check someting is availale withing something , return boolean \n",
    "\n",
    "\"Py\" in \"Python\"  # Check whether \"Py\" is available in \"Python\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "29cd5d43",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Pt\" in \"Python\" # Pt is avaible not side by side, return false"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "a7e9d2cf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"p\" in \"Python\" # case sensitive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "f2a6f583",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"P\" in \"Python\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "c269811d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Ba\" in \"Banana\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "97b952c7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Ba\" in \"Mango\" # Ba not availabe in \"Banana\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "3465a5d2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 in [2, 3, 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "46626d13",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2.5 in [2, 3, 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "e10c513c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Dictionary\n",
    "1 in {1:\"John\", 2:\"Tessa\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "6a0b0e38",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 in {1:\"John\", 2:\"Tessa\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "64dc2d78",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 in {1:\"John\", 2:\"Tessa\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "87fcc946",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# it check & verify with keys only, not for value\n",
    "\"John\"in {1:\"John\", 2:\"Tessa\"}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5649fe76",
   "metadata": {},
   "source": [
    "### Equality or IS Operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "6524edc7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Test1\n",
    "a = 2.0\n",
    "b = 2\n",
    "a is b # Is not only check number, rather check type & value (one is float & another is int) as well"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "f8e36bca",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Test1\n",
    "a  = 2.0\n",
    "b == 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41f25490",
   "metadata": {},
   "source": [
    "### Bitwise Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd5f1e7a",
   "metadata": {},
   "source": [
    "- Understanding Binary number system is prerequisit for understanding bitwise operator\n",
    "- It used rarely"
   ]
  }
 ],
 "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}