012_Python_Operators.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<small><small><i>\n",
    "All the IPython Notebooks in **Python Introduction** lecture series by Dr. Milaan Parmar are available @ **[GitHub](https://github.com/milaan9/01_Python_Introduction)**\n",
    "</i></small></small>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Operators\n",
    "\n",
    "Python can be used like a calculator. Simply type in expressions to get them evaluated.\n",
    "\n",
    "**What are operators in python?**\n",
    "\n",
    "Operators are special **symbols** in Python that carry out **arithmetic** or **logical computation**. The value that the operator operates on is called the **operand**.\n",
    "\n",
    "For example:\n",
    "\n",
    "```python\n",
    ">>>6+3\n",
    "\n",
    "9\n",
    "```\n",
    "\n",
    "Here, **`+`** is the operator that performs addition. **`2`** and **`3`** are the operands and **`5`** is the output of the **operation**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:25:25.114694Z",
     "start_time": "2021-10-02T08:25:25.094187Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "6+3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Arithmatic Operators\n",
    "\n",
    "Arithmetic operators are used to perform **mathematical operations** like **addition**, **subtraction**, **multiplication** etc.\n",
    "\n",
    "| Symbol | Task Performed | Meaning | Example | \n",
    "|:------:|:---------------| :------: |:--------:|\n",
    "| **`+`**      | Addition | add two operands or unary plus | **x + y** or **+2** | \n",
    "| **`-`**      | Subtraction | substract right operand from the left or unary minus | **x - y** or **-2** | \n",
    "| **`*`**      | Multiplication | Multiply two operands | **x \\* y** |\n",
    "| **`/`**      | Division | Divide left operand by the right one (always results into float) | **x / y** | \n",
    "| **`%`**      | Modulus (remainder) | remainder of the division of left operand by the right | **x % y** (remainder of **x/y**) | \n",
    "| **`//`**     | Integer/Floor division | division that results into whole number adjusted to the left in the number line | **x // y** | \n",
    "| <b>`**`</b>     | Exponentiation (power) | left operand raised to the power of right | **x \\*\\* y** (**x** to the power **y**) |\n",
    "\n",
    "As expected these operations generally promote to the most general type of any of the numbers involved i.e. int -> float -> complex.\n",
    "\n",
    "#### Example : Arithmetic operators in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:25:25.239206Z",
     "start_time": "2021-10-02T08:25:25.117624Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Addition:  3\n",
      "Subtraction:  1\n",
      "Multiplication:  6\n",
      "Division:  2.0\n",
      "Division:  3.0\n",
      "Division:  3.5\n",
      "Division without the remainder:  3\n",
      "Modulus:  1\n",
      "Division without the remainder:  2\n",
      "Exponential:  9\n"
     ]
    }
   ],
   "source": [
    "print('Addition: ', 1 + 2)\n",
    "print('Subtraction: ', 2 - 1)\n",
    "print('Multiplication: ', 2 * 3)\n",
    "print ('Division: ', 4 / 2)                         # Division in python gives floating number\n",
    "print('Division: ', 6 / 2)\n",
    "print('Division: ', 7 / 2)\n",
    "print('Division without the remainder: ', 7 // 2)   # gives without the floating number or without the remaining\n",
    "print('Modulus: ', 3 % 2)                           # Gives the remainder\n",
    "print ('Division without the remainder: ',7 // 3)\n",
    "print('Exponential: ', 3 ** 2)                      # it means 3 * 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:25:25.375922Z",
     "start_time": "2021-10-02T08:25:25.248971Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x + y = 19\n",
      "x - y = 13\n",
      "x * y = 48\n",
      "x / y = 5.333333333333333\n",
      "x // y = 5\n"
     ]
    }
   ],
   "source": [
    "x = 16\n",
    "y = 3\n",
    "\n",
    "print('x + y =',x+y) # 19\n",
    "print('x - y =',x-y) # 13\n",
    "print('x * y =',x*y) # 48\n",
    "print('x / y =',x/y) # 5.333\n",
    "print('x // y =',x//y) # 519"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:25:25.528268Z",
     "start_time": "2021-10-02T08:25:25.383735Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1+2+3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:25:25.663036Z",
     "start_time": "2021-10-02T08:25:25.533150Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "7-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:25:25.770456Z",
     "start_time": "2021-10-02T08:25:25.667916Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(18+0j)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "6 * (3+0j) * 1.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:25:25.914987Z",
     "start_time": "2021-10-02T08:25:25.773383Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8333333333333334"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5/6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In many languages (and older versions of python) $\\frac{1}{2}=0$ (truncated division). In Python 3 this behaviour is captured by a separate operator that rounds down: (i.e., **a // b$=\\lfloor \\frac{a}{b}\\rfloor$**)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:25:26.032171Z",
     "start_time": "2021-10-02T08:25:25.923776Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5//6.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:25:26.155218Z",
     "start_time": "2021-10-02T08:25:26.037055Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "15%10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:25:26.281684Z",
     "start_time": "2021-10-02T08:25:26.158150Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 ** 2      # it means 3 * 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python natively allows (nearly) infinite length integers while floating point numbers are double precision numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:25:26.446233Z",
     "start_time": "2021-10-02T08:25:26.288522Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "28418980453852622603883856494709731311218158362293224700445543940796643776911788129508577246309929258069598467896008287596053863082109746801947722280783720032649818198464452375358348619120021135797251857019557032565638659667745421115194468559021541269027438746788486392649581405327516658718317011453858465218779880972140612551504149701082164179367484198570734230003528355826545644223794779911723917115845213739921327820409005460708547942445234906498880588411276755120002108963510955276534630522965966177951626038063994937181228938844252668098515385045718428663547788122173798704717510979319749834083419004355222012043715855123615249682039587844431246269017612728291710718821388840627277407189863509789929339102406655115786899696829902032282666983426897111750208839152830573688512831984602085360572485861376"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "22**600"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:25:26.849067Z",
     "start_time": "2021-10-02T08:25:26.450143Z"
    }
   },
   "outputs": [
    {
     "ename": "OverflowError",
     "evalue": "(34, 'Result too large')",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mOverflowError\u001b[0m                             Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-12-bfc5aa62a0ff>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;36m22.0\u001b[0m\u001b[1;33m**\u001b[0m\u001b[1;36m600\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mOverflowError\u001b[0m: (34, 'Result too large')"
     ]
    }
   ],
   "source": [
    "22.0**600"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Comparison/Relational operators\n",
    "\n",
    "Comparison operators are used to **compare values**. It either returns **True** or **False** according to the **condition**.\n",
    "\n",
    "| Symbol | Task Performed | Meaning | Example | \n",
    "|:----:| :--- |:--- |:---: |\n",
    "| **`>`** | greater than | True if left operand is greater than the right | **x > y** | \n",
    "| **`<`** | less than | True if left operand is less than the right | **x < y** | \n",
    "| **`==`** | equal to | True if both operands are equal | **x == y** | \n",
    "| **`!=`**  | not equal to | True if both operands are not equal | **x != y** | \n",
    "| **`>=`**  | greater than or equal to | True if left operand is greater than or equal to the right | **x >= y** | \n",
    "| **`<=`**  | less than or equal to | True if left operand is less than or equal to the right | **x <= y** | \n",
    "\n",
    "Note the difference between **`==`** (equality test) and **`=`** (assignment)\n",
    "\n",
    "#### Example : Comparison operators in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:25:38.142518Z",
     "start_time": "2021-10-02T08:25:38.121036Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n",
      "True\n",
      "True\n",
      "False\n",
      "True\n",
      "False\n",
      "True\n",
      "True\n",
      "False\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(6 > 3)                           # True, because 3 is greater than 2\n",
    "print(6 >= 3)                          # True, because 3 is greater than 2\n",
    "print(6 < 3)                           # False,  because 3 is greater than 2\n",
    "print(3 < 6)                           # True, because 2 is less than 3\n",
    "print(3 <= 6)                          # True, because 2 is less than 3\n",
    "print(6 == 3)                          # False, because 3 is not equal to 2\n",
    "print(6 != 3)                          # True, because 3 is not equal to 2\n",
    "print(len(\"apple\") == len(\"avocado\"))  # False\n",
    "print(len(\"apple\") != len(\"avocado\"))  # True\n",
    "print(len(\"apple\") < len(\"avocado\"))   # True\n",
    "print(len(\"banana\") != len(\"orange\"))  # False\n",
    "print(len(\"banana\") == len(\"orange\"))  # True\n",
    "print(len(\"tomato\") == len(\"potato\"))  # True\n",
    "print(len(\"python\") > len(\"coding\"))   # False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:25:38.770445Z",
     "start_time": "2021-10-02T08:25:38.728454Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x > y is True\n",
      "x < y is False\n",
      "x >= y is True\n",
      "x <= y is False\n"
     ]
    }
   ],
   "source": [
    "x = 30\n",
    "y = 22\n",
    "\n",
    "print('x > y is',x>y)   # False\n",
    "print('x < y is',x<y)   # True\n",
    "print('x >= y is',x>=y) # False\n",
    "print('x <= y is',x<=y) # True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:25:39.016540Z",
     "start_time": "2021-10-02T08:25:39.007753Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = 3  # 3 is assign to variable z\n",
    "z == 3 # 3 is equal to z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:25:39.277771Z",
     "start_time": "2021-10-02T08:25:39.266053Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z > 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comparisons can also be chained in the mathematically obvious way. The following will work as expected in Python (but not in other languages like C/C++):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:25:39.740660Z",
     "start_time": "2021-10-02T08:25:39.722109Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.5 < z <= 1   # z == 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Logical/Boolean operators \n",
    "\n",
    "Logical operators are the **`and`**, **`or`**, **`not`** operators.\n",
    "\n",
    "| Symbol | Meaning | Example | \n",
    "|:----:| :---: |:---:|\n",
    "| **`and`** |  True if both the operands are true | **x and y** | \n",
    "| **`or`** |  True if either of the operand is true | **x or y** | \n",
    "| **`not`** |  True if operand are false (complements the operand) | **not x** | \n",
    "\n",
    "\n",
    "#### Example : Logical operators in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:25:40.184507Z",
     "start_time": "2021-10-02T08:25:40.169373Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True == True:  True\n",
      "True == False:  False\n",
      "False == False: True\n",
      "True and True:  True\n",
      "True or False: True\n"
     ]
    }
   ],
   "source": [
    "print('True == True: ', True == True)\n",
    "print('True == False: ', True == False)\n",
    "print('False == False:', False == False)\n",
    "print('True and True: ', True and True)\n",
    "print('True or False:', True or False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:25:40.415466Z",
     "start_time": "2021-10-02T08:25:40.390077Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 is 1 True\n",
      "1 is not 2 True\n",
      "A in Milaan False\n",
      "B in Milaan False\n",
      "True\n",
      "a in an: True\n",
      "27 is 3 ** 3: True\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<>:3: SyntaxWarning: \"is\" with a literal. Did you mean \"==\"?\n",
      "<>:4: SyntaxWarning: \"is not\" with a literal. Did you mean \"!=\"?\n",
      "<>:9: SyntaxWarning: \"is\" with a literal. Did you mean \"==\"?\n",
      "<>:3: SyntaxWarning: \"is\" with a literal. Did you mean \"==\"?\n",
      "<>:4: SyntaxWarning: \"is not\" with a literal. Did you mean \"!=\"?\n",
      "<>:9: SyntaxWarning: \"is\" with a literal. Did you mean \"==\"?\n",
      "<ipython-input-19-7c9145eb11e9>:3: SyntaxWarning: \"is\" with a literal. Did you mean \"==\"?\n",
      "  print('1 is 1', 1 is 1)                  # True  - because the data values are the same\n",
      "<ipython-input-19-7c9145eb11e9>:4: SyntaxWarning: \"is not\" with a literal. Did you mean \"!=\"?\n",
      "  print('1 is not 2', 1 is not 2)          # True  - because 1 is not 2\n",
      "<ipython-input-19-7c9145eb11e9>:9: SyntaxWarning: \"is\" with a literal. Did you mean \"==\"?\n",
      "  print('27 is 3 ** 3:', 27 is 3**3)       # True\n"
     ]
    }
   ],
   "source": [
    "# Another way comparison \n",
    "\n",
    "print('1 is 1', 1 is 1)                  # True  - because the data values are the same\n",
    "print('1 is not 2', 1 is not 2)          # True  - because 1 is not 2\n",
    "print('A in Milaan', 'A' in 'Milaan')    # True  - A found in the string\n",
    "print('B in Milaan', 'B' in 'Milaan')    # False - there is no uppercase B\n",
    "print('python' in 'python is fun')       # True  - because coding for all has the word coding\n",
    "print('a in an:', 'a' in 'an')           # True\n",
    "print('27 is 3 ** 3:', 27 is 3**3)       # True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:25:40.632261Z",
     "start_time": "2021-10-02T08:25:40.610778Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n",
      "True\n",
      "True\n",
      "False\n",
      "False\n",
      "False\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(6 > 3 and 5 > 3) # True  - because both statements are true\n",
    "print(6 > 3 and 5 < 3) # False - because the second statement is false\n",
    "print(6 < 3 and 5 < 3) # False - because both statements are false\n",
    "print(6 > 3 or 5 > 3)  # True  - because both statements are true\n",
    "print(6 > 3 or 5 < 3)  # True  - because one of the statement is true\n",
    "print(6 < 3 or 5 < 3)  # False - because both statements are false\n",
    "print(not 6 > 3)       # False - because 6 > 3 is true, then not True gives False\n",
    "print(not True)        # False - Negation, the not operator turns true to false\n",
    "print(not False)       # True\n",
    "print(not not True)    # True\n",
    "print(not not False)   # False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:25:40.815854Z",
     "start_time": "2021-10-02T08:25:40.802187Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x and y is False\n",
      "x or y is True\n",
      "not x is False\n"
     ]
    }
   ],
   "source": [
    "x = True\n",
    "y = False\n",
    "\n",
    "print('x and y is',x and y) # False\n",
    "print('x or y is',x or y) # True\n",
    "print('not x is',not x) # False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:25:41.047300Z",
     "start_time": "2021-10-02T08:25:41.025817Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and (not(not False)) or (True and (not True))  # What will be output?\n",
    "\n",
    "# True and (not(True)) or (True and (False))\n",
    "# True and False or (False)\n",
    "# False or False\n",
    "# False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is the **[truth table (@ and, or, not)](https://github.com/milaan9/01_Python_Introduction/blob/main/Python_Keywords_List.ipynb)** for these operators."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Bitwise operators\n",
    "\n",
    "Bitwise operators act on operands as if they were string of binary digits. It operates **bit by bit**, hence the name.\n",
    "\n",
    "**For example:** 2 is **`10`** in binary and 7 is **`111`**.\n",
    "\n",
    "**In the table below:** Let **`x`** = 10 (**`0000 1010`** in binary) and **`y`** = 4 (**`0000 0100`** in binary)\n",
    "\n",
    "| Operator | Meaning  | Symbol | Task Performed | Example |\n",
    "|:---:|:---:| :---:|:---:|:---:|\n",
    "|**`and`** | Logical and |  **`&`**    | Bitwise And | **x & y** = 0 (**`0000 0000`**) | \n",
    "|**`or`**  | Logical or  |  **$\\mid$** | Bitwise OR  | **x \\| y** = 14 (**`0000 1110`**) |\n",
    "|**`not`** | Not         |  **`~`**    | Bitwise NOT | **~x** = -11 (**`1111 0101`**) |\n",
    "| &nbsp;   |&nbsp;       |    **`^`**  | Bitwise XOR | **x ^ y** = 14 (**`0000 1110`**) |\n",
    "| &nbsp;   |&nbsp;       |   **`>>`**  | Bitwise right shift | **x >> 2** = 2 (**`0000 0010`**) |\n",
    "| &nbsp;   |&nbsp;       |   **`<<`**  | Bitwise left shift | **x << 2** = 40 (**`0010 1000`**) |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:25:41.648375Z",
     "start_time": "2021-10-02T08:25:41.638613Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a & b = 2 = 0b10\n"
     ]
    }
   ],
   "source": [
    "a = 2 #binary: 0010\n",
    "b = 3 #binary: 0011\n",
    "print('a & b =',a & b,\"=\",bin(a&b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:25:41.877864Z",
     "start_time": "2021-10-02T08:25:41.862241Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 >> 1\n",
    "\n",
    "# 0 ➡ 0000 0101\n",
    "#      0000 0010 \n",
    "# 0010 is 2 in decimal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation**:\n",
    "\n",
    "0000 0101 -> 5  (5 is 0101 in binary)\n",
    "\n",
    "Shifting the digits by 1 to the right and zero padding that will be: 0 ➡ 0000 0101 = 0000 0010\n",
    "\n",
    "0000 0010 -> 2 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:25:42.355408Z",
     "start_time": "2021-10-02T08:25:42.345642Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 << 1\n",
    "\n",
    "# 0000 0101  ⬅ 0\n",
    "# 0000 1010 \n",
    "# 1010 is 10 in decimal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation**:\n",
    "\n",
    "0000 0101 -> 5\n",
    "\n",
    "Shifting the digits by 1 to the left and zero padding will be: 0000 0101  ⬅ 0 = 0000 1010\n",
    "\n",
    "0000 1010 -> 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:25:43.707945Z",
     "start_time": "2021-10-02T08:25:43.696227Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "6 >> 2  # What will be output???"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:25:43.925717Z",
     "start_time": "2021-10-02T08:25:43.913024Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True == True\n"
     ]
    }
   ],
   "source": [
    "print(not (True and False), \"==\", not True or not False)\n",
    "#      TRUE                  ==     True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:25:44.170833Z",
     "start_time": "2021-10-02T08:25:44.157164Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False == False\n"
     ]
    }
   ],
   "source": [
    "print (False and (not False) or (False and True), \"==\",not (True and (not False) or (not True)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Assignment operators\n",
    "\n",
    "Assignment operators are used in Python to **assign values** to **variables**.\n",
    "\n",
    "**`a = 5`** is a simple assignment operator that assigns the value 5 on the right to the variable **`a`** on the left.\n",
    "\n",
    "There are various compound operators in Python like a **`+= 5`** that adds to the variable and later assigns the same. It is equivalent to **`a = a + 5`**.\n",
    "\n",
    "| Symbol | Example | Equivalent to | \n",
    "|:---:|:---:|:---:|\n",
    "| **`=`** | **x = 5** | **x = 5** | \n",
    "| **`+=`** | **x += 5** | **x = x + 5** | \n",
    "| **`-=`** | **x -= 5** | **x = x - 5** | \n",
    "| **`*=`** | **x \\*= 5** | **x = x \\* 5** | \n",
    "| **`/=`** | **x /= 5** | **x = x / 5** | \n",
    "| **`%=`** | **x %= 5** | **x = x % 5** | \n",
    "| **`//=`** | **x //= 5** | **x = x // 5** | \n",
    "| <b>`**=`</b> | **x \\*\\*= 5** | **x = x \\*\\* 5** | \n",
    "| **`&=`** | **x &= 5** | **x = x & 5** | \n",
    "| **`\\|=`** | **x \\|= 5** | **x = x \\| 5** | \n",
    "| **`^=`** | **x ^= 5** | **x = x ^ 5** | \n",
    "| **`>>=`** | **x >>= 5** | **x = x >> 5** | \n",
    "| **`<<=`** | **x <<= 5** | **x = x << 5** | "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The binary operators can be combined with assignment to modify a variable value. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:25:44.848078Z",
     "start_time": "2021-10-02T08:25:44.830504Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is 3\n",
      "x is 12\n",
      "x is 144\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "x += 2 # add 2 to x\n",
    "print(\"x is\",x)\n",
    "x <<= 2 # left shift by 2 (equivalent to x *= 4)\n",
    "print('x is',x)\n",
    "x **= 2 # x := x^2\n",
    "print('x is',x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Special operators\n",
    "\n",
    "Python language offers some special types of operators like the identity operator or the membership operator. They are described below with examples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Identity operators\n",
    "\n",
    "**`is`** and **`is not`** are the identity operators in Python. They are used to check if two values (or variables) are located on the same part of the **memory**. Two variables that are equal does not imply that they are **identical**.\n",
    "\n",
    "| Symbol | Meaning | Example | \n",
    "|:---:| :---: |:---:|\n",
    "| **`is`** |  True if the operands are identical (refer to the same object) | **x is True**  | \n",
    "| **`is not`** |  True if the operands are not identical (do not refer to the same object)  | **x is not True** | \n",
    "\n",
    "#### Example : Identity operators in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:25:45.559015Z",
     "start_time": "2021-10-02T08:25:45.542417Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "x1 = 6\n",
    "y1 = 6\n",
    "x2 = 'Hello'\n",
    "y2 = 'Hello'\n",
    "x3 = [1,2,3] # list\n",
    "y3 = [1,2,3] # list\n",
    "\n",
    "# Output: False\n",
    "print(x1 is not y1)\n",
    "\n",
    "# Output: True\n",
    "print(x2 is y2)\n",
    "\n",
    "# Output: False because two list [] can never be equal\n",
    "print(x3 is y3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "Here, we see that **`x1`** and **`y1`** are integers of same values, so they are equal as well as identical. Same is the case with **`x2`** and **`y2`** (strings).\n",
    "\n",
    "But **`x3`** and **`y3`** are list. They are equal but not identical. It is because interpreter locates them **separately in memory** although they are equal."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Membership operators\n",
    "\n",
    "**`in`** and **`not in`** are the membership operators in Python. They are used to test whether a value or variable is found in a **sequence** (**[string](https://github.com/milaan9/02_Python_Datatypes/blob/main/002_Python_String.ipynb)**, **[list](https://github.com/milaan9/02_Python_Datatypes/blob/main/003_Python_List.ipynb)**, **[tuple](https://github.com/milaan9/02_Python_Datatypes/blob/main/004_Python_Tuple.ipynb)**, **[set](https://github.com/milaan9/02_Python_Datatypes/blob/main/006_Python_Sets.ipynb)** and **[dictionary](https://github.com/milaan9/02_Python_Datatypes/blob/main/005_Python_Dictionary.ipynb)**).\n",
    "\n",
    "In a dictionary we can only test for presence of **key, not the value**.\n",
    "\n",
    "| Symbol | Meaning | Example | \n",
    "|:---:| :---: |:---:|\n",
    "| **`in`** |  True if value/variable is found in sequence | **5 in x**  | \n",
    "| **`not in`** |  True if value/variable is not found in sequence | **5 not in x**  | \n",
    "\n",
    "#### Example : Membership operators in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:25:46.265068Z",
     "start_time": "2021-10-02T08:25:46.246518Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "x = 'Hello world'\n",
    "y = {1:'a',2:'b'} # dictionary 1 is key and 'a' is element. So we access element without its key.\n",
    "\n",
    "# Output: True\n",
    "print('H' in x)  # Do we have 'H' in 'Hello World' ?\n",
    "\n",
    "# Output: True\n",
    "print('hello' not in x)  # Do we have 'hello' in 'Hello World' ?\n",
    "\n",
    "# Output: True\n",
    "print(1 in y)\n",
    "\n",
    "# Output: False because we cannot identify 'a' without its key hence it is Flase.\n",
    "print('a' in y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "Here, **'`H`'** is in **`x`** but **'`hello`'** is not present in **`x`** (remember, Python is case sensitive). Similary, **`1`** is key and **'`a`'** is the value in dictionary y. Hence, **`'a'in y`** returns **`False`**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 💻 Exercises ➞ <span class='label label-default'>Operators</span>\n",
    "\n",
    "1. Declare your age as integer variable\n",
    "2. Declare your height as a float variable\n",
    "3. Declare a variable that store a complex number\n",
    "4. Write a code that prompts the user to enter base and height of the triangle and calculate an area of this triangle (area = 0.5 x b x h).\n",
    "\n",
    "```py\n",
    "    Enter base: 20\n",
    "    Enter height: 10\n",
    "    The area of the triangle is 100\n",
    "```\n",
    "\n",
    "5. Write a code that prompts the user to enter side a, side b, and side c of the triangle. Calculate the perimeter of the triangle (perimeter = a + b + c).\n",
    "\n",
    "```py\n",
    "Enter side a: 5\n",
    "Enter side b: 4\n",
    "Enter side c: 3\n",
    "The perimeter of the triangle is 12\n",
    "```\n",
    "\n",
    "6. Get length and width of a rectangle using prompt. Calculate its area (**area = length x width**) and perimeter (**perimeter = 2 x (length + width)**)\n",
    "7. Get radius of a circle using prompt. Calculate the area (**area = pi x r x r**) and circumference (**c = 2 x pi x r**) where pi = 3.14.\n",
    "8. Calculate the slope, x-intercept and y-intercept of $y = 2x -2$\n",
    "9. Slope is ($m = (y2-y1)/(x2-x1)$). Find the slope and **[Euclidean distance](https://en.wikipedia.org/wiki/Euclidean_distance#:~:text=In%20mathematics%2C%20the%20Euclidean%20distance,being%20called%20the%20Pythagorean%20distance.)** between point (2, 2) and point (6,10) \n",
    "10. Compare the slopes in tasks 8 and 9.\n",
    "11. Calculate the value of y ($y = x^2 + 6x + 9$). Try to use different x values and figure out at what x value y is going to be 0.\n",
    "12. Find the length of **`'python'`** and **`'datascience'`** and make a falsy comparison statement.\n",
    "13. Use **`and`** operator to check if **`on`** is found in both **`python`** and **`cannon`**\n",
    "14. **`I hope this course is not full of jargon`**. Use **`in`** operator to check if **`jargon`** is in the sentence.\n",
    "15. There is no **`on`** in both **`python`** and **`cannon`**\n",
    "16. Find the length of the text **`python`** and convert the value to float and convert it to string\n",
    "17. Even numbers are divisible by 2 and the remainder is zero. How do you check if a number is even or not using python?\n",
    "18. Check if the floor division of 7 by 3 is equal to the int converted value of 2.7.\n",
    "19. Check if type of **\"10\"** is equal to type of 10\n",
    "20. Check if int(**\"9.6\"**) is equal to 10\n",
    "21. Write a code that prompts the user to enter hours and rate per hour. Calculate pay of the person?\n",
    "\n",
    "```py\n",
    "Enter hours: 40\n",
    "Enter rate per hour: 30\n",
    "Your weekly earning is 1200\n",
    "```\n",
    "\n",
    "22. Write a script that prompts the user to enter number of years. Calculate the number of seconds a person can live. Assume a person can live hundred years\n",
    "\n",
    "```py\n",
    "Enter number of years you have lived: 100\n",
    "You have lived for 3153600000 seconds.\n",
    "```\n",
    "\n",
    "23. Write a Python code that displays the following table\n",
    "\n",
    "```py\n",
    "1 2 3 4 5  \n",
    "2 4 6 8 10\n",
    "3 6 9 12 15\n",
    "4 8 12 16 20\n",
    "5 10 15 20 25\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.8.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {
    "height": "276px",
    "width": "386px"
   },
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "445px",
    "left": "379px",
    "top": "159px",
    "width": "204.797px"
   },
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}