05-Operators.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"images/logo.jpg\" width=\"150\" alt=\"EPYTHON LAB logo\"  />\n",
    "</center>\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"expressions\" align='center'>Operators and Expression in Python</h2>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>In Python, operators are special symbols that designate that some sort of computation should be performed.\n",
    "    The values that an operator acts on are called <strong>operands</strong>.</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<strong>Operators</strong> are the constructs which can manipulate the value of <strong>operands</strong>.\n",
    "<h2 id=\"expression\"> Expressions </h2> \n",
    "<p>Expressions in Python can include operations among compatible types (e.g., integers and floats). For example, basic arithmetic operations like adding multiple numbers:</p>\n",
    "\n",
    "Consider the expression <code> 4 + 5 = 9 </code>. Here, <code>4 and 5</code> are called <strong>operands</strong> and <code>+</code> is called <strong>operator</strong>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"operator\"> Types of Operator </h2>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python language supports the following types of operators.\n",
    "- Arithmetic Operators\n",
    "- Comparison (Relational) Operators\n",
    "- Assignment Operators\n",
    "- Logical Operators\n",
    "- Membership Operators\n",
    "- Identity Operators\n",
    "- Bitwise Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"arithmentic\">Arithmetic Operators</h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    " <table id=\"operators\">\n",
    "     <th>Operator </th>\n",
    "      <th>Description </th>\n",
    "      <th>Example </th>\n",
    "     <tr> \n",
    "         <td>+ Addition</td>\n",
    "         <td>Adds values on either side of the operator.</td>\n",
    "         <td> x + y </td>\n",
    "     </tr>\n",
    "      <tr> \n",
    "         <td>- Subtraction</td>\n",
    "         <td>Subtracts right hand operand from left hand operand.</td>\n",
    "         <td> x - y </td>\n",
    "     </tr>\n",
    "      <tr> \n",
    "         <td>* Multiplication</td>\n",
    "         <td>Multiplies values on either side of the operator.</td>\n",
    "         <td> x * y </td>\n",
    "     </tr>\n",
    "      <tr> \n",
    "         <td>/ Division</td>\n",
    "         <td>Divides left hand operand by right hand operand.</td>\n",
    "          <td> x / y\n",
    "              The result always has type <code>float</code>.</td>\n",
    "     </tr>\n",
    "      <tr> \n",
    "         <td>% Modulus</td>\n",
    "         <td>Divides left hand operand by right hand operand and returns remainder.</td>\n",
    "         <td> x % y</td>\n",
    "     </tr>\n",
    "      <tr> \n",
    "         <td>** Exponent</td>\n",
    "         <td>Performs exponential (power) calculation on operators.</td>\n",
    "         <td> x ** y, x to the power y </td>\n",
    "     </tr>\n",
    "     <tr> \n",
    "         <td>// Floor Division (also called Integer Division)</td>\n",
    "         <td>Quotient when x is divided by y, rounded to the next smallest whole number.</td>\n",
    "         <td> x // y, 9//2 = 4 and 9.0//2.0 = 4.0, -11//3 = -4, -11.0//3 = -4.0</td>\n",
    "     </tr>\n",
    "    </table>\n",
    "    <center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6666666666666666\n",
      "0\n",
      "6\n",
      "2\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "# Examples here..\n",
    "x = 2\n",
    "y = 3\n",
    "print(x/y) # Float type\n",
    "print(x//y) # int type\n",
    "print(x*y)\n",
    "print(x%y)\n",
    "print(x**y) # ^"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"comparison\">Comparison Operators</h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    " <table id=\"operators\">\n",
    "     <th>Operator </th>\n",
    "      <th>Description </th>\n",
    "      <th>Example </th>\n",
    "     <tr> \n",
    "         <td>==</td>\n",
    "         <td>The condition becomes True If the values of two operands are equal. False otherwise.</td>\n",
    "         <td> x == y</td>\n",
    "     </tr>\n",
    "      <tr> \n",
    "         <td>!=</td>\n",
    "         <td>The condition becomes True If values of two operands are not equal. False otherwise.</td>\n",
    "         <td> x != y</td>\n",
    "     </tr>\n",
    "      <tr> \n",
    "          <td> <> </td>\n",
    "         <td>The condition becomes True If values of two operands are not equal.False otherwise.</td>\n",
    "         <td> x <> y. This is similar to !=</td>\n",
    "     </tr>\n",
    "      <tr> \n",
    "         <td>></td>\n",
    "         <td> The conditin becomes True If the value of left operand is greater than the value of right operand. False otherwise.</td>\n",
    "          <td> x > y  </td>\n",
    "     </tr>\n",
    "      <tr> \n",
    "         <td>< </td>\n",
    "         <td>The condition becomes True If the value of left operand is less than the value of right operand. False otherwise</td>\n",
    "         <td> x < y </td>\n",
    "     </tr>\n",
    "      <tr> \n",
    "         <td>>=</td>\n",
    "         <td>The condition becomes True If the value of left operand is greater than or equal to the value of right operand. False otherwise.</td>\n",
    "         <td> x >= y</td>\n",
    "     </tr>\n",
    "     <tr> \n",
    "         <td> <span>&#8804;</span> </td>\n",
    "         <td>The condition becomes True If the value of left operand is less than or equal to the value of right operand. False otherwise.</td>\n",
    "         <td> x<span>&#8804;</span>y </td>\n",
    "     </tr>\n",
    "    </table>\n",
    "    <center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "12\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Examples here...\n",
    "x = 3\n",
    "y = 6\n",
    "z = x+y\n",
    "print(x)\n",
    "print(z)\n",
    "x==z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"assignment\">Assignment Operators</h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    " <table id=\"operators\">\n",
    "     <th>Operator </th>\n",
    "      <th>Description </th>\n",
    "      <th>Example </th>\n",
    "     <tr> \n",
    "         <td>= Assignment</td>\n",
    "         <td>Assigns values from right side operands to left side operand.</td>\n",
    "         <td> z = x + y, assigns value of x+y into z</td>\n",
    "     </tr>\n",
    "      <tr> \n",
    "         <td>+= Add AND</td>\n",
    "         <td>It adds right operand to the left operand and assign the result to left operand.</td>\n",
    "         <td> z += x is equavalent to z = z+x</td>\n",
    "     </tr>\n",
    "      <tr> \n",
    "          <td> -= Subtract AND </td>\n",
    "         <td>It subtracts right operand from the left operand and assign the result to left operand.</td>\n",
    "         <td> z -= x is equavalent to z = z-x.</td>\n",
    "     </tr>\n",
    "      <tr> \n",
    "         <td>*= Multiply AND</td>\n",
    "         <td>It multiplies right operand with the left operand and assign the result to left operand.</td>\n",
    "          <td> z *= x is equavalent to z = z*x </td>\n",
    "     </tr>\n",
    "      <tr> \n",
    "         <td>/= Divide AND </td>\n",
    "         <td>It divides left operand with the right operand and assign the result to left operand.</td>\n",
    "         <td> z /= x is equavalent to z = z/x</td>\n",
    "     </tr>\n",
    "      <tr> \n",
    "         <td>%= Modulus AND</td>\n",
    "         <td>It takes modulus using two operands and assign the result to left operand.</td>\n",
    "         <td> z %= x is equavalent to z = z%y</td>\n",
    "     </tr>\n",
    "     <tr> \n",
    "         <td>**= Exponent AND</td>\n",
    "         <td>Performs exponential (power) calculation on operators and assign value to the left operand.</td>\n",
    "         <td> z **= x is equavalent to z = z**x</td>\n",
    "     </tr>\n",
    "     <tr> \n",
    "         <td>//= Floor Division</td>\n",
    "         <td>It performs floor division on operators and assign value to the left operand.</td>\n",
    "         <td> z //= x is equavalent to z = z//x</td>\n",
    "     </tr>\n",
    "    </table>\n",
    "    <center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Examples here\n",
    "x = 8\n",
    "\n",
    "x += 4 # x = x+4\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"logical\">Logical Operators</h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    " <table id=\"operators\">\n",
    "     <th>Operator </th>\n",
    "      <th>Description </th>\n",
    "      <th>Example </th>\n",
    "     <tr> \n",
    "         <td>not</td>\n",
    "         <td>True if x is False. False if x is True. (Logically reverses the sense of x).</td>\n",
    "         <td> not x</td>\n",
    "     </tr>\n",
    "      <tr> \n",
    "         <td>or</td>\n",
    "         <td>True if either x or y is True. False otherwise.</td>\n",
    "         <td> x or y</td>\n",
    "     </tr>\n",
    "      <tr> \n",
    "          <td> and </td>\n",
    "         <td>True if both x and y are True. False otherwise.</td>\n",
    "         <td> x and y</td>\n",
    "     </tr>\n",
    "    </table>\n",
    "    <center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Examples here\n",
    "x = True\n",
    "y = True\n",
    "not x or y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"member\">Membership Operators</h2>\n",
    "<p>Python’s membership operators test for membership in a sequence, such as <code>strings, lists, or tuples</code>. There are two membership operators as explained below</p> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    " <table id=\"operators\">\n",
    "     <th>Operator </th>\n",
    "      <th>Description </th>\n",
    "      <th>Example </th>\n",
    "     <tr> \n",
    "         <td>in</td>\n",
    "         <td>Evaluates to true if it finds a variable in the specified sequence and false otherwise.</td>\n",
    "         <td> x in y, here in results <strong>in</strong> a 1 if x is a member of sequence y.</td>\n",
    "     </tr>\n",
    "      <tr> \n",
    "          <td> not in </td>\n",
    "         <td>Evaluates to true if it does not finds a variable in the specified sequence and false otherwise.</td>\n",
    "          <td> x not in y, here <strong>not in</strong> results in a 1 if x is not a member of sequence y.</td>\n",
    "     </tr>\n",
    "    </table>\n",
    "    <center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Examples here\n",
    "x = \"Hello Python\"\n",
    "y = \"P\"\n",
    "y in x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"identity\">Identity Operators</h2>\n",
    "<p>Identity operators compare the memory locations of two objects. There are two Identity operators explained below</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    " <table id=\"operators\">\n",
    "     <th>Operator </th>\n",
    "      <th>Description </th>\n",
    "      <th>Example </th>\n",
    "     <tr> \n",
    "         <td>is</td>\n",
    "         <td>Evaluates to true if the variables on either side of the operator point to the same object and false otherwise.</td>\n",
    "         <td> x is y, here <strong>is</strong> results in 1 if id(x) equals id(y).</td>\n",
    "     </tr>\n",
    "      <tr> \n",
    "         <td>is not</td>\n",
    "         <td>Evaluates to false if the variables on either side of the operator point to the same object and true otherwise.</td>\n",
    "         <td> x is not y, here <strong>is not</strong> results in 1 if id(x) is not equal to id(y).</td>\n",
    "     </tr>\n",
    "    </table>\n",
    "    <center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "140210985835088\n",
      "140210885993616\n",
      "False\n",
      "True\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "y = 10.0\n",
    "print(id(x))\n",
    "print(id(y))\n",
    "print(x is y)\n",
    "print(x is not y)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2+3*3-2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"ass\">Reading Assignment</h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Read about:\n",
    "- Bitwise Operators\n",
    "- Operators Preceedence\n",
    "- Expressions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "*Copyright &copy; 2021 EPYTHON LAB.  All rights reserved.*"
   ]
  }
 ],
 "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.10.8"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}