tu007-introToBasicPython.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "dff07847",
   "metadata": {},
   "source": [
    "# Introduction to basic Python variables and operators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe59c13e",
   "metadata": {},
   "source": [
    "## Learning goals\n",
    "\n",
    "* understand more details on the mechanics of coding\n",
    "* basic types of variables in Python\n",
    "* basic types of operators that can modify variables "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbad01eb",
   "metadata": {},
   "source": [
    "## Understanding the basic Python data types"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0103f956",
   "metadata": {},
   "source": [
    "In the previous tutorials, we have used code written to perform interesting operations. We loaded data, made plots, modified the plots by passing 'parameters' to 'functions', etc. This tutorial is about understanding the meaning of some of the foundamental operations in Python programming."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d7fa0e6",
   "metadata": {},
   "source": [
    "Most (if not all) programming works by assigning value to variables, and performing operations (calculations) that change the value of assigned to variables. In a certain way this is similar to what you have learned in math. For example:\n",
    "\n",
    "  - A variable say `a` is assigned a value say `3`. \n",
    "  - A function (or an operator) is used to modify the value of the variable `a`, say you might want to square the function (a square operation can be implemented as `a` *times* `a`). \n",
    "  - The result of the calculation will need to be stored in a variable different from `a`, say `b`, to be used later on, for other operations, or simply to report the results.\n",
    "  \n",
    "The above squaring operation can be streamlined as follow: \n",
    "\n",
    "  ```\n",
    "  a = 3\n",
    "  b = a*a\n",
    "  ```\n",
    "\n",
    "Logic similar to the above is often used in programming. The first operation the one using the `=` is called **variable assigment**, a value is stored in a variable for later reuse. The second line above, the one containing `*` is an example of use of an **operator**, the symbol that implements the operation of multiplying one or more variables (the operator was `*` in our case."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e02397f2",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Answer the following questions.}}$\n",
    "\n",
    "  - Copy and paste hereafter two examples of *variable assigment* from `tutorial001` and `tutorial006`: \n",
    "    - [Write example 1 here]\n",
    "    - [Write example 2 here]\n",
    "    \n",
    "    \n",
    "  - Without yet knowing much about the types of operators, can you guess which one of the options below is not an example of an *operator*?\n",
    "  \n",
    "    - A. `*`\n",
    "    - B. `/`\n",
    "    - C. `+`\n",
    "    - D. `-`\n",
    "    - E. `A`\n",
    "    \n",
    "    [Type your answer here (your option selected from above)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c26418e8",
   "metadata": {},
   "source": [
    "We have seen variable assigments (and some types of operators) in the previous tutorials. So far, we have not yet described the basic operators and variables types that `Python` offers to work with. This is precisely what we will do below."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9abd392",
   "metadata": {},
   "source": [
    "## The basic variables types in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36e7126d",
   "metadata": {},
   "source": [
    "A distinction between variables types is needed because a computer needs to decide how much memeory to store for each variable. Memory depends not so much on the value of a variable (say if a variable is 2 or 100 or 1,000), but more on the type of variable (say if a variable is text, numbers, or if numbers have decimals or not). For example, decimals (such as 1.5) will require more space to be stored on your computer memory than simpler, entire numbers (such as 1 or 2). \n",
    "\n",
    "\n",
    "Python provides four types of basic variable types. \n",
    "\n",
    "*Note* that below we will use the python function `type()` to return the, ahem, type of each variable."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6041a4e",
   "metadata": {},
   "source": [
    "### 1. Integer (int)\n",
    "\n",
    "These are used to describe variables with *whole* values, variables not requiring to store decimals. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3500be52",
   "metadata": {},
   "outputs": [],
   "source": [
    "1 + 1 # 1 is an integer and the sum of two integers is an integer\n",
    "type(1 + 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9af1cc89",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 4 # a variable can be assigned a whole number and the variable will be defined as an integer\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c09c374",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Answer the following questions.}}$\n",
    "\n",
    "  - Insert three example (not used above) of `int` numbers: [Write your three answers here 1. xx, 2. xx and 3. xx]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e831402",
   "metadata": {},
   "source": [
    "### 2. Floats\t\n",
    "\n",
    "Conversely, floats are used to store variables and values that do need decimals to represent them. \n",
    "\n",
    "*Note.* If you are interested to learn more about Floating Point numbers (Floats) Wikipedia has a nice Article about it: [Floating Point Arithmetic](https://en.wikipedia.org/wiki/Floating-point_arithmetic)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "980c4666",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = 2.1\n",
    "type(c)   "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6c84675",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Answer the following questions.}}$\n",
    "\n",
    "  - Insert three example (not used above) of `float` numbers: [Write your three answers here 1. xx, 2. xx and 3. xx]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "923404b3",
   "metadata": {},
   "source": [
    "### 3. Complex\n",
    "\n",
    "Complex data types store values such as the [complex numbers](https://en.wikipedia.org/wiki/Complex_number) in Math. \n",
    "\n",
    "*Note.* We will not use these variables in our tutorials, and if you have never encountered complex numbers before, you should nto feel obliged to learn about them now. yet, chances are you might encoutner complex numbers if you were to become a serious data scientists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "34b7692d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "complex"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 1.5 + 0.5j\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "590e004e",
   "metadata": {},
   "source": [
    "*note* `j` is an existing variable in Python, preconfigures to serve the purpuse of allowing creating complex datatypes. The variable represents the [imaginary unit](https://en.wikipedia.org/wiki/Imaginary_unit).\n",
    "\n",
    "The value of a complex variable comprises of a `real` and `imag` (short for imaginary) component. We can query the components using the `.` operator to index the component of the variable value we wish to recall:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "152ebb17",
   "metadata": {},
   "outputs": [],
   "source": [
    "a.real # this is the real part of `a`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2cfbd8a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "a.imag # this is the imaginary part of `a`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1960bdd7",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Answer the following questions.}}$\n",
    "\n",
    "  - Insert three example (not used above) of `complex` numbers: [Write your three answers here 1. xx, 2. xx and 3. xx]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6065787",
   "metadata": {},
   "source": [
    "### Python will change your type!\n",
    "\n",
    "Python is a dynamically typed language. Dynamically-typed means that we can define a variable, assign a value to it and we can then change the datatype associated with a variable. There are several built-in datatypes that are good to be aware of. This is good thing for us starting to work with the programming language because it makes the language less strict, easier to learn, although perhaps also more prone to potential mistakes and bugs. This is perhaps also one of the reasons why Python is so famous in data science and scientific programming. \n",
    "\n",
    "When using a dynamically-typed language we need to be aware of it because it will be possible to combine some variables safely but not others. If two (or more) variables have the same type (i.e., they are both integer, floats or imaginary) they can be combined safely and their combination will maintain the original type. If two (or more) variables are not the same type, combining them will change the type of the variable to the *more complex one*. \n",
    "\n",
    "Complexity here is a vague but easy-to-remmeber term. Variabless are stored differently on your computer, some need less memeory than others. `Integers` need less memory to be represented than `Floats` and `Complex` need more memory then either of them. Python is smart (i.e., dynamically typed) so it can make an educated guess to how to combine into an output numerical variables of different type, yet, in doing so it will need to change the type of the output variables. The simplest type will be dropped and the more complex, or memory greedy type will be returned as the type of the output.\n",
    "\n",
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2cc728e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1.5 + 0.5j # a is a complex type variable\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "14322e79",
   "metadata": {},
   "outputs": [],
   "source": [
    "b = 2 # b is defined as an integer type variable\n",
    "type(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b2b87ff9",
   "metadata": {},
   "outputs": [],
   "source": [
    "c = a + b # a is a complex type variable (the more complex type takes over)\n",
    "type(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c5a818b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1.5 # a is a Float\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "91a324ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "b = 2 # b is an int\n",
    "type(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d6a0ac80",
   "metadata": {},
   "outputs": [],
   "source": [
    "c = a + b  # c is a Float (the more complex type takes over)\n",
    "type(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "485711ae",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Answer the following questions.}}$\n",
    "\n",
    "  - Write an example of a `float` variable added to an `int` variable. Specify each variable name and show the type for each variable, as well as for the output variable. Write the code in the cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "83c9c000",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "a4cf2e76",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Answer the following questions.}}$\n",
    "\n",
    "  - Write an example of a `float` variable added to an `complex` variable. Specify each variable name and show the type for each variable, as well as for the output variable. Write the code in the cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3b20f5c7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "a176ebfa",
   "metadata": {},
   "source": [
    "### 4. Booleans\n",
    "\n",
    "In addition to numerical variables, Python can also represent other types of variables. Logical variables are stored in a dedicated (memory efficient) data type, called `bool` (short for [boolean](https://en.wikipedia.org/wiki/Boolean_data_type)). \n",
    "\n",
    "`Bool`eans can take only one of two possible values `True` or `False`. Using boolean variables can make your code fast and efficient. But that is something you will worry about only in the future. For the moment, let's see how `bool` can be defined in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "17a2616d",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = True\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "20f503c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "b = False\n",
    "type(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6976725",
   "metadata": {},
   "source": [
    "*Note* `True` and `False` are not just words, but proper Python commands and must have an **Upper Case** first letter. Using a lowercase true returns an error.  Actually, under the Python-hood, `True` and `False`, are defined as special versions of the `int` `1` (`True`) and `0` (`False`). This is helpful to know because `True` and `False` behave as such in arithmetic contexts."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0677c4e4",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Answer the following questions.}}$\n",
    "\n",
    "  - What happens if you define a new variable `a` using the word `false` (without uppercase)? [Describe the result here using your own words.]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbe9b58c",
   "metadata": {},
   "source": [
    "A `bool` variable can be also created by requesting a logical operation, for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c465b326",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 3 > 4\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a84cfdf4",
   "metadata": {},
   "source": [
    "Whereas the type of `a` is `bool`, its value is `False`, because `3` is not greater than `4`. Below we use the python function `print()` to return (print on screen) the content of the variable `a`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "86916e04",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ba5b47a",
   "metadata": {},
   "source": [
    "The next example will create a logical (`bool`) variable with value set to `True`, this is because the result of the operation is actually true, `3` is less or equal than `3`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c3b5da18",
   "metadata": {},
   "outputs": [],
   "source": [
    "b = 3 <= 3\n",
    "type(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ac9ced9b",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e99beaf",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Answer the following questions.}}$\n",
    "\n",
    "  - What happens if you define a two variables `a` which is `bool` and `b` which is `int` and attempt to add them together? [Use the following cell to write code to implement the situation describe here.]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7faaa8cb",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "6ecd3290",
   "metadata": {},
   "source": [
    "[Describe here, using your own words what happened above and why it happened.]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3dcdc18b",
   "metadata": {},
   "source": [
    "### 5. Strings\n",
    "\n",
    "Text is used very often in programming. Words might be needed to be dsiplayed say on top of a plot as a title or next to the axes of the plot. Text has a dedicated variable type in Python: `str` (short for string)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "978e9ce4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 'hello'\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85174c48",
   "metadata": {},
   "source": [
    "Space is a character in Python (just like in a terminal!, oh my gosh thank you python)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "6df16063",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = ' '\n",
    "type(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6de27d2c",
   "metadata": {},
   "source": [
    "String can be combined in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "3799930c",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'b' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/ym/g0t45zsx6kj122mw2d8vf7zm0000gq/T/ipykernel_34916/2882753126.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mc\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mb\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'world!'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'b' is not defined"
     ]
    }
   ],
   "source": [
    "c = a + b + 'world!'\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1cf64d29",
   "metadata": {},
   "source": [
    "String variables can span multiple lines (this is because python recognizes the return character). To write a variablel spanning multiple lines you will need to act creative with the use of quotation marks *' '*. You can use triple quotes `''' '''` to write a string that spans multiple lines:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b46aaf7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = '''Hello World,\n",
    "How are you?\n",
    "Marvelous!''' \n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "011890ec",
   "metadata": {},
   "source": [
    "### 6. NoneType\n",
    "\n",
    "Python has another quirky variable type that is seldom used (or at least I seldom used it). The `NoneType`, this type stores a variable that does not have a specified type from the ones described above determined. A `NoneType` variable is defined by assign to it the value `None` (upper case), which is also a proprietary word in Python, just like `False` and `True`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36376932",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = None\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "417c0752",
   "metadata": {},
   "source": [
    "The value of a `NoneType` variable is `None`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1de0cbf8",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28f42b60",
   "metadata": {},
   "source": [
    "## Basic math, strings and logic operators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea5555d1",
   "metadata": {},
   "source": [
    "### Math Operators\n",
    "\n",
    "Math operators implement basic forms of, ahem, operations with numbers. The operators allow to add numbers, multiply and divide them, suctract then\n",
    "\n",
    "The table below (adapted from [here](https://www.tutorialspoint.com/python/python_basic_operators.htm)) provides an overview of the foundamental Python math opertors.\n",
    "\n",
    "| Operator | Description | Example |\n",
    "| --- | --- | --- |\n",
    "| `+` Addition |\tAdds values on either side of the operator.\t| `a + b = 30` |\n",
    "| `-` Subtraction\t| Subtracts right hand operand from left hand operand. | `a – b = -10` |\n",
    "| `*` Multiplication\t| Multiplies values on either side of the operator |\t`a * b = 200` |\n",
    "| `/` Division\t| Divides left hand operand by right hand operand |\t`b / a = 2` |\n",
    "| `%` Modulus\t| Divides left hand operand by right hand operand and returns remainder\t| `b % a = 0` | \n",
    "| `**` | Exponentiation. It implements exponentials, power calculation on operators\t| `a**b =10` to the power `20` |\n",
    "| `//` Floor Division | The division of operands where the result is the quotient in which the digits after the decimal point are removed. But if one of the operands is negative, the result is floored, i.e., rounded away from zero (towards negative infinity) |\t9//2 = 4 and 9.0//2.0 = 4.0, -11//3 = -4, -11.0//3 = -4.0 |"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6abada9d",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Answer the following questions.}}$\n",
    "\n",
    "  - What is the cube of 3.33? [Return you answers in the below]\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "495322ca",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b2fec2f2",
   "metadata": {},
   "source": [
    "  - Write code to perform the sum of `a = 3` and `b = 5.51` multiplied by `65.1233`? [Return you answers in the below]\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "958e1f88",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "e5a58a3c",
   "metadata": {},
   "source": [
    "### Logical Operators\n",
    "\n",
    "Logical operators perform logical comparisons between variables and return a `Bool` valued output variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "59658328",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "8aac3022",
   "metadata": {},
   "source": [
    "| Operator\t| Description\t| Example |\n",
    "| --- | --- | --- | \n",
    "| ==\t| If the values of two operands are equal, then the condition becomes true.\t| (a == b) is not true. |\n",
    "| !=\t| If values of two operands are not equal, then condition becomes true.\t| (a != b) is true. |\n",
    "| <>\t| If values of two operands are not equal, then condition becomes true.\t| (a <> b) is true. This is similar to  != operator. |\n",
    "| >\t| If the value of left operand is greater than the value of right operand, then condition becomes true.\t| (a > b) is not true. |\n",
    "| <\t| If the value of left operand is less than the value of right operand, then condition becomes true.\t| (a < b) is true. |\n",
    "| >=\t| If the value of left operand is greater than or equal to the value of right operand, then condition becomes true.\t| (a >= b) is not true. |\n",
    "| <=\t| If the value of left operand is less than or equal to the value of right operand, then condition becomes true. |\t(a <= b) is true. |\n",
    "AD"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b854e681",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Answer the following questions.}}$\n",
    "\n",
    "  - Compare 3.33333 and 5.55, which one is bigger? [Return you answers in the cell below]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8061a25a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "79777920",
   "metadata": {},
   "source": [
    "  - Is it true that 3.33333 and 5.55 are not equal? [Return you answers in the cell below]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6621a83b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f77e7d22",
   "metadata": {},
   "source": [
    "*Additional reading* [This is](https://www.tutorialspoint.com/python/python_basic_operators.htm) an exhaustive tutorial covering more types of operators in python. "
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}