chukwuezi.tochukwu-day01-report.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "view-in-github"
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/ai-technipreneurs/python_course_colab_notebooks/blob/main/01_Lecture01.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qFDWHzbWaKv5"
   },
   "source": [
    "<center>\n",
    "    <a href=\"https://aims-senegal.org/\" ><img src=\"images/logoaimssn.jpeg\" style=\"float:left; max-width: 650px; display: inline\" alt=\"AIMS-SN\"/> </a>\n",
    "    </center>\n",
    "\n",
    "\n",
    "\n",
    "<center>\n",
    "    \n",
    "<a href=\"https://acas-yde.org/\" ><img src=\"images/logo-ACAS.jpg\" style=\"float:right; max-width: 250px; display: inline\" alt=\"ACAS\"/></a>\n",
    "    \n",
    "</center>\n",
    "\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "su9mwz_3aKv9"
   },
   "source": [
    "****\n",
    "\n",
    "# <center> <b> <span style=\"color:orange;\"> Python Proficiency for Scientific Computing and Data Science (PyPro-SCiDaS)  </span> </b></center>\n",
    "\n",
    "### <center> <b> <span style=\"color:green;\">An Initiation to Programming using Python (Init2Py) </span> </b></center>\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "j6o1HRQbaKv-"
   },
   "source": [
    "\n",
    "****\n",
    "\n",
    "# <center> <b> <span style=\"color:blue;\">Lecture 1: Variables and assignments </span> </b></center>\n",
    "\n",
    "\n",
    "<!--NAVIGATION-->\n",
    "< [0. Introduction](00.introduction_to_python.ipynb) | [ToC](Index.ipynb) | [2. Strings & Files](02-Strings.ipynb) >\n",
    "\n",
    "\n",
    "****\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-niAFUQWaKv_"
   },
   "source": [
    "\n",
    "### <left> <b> <span style=\"color:brown;\">Instructeur : </span> </b></left>[Yaé Ulrich Gaba](https://github.com/gabayae)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    ">    **Summary:** As soon as we have *data types*, we need *variables* to store the data. In reality, Python does not offer the concept of a variable, but rather that of an *object reference*. As long as the object is immutable (like integers, floats, etc.), there is no significant difference. In this notebook, we discuss the main points surrounding the use of variables in Python.\n",
    "\n",
    "****"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "W5ah9nfiaKv_"
   },
   "source": [
    "## 0. Introduction\n",
    "\n",
    "In Python, a variable is a fundamental programming construct that facilitates the storage and management of information in the computer's memory. It is assigned a symbolic name, which serves as a reference to the data stored at a particular location in memory. This symbolic name enables you to access and modify the stored information throughout your code with ease.\n",
    "\n",
    "Variables in Python are defined using the assignment operator =. You can assign a value to a variable directly or assign the value from another variable, making Python flexible in how it handles data. Rather than containing the data themselves, variables in Python act as references to objects in memory. This reference-based approach allows for efficient memory management and provides the flexibility to interact with and modify the data dynamically.\n",
    "\n",
    "Python's dynamic typing system means that variables can be reassigned to different types of data during program execution. This dynamic nature, combined with the reference model, enhances the language's capability to handle various data types and operations seamlessly. Additionally, Python's garbage collection system manages memory allocation and deallocation, further optimizing performance and resource utilization."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IPSQvNuKaKwA"
   },
   "source": [
    "## 1. Define variable\n",
    "\n",
    "In Python, there are four fundamental ways to define a variable, each suited to different purposes and contexts:\n",
    "\n",
    "1. **Direct Assignment**: This is the most straightforward method where a variable is assigned a specific value directly. This method is used for initializing variables with known values that will be used later in the code.\n",
    "\n",
    "\n",
    "2. **Multiple Assignment**: This technique allows you to assign the same value to multiple variables simultaneously. It is useful for initializing several variables with the same value efficiently.\n",
    "\n",
    "3. **Parallel Assignment**: This method involves defining multiple variables in a single statement with different values. It is effective for initializing several variables at once with distinct values.\n",
    "\n",
    "\n",
    "4. **Assignment from Expressions**: Variables can be defined based on expressions involving other variables. This method allows you to create variables that represent calculations or transformations of existing variables.\n",
    "\n",
    "\n",
    "Each of these methods provides flexibility in how you manage and utilize variables in your code, catering to different scenarios and requirements.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mlRNSu59aKwB"
   },
   "source": [
    "### 1.0. Through direct assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "O4gNkF8yaKwB"
   },
   "source": [
    "\n",
    "```python\n",
    "y = 4.8134  # Defines a variable named y and assigns it the value 4.8134\n",
    "salutation = \"How are you ?\"  # Defines a variable named salutation and assigns it the value \"How are\"\n",
    "```\n",
    "\n",
    "This code snippet illustrates the process of creating variables in Python by assigning them specific values. The variable `y` is assigned a floating-point number, while the variable `salutation` is assigned a string value. In Python, this assignment operation creates a reference between the variable name and the data, allowing you to reuse and manipulate the data through the variable name in subsequent parts of your code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "wAyfy4PYaKwB"
   },
   "outputs": [],
   "source": [
    "# y = 4.8134  # Defines a variable named y and assigns it the value 4.8134\n",
    "salutation = \"How are you?\"  # Defines a variable named salutation and assigns it the value \"How are you?\"\n",
    "x = 56"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rRp46-X6aKwD"
   },
   "source": [
    "To display the values of the three defined variables, we use the `print()` function—a function that we will discuss in more detail when we cover function objects in Python. The `print()` function is essential in Python for outputting data to the console, allowing you to see the current state of your variables and debug your code effectively. This function can take multiple arguments, meaning you can print several variables at once, and it automatically converts them to their string representation if necessary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "I9vsTYT_aKwD"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "56\n",
      "4.8134\n",
      "How are you?\n"
     ]
    }
   ],
   "source": [
    "print(x)\n",
    "print(y)\n",
    "print(salutation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "44fpkTzLaKwD"
   },
   "source": [
    "To display the three values on the same line, you use a single `print()` function, separating the variables with commas. The commas in the print() function automatically insert spaces between the values, making it easy to format your output in a readable manner. This approach allows you to output multiple pieces of data in a single line without needing to manually concatenate strings or add spaces."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "tX3HgnGOaKwD"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "56 4.8134 How are you?\n"
     ]
    }
   ],
   "source": [
    "print(x,y,salutation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "N5yEvfC5aKwD"
   },
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AG1wn19XaKwD"
   },
   "source": [
    "### 1.1. Through multiple assignment\n",
    "\n",
    "The examples presented fall under what we call `direct assignment`. A `multiple assignment` is a specific case of `direct assignment` where the same value is assigned to multiple variables in a single line of code. This technique is useful when you need to initialize several variables with the same starting value efficiently, keeping your code concise and readable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "o4S7T3z6aKwE"
   },
   "source": [
    "\n",
    "```python\n",
    "x = y = 7  # x and y are both assigned the value 7 simultaneously.\n",
    "```\n",
    "\n",
    "In this line of code, the variables `x` and `y` are assigned the same value of $7$ at the same time. This is an example of a `multiple assignment`, where a single value is efficiently assigned to multiple variables in one statement. This technique is particularly useful when initializing variables with the same initial value, ensuring consistency across your code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "PK_4rtfbaKwE"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "=======================\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "x = y = 7  # x and y are both assigned the value 7 simultaneously.\n",
    "print(x)\n",
    "print(\"=======================\")\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "NoUAagntaKwE"
   },
   "source": [
    "### 1.2. Parallel assignment\n",
    "\n",
    "\n",
    "\n",
    "A `parallel assignment` involves defining multiple variables using a single equals sign. This technique allows you to assign different values to several variables simultaneously in a single line of code. It enhances code readability and efficiency, especially when you need to initialize multiple variables at once. Example:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "h72adqrCaKwE"
   },
   "source": [
    "\n",
    "```python\n",
    "x, y = 4, 8.33  # Defines two variables, x and y, with values 4 and 8.33 respectively.\n",
    "```\n",
    "\n",
    "In this line of code, `x` is assigned the value 4, and `y` is assigned the value 8.33 simultaneously. This is an example of `parallel assignment`, where multiple variables are defined in a single statement. This approach is particularly useful for initializing or updating several variables in a concise and organized manner."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "Aqm_0FFNaKwF"
   },
   "outputs": [],
   "source": [
    "x, y = 4, 8.33  # Defines two variables, x and y, with values 4 and 8.33 respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 8.33\n"
     ]
    }
   ],
   "source": [
    "print(x,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KdBzKTgGaKwG"
   },
   "source": [
    "### 1.3. Based on other variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "LVpvGqT7aKwG"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12.33 9 16.66\n"
     ]
    }
   ],
   "source": [
    "#Define a variable based on other variables\n",
    "z1 = x + y  # Defines the variable named z1 and assigns it the sum of variables x and y\n",
    "z2 = x + 5  # Defines the variable named z2 by adding 5 to the value of x\n",
    "z3 = 2 * y  # Defines the variable named z3 by multiplying the value of y by 2\n",
    "\n",
    "print(z1,z2,z3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "eb8yyX7YaKwG"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XTpvb2JBaKwG"
   },
   "source": [
    "<left> <b> <span style=\"color:red;\">Assignment is not comparison!</span> </b></left>\n",
    "It is important to note that the assignment operator `=` does not have the same meaning as the equality symbol `=` in mathematics. For example, the assignment operator is not symmetric, while the equality symbol is: attempting to swap the order of elements in an assignment statement will inevitably result in an error in the interpreter:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "LCSIQtWXaKwG"
   },
   "outputs": [],
   "source": [
    "# Error\n",
    "128 = a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "q0ekTChtaKwH"
   },
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xwIuuQyLaKwH"
   },
   "source": [
    "This brings us to briefly discuss permissible variable names in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mB71wQxYaKwH"
   },
   "source": [
    "#### <left> <b> <span style=\"color:brown;\">Naming Conventions</span> </b></left>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KzaWniImaKwH"
   },
   "source": [
    "Naming conventions for different elements of code are important because they provide additional information to developers about the nature of certain attributes or variables. The conventions for variable names are as follows:\n",
    "\n",
    "   - Reserved keywords such as `if`, `else`, etc., cannot be used as variable names.\n",
    "   - Variable names can start with `_`, `$`, or a letter.\n",
    "   - Variable names can be in lowercase or uppercase.\n",
    "   - Variable names cannot start with a digit.\n",
    "   - White spaces are not allowed in variable names.\n",
    "\n",
    "<left> <b> <span style=\"color:brown;\"> A good programmer naturally strives to choose the most meaningful variable names possible. </span> </b></left>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zsJ0IfnEaKwH"
   },
   "source": [
    "In Python, there are **33** reserved keywords, and the list is provided below:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "X3D7heJWaKwH"
   },
   "source": [
    "|             |                  |                  |                  |                  |\n",
    "|-------------|------------------|------------------|------------------|------------------|\n",
    "|``and``      | ``elif``         | ``if``           | ``or``           | ``yield``        |\n",
    "|``as``       | ``else``         | ``import``       | ``pass``         |                  |\n",
    "|``assert``   | ``except``       | ``in``           | ``raise``        |                  |  \n",
    "|``break``    | ``False``        | ``is``           | ``return``       |                  |\n",
    "|``class``    | ``finally``      | ``lambda``       | ``True``         |                  |\n",
    "|``continue`` | ``for``          | ``None``         | ``try``          |                  |\n",
    "|``def``      | ``from``         | ``nonlocal``     | ``while``        |                  |\n",
    "|``del``      | ``global``       | ``not``          | ``with``         |                  |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IhHyNR3DaKwH"
   },
   "source": [
    "To get the list of reserved keywords in Python, you can use the `keyword` module. Here’s how you can do it:\n",
    "\n",
    "1. **Import the `keyword` module**:\n",
    "   ```python\n",
    "   import keyword\n",
    "   ```\n",
    "\n",
    "2. **Use the `keyword.kwlist` attribute to get the list of keywords**:\n",
    "   ```python\n",
    "   print(keyword.kwlist)\n",
    "   ```\n",
    "\n",
    "3. **To check if a specific word is a keyword**:\n",
    "   ```python\n",
    "   print(keyword.iskeyword('if'))  # Returns True\n",
    "   print(keyword.iskeyword('my_var'))  # Returns False\n",
    "   ```\n",
    "\n",
    "The `keyword.kwlist` attribute returns a list of all reserved keywords in Python, and the `keyword.iskeyword()` function checks if a given string is a keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "id": "GZ-AARhIaKwH"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']\n",
      "35\n"
     ]
    }
   ],
   "source": [
    "import keyword\n",
    "print(keyword.kwlist)\n",
    "print(len(keyword.kwlist))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "7zZk02AxaKwI"
   },
   "outputs": [],
   "source": [
    "print(keyword.iskeyword('if'))  # Returns True\n",
    "print(keyword.iskeyword('my_var'))  # Returns False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SO1uqblaaKwI"
   },
   "source": [
    "**Note**: Python is case-sensitive, so variable names `Age` and `age` are considered distinct. Depending on the language, there is a [naming convention](https://en.wikipedia.org/wiki/Naming_convention_(programming)#Python_and_Ruby) that is recommended:\n",
    "\n",
    "- `UpperCamelCase` for class names;\n",
    "\n",
    "- `CAPITALIZED_WITH_UNDERSCORES` for constants;\n",
    "\n",
    "- `lowercase_separated_by_underscores` or `snake_case` for other variables.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BIhPee9jaKwI"
   },
   "source": [
    "****\n",
    "**A Fundamental Exercise: Swapping the Contents of Two Variables**\n",
    "\n",
    "> Let's assume that the variables `x` and `y` have the values of integers $\\alpha$ and $\\beta$ respectively. The goal is to swap the contents of these two variables.\n",
    "\n",
    ">   - a. First Method: Propose a method that uses an auxiliary variable `tmp`.\n",
    "       ```python\n",
    "          tmp = x\n",
    "          x = y\n",
    "          y = tmp\n",
    "       ```\n",
    ">   - b. Second Method: Execute the following sequence of instructions:\n",
    "       ```python\n",
    "          x = x + y; y = x - y; x = x - y  \n",
    "       ```\n",
    "       \n",
    ">   - c. Third Method (the most \"Pythonic\"): Use parallel assignment.\n",
    "      ```python\n",
    "         x, y = y, x\n",
    "      ```   \n",
    "****\n",
    "\n",
    "Example:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "id": "8yWMWbhqaKwI"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 4\n",
      "================================================\n",
      "\t\n",
      "4 5\n",
      "7 9\n",
      "================================================\n",
      "\t\n",
      "9 7\n",
      "90 15\n",
      "================================================\n",
      "\t\n",
      "15 90\n"
     ]
    }
   ],
   "source": [
    "# First Method\n",
    "\n",
    "x = 5\n",
    "y = 4\n",
    "print(x, y)\n",
    "print(\"================================================\")\n",
    "print('\\t')\n",
    "\n",
    "tmp = x\n",
    "x = y\n",
    "y = tmp\n",
    "print(x, y)\n",
    "\n",
    "# Second Method\n",
    "\n",
    "x = 7\n",
    "y = 9\n",
    "print(x, y)\n",
    "print(\"================================================\")\n",
    "print('\\t')\n",
    "\n",
    "x = x + y; y = x - y; x = x - y\n",
    "print(x, y)\n",
    "\n",
    "# Third Method\n",
    "\n",
    "x = 90\n",
    "y = 15\n",
    "print(x, y)\n",
    "print(\"================================================\")\n",
    "print('\\t')\n",
    "\n",
    "x, y = y, x\n",
    "print(x, y)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zZB9CoyCaKwJ"
   },
   "source": [
    "It's worth noting that to delete a variable in Python, you can use the `del` function. This function removes the variable from the current namespace, effectively deleting it and freeing up any resources it was using. For example:\n",
    "\n",
    "```python\n",
    "x = 10  # Define a variable x\n",
    "del x   # Delete the variable x\n",
    "```\n",
    "\n",
    "After executing `del x`, the variable `x` will no longer exist in the current scope, and attempting to access it will result in a `NameError`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "Lw54BXAdaKwJ"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'x' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[14], line 5\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[38;5;28mprint\u001b[39m(x)\n\u001b[0;32m      4\u001b[0m \u001b[38;5;28;01mdel\u001b[39;00m x   \u001b[38;5;66;03m# Delete the variable x\u001b[39;00m\n\u001b[1;32m----> 5\u001b[0m \u001b[38;5;28mprint\u001b[39m(x)\n",
      "\u001b[1;31mNameError\u001b[0m: name 'x' is not defined"
     ]
    }
   ],
   "source": [
    "x = 10  # Define a variable x\n",
    "print(x)\n",
    "\n",
    "del x   # Delete the variable x\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "debXLQeWaKwJ"
   },
   "source": [
    "## 2. Type of a Variable\n",
    "\n",
    "In Python, the type of a variable refers to the kind of data it holds, such as integers, floating-point numbers, strings, or more complex data structures. Python dynamically assigns the type based on the value assigned to the variable. This type can be determined at any point in the code using the `type()` function.\n",
    "\n",
    "The type of a variable corresponds to its nature. There are many types of variables (integer, real number, strings, etc.). The most commonly encountered types of variables are integers (`int`), real numbers (`float`), and strings (`str`).\n",
    "\n",
    "**The basic types include:**\n",
    "\n",
    "- **None** (nothing)\n",
    "- **String types:** `str`\n",
    "   - Enclosed in (single, double, or triple) quotes `'` or `\"`: `'Calvin'`, `\"Calvin'n'Hobbes\"`, `'''Two\\nlines'''`, `\"\"\"'Why?' he asked.\"\"\"`\n",
    "   - Conversion: `str(3.2)`\n",
    "- **Numeric types:**\n",
    "   - **Booleans** `bool` (true/false): `True`, `False`\n",
    "   - **Integers** `int` (no explicit limit value, corresponds to at least C's long type): `-2`, `int(2.1)`, `int(\"4\")`\n",
    "   - **Reals** `float`\n",
    "   - **Complex** `complex`: `1+2j`, `5.1j`, `complex(-3.14)`, `complex('j')`\n",
    "- **Iterable objects:**\n",
    "   - **Lists** `list`: `['a', 3, [1, 2], 'a']`\n",
    "   - **Immutable lists** `tuple`: `(2, 3.1, 'a', [])` (depending on the usage, parentheses are not always required)\n",
    "   - **Keyed lists** `dict`: `{'a':1, 'b':[1, 2], 3:'c'}`\n",
    "   - **Unordered sets of unique elements** `set`: `{1, 2, 3, 2}`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LfiORq3waKwJ"
   },
   "source": [
    "### 2.0. None (nothing)\n",
    "The `None` type represents the absence of a value or a null value in Python. It is often used to signify that a variable has no value assigned to it or to indicate the end of a list, function, or loop.\n",
    "\n",
    "**Example:**\n",
    "```python\n",
    "x = None\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "id": "1Hvmm9draKwJ"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None <class 'NoneType'>\n"
     ]
    }
   ],
   "source": [
    "x = None\n",
    "print(x, type(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "80hwY-fGaKwK"
   },
   "source": [
    "# 2.1. String Types (`str`)\n",
    "Strings in Python are sequences of characters enclosed in quotes. They can be defined using single (`'`), double (`\"`), or triple quotes (`'''` or `\"\"\"`). Triple quotes allow for multi-line strings.\n",
    "\n",
    "**Examples:**\n",
    "```python\n",
    "name = 'Calvin'\n",
    "quote = \"Calvin'n'Hobbes\"\n",
    "multi_line = '''Two\n",
    "lines'''\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "id": "Gt-N0VJvaKwK"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calvin <class 'str'> \n",
      "\n",
      "====================================\n",
      "Calvin'n'Hobbes <class 'str'> \n",
      "\n",
      "====================================\n",
      "Two\n",
      "lines <class 'str'>\n",
      "====================================\n"
     ]
    }
   ],
   "source": [
    "name = 'Calvin'\n",
    "quote = \"Calvin'n'Hobbes\"\n",
    "multi_line = '''Two\n",
    "lines'''\n",
    "\n",
    "print(name, type(name), '\\n')\n",
    "print('====================================')\n",
    "\n",
    "print(quote, type(quote),'\\n')\n",
    "print('====================================')\n",
    "\n",
    "\n",
    "print(multi_line, type(multi_line))\n",
    "print('====================================')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bNs41IFqaKwK"
   },
   "source": [
    "### 2.2. Numeric Types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "czqop6T1aKwK"
   },
   "source": [
    "#### 2.2.0. Booleans (`bool`)\n",
    "Booleans represent one of two values: `True` or `False`. They are often used in conditional statements to determine the flow of a program.\n",
    "\n",
    "**Examples:**\n",
    "```python\n",
    "is_active = True\n",
    "has_permission = False\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "id": "jRlQRdvhaKwK"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True <class 'bool'> \n",
      "\n",
      "====================================\n",
      "False <class 'bool'> \n",
      "\n"
     ]
    }
   ],
   "source": [
    "is_active = True\n",
    "has_permission = False\n",
    "\n",
    "\n",
    "print(is_active, type(is_active), '\\n')\n",
    "print('====================================')\n",
    "\n",
    "print(has_permission, type(has_permission), '\\n')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__abs__',\n",
       " '__add__',\n",
       " '__and__',\n",
       " '__bool__',\n",
       " '__ceil__',\n",
       " '__class__',\n",
       " '__delattr__',\n",
       " '__dir__',\n",
       " '__divmod__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__float__',\n",
       " '__floor__',\n",
       " '__floordiv__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getnewargs__',\n",
       " '__getstate__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__index__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__int__',\n",
       " '__invert__',\n",
       " '__le__',\n",
       " '__lshift__',\n",
       " '__lt__',\n",
       " '__mod__',\n",
       " '__mul__',\n",
       " '__ne__',\n",
       " '__neg__',\n",
       " '__new__',\n",
       " '__or__',\n",
       " '__pos__',\n",
       " '__pow__',\n",
       " '__radd__',\n",
       " '__rand__',\n",
       " '__rdivmod__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__rfloordiv__',\n",
       " '__rlshift__',\n",
       " '__rmod__',\n",
       " '__rmul__',\n",
       " '__ror__',\n",
       " '__round__',\n",
       " '__rpow__',\n",
       " '__rrshift__',\n",
       " '__rshift__',\n",
       " '__rsub__',\n",
       " '__rtruediv__',\n",
       " '__rxor__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__sub__',\n",
       " '__subclasshook__',\n",
       " '__truediv__',\n",
       " '__trunc__',\n",
       " '__xor__',\n",
       " 'as_integer_ratio',\n",
       " 'bit_count',\n",
       " 'bit_length',\n",
       " 'conjugate',\n",
       " 'denominator',\n",
       " 'from_bytes',\n",
       " 'imag',\n",
       " 'numerator',\n",
       " 'real',\n",
       " 'to_bytes']"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xFa95RpfaKwK"
   },
   "source": [
    "####  2.2.1. Integers (`int`)\n",
    "Integers are whole numbers without a fractional component. In Python, integers can be of arbitrary precision, meaning they can be as large as the memory allows.\n",
    "\n",
    "**Examples:**\n",
    "```python\n",
    "age = 25\n",
    "negative_number = -42\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "id": "QJauvxXTaKwL"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25 <class 'int'> \n",
      "\n",
      "====================================\n",
      "-42 <class 'int'>\n"
     ]
    }
   ],
   "source": [
    "age = 25\n",
    "negative_number = -42\n",
    "\n",
    "print(age, type(age), '\\n')\n",
    "print('====================================')\n",
    "print(negative_number, type(negative_number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "S_IGnv8maKwL"
   },
   "source": [
    "####  2.2.2. Reals (`float`)\n",
    "Floating-point numbers (floats) are numbers with a decimal point. They are used to represent real numbers in Python.\n",
    "\n",
    "**Examples:**\n",
    "```python\n",
    "pi = 3.14159\n",
    "temperature = -2.5\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "id": "MS-mwNJGaKwL"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.14159 <class 'float'> \n",
      "\n",
      "====================================\n",
      "-2.5 <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "pi = 3.14159\n",
    "temperature = -2.5\n",
    "\n",
    "\n",
    "print(pi, type(pi), '\\n')\n",
    "print('====================================')\n",
    "print(temperature, type(temperature))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uWVP_s-3aKwL"
   },
   "source": [
    "#### 2.2.3. Complex (`complex`)\n",
    "Complex numbers in Python consist of a real part and an imaginary part. They are represented by `a + bj`, where `a` is the real part and `b` is the imaginary part.\n",
    "\n",
    "**Examples:**\n",
    "```python\n",
    "z = 1 + 2j\n",
    "w = complex(3, -4)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "id": "o5_BApqKaKwL"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1+2j) <class 'complex'>\n",
      "====================================\n",
      "(3-4j) <class 'complex'>\n"
     ]
    }
   ],
   "source": [
    "z = 1 + 2j\n",
    "w = complex(3, -4)\n",
    "\n",
    "print(z, type(z))\n",
    "print('====================================')\n",
    "print(w, type(w))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TCaQLIgUaKwM"
   },
   "source": [
    "### 2.3. Iterable Objects\n",
    "\n",
    "#### 2.3.0. Lists (`list`)\n",
    "A list is an ordered collection of items that can be of different types. Lists are mutable, meaning their contents can be changed after creation.\n",
    "\n",
    "**Examples:**\n",
    "```python\n",
    "fruits = ['apple', 'banana', 'cherry']\n",
    "mixed = [1, 'two', 3.0, [4, 5]]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "id": "H0VguWrCaKwM"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apple', 'banana', 'cherry'] <class 'list'>\n",
      "====================================\n",
      "[1, 'two', 3.0, [4, 5]] <class 'list'>\n"
     ]
    }
   ],
   "source": [
    "fruits = ['apple', 'banana', 'cherry']\n",
    "mixed = [1, 'two', 3.0, [4, 5]]\n",
    "\n",
    "\n",
    "print(fruits, type(fruits))\n",
    "print('====================================')\n",
    "print(mixed, type(mixed))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9r9xyn9JaKwM"
   },
   "source": [
    "#### 2.3.1. Immutable Lists (`tuple`)\n",
    "A tuple is similar to a list but is immutable, meaning its contents cannot be changed after creation. Tuples are often used to store collections of related data.\n",
    "\n",
    "**Examples:**\n",
    "```python\n",
    "coordinates = (10.5, 20.8)\n",
    "colors = ('red', 'green', 'blue')\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "id": "KaIp7Td1aKwM"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10.5, 20.8) <class 'tuple'>\n",
      "====================================\n",
      "('red', 'green', 'blue') <class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "coordinates = (10.5, 20.8)\n",
    "colors = ('red', 'green', 'blue')\n",
    "\n",
    "print(coordinates, type(coordinates))\n",
    "print('====================================')\n",
    "print(colors, type(colors))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HDGv4o04aKwN"
   },
   "source": [
    "#### 2.3.2. Keyed Lists (`dict`)\n",
    "A dictionary is a collection of key-value pairs, where each key is associated with a value. Dictionaries are mutable and allow for fast lookup of values based on their keys.\n",
    "\n",
    "**Examples:**\n",
    "```python\n",
    "person = {'name': 'Alice', 'age': 30}\n",
    "inventory = {'apples': 10, 'bananas': 20}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "id": "Vqtr60uhaKwN"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'Alice', 'age': 30} <class 'dict'>\n",
      "====================================\n",
      "{'apples': 10, 'bananas': 20} <class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "person = {'name': 'Alice', 'age': 30}\n",
    "inventory = {'apples': 10, 'bananas': 20}\n",
    "\n",
    "\n",
    "print(person, type(person))\n",
    "print('====================================')\n",
    "print(inventory, type(inventory))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "aM4x-AraaKwN"
   },
   "source": [
    "#### 2.3.3. Unordered Sets of Unique Elements (`set`)\n",
    "A set is an unordered collection of unique elements. Sets are useful for membership tests and eliminating duplicate entries.\n",
    "\n",
    "**Examples:**\n",
    "```python\n",
    "unique_numbers = {1, 2, 3, 2}\n",
    "letters = {'a', 'b', 'c', 'a'}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "id": "PXwex1P4aKwN"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3} <class 'set'>\n",
      "====================================\n",
      "{'c', 'b', 'a'} <class 'set'>\n"
     ]
    }
   ],
   "source": [
    "unique_numbers = {1, 2, 3, 2}\n",
    "letters = {'a', 'b', 'c', 'a'}\n",
    "\n",
    "print(unique_numbers, type(unique_numbers))\n",
    "print('====================================')\n",
    "print(letters , type(letters ))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'> <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "my_variable_1 = 5\n",
    "my_vairable_2 = 5.\n",
    "print(type(my_variable_1), type(my_vairable_2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3VTM37a3aKwN"
   },
   "source": [
    "### 2.4. Dynamic Typing in Python\n",
    "\n",
    "Python is a dynamically typed language, meaning that the type of a variable is determined at runtime rather than at compile time. In Python, you don't need to declare the type of a variable when you create it. Instead, the type is inferred based on the value assigned to the variable. This allows for more flexibility but also requires careful handling to avoid type-related errors.\n",
    "\n",
    "#### Key Characteristics of Dynamic Typing:\n",
    "\n",
    "- **No Type Declaration**: You simply assign a value to a variable, and Python automatically knows what type it is.\n",
    "    ```python\n",
    "    x = 10        # x is an integer\n",
    "    x = \"hello\"   # Now, x is a string\n",
    "    ```\n",
    "- **Type Flexibility**: The type of a variable can change over its lifetime. You can reassign a variable to a value of a different type without any issues.\n",
    "    ```python\n",
    "    y = 3.14      # y is initially a float\n",
    "    y = True      # Now, y is a boolean\n",
    "    ```\n",
    "- **Memory Management**: Python handles memory management automatically. When you reassign a variable to a new value, the previous value is discarded if it’s no longer referenced elsewhere in the code.\n",
    "\n",
    "#### Pros and Cons of Dynamic Typing:\n",
    "\n",
    "- **Pros**:\n",
    "  - **Flexibility**: You can write more general-purpose code since the type is not fixed.\n",
    "  - **Ease of Use**: Less boilerplate code, as there is no need for explicit type declarations.\n",
    "  \n",
    "- **Cons**:\n",
    "  - **Type-Related Errors**: Since types are determined at runtime, it’s possible to encounter errors if the wrong type is used in an operation.\n",
    "  - **Performance**: Dynamic typing can be slower than static typing because type checks are done at runtime.\n",
    "\n",
    "#### Example:\n",
    "```python\n",
    "# Initially, 'data' is an integer\n",
    "data = 100\n",
    "\n",
    "# Now, 'data' is a string\n",
    "data = \"Dynamic Typing\"\n",
    "\n",
    "# And now 'data' is a list\n",
    "data = [1, 2, 3]\n",
    "\n",
    "# Python handles these changes without any issues\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "GBstLCuuaKwN"
   },
   "source": [
    "### 2.5.  Coercion in Python\n",
    "\n",
    "**Coercion** in Python refers to the automatic conversion of one data type to another during operations that involve different types. Python is designed to handle these type conversions in a way that makes the language easier to use and reduces the need for manual type casting.\n",
    "\n",
    "#### Key Points About Coercion:\n",
    "\n",
    "- **Implicit Coercion**: Python automatically converts one data type to another when necessary to perform an operation. This usually happens in arithmetic operations involving different types, like an integer and a float.\n",
    "  - For example, if you add an integer to a float, Python will convert the integer to a float before performing the addition.\n",
    "  \n",
    "- **Explicit Coercion**: While Python handles many conversions automatically, you can also manually convert types using built-in functions like `int()`, `float()`, `str()`, etc. This is known as explicit type casting."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0qaCkEhjaKwO"
   },
   "source": [
    "#### 2.5. 0. Implicit Coercion Example:\n",
    "\n",
    "```python\n",
    "# Adding an integer and a float\n",
    "x = 5        # int\n",
    "y = 3.2      # float\n",
    "\n",
    "# Python automatically converts 'x' to a float before performing the addition\n",
    "result = x + y\n",
    "\n",
    "print(result)  # Output: 8.2 (float)\n",
    "```\n",
    "\n",
    "In the example above, Python automatically converts the integer `5` to a float `5.0` to perform the addition with the float `3.2`, resulting in a float `8.2`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "id": "aXASoEi2aKwO"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 <class 'int'> \n",
      "\n",
      "====================================\n",
      "3.2 <class 'float'> \n",
      "\n",
      "====================================\n",
      "8.2 <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "# Adding an integer and a float\n",
    "x = 5        # int\n",
    "y = 3.2      # float\n",
    "\n",
    "# Python automatically converts 'x' to a float before performing the addition\n",
    "result = x + y\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "print(x, type(x), '\\n')\n",
    "print('====================================')\n",
    "print(y, type(y),'\\n')\n",
    "print('====================================')\n",
    "print(result, type(result))  # Output: 8.2 (float)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Emg2q50caKwO"
   },
   "source": [
    "#### 2.5.1. Explicit Coercion Example:\n",
    "\n",
    "```python\n",
    "# Converting a float to an integer\n",
    "a = 7.9\n",
    "b = int(a)  # Explicit coercion using the int() function\n",
    "\n",
    "print(b)  # Output: 7 (integer, with the decimal part truncated)\n",
    "```\n",
    "\n",
    "Here, the float `7.9` is explicitly converted to the integer `7` using the `int()` function, which removes the fractional part."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "4KdKGOxEaKwO"
   },
   "outputs": [],
   "source": [
    "a = 7.9\n",
    "b = int(a)  # Explicit coercion using the int() function\n",
    "\n",
    "print(b)  # Output: 7 (integer, with the decimal part truncated)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "GhUd_PwSaKwO"
   },
   "source": [
    "\n",
    "#### 2.5.2. Common Coercion Scenarios:\n",
    "\n",
    "- **String to Integer/Float**: When you need to convert a string containing numeric characters to an integer or float.\n",
    "  ```python\n",
    "  num_str = \"123\"\n",
    "  num_int = int(num_str)   # Converts to integer 123\n",
    "  num_float = float(num_str)  # Converts to float 123.0\n",
    "  ```\n",
    "\n",
    "- **Integer/Float to String**: When you need to concatenate a number with a string.\n",
    "  ```python\n",
    "  age = 25\n",
    "  message = \"I am \" + str(age) + \" years old.\"\n",
    "  ```\n",
    "\n",
    "- **Boolean to Integer**: `True` is coerced to `1` and `False` to `0` in numeric operations.\n",
    "  ```python\n",
    "  result = True + 2   # Output: 3 (1 + 2)\n",
    "  ```\n",
    "\n",
    "#### 2.5.3. Pros and Cons of Coercion:\n",
    "\n",
    "- **Pros**:\n",
    "  - Simplifies code by reducing the need for explicit type conversions.\n",
    "  - Makes the language more intuitive and user-friendly.\n",
    "\n",
    "- **Cons**:\n",
    "  - Can lead to unexpected results if the automatic type conversion doesn't align with the programmer's intent.\n",
    "  - Potentially hides bugs related to incorrect data types.\n",
    "\n",
    "Coercion in Python allows for smoother and more intuitive operations involving different data types. While it adds convenience, it's important to understand how and when Python performs these conversions to avoid unexpected behaviors."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bCB3bPDUaKwP"
   },
   "source": [
    "## 3. Methods associated with variables\n",
    "\n",
    "In Python, every variable is linked to a variety of attributes and methods that define its behavior and interactions. These methods are functions that are built into the variable's type and allow you to perform various operations on the variable. For example, methods can help you manipulate strings, perform mathematical operations, or interact with lists and dictionaries.\n",
    "\n",
    "The `dir()` function is useful for exploring these methods and understanding what operations are available for a given variable. By calling `dir()` on a variable, you get a list of all its attributes and methods, including those inherited from its type. This can be particularly helpful for discovering how to use a variable's methods or for debugging.\n",
    "\n",
    "Here's how you might use `dir()`:\n",
    "\n",
    "```python\n",
    "# Example with a string variable\n",
    "text = \"Hello, world!\"\n",
    "print(dir(text))\n",
    "\n",
    "# Example with a list variable\n",
    "numbers = [1, 2, 3, 4, 5]\n",
    "print(dir(numbers))\n",
    "```\n",
    "\n",
    "In the examples above, `dir(text)` will list methods related to string operations such as `upper()`, `lower()`, and `split()`, while `dir(numbers)` will show methods related to list operations like `append()`, `remove()`, and `sort()`. This feature of Python makes it easier to explore and utilize the functionalities associated with different data types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "id": "lZteprvjaKwP"
   },
   "outputs": [],
   "source": [
    "x = 2.5 # Définit une variable numérique x\n",
    "y = 'my text' # Définit une variable en chaîne de caractères y."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JQMn9LCpaKwP"
   },
   "source": [
    "Pour afficher l’ensemble des méthodes associées à chacune de ces variables, on fait :\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "id": "v-3yc5FNaKwP"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['__abs__', '__add__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getformat__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__int__', '__le__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__pos__', '__pow__', '__radd__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rmod__', '__rmul__', '__round__', '__rpow__', '__rsub__', '__rtruediv__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', 'as_integer_ratio', 'conjugate', 'fromhex', 'hex', 'imag', 'is_integer', 'real']\n"
     ]
    }
   ],
   "source": [
    "print(dir(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "id": "6esJte7JaKwP"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']\n"
     ]
    }
   ],
   "source": [
    "print(dir(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "N_h-fgBMaKwP"
   },
   "source": [
    "You can also type `variable_name.` followed by `TAB` in many interactive Python environments or integrated development environments (IDEs). This action triggers autocompletion, which helps you see and select available methods and attributes associated with that variable. For example:\n",
    "\n",
    "1. Type `variable_name.` and press `TAB`.\n",
    "2. A list of methods and attributes that can be used with `variable_name` will appear.\n",
    "\n",
    "This feature is especially useful for exploring what operations you can perform on a variable and for quickly finding the right method without needing to remember exact method names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "1ym195tgaKwP"
   },
   "outputs": [],
   "source": [
    "# Type x. followed by `TAB`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kjkm83daaKwQ"
   },
   "source": [
    "To get help on a specific method in Python, you can use the `help()` function. The syntax is `help(variable_name.method_name)`, where `method_name` is the name of the method you are interested in. For example, if you have a numeric variable of type `float`, which includes a method named `conjugate`, you can obtain information about this method by running:\n",
    "\n",
    "```python\n",
    "print(help(x.conjugate))\n",
    "```\n",
    "\n",
    "This will display documentation about the `conjugate` method, including its purpose and usage, in the console or terminal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "id": "FWm4URK5aKwQ"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function conjugate:\n",
      "\n",
      "conjugate() method of builtins.float instance\n",
      "    Return self, the complex conjugate of any float.\n",
      "\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "print(help(x.conjugate))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gTtq_BukaKwQ"
   },
   "source": [
    "To display help on all the functions associated with a variable `x`, you simply use:\n",
    "\n",
    "```python\n",
    "help(x)\n",
    "```\n",
    "\n",
    "This command will show the documentation for the type of the variable `x`, including all the methods and attributes available for that type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "id": "E98af-XlaKwQ"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on float object:\n",
      "\n",
      "class float(object)\n",
      " |  float(x=0, /)\n",
      " |  \n",
      " |  Convert a string or number to a floating point number, if possible.\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __abs__(self, /)\n",
      " |      abs(self)\n",
      " |  \n",
      " |  __add__(self, value, /)\n",
      " |      Return self+value.\n",
      " |  \n",
      " |  __bool__(self, /)\n",
      " |      True if self else False\n",
      " |  \n",
      " |  __ceil__(self, /)\n",
      " |      Return the ceiling as an Integral.\n",
      " |  \n",
      " |  __divmod__(self, value, /)\n",
      " |      Return divmod(self, value).\n",
      " |  \n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __float__(self, /)\n",
      " |      float(self)\n",
      " |  \n",
      " |  __floor__(self, /)\n",
      " |      Return the floor as an Integral.\n",
      " |  \n",
      " |  __floordiv__(self, value, /)\n",
      " |      Return self//value.\n",
      " |  \n",
      " |  __format__(self, format_spec, /)\n",
      " |      Formats the float according to format_spec.\n",
      " |  \n",
      " |  __ge__(self, value, /)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __getnewargs__(self, /)\n",
      " |  \n",
      " |  __gt__(self, value, /)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __hash__(self, /)\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __int__(self, /)\n",
      " |      int(self)\n",
      " |  \n",
      " |  __le__(self, value, /)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __lt__(self, value, /)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __mod__(self, value, /)\n",
      " |      Return self%value.\n",
      " |  \n",
      " |  __mul__(self, value, /)\n",
      " |      Return self*value.\n",
      " |  \n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __neg__(self, /)\n",
      " |      -self\n",
      " |  \n",
      " |  __pos__(self, /)\n",
      " |      +self\n",
      " |  \n",
      " |  __pow__(self, value, mod=None, /)\n",
      " |      Return pow(self, value, mod).\n",
      " |  \n",
      " |  __radd__(self, value, /)\n",
      " |      Return value+self.\n",
      " |  \n",
      " |  __rdivmod__(self, value, /)\n",
      " |      Return divmod(value, self).\n",
      " |  \n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __rfloordiv__(self, value, /)\n",
      " |      Return value//self.\n",
      " |  \n",
      " |  __rmod__(self, value, /)\n",
      " |      Return value%self.\n",
      " |  \n",
      " |  __rmul__(self, value, /)\n",
      " |      Return value*self.\n",
      " |  \n",
      " |  __round__(self, ndigits=None, /)\n",
      " |      Return the Integral closest to x, rounding half toward even.\n",
      " |      \n",
      " |      When an argument is passed, work like built-in round(x, ndigits).\n",
      " |  \n",
      " |  __rpow__(self, value, mod=None, /)\n",
      " |      Return pow(value, self, mod).\n",
      " |  \n",
      " |  __rsub__(self, value, /)\n",
      " |      Return value-self.\n",
      " |  \n",
      " |  __rtruediv__(self, value, /)\n",
      " |      Return value/self.\n",
      " |  \n",
      " |  __sub__(self, value, /)\n",
      " |      Return self-value.\n",
      " |  \n",
      " |  __truediv__(self, value, /)\n",
      " |      Return self/value.\n",
      " |  \n",
      " |  __trunc__(self, /)\n",
      " |      Return the Integral closest to x between 0 and x.\n",
      " |  \n",
      " |  as_integer_ratio(self, /)\n",
      " |      Return integer ratio.\n",
      " |      \n",
      " |      Return a pair of integers, whose ratio is exactly equal to the original float\n",
      " |      and with a positive denominator.\n",
      " |      \n",
      " |      Raise OverflowError on infinities and a ValueError on NaNs.\n",
      " |      \n",
      " |      >>> (10.0).as_integer_ratio()\n",
      " |      (10, 1)\n",
      " |      >>> (0.0).as_integer_ratio()\n",
      " |      (0, 1)\n",
      " |      >>> (-.25).as_integer_ratio()\n",
      " |      (-1, 4)\n",
      " |  \n",
      " |  conjugate(self, /)\n",
      " |      Return self, the complex conjugate of any float.\n",
      " |  \n",
      " |  hex(self, /)\n",
      " |      Return a hexadecimal representation of a floating-point number.\n",
      " |      \n",
      " |      >>> (-0.1).hex()\n",
      " |      '-0x1.999999999999ap-4'\n",
      " |      >>> 3.14159.hex()\n",
      " |      '0x1.921f9f01b866ep+1'\n",
      " |  \n",
      " |  is_integer(self, /)\n",
      " |      Return True if the float is an integer.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods defined here:\n",
      " |  \n",
      " |  __getformat__(typestr, /) from builtins.type\n",
      " |      You probably don't want to use this function.\n",
      " |      \n",
      " |        typestr\n",
      " |          Must be 'double' or 'float'.\n",
      " |      \n",
      " |      It exists mainly to be used in Python's test suite.\n",
      " |      \n",
      " |      This function returns whichever of 'unknown', 'IEEE, big-endian' or 'IEEE,\n",
      " |      little-endian' best describes the format of floating point numbers used by the\n",
      " |      C type named by typestr.\n",
      " |  \n",
      " |  fromhex(string, /) from builtins.type\n",
      " |      Create a floating-point number from a hexadecimal string.\n",
      " |      \n",
      " |      >>> float.fromhex('0x1.ffffp10')\n",
      " |      2047.984375\n",
      " |      >>> float.fromhex('-0x1p-1074')\n",
      " |      -5e-324\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  imag\n",
      " |      the imaginary part of a complex number\n",
      " |  \n",
      " |  real\n",
      " |      the real part of a complex number\n",
      "\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "print(help(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2KJvKelNaKwQ"
   },
   "source": [
    "### 4. Arithmetic and Logical (Boolean) Operators\n",
    "\n",
    "In Python, two major categories of operators are used to define variables and instructions: arithmetic operators and logical (boolean) operators.\n",
    "\n",
    "- **Arithmetic Operators**: These operators perform common mathematical operations. They include addition, subtraction, multiplication, division, and others that are essential for numerical computations.\n",
    "\n",
    "- **Logical (Boolean) Operators**: These operators are used for comparing values and evaluating logical expressions. A boolean value represents one of two possibilities: true or false. Boolean values result from evaluating logical expressions and are used to make decisions within a program, such as executing certain actions when specific conditions are met.\n",
    "\n",
    "**Boolean values** are crucial for control flow in programming, allowing for conditional execution based on whether a condition evaluates to true or false."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gDPRWEcnaKwQ"
   },
   "source": [
    "\n",
    "\n",
    "\n",
    "#### 4.0. Arithmetic Operators\n",
    "\n",
    "| **Operation**            | **Symbol**  | **Example**       |\n",
    "|:-------------------------:|:-----------:|:-----------------:|\n",
    "| Addition                  | `+`         | `x = 2 + 3`       |\n",
    "| Subtraction               | `-`         | `z = x - y`       |\n",
    "| Multiplication            | `*`         | `y = 3 * x`       |\n",
    "| Real Division             | `/`         | `5 / 2 = 2.5`    |\n",
    "| Integer Division          | `//`        | `5 // 2 = 2`     |\n",
    "| Exponentiation            | `**`        | `x ** 2 = x * x` |\n",
    "| Modulo (Remainder)        | `%`         | `17 % 3 = 2`     |\n",
    "| Increment Addition        | `+=`        | `x += 4` (i.e., `x = x + 4`) |\n",
    "| Increment Subtraction     | `-=`        | `x -= 4` (i.e., `x = x - 4`) |\n",
    "\n",
    "---\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DieIDs_NaKwR"
   },
   "source": [
    "\n",
    "\n",
    "#### 4.1. Logical Operators<\n",
    "\n",
    "| **Operation**                | **Symbol** | **Description**                                | **Example**               |\n",
    "|:----------------------------:|:----------:|:---------------------------------------------:|:--------------------------:|\n",
    "| Logical AND                  | `and`      | Returns `True` if both operands are true     | `True and False` yields `False` |\n",
    "| Logical OR                   | `or`       | Returns `True` if at least one operand is true| `True or False` yields `True`  |\n",
    "| Logical NOT                  | `not`      | Returns `True` if the operand is false       | `not True` yields `False`      |\n",
    "| Logical XOR (Exclusive OR)   | `^`        | Returns `True` if operands are different     | `True ^ False` yields `True`   |\n",
    "| Logical equality             | `==`       | Returns `True` if both operands are equal    | `x == y`                    |\n",
    "| Logical inequality           | `!=`       | Returns `True` if operands are not equal    | `x != y`                    |\n",
    "| Less than                    | `<`        | Returns `True` if left operand is less than right operand | `x < y`                  |\n",
    "| Greater than                 | `>`        | Returns `True` if left operand is greater than right operand | `x > y`                  |\n",
    "| Less than or equal to        | `<=`       | Returns `True` if left operand is less than or equal to right operand | `x <= y`                 |\n",
    "| Greater than or equal to     | `>=`       | Returns `True` if left operand is greater than or equal to right operand | `x >= y`                 |\n",
    "\n",
    "---\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "FzO7WiicaKwR"
   },
   "source": [
    "\n",
    "To access the complete list of standard Python operators and their equivalent functions, see [this page](https://docs.python.org/3/library/operator.html). You can also refer to [this page](https://www.tutorialspoint.com/python/python_operators.htm) for some examples of standard operator usage.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "N1jAndubaKwR"
   },
   "source": [
    "### 5. User input ( the `input()` function)\n",
    "\n",
    "In Python, the `input()` function is used to capture user input from the console. It pauses the program's execution and waits for the user to type something, which is then returned as a string. This input can be stored in a variable, allowing you to use the entered data later in your code.\n",
    "\n",
    "#### 5.0. Basic Usage\n",
    "\n",
    "The basic syntax for the `input()` function is:\n",
    "\n",
    "```python\n",
    "variable_name = input(prompt)\n",
    "```\n",
    "\n",
    "- **`prompt`**: This is an optional argument. It is a string that is displayed to the user, providing instructions or asking for specific input.\n",
    "- **`variable_name`**: This is the variable that will store the value entered by the user.\n",
    "\n",
    "#### Example\n",
    "\n",
    "Here’s a simple example of using the `input()` function:\n",
    "\n",
    "```python\n",
    "name = input(\"Enter your name: \")\n",
    "print(\"Hello, \" + name + \"!\")\n",
    "```\n",
    "\n",
    "In this example:\n",
    "- The program prompts the user to enter their name.\n",
    "- The entered name is stored in the variable `name`.\n",
    "- The program then greets the user using the name provided."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "id": "V6AcIA3saKwR"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your name: Precious\n",
      "Hello, Precious!\n"
     ]
    }
   ],
   "source": [
    "name = input(\"Enter your name: \")\n",
    "print(\"Hello, \" + name + \"!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ND8vSfaXaKwS"
   },
   "source": [
    "#### 5.1. Important Notes\n",
    "\n",
    "- **Type Conversion**: Since `input()` always returns the input as a string, you may need to convert it to the appropriate type (e.g., `int`, `float`) depending on the context.\n",
    "\n",
    "  ```python\n",
    "  age = int(input(\"Enter your age: \"))\n",
    "  ```\n",
    "\n",
    "- **Handling Errors**: When converting input, it’s important to handle potential errors, such as the user entering a non-numeric value when an integer is expected.\n",
    "\n",
    "- **Security Considerations**: Be cautious when using `input()` in sensitive applications, as it can introduce security risks if the input is not properly validated or sanitized.\n",
    "\n",
    "Using the `input()` function is a common way to make your Python programs interactive, enabling users to provide data that can be processed and utilized by the program."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "i4NhvF1-aKwS"
   },
   "source": [
    "#### 5.2.  Accepting User Inputs (as both integer and string)\n",
    "\n",
    "**`input(prompt)`** prompts for and returns input as a string. Hence, if the user inputs a integer, the code should convert the string to an integer and then proceed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "id": "YYEE6ii2aKwS"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, \n",
      "How are you?  45\n",
      "================================== \n",
      "\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "a = input(\"Hello, \\nHow are you?  \") # \\n means new line\n",
    "\n",
    "\n",
    "print(\"================================== \\n\")\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "id": "43ACxd6HaKwS"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type something here and it will be stored in variable try_something \tI just typed something!\n",
      "================================== \n",
      "\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "try_something = input(\"Type something here and it will be stored in variable try_something \\t\")\n",
    "\n",
    "print(\"================================== \\n\")\n",
    "print(type(try_something))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "id": "P0REqCj-aKwS"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter number: 23\n",
      "Enter name: Precious\n",
      "\n",
      "\n",
      "Printing type of a input value\n",
      "================================== \n",
      "\n",
      "Type of number <class 'str'>\n",
      "================================== \n",
      "\n",
      "Type of name <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "number = input(\"Enter number: \")\n",
    "name = input(\"Enter name: \")\n",
    "\n",
    "print(\"\\n\")\n",
    "print(\"Printing type of a input value\")\n",
    "print(\"================================== \\n\")\n",
    "print(\"Type of number\", type(number))\n",
    "print(\"================================== \\n\")\n",
    "print(\"Type of name\", type(name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "37aYG2u5aKwS"
   },
   "source": [
    "#### 5.3. `eval()` (accepting user inputs; only as integer)\n",
    "\n",
    "The `eval()` function in Python can be used in conjunction with `input()` to evaluate a string as a Python expression. This can be particularly useful when you want to allow the user to input a mathematical expression or Python code directly and have it evaluated at runtime.\n",
    "\n",
    "#### Basic Usage of `eval()`\n",
    "\n",
    "The basic syntax for using `eval()` with `input()` is:\n",
    "\n",
    "```python\n",
    "result = eval(input(prompt))\n",
    "```\n",
    "\n",
    "- **`prompt`**: This is the text displayed to the user to guide them on what to input.\n",
    "- **`result`**: This variable stores the output after evaluating the user input as a Python expression.\n",
    "\n",
    "#### Example\n",
    "\n",
    "Here’s an example where the user is allowed to input a mathematical expression, and `eval()` evaluates it:\n",
    "\n",
    "```python\n",
    "expression = input(\"Enter a mathematical expression: \")\n",
    "result = eval(expression)\n",
    "print(\"The result is:\", result)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "UnTHoZ7EaKwT"
   },
   "outputs": [],
   "source": [
    "expression = input(\"Enter a mathematical expression: \")\n",
    "result = eval(expression)\n",
    "print(\"The result is:\", result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KIbA085vaKwT"
   },
   "source": [
    "In this example:\n",
    "- The program prompts the user to enter a mathematical expression.\n",
    "- The input is passed to `eval()`, which evaluates the expression.\n",
    "- The result is then printed out.\n",
    "\n",
    "#### Important Notes\n",
    "\n",
    "- **Use with Caution**: The `eval()` function can be dangerous if used with untrusted input, as it will execute any code passed to it. This could potentially lead to security vulnerabilities, such as code injection attacks. It should only be used in safe, controlled environments where the input is trusted.\n",
    "  \n",
    "- **Valid Python Expressions**: The string passed to `eval()` must be a valid Python expression. If the string contains syntax errors or invalid operations, Python will raise an exception.\n",
    "\n",
    "- **Alternative**: In many cases, using `int()` or `float()` for type conversion, or safely parsing and evaluating input without `eval()`, may be preferable for security reasons.\n",
    "\n",
    "Using `eval()` with `input()` can be powerful for dynamic code evaluation, but it should be used responsibly to avoid unintended consequences.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "RVm2z9JZaKwT"
   },
   "source": [
    "### Practice Problem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "id": "xKbxQmw8aKwT"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter first number: 23\n",
      "Enter second number: 32\n",
      "Final result is:  55.0\n"
     ]
    }
   ],
   "source": [
    "# Accept one integer and one float number from the user and calculate the addition of both the numbers.\n",
    "num1 = int(input(\"Enter first number: \"))\n",
    "num2 = float(input(\"Enter second number: \"))\n",
    "\n",
    "result=(num1+num2)\n",
    "print(\"Final result is: \", result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "id": "M1fXkto-aKwT"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter first number: 23\n",
      "Enter second number: 24\n",
      "Enter third number: 25\n",
      "\n",
      "\n",
      "First Number:  23\n",
      "Second Number:  24\n",
      "Third Number:  25\n",
      "Final result is:  1175\n"
     ]
    }
   ],
   "source": [
    "# Write code to get three numbers and add first 2 number and multiply with third number\n",
    "\n",
    "num1 = int(input(\"Enter first number: \"))   # converting input value to integer\n",
    "num2 = int(input(\"Enter second number: \"))  # converting input value to integer\n",
    "num3 = int(input(\"Enter third number: \"))   # converting input value to integer\n",
    "\n",
    "print(\"\\n\")\n",
    "print(\"First Number: \", num1)\n",
    "print(\"Second Number: \", num2)\n",
    "print(\"Third Number: \", num3)\n",
    "\n",
    "result=(num1+num2)*num3\n",
    "print(\"Final result is: \", result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "id": "2OOS09QvaKwT"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter first number: 1\n",
      "Enter second number: 2\n",
      "Enter third number: 3\n",
      "Enter fourth number: 4\n",
      "\n",
      "\n",
      "First Number:  1\n",
      "Second Number:  2\n",
      "Third Number:  3\n",
      "Fourth number:  4\n",
      "Final result is:  4.666666666666667\n"
     ]
    }
   ],
   "source": [
    "# Write a code to get four numbers:\n",
    "#Step 1. Multiply first and fourth number\n",
    "#Step 2. Divide second and third number\n",
    "#Step3. Add Step 1 and Step 2 outputs.\n",
    "\n",
    "num1 = int(input(\"Enter first number: \"))\n",
    "num2 = int(input(\"Enter second number: \"))\n",
    "num3 = int(input(\"Enter third number: \"))\n",
    "num4 = int(input(\"Enter fourth number: \"))\n",
    "\n",
    "print(\"\\n\")\n",
    "print(\"First Number: \", num1)\n",
    "print(\"Second Number: \", num2)\n",
    "print(\"Third Number: \", num3)\n",
    "print(\"Fourth number: \", num4)\n",
    "\n",
    "result=(num1*num4)+(num2/num3)\n",
    "print(\"Final result is: \", result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "id": "EkfYDZrlaKwU"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter float number: 6.7\n",
      "\n",
      "\n",
      "input float number is:  6.7\n",
      "type is: <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "# Let’s see how to accept float value from a user in Python.\n",
    "# You need to convert user input to the float number using\n",
    "# the **`float()`** function as we did for the integer value.\n",
    "float_number = float(input(\"Enter float number: \"))  # converting input value to float\n",
    "print(\"\\n\")\n",
    "print(\"input float number is: \", float_number)\n",
    "print(\"type is:\", type(float_number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "FTkWUNPCaKwV"
   },
   "source": [
    "<!--NAVIGATION-->\n",
    "< [0. Introduction](00.introduction_to_python.ipynb) | [ToC](Index.ipynb) | [2. Strings & Files](02-Strings.ipynb) >\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solutions to Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "\n",
    "### Exercise 1:\n",
    "Declare a variable `x` and assign it the value `10`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 10\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 2:\n",
    "Assign the value `True` to a variable called `is_valid`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "is_valid = True\n",
    "print(is_valid)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "### Exercise 3:\n",
    "Create a string variable `name` with the value \"Python Programming\".\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Python Programming\"\n",
    "print(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 4:\n",
    "Assign the result of `5 + 3` to a variable `sum_result`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sum_result = 5 + 3\n",
    "print(sum_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 5:\n",
    "Assign multiple variables in one line: `a = 5`, `b = 10`, `c = 15`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 5; b = 10; c = 15\n",
    "print(a,b,c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Exercise 6:\n",
    "Assign the value of one variable `x` to another variable `y`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 3\n",
    "y = x\n",
    "print(x,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 7:\n",
    "Assign a floating-point number `9.8` to a variable `gravity`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gravity = 9.8\n",
    "print(gravity)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 8:\n",
    "Create a variable `country` and assign it the string value of your favorite country.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "country = \"United States of America\"\n",
    "print(country)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 9:\n",
    "Change the value of variable `age` from `25` to `26` in two separate steps.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "age = 25\n",
    "age = 26\n",
    "print(age)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 10:\n",
    "Use one variable to store the result of subtracting two numbers `20 - 7`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n"
     ]
    }
   ],
   "source": [
    "difference = 20 - 7\n",
    "print(difference)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 11:\n",
    "Assign an integer value and a floating-point value to two different variables.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Integer:  45 Float:  4.5\n"
     ]
    }
   ],
   "source": [
    "int_var = 45\n",
    "float_var = 4.5\n",
    "\n",
    "print(\"Integer: \", int_var, \"Float: \", float_var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 12:\n",
    "Assign a boolean value `False` to a variable `is_completed`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "is_completed = False\n",
    "print(is_completed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 13:\n",
    "Swap the values of two variables `x` and `y`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current values of x = 3 and current value of y = 4\n",
      "\n",
      "After Swapping\n",
      "\n",
      "Current values of x = 4 and current value of y = 3\n"
     ]
    }
   ],
   "source": [
    "x = 3\n",
    "y = 4\n",
    "\n",
    "print(\"Current values of x =\", x, \"and current value of y =\", y)\n",
    "\n",
    "print(\"\\nAfter Swapping\\n\")\n",
    "\n",
    "x,y = y,x\n",
    "\n",
    "print(\"Current values of x =\", x, \"and current value of y =\", y)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 14:\n",
    "Assign a complex number `3 + 4j` to a variable `complex_num`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3+4j)\n"
     ]
    }
   ],
   "source": [
    "complex_num = 3 + 4j\n",
    "print(complex_num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Exercise 15:\n",
    "Reassign a variable from an integer to a string.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25\n"
     ]
    }
   ],
   "source": [
    "var1 = 25\n",
    "var1 = \"25\"\n",
    "print(var1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 16:\n",
    "Create two variables `first_name` and `last_name`, and assign them your first and last names.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tochukwu Precious Chukwuezi\n"
     ]
    }
   ],
   "source": [
    "first_name = \"Tochukwu Precious\"\n",
    "last_name = \"Chukwuezi\"\n",
    "\n",
    "print(first_name, last_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 17:\n",
    "Create a variable `temperature` and assign it the value of `35.5`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "35.5\n"
     ]
    }
   ],
   "source": [
    "temperature = 35.5\n",
    "print(temperature)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 18:\n",
    "Assign the result of the multiplication of two numbers `8 * 6` to a variable `product`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "64\n"
     ]
    }
   ],
   "source": [
    "product = 8*8\n",
    "print(product)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 19:\n",
    "Assign a sentence of your choice to a variable `sentence`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sentence = \"I think I will love this Python Class\"\n",
    "print(sentence)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 20:\n",
    "Use an assignment to convert a string `'50'` into an integer variable `int_value`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50\n"
     ]
    }
   ],
   "source": [
    "string_no = 50\n",
    "int_value = int(string_no)\n",
    "print(int_value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 21:\n",
    "Assign the result of dividing `144` by `12` to a variable `quotient`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12.0\n"
     ]
    }
   ],
   "source": [
    "quotient = 144/12\n",
    "print(quotient)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 22:\n",
    "Assign the remainder of `47 divided by 5` to a variable `remainder`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "remainder = 47%5\n",
    "print(remainder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 23:\n",
    "Create a variable `is_student` and assign it the value `True`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "is_student = True\n",
    "print(is_student)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 24:\n",
    "Use a variable to store the result of a modulo operation: `45 % 4`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "remainder = 45 & 4\n",
    "print(remainder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 25:\n",
    "Create a variable `pi` and assign it the value `3.14159`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.14159\n"
     ]
    }
   ],
   "source": [
    "pi = 3.14159\n",
    "print(pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 26:\n",
    "Create two variables `length` and `width`, assign them values, and calculate the area of a rectangle.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "360\n"
     ]
    }
   ],
   "source": [
    "length = 15\n",
    "width = 24\n",
    "area = length * width\n",
    "print(area)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Exercise 27:\n",
    "Assign a negative number to a variable `negative_value`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-20000.0\n"
     ]
    }
   ],
   "source": [
    "negative_value = -2e4\n",
    "print(negative_value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 28:\n",
    "Assign a string containing a special character (e.g., \"Hello, World!\") to a variable `greeting`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello greeting!\n"
     ]
    }
   ],
   "source": [
    "greeting = \"Hello, World!\"\n",
    "print(greeting)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 29:\n",
    "Create a variable `population` and assign it a large integer value (in billions).\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "37800000000000.0\n"
     ]
    }
   ],
   "source": [
    "population  = 3.78e13\n",
    "print(population)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 30:\n",
    "Use a variable to store the result of raising `2` to the power of `8`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "256\n"
     ]
    }
   ],
   "source": [
    "my_string = \"she o wa da da\"\n",
    "\n",
    "pow = 2**8\n",
    "print(pow)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 31:\n",
    "Assign a list of your favorite fruits to a variable `fruits`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Pear', 'Apply', 'Mongo', 'Pawpaw']\n"
     ]
    }
   ],
   "source": [
    "fruits = [\"Pear\", \"Apply\", \"Mongo\", \"Pawpaw\"]\n",
    "print(fruits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 32:\n",
    "Assign a tuple of three numbers to a variable `coordinates`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "coordinates = (1,2,3)\n",
    "print(coordinates)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 33:\n",
    "Assign a dictionary with keys `name` and `age` to a variable `person`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'Precious', 'age': 27}\n"
     ]
    }
   ],
   "source": [
    "person = {\n",
    "    \"name\" : \"Precious\",\n",
    "    \"age\" : 27\n",
    "}\n",
    "print(person)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 34:\n",
    "Use variables to store the sum of two floating-point numbers.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "79.46000000000001 <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "num_1 = 78.90\n",
    "num_2 = 0.56\n",
    "\n",
    "add_two = num_1 + num_2\n",
    "print(add_two, type(add_two))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 35:\n",
    "Create a variable `is_sunny` and assign it the result of a comparison `10 > 5`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "is_sunny = 10 > 5\n",
    "print(is_sunny)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 36:\n",
    "Assign a string and an integer to two different variables, then print both on one line.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Precious 23\n"
     ]
    }
   ],
   "source": [
    "str_var = \"Precious\"\n",
    "int_var = 23\n",
    "\n",
    "print(str_var, int_var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Exercise 37:\n",
    "Reassign a variable that originally held a number to a boolean value.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "num = 34\n",
    "num = num > 15\n",
    "\n",
    "print(num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 38:\n",
    "Create a variable `is_weekend` and assign it the result of `False`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "is_weekend = False\n",
    "print(is_weekend)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 39:\n",
    "Assign a multi-line string to a variable `description`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is Precious\n",
      "This is the second line\n",
      "This is the third line\n",
      "I don't know what to write on the 5th line\n"
     ]
    }
   ],
   "source": [
    "description = \"\"\"My name is Precious\n",
    "This is the second line\n",
    "This is the third line\n",
    "I don't know what to write on the 5th line\"\"\"\n",
    "\n",
    "print(description)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Exercise 40:\n",
    "Use variables to store the result of the absolute value of `-25`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25\n"
     ]
    }
   ],
   "source": [
    "my_var = abs(-25)\n",
    "\n",
    "print(my_var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 41:\n",
    "Assign the result of a floor division `100 // 6` to a variable `floor_div_result`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16\n"
     ]
    }
   ],
   "source": [
    "floor_div_result = 100//6\n",
    "print(floor_div_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 42:\n",
    "Assign the result of adding a floating-point number to an integer to a variable `mixed_sum`.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23.0\n"
     ]
    }
   ],
   "source": [
    "mixed_sum = 23 + 0.0\n",
    "\n",
    "print(mixed_sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Exercise 43:\n",
    "Use variables to store a combination of string concatenation.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A to letter Z\n"
     ]
    }
   ],
   "source": [
    "x = \"A to\"\n",
    "y = \" letter Z\"\n",
    "\n",
    "z = x + y\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 44:\n",
    "Assign an empty list to a variable `empty_list`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "empty_list = list()\n",
    "print(empty_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 45:\n",
    "Assign a boolean value based on the comparison of two variables `a = 10` and `b = 15`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "a = 10\n",
    "b = 15\n",
    "my_bool = (a > b)\n",
    "print(my_bool)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 46:\n",
    "Assign a long sentence to a variable and count its characters using `len()`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "226\n"
     ]
    }
   ],
   "source": [
    "long_sentence = \"This diagram [shows] the proportion of individuals in the UK above 4 years old from Oct-Dec 1992, who are either watching television or listening to the radio for each hour of the day over a 24 hour period, starting from 6 am.\"\n",
    "len_sentence = len(long_sentence)\n",
    "print(len_sentence)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 47:\n",
    "Assign a fractional result `7 / 3` to a variable `division_result`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.3333333333333335\n"
     ]
    }
   ],
   "source": [
    "division_result = 7/3\n",
    "print(division_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 48:\n",
    "Create a variable `speed` and assign it the value of 100 kilometers per hour.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 Kilometers per hour\n"
     ]
    }
   ],
   "source": [
    "speed = str(100) + \" Kilometers per hour\"\n",
    "print(speed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 49:\n",
    "Assign a multi-variable equation like `y = 3x + 5` where `x = 4` to a variable `y`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4, 17)\n"
     ]
    }
   ],
   "source": [
    "x = 4\n",
    "y = 3*x + 5\n",
    "\n",
    "print((x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 50:\n",
    "Use variables to calculate and store the average of three numbers.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The average is = 24.0\n"
     ]
    }
   ],
   "source": [
    "a = float(input(\"Enter a number: \"))\n",
    "b = float(input(\"Enter a second number: \"))\n",
    "c = float(input(\"Enter a third number: \"))\n",
    "\n",
    "average = sum([a,b,c])/3\n",
    "\n",
    "print(\"The average is =\", average)"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "include_colab_link": true,
   "provenance": []
  },
  "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}