Python tips.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/epythonlab/PythonLab/blob/master/Python%20tips.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# List vs Generator"
      ],
      "metadata": {
        "id": "hVpSAKZLGKj6"
      },
      "id": "hVpSAKZLGKj6"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Introduction:"
      ],
      "metadata": {
        "id": "bp6jySbKGPa_"
      },
      "id": "bp6jySbKGPa_"
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Lists** and **generators** are both used to manage and manipulate collections of data, but they have some key differences in terms of their implementation, behavior, and use cases."
      ],
      "metadata": {
        "id": "N-d_UMPhGw2R"
      },
      "id": "N-d_UMPhGw2R"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 1.Evaluation"
      ],
      "metadata": {
        "id": "TWVR7KLoG4JG"
      },
      "id": "TWVR7KLoG4JG"
    },
    {
      "cell_type": "markdown",
      "source": [
        "- Lists are eager evaluation because, lists are collections that store all their elements in memory at once.\n",
        "- When you create a list, all the elements are evaluated and stored in memory."
      ],
      "metadata": {
        "id": "Op9spS2VHB_l"
      },
      "id": "Op9spS2VHB_l"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Example:"
      ],
      "metadata": {
        "id": "mfCV9OcTIe6n"
      },
      "id": "mfCV9OcTIe6n"
    },
    {
      "cell_type": "code",
      "source": [
        "def list_numbers(n):\n",
        "  return [i for i in range(n)]"
      ],
      "metadata": {
        "id": "K4qIh7X4HKS3"
      },
      "id": "K4qIh7X4HKS3",
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Generators:\n",
        "\n"
      ],
      "metadata": {
        "id": "SdtYa3aMH3Ps"
      },
      "id": "SdtYa3aMH3Ps"
    },
    {
      "cell_type": "markdown",
      "source": [
        "- **Generators** use lazy evaluation, meaning they generate values on-the-fly and only when requested.\n",
        "- Elements are computed one at a time and not stored in memory all at once."
      ],
      "metadata": {
        "id": "Xv9_IrZbH9CM"
      },
      "id": "Xv9_IrZbH9CM"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Example:"
      ],
      "metadata": {
        "id": "2TOqgogzIngw"
      },
      "id": "2TOqgogzIngw"
    },
    {
      "cell_type": "code",
      "source": [
        "def generate_numbers(n):\n",
        "  for i in range(n):\n",
        "    yield i"
      ],
      "metadata": {
        "id": "MEGDpcOAImno"
      },
      "id": "MEGDpcOAImno",
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 2. Memory Usage:"
      ],
      "metadata": {
        "id": "3xQYI8ufI0yR"
      },
      "id": "3xQYI8ufI0yR"
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Lists:\n"
      ],
      "metadata": {
        "id": "MREs_lmxI9am"
      },
      "id": "MREs_lmxI9am"
    },
    {
      "cell_type": "markdown",
      "source": [
        "- Lists can consume more memory, especially for large datasets, as all elements are stored in memory."
      ],
      "metadata": {
        "id": "BgKxr90tI_b8"
      },
      "id": "BgKxr90tI_b8"
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Example:"
      ],
      "metadata": {
        "id": "7VeqkOA3JEMs"
      },
      "id": "7VeqkOA3JEMs"
    },
    {
      "cell_type": "code",
      "source": [
        "import sys\n",
        "\n",
        "# testing the memory with large number\n",
        "n = 10000000\n",
        "\n",
        "# measure memory\n",
        "list_memory = sys.getsizeof(list_numbers(n))\n",
        "\n",
        "print(f'Memory:{list_memory} bytes')"
      ],
      "metadata": {
        "id": "NRcjza_SPKuE",
        "outputId": "edd8b7fe-6eb3-466d-cd9f-9ed11a407fb0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "id": "NRcjza_SPKuE",
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Memory:89095160 bytes\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Generators:"
      ],
      "metadata": {
        "id": "2WqiMwhiPd_D"
      },
      "id": "2WqiMwhiPd_D"
    },
    {
      "cell_type": "markdown",
      "source": [
        "- Generators are memory-efficient, especially for large datasets, as only one element is generated at a time."
      ],
      "metadata": {
        "id": "xK1SPkvgPgCi"
      },
      "id": "xK1SPkvgPgCi"
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Example:"
      ],
      "metadata": {
        "id": "bS5fMOhbTtov"
      },
      "id": "bS5fMOhbTtov"
    },
    {
      "cell_type": "code",
      "source": [
        "import sys\n",
        "\n",
        "# testing the memory with large number\n",
        "n = 10000000\n",
        "\n",
        "# measure memory\n",
        "generator = sys.getsizeof(generate_numbers(n))\n",
        "\n",
        "print(f'Memory:{generator} bytes')"
      ],
      "metadata": {
        "id": "AUYMnM5uQxfm",
        "outputId": "9792a567-d360-4feb-b2d1-50d9bb5e7945",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "id": "AUYMnM5uQxfm",
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Memory:104 bytes\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 3. Speed:\n"
      ],
      "metadata": {
        "id": "D0AQQA4wQ6kJ"
      },
      "id": "D0AQQA4wQ6kJ"
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Lists:"
      ],
      "metadata": {
        "id": "lnGfiC05T_uh"
      },
      "id": "lnGfiC05T_uh"
    },
    {
      "cell_type": "markdown",
      "source": [
        "You can iterate over a list multiple times.\n",
        "\n",
        "- Accessing elements is fast and direct, as they are stored in contiguous memory locations."
      ],
      "metadata": {
        "id": "OBOqd4E8RtUU"
      },
      "id": "OBOqd4E8RtUU"
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Example:"
      ],
      "metadata": {
        "id": "JyMQ2pYaUONi"
      },
      "id": "JyMQ2pYaUONi"
    },
    {
      "cell_type": "code",
      "source": [
        "import timeit\n",
        "\n",
        "# testing the processing time with large number\n",
        "n = 10000000\n",
        "\n",
        "# measure processing time\n",
        "time = timeit.timeit(lambda: list_numbers(n), number=1)\n",
        "\n",
        "print(f'Time:{time} seconds')"
      ],
      "metadata": {
        "id": "_pqN4m8LUNTz",
        "outputId": "b24c8e70-e4c3-4496-a972-bec0dfc23837",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "id": "_pqN4m8LUNTz",
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Time:0.9491521830000238 seconds\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Generators:\n"
      ],
      "metadata": {
        "id": "Y1SGOzqsRtsC"
      },
      "id": "Y1SGOzqsRtsC"
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "- Generators can be iterated only once. Once exhausted, they need to be recreated to start over."
      ],
      "metadata": {
        "id": "OvsSoahbRwPD"
      },
      "id": "OvsSoahbRwPD"
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Example:"
      ],
      "metadata": {
        "id": "Hvog03yoVelO"
      },
      "id": "Hvog03yoVelO"
    },
    {
      "cell_type": "code",
      "source": [
        "import timeit\n",
        "\n",
        "# testing the processing time with large number\n",
        "n = 10000000\n",
        "\n",
        "# measure processing time\n",
        "time = timeit.timeit(lambda: list(generate_numbers(n)), number=1)\n",
        "\n",
        "print(f'Time:{str(time)} seconds')"
      ],
      "metadata": {
        "id": "bEt0Aqv0S4MN",
        "outputId": "0371708a-10c8-48ae-dd1d-30b18d42be1a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "id": "bEt0Aqv0S4MN",
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Time:2.284345508000115 seconds\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Use Cases:\n",
        "### Lists:\n",
        "\n",
        "- Use when you need to access elements randomly.\n",
        "- When you want to perform multiple operations on the data(e.g., `append()`, `extend()`, `remove(`), etc).\n",
        "- When the dataset is small enough to fit in memory.\n",
        "\n",
        "### Generators:\n",
        "\n",
        "- Use when dealing with large datasets to conserve memory.\n",
        "- When you need to generate values on-the-fly.\n",
        "- For scenarios where you only need to iterate over the data once.\n"
      ],
      "metadata": {
        "id": "RlWxKjaDVhWV"
      },
      "id": "RlWxKjaDVhWV"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Summary:"
      ],
      "metadata": {
        "id": "egqX9oDUVzaP"
      },
      "id": "egqX9oDUVzaP"
    },
    {
      "cell_type": "markdown",
      "source": [
        "In summary, choose between **lists** and **generators** based on your specific requirements, considering factors like memory usage, lazy evaluation, and the need for random access or multiple operations."
      ],
      "metadata": {
        "id": "6tnv5kJoV1Ef"
      },
      "id": "6tnv5kJoV1Ef"
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "htwkdNGvGIKs"
      },
      "id": "htwkdNGvGIKs"
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Structural Pattern Matching"
      ],
      "metadata": {
        "id": "T383AQsQEZ5y"
      },
      "id": "T383AQsQEZ5y"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Introduction"
      ],
      "metadata": {
        "id": "CIsJArUcEjly"
      },
      "id": "CIsJArUcEjly"
    },
    {
      "cell_type": "markdown",
      "source": [
        "Hey everyone, and welcome to this tutorial on structural pattern matching in Python! Structural pattern matching is a new feature in Python 3.10 that allows you to match patterns against complex data structures, such as lists, dictionaries, and objects. This can make your code more concise and readable.\n",
        "\n",
        "In this tutorial, I'll show you how structural pattern matching can simplify your code. We'll start by comparing it with traditional if-else statements."
      ],
      "metadata": {
        "id": "M5WVLqvyKm1Y"
      },
      "id": "M5WVLqvyKm1Y"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## What is structural pattern matching?"
      ],
      "metadata": {
        "id": "lPRf6gQiKixv"
      },
      "id": "lPRf6gQiKixv"
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Structural pattern matching** is a new feature in Python 3.10 that allows you to match patterns against complex data structures, such as **lists**, **tuples**, **dictionaries**, and **objects**.\n",
        "\n",
        "This feature facilitates the concise and readable handling of structured data, making code more expressive and easier to maintain."
      ],
      "metadata": {
        "id": "wT6UHG6AEmGs"
      },
      "id": "wT6UHG6AEmGs"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Example 1:\n",
        "Example of structural pattern matching in Python 3.10"
      ],
      "metadata": {
        "id": "0G1fhVy9J_IT"
      },
      "id": "0G1fhVy9J_IT"
    },
    {
      "cell_type": "code",
      "source": [
        "data = (3, 3, 3)\n",
        "\n",
        "match data:\n",
        "    case (1, x, y):\n",
        "        print(f\"First element is 1, and other elements are {x} and {y}.\")\n",
        "    case (1, 2, 3):\n",
        "        print(\"Data matches the pattern (1, 2, 3).\")\n",
        "    case (a, b, c) if a == b == c:\n",
        "        print(f\"All elements are the same and have a value of {a}.\")\n",
        "    case _:\n",
        "        print(\"No match found.\")\n"
      ],
      "metadata": {
        "id": "kPR93Zk1KBF4"
      },
      "id": "kPR93Zk1KBF4",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Code explanation:"
      ],
      "metadata": {
        "id": "ZRByFfNmNBCm"
      },
      "id": "ZRByFfNmNBCm"
    },
    {
      "cell_type": "markdown",
      "source": [
        "In this example, the `match` statement is used to match the structure of the data **tuple** against different patterns.\n",
        "\n",
        " - The `case` keyword is used to define different patterns, and the code within each case block is executed when the corresponding pattern is matched.\n",
        "\n",
        "- The `_` case serves as a wildcard for any pattern that does not match the earlier cases.\n",
        "\n"
      ],
      "metadata": {
        "id": "5YJlTIxANEoH"
      },
      "id": "5YJlTIxANEoH"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Example 2: Replace nested if-else statement"
      ],
      "metadata": {
        "id": "hdSFyWMAPHoS"
      },
      "id": "hdSFyWMAPHoS"
    },
    {
      "cell_type": "markdown",
      "source": [
        "It can also replace the need for multiple nested if-else or switch-case statements, making the code more elegant and easier to understand."
      ],
      "metadata": {
        "id": "QYaBiOjOJ85y"
      },
      "id": "QYaBiOjOJ85y"
    },
    {
      "cell_type": "code",
      "source": [
        "# Nested if-else statement example\n",
        "x, y = 10, 5\n",
        "\n",
        "if x > 5:\n",
        "    if y > 5:\n",
        "        print(\"Both x and y are greater than 5\")\n",
        "    else:\n",
        "        print(\"x is greater than 5, but y is not greater than 5\")\n",
        "else:\n",
        "    print(\"x is not greater than 5\")"
      ],
      "metadata": {
        "id": "04JnhozKPNsN"
      },
      "id": "04JnhozKPNsN",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Equivalent code using structural pattern matching\n",
        "match (x, y):\n",
        "    case (a, b) if a > 5 and b > 5:\n",
        "        print(\"Both x and y are greater than 5\")\n",
        "    case (a, b) if a > 5 and b <= 5:\n",
        "        print(\"x is greater than 5, but y is not greater than 5\")\n",
        "    case _:\n",
        "        print(\"x is not greater than 5\")\n"
      ],
      "metadata": {
        "id": "zBgsZxCjPUGe"
      },
      "id": "zBgsZxCjPUGe",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "2a0k3DdGPoKQ"
      },
      "id": "2a0k3DdGPoKQ"
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "# How to Read a Digit from an Image in Python(Easy OCR Tutorial)"
      ],
      "metadata": {
        "id": "o3z98JGGbvv9"
      },
      "id": "o3z98JGGbvv9"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Introduction"
      ],
      "metadata": {
        "id": "d7ojAeeCb0gP"
      },
      "id": "d7ojAeeCb0gP"
    },
    {
      "cell_type": "markdown",
      "source": [
        "In this video, we will learn how to read a digit from an image in Python on Google Colab using EasyOCR. EasyOCR is a powerful and easy-to-use OCR library that is well-suited for a variety of tasks, including reading digits from images.\n",
        "\n",
        "Python,\n",
        "EasyOCR,\n",
        "Google Colab,\n",
        "OCR,\n",
        "digit recognition,\n",
        "optical character recognition,\n",
        "image processing,\n",
        "image analysis,\n",
        "read digits python,\n",
        "opencv,\n",
        "image detection,\n",
        "python detecting image,"
      ],
      "metadata": {
        "id": "StIw2mlnb5lL"
      },
      "id": "StIw2mlnb5lL"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Code"
      ],
      "metadata": {
        "id": "cPZ98sWGb_l-"
      },
      "id": "cPZ98sWGb_l-"
    },
    {
      "cell_type": "code",
      "source": [
        "#!pip install easyocr"
      ],
      "metadata": {
        "id": "cVD6U3qjcDnB"
      },
      "id": "cVD6U3qjcDnB",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import easyocr\n",
        "\n",
        "def read_digit(input_image):\n",
        "  reader = easyocr.Reader(['en'])\n",
        "  results = reader.readtext(input_image)\n",
        "  return results"
      ],
      "metadata": {
        "id": "tCzH1Lebb-ht"
      },
      "id": "tCzH1Lebb-ht",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "results = read_digit('196.jpg')"
      ],
      "metadata": {
        "id": "XjDuXyWncJGe"
      },
      "id": "XjDuXyWncJGe",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "for digit in results:\n",
        "  print(digit)"
      ],
      "metadata": {
        "id": "D3jnuTMZcLZf"
      },
      "id": "D3jnuTMZcLZf",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# digit = results[0][1][0]\n",
        "for digit in results:\n",
        "  if digit[1].isdigit():\n",
        "    print(f'The digit is:{digit[1]}')\n",
        "  else:\n",
        "    print(f'{digit[1]} is not digit.')"
      ],
      "metadata": {
        "id": "2I5SxcWBcOaE"
      },
      "id": "2I5SxcWBcOaE",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Result"
      ],
      "metadata": {
        "id": "9wj5gNZobd5B"
      },
      "id": "9wj5gNZobd5B"
    },
    {
      "cell_type": "markdown",
      "source": [
        "The first element is a list of four coordinates, which represent the bounding box of the digit that was recognized.\n",
        "\n",
        "The coordinates are in the format [x, y, x, y], where x and y are the coordinates of the top-left and bottom-right corners of the bounding box, respectively.\n",
        "\n",
        "The second element is the string representation of the digit that was recognized.\n",
        "\n",
        "The third element is the confidence score of the recognition. A confidence score of 1.0 indicates that the recognition is very confident, while a confidence score of 0.0 indicates that the recognition is very uncertain.\n"
      ],
      "metadata": {
        "id": "4AG433QFbiXn"
      },
      "id": "4AG433QFbiXn"
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "j-z1SPdSbh6L"
      },
      "id": "j-z1SPdSbh6L",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "---\n",
        "---\n",
        "---\n",
        "# Args and Kwargs in Python"
      ],
      "metadata": {
        "id": "k9HQH69jH0bV"
      },
      "id": "k9HQH69jH0bV"
    },
    {
      "cell_type": "markdown",
      "source": [
        "By the end of this tutorial, you will be able to understand:\n",
        "- about args and kwargs\n",
        "- how to use them\n",
        "- benefits of using them"
      ],
      "metadata": {
        "id": "ucndhxv8IC2N"
      },
      "id": "ucndhxv8IC2N"
    },
    {
      "cell_type": "markdown",
      "source": [
        "In Python, `*args` and `**kwargs` allow you to pass a variable number of arguments to a function.\n",
        "\n",
        "They are used to handle the cases where you are not sure about the number of arguments that will be passed to a function.\n",
        "\n",
        "Here's a detailed explanation of `*args` and `**kwargs` with examples:"
      ],
      "metadata": {
        "id": "I0YsCKHiIT8R"
      },
      "id": "I0YsCKHiIT8R"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 1. *args (Non-Keyword Arguments):"
      ],
      "metadata": {
        "id": "mrkXc93mKH-l"
      },
      "id": "mrkXc93mKH-l"
    },
    {
      "cell_type": "markdown",
      "source": [
        "It is used to pass a variable number of non-keyword arguments to a function.\n",
        "\n",
        "The `* (asterisk)` before the variable name args allows you to pass any number of arguments to the function."
      ],
      "metadata": {
        "id": "MWvwhIXBKKz5"
      },
      "id": "MWvwhIXBKKz5"
    },
    {
      "cell_type": "markdown",
      "source": [
        "`*args` specifies the number of non-keyworded arguments that can be passed and the operations that can be performed on the function  "
      ],
      "metadata": {
        "id": "jHKpeOYwJCjl"
      },
      "id": "jHKpeOYwJCjl"
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Example"
      ],
      "metadata": {
        "id": "-E_nDlIzKoyP"
      },
      "id": "-E_nDlIzKoyP"
    },
    {
      "cell_type": "code",
      "source": [
        "def my_function(*args):\n",
        "    for arg in args:\n",
        "        print(arg, end=' ')\n"
      ],
      "metadata": {
        "id": "pvvTUPcoKuAc"
      },
      "id": "pvvTUPcoKuAc",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "my_function('Hello', 'Asibeh', 'Welcome')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "StaJBASjK4ya",
        "outputId": "0f9f611b-df10-4295-e03a-7009fa4db554"
      },
      "id": "StaJBASjK4ya",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello Asibeh Welcome "
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "my_function('Hello', 'Asibeh!', 'Welcome', 'to', 'epythonlab')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "d5y5qVYxK9Op",
        "outputId": "124d7f31-0df7-4bdd-8555-f26446d140ba"
      },
      "id": "d5y5qVYxK9Op",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello Asibeh! Welcome to epythonlab "
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 2. `**kwargs (Keyword Arguments)`:"
      ],
      "metadata": {
        "id": "sok8ZsE-LrHz"
      },
      "id": "sok8ZsE-LrHz"
    },
    {
      "cell_type": "markdown",
      "source": [
        "**kwargs is a variable number of keyword arguments that can be passed to a function that can perform dictionary operations\n",
        "\n",
        "The `** (double asterisks)` before the variable name kwargs allows you to pass any number of keyword arguments to the function."
      ],
      "metadata": {
        "id": "5Pf4RiSpKneU"
      },
      "id": "5Pf4RiSpKneU"
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Example"
      ],
      "metadata": {
        "id": "ZMVilEneKHad"
      },
      "id": "ZMVilEneKHad"
    },
    {
      "cell_type": "code",
      "source": [
        "def my_function(**kwargs):\n",
        "  print(kwargs.items())\n",
        "  for key, value in kwargs.items():\n",
        "      print(f\"{key}: {value}\")\n"
      ],
      "metadata": {
        "id": "PwJWUbUIMeZa"
      },
      "id": "PwJWUbUIMeZa",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "my_function(first_name='Asibeh', last_name='Tenager', age=30)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xYeSO6bjMhfY",
        "outputId": "91fb25f7-ac65-42d0-f02d-7740997898bf"
      },
      "id": "xYeSO6bjMhfY",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "dict_items([('first_name', 'Asibeh'), ('last_name', 'Tenager'), ('age', 30)])\n",
            "first_name: Asibeh\n",
            "last_name: Tenager\n",
            "age: 30\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Benefits of using *args and **kwargs:\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "s6zZYLryNLDS"
      },
      "id": "s6zZYLryNLDS"
    },
    {
      "cell_type": "markdown",
      "source": [
        "- **Flexibility**: They provide the flexibility to handle an arbitrary number of arguments, which can be useful when you're unsure about the number of inputs to your function.\n",
        "\n",
        "- **Code Readability**: They enhance the readability of your code, as they allow you to pass multiple arguments without explicitly defining them in the function definition.\n",
        "\n",
        "- **Function Overloading**: Python does not support function overloading by default, but using `*args` and `**kwargs`, you can create functions that can accept different numbers of arguments."
      ],
      "metadata": {
        "id": "xnmAzSumNOmS"
      },
      "id": "xnmAzSumNOmS"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Conclusion"
      ],
      "metadata": {
        "id": "0DbMsH7INiqD"
      },
      "id": "0DbMsH7INiqD"
    },
    {
      "cell_type": "markdown",
      "source": [
        "Using `*args` and `**kwargs` can significantly improve the flexibility and readability of your code, especially when dealing with functions that need to handle varying numbers of inputs."
      ],
      "metadata": {
        "id": "47WFiyCxNkNl"
      },
      "id": "47WFiyCxNkNl"
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n"
      ],
      "metadata": {
        "id": "emV6NDuNH1Zr"
      },
      "id": "emV6NDuNH1Zr"
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Decorators in Python"
      ],
      "metadata": {
        "id": "euy10EAB8XWT"
      },
      "id": "euy10EAB8XWT"
    },
    {
      "cell_type": "markdown",
      "source": [
        "By the end of this tutorial, you be able to understand:\n",
        "- what is decorator\n",
        "- how to implement decorators\n",
        "- what are the benefits of using decorators"
      ],
      "metadata": {
        "id": "JT_tbrx-AYwU"
      },
      "id": "JT_tbrx-AYwU"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## What is decorator?"
      ],
      "metadata": {
        "id": "kz4bn05H8bSR"
      },
      "id": "kz4bn05H8bSR"
    },
    {
      "cell_type": "markdown",
      "source": [
        "A **decorator** is a design pattern in Python that allows a user to add new functionality to an existing object without modifying its structure.\n",
        "\n",
        "**Decorators** are usually called before the definition of a function you want to decorate."
      ],
      "metadata": {
        "id": "wAMsDYwl8o9F"
      },
      "id": "wAMsDYwl8o9F"
    },
    {
      "cell_type": "markdown",
      "source": [
        "In Python, a **decorator** is a callable that returns a callable. This means that a decorator can be:\n",
        "- a function,\n",
        "- a class,\n",
        "- or any other object that implements the `__call__()` method."
      ],
      "metadata": {
        "id": "CURTwLvi9Jv3"
      },
      "id": "CURTwLvi9Jv3"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Example: a Python decorator that can help with authentication in a web application:"
      ],
      "metadata": {
        "id": "6LkWSmu29dnh"
      },
      "id": "6LkWSmu29dnh"
    },
    {
      "cell_type": "code",
      "source": [
        "# Simulating user authentication with a simple dictionary\n",
        "USER_DATA = {\n",
        "    'username': 'admin',\n",
        "    'password': '1234'\n",
        "}\n"
      ],
      "metadata": {
        "id": "_HSyzahc9n_V"
      },
      "id": "_HSyzahc9n_V",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Define a decorator for authentication\n",
        "def authenticate(func):\n",
        "    def wrapper(*args, **kwargs):\n",
        "        username = input(\"Enter your username: \")\n",
        "        password = input(\"Enter your password: \")\n",
        "        if username == USER_DATA['username'] and password == USER_DATA['password']:\n",
        "            print(\"Authentication successful\")\n",
        "            return func(*args, **kwargs)\n",
        "        else:\n",
        "            print(\"Authentication failed. Access denied.\")\n",
        "    return wrapper"
      ],
      "metadata": {
        "id": "Zaq94z3N9p18"
      },
      "id": "Zaq94z3N9p18",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Apply the decorator to a function that requires authentication\n",
        "@authenticate\n",
        "def sensitive_operation():\n",
        "    print(\"Performing sensitive operation...\")\n",
        "\n",
        "# Trying to access the sensitive operation\n",
        "sensitive_operation()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nRkNzM0g94EL",
        "outputId": "9e1c3c33-f90c-483b-f784-7b81186b2e4e"
      },
      "id": "nRkNzM0g94EL",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter your username: 23\n",
            "Enter your password: 5\n",
            "Authentication failed. Access denied.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Explanation of the code"
      ],
      "metadata": {
        "id": "AKzif2l_-jMA"
      },
      "id": "AKzif2l_-jMA"
    },
    {
      "cell_type": "markdown",
      "source": [
        "In this example:\n",
        "\n",
        "The **authenticate** decorator checks for valid user credentials before allowing access to the decorated function.\n",
        "\n",
        "The **wrapper** function prompts the user to enter a username and password, and if the credentials match those in **USER_DATA**, the decorated function is executed; otherwise, **access is denied**.\n",
        "\n",
        "The **sensitive_operation** function, decorated with **@authenticate**, simulates a sensitive operation that should only be accessible to authorized users.\n",
        "\n",
        "When you run the script, you will be prompted to enter your username and password. If you enter the correct credentials ('admin' and '1234' in this case), you will see:"
      ],
      "metadata": {
        "id": "rSURF_Je-lxb"
      },
      "id": "rSURF_Je-lxb"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Benefits of using decorators"
      ],
      "metadata": {
        "id": "2vtcfZN9_vb2"
      },
      "id": "2vtcfZN9_vb2"
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "There are several benefits to using decorators:\n",
        "\n",
        "- **Improved code readability**: Decorators can make code more readable by separating cross-cutting concerns from the core functionality of a function.\n",
        "- **Reduced code duplication**: Decorators can help to reduce code duplication by providing a way to add common functionality to multiple functions.\n",
        "- **Increased flexibility**: Decorators can be used to create more flexible and reusable code."
      ],
      "metadata": {
        "id": "c7qYXyt7_yUW"
      },
      "id": "c7qYXyt7_yUW"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Conclusion"
      ],
      "metadata": {
        "id": "NaVmqffP_Ki_"
      },
      "id": "NaVmqffP_Ki_"
    },
    {
      "cell_type": "markdown",
      "source": [
        "This example demonstrates the importance of decorators in providing a way to add functionality, such as **authentication**, to functions or methods without modifying their actual code. **Decorators** allow you to implement cross-cutting concerns in a clean and modular way, improving the maintainability and reusability of your code."
      ],
      "metadata": {
        "id": "5mIxMwsF_MKv"
      },
      "id": "5mIxMwsF_MKv"
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "jihzXKo98b2n"
      },
      "id": "jihzXKo98b2n"
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Mastering Code Review Techniques in Python"
      ],
      "metadata": {
        "id": "YdGGKRbsr-kG"
      },
      "id": "YdGGKRbsr-kG"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Description:"
      ],
      "metadata": {
        "id": "prRIN5hRpSqM"
      },
      "id": "prRIN5hRpSqM"
    },
    {
      "cell_type": "markdown",
      "source": [
        "Dive deep into essential code review techniques in Python and enhance your software development skills. This comprehensive tutorial covers style guidelines, readability and maintainability, error detection and bug fixing, scalability and performance optimization, security and robustness considerations, and testability. Gain practical insights and learn through hands-on examples to improve your code quality and collaboration efficiency.\n",
        "\n",
        "Keywords: code review techniques, Python, software development, style guidelines, readability, maintainability, error detection, bug fixing, scalability, performance optimization, security, robustness, testability, examples, collaboration"
      ],
      "metadata": {
        "id": "b1wLPzGZpL0j"
      },
      "id": "b1wLPzGZpL0j"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 1. Style Guidelines"
      ],
      "metadata": {
        "id": "cveZlYLBpY1O"
      },
      "id": "cveZlYLBpY1O"
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Explore the importance of adhering to style guidelines such as PEP 8 for consistent code formatting and readability.\n",
        "* Compare poorly formatted code with PEP 8-compliant code, highlighting the significance of proper indentation, spacing, and naming conventions."
      ],
      "metadata": {
        "id": "04voGflVpgS8"
      },
      "id": "04voGflVpgS8"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Example:\n"
      ],
      "metadata": {
        "id": "5fK3FtuZpj4i"
      },
      "id": "5fK3FtuZpj4i"
    },
    {
      "cell_type": "code",
      "source": [
        "# PEP 8 violation\n",
        "my_variable= 10\n",
        "\n",
        "# PEP 8 compliant\n",
        "my_variable = 10\n"
      ],
      "metadata": {
        "id": "Un3KNvQkpl7D"
      },
      "id": "Un3KNvQkpl7D",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 2. Readability and Maintainability:\n",
        "\n"
      ],
      "metadata": {
        "id": "6FaBy3WCp5Z2"
      },
      "id": "6FaBy3WCp5Z2"
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Discuss the significance of writing code that is easy to understand, modify, and maintain over time.\n",
        "* Compare code with poorly named variables and functions to code with descriptive names, emphasizing the importance of clarity and maintainability.\n"
      ],
      "metadata": {
        "id": "1J1QLF_Np-sr"
      },
      "id": "1J1QLF_Np-sr"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Example:"
      ],
      "metadata": {
        "id": "HXHcuEwHqAIO"
      },
      "id": "HXHcuEwHqAIO"
    },
    {
      "cell_type": "code",
      "source": [
        "# Poorly named variable\n",
        "x = 10\n",
        "\n",
        "# Descriptive variable name\n",
        "total_students = 10\n"
      ],
      "metadata": {
        "id": "dy5IxhomqM75"
      },
      "id": "dy5IxhomqM75",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 3. Error Detection and Bug Fixing:\n"
      ],
      "metadata": {
        "id": "0rdgBWHpqmjd"
      },
      "id": "0rdgBWHpqmjd"
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "* Identify and resolve logical errors, missing or redundant statements, and exceptions in Python code.\n",
        "*  Identify a logical error in a function calculating discount prices and suggest a fix. Also, review exception handling in code that performs division and propose improvements.\n"
      ],
      "metadata": {
        "id": "xgfbwp10qqZs"
      },
      "id": "xgfbwp10qqZs"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Example:"
      ],
      "metadata": {
        "id": "OEfSwyXOqra8"
      },
      "id": "OEfSwyXOqra8"
    },
    {
      "cell_type": "code",
      "source": [
        "# Logical error\n",
        "def calculate_discount(price, discount_percentage):\n",
        "    discount = price * discount_percentage / 100 # logical error\n",
        "    # corrected formula is\n",
        "    discount = price * (discount_percentage / 100)\n",
        "    discounted_price = price - discount\n",
        "    return discounted_price\n"
      ],
      "metadata": {
        "id": "TGGNwO5XqtLY"
      },
      "id": "TGGNwO5XqtLY",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# Missing exception handling\n",
        "def divide_numbers(a, b):\n",
        "  try:\n",
        "\n",
        "    return a / b\n",
        "  except ZeroDivisionError:\n",
        "    print('Does not divid by zero')\n",
        "\n",
        "divide_numbers(2, 0)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kkapp7UWq5h4",
        "outputId": "d54341ed-c27d-4471-ecb9-e48ef97e8b9c"
      },
      "id": "kkapp7UWq5h4",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Does not divid by zero\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 4.Scalability and Performance Optimization:\n",
        "\n"
      ],
      "metadata": {
        "id": "zZUJO0fPrfyg"
      },
      "id": "zZUJO0fPrfyg"
    },
    {
      "cell_type": "markdown",
      "source": [
        "* optimize code for better scalability and performance.\n",
        "* Compare an inefficient loop for summing numbers with a more efficient approach using built-in functions, showcasing the impact of optimizing code for better performance.\n"
      ],
      "metadata": {
        "id": "6CVepirWvUNl"
      },
      "id": "6CVepirWvUNl"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Example:"
      ],
      "metadata": {
        "id": "XDrKcISirlel"
      },
      "id": "XDrKcISirlel"
    },
    {
      "cell_type": "code",
      "source": [
        "# Inefficient loop\n",
        "numbers = [1, 2, 3, 4, 5]\n",
        "sum = 0\n",
        "for num in numbers:\n",
        "    sum += num\n",
        "print(sum)"
      ],
      "metadata": {
        "id": "J7u_SkeurmrR"
      },
      "id": "J7u_SkeurmrR",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# More efficient approach using sum()\n",
        "numbers = [1, 2, 3, 4, 5]\n",
        "total = sum(numbers)\n",
        "print(total)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YcYQHdGwrtYQ",
        "outputId": "2d7bb46a-fd85-4bd6-e256-1b4599f27cbb"
      },
      "id": "YcYQHdGwrtYQ",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "15\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 5. Security and Robustness Considerations:\n",
        "\n"
      ],
      "metadata": {
        "id": "rIq8r7egr0Br"
      },
      "id": "rIq8r7egr0Br"
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Discuss the importance of writing secure and robust code.\n",
        "* Identify code vulnerable to SQL injections and propose a safer approach using parameterized queries, highlighting the significance of input validation and security measures.\n"
      ],
      "metadata": {
        "id": "4ebI-lXvsQbt"
      },
      "id": "4ebI-lXvsQbt"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Example:"
      ],
      "metadata": {
        "id": "TLHNqgYMsSxd"
      },
      "id": "TLHNqgYMsSxd"
    },
    {
      "cell_type": "code",
      "source": [
        "# Vulnerable to SQL injection\n",
        "query = \"SELECT * FROM users WHERE username = '{}'\".format(user_input)\n",
        "\n",
        "# Preventing SQL injection with parameterized queries\n",
        "query = \"SELECT * FROM users WHERE username = %s\"\n",
        "cursor.execute(query, (user_input,))\n"
      ],
      "metadata": {
        "id": "KEuV3eXzsX3L"
      },
      "id": "KEuV3eXzsX3L",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 6. Testability:\n",
        "\n"
      ],
      "metadata": {
        "id": "9JLFqMfbsoMv"
      },
      "id": "9JLFqMfbsoMv"
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Emphasize the significance of testability in code review.\n",
        "*  Evaluate code with inadequate test coverage and suggest additional test cases, demonstrating the importance of comprehensive testing and providing practical scenarios."
      ],
      "metadata": {
        "id": "aJZFyOs2sqjz"
      },
      "id": "aJZFyOs2sqjz"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Example:"
      ],
      "metadata": {
        "id": "VnBLoIKdssba"
      },
      "id": "VnBLoIKdssba"
    },
    {
      "cell_type": "code",
      "source": [
        "# Inadequate test coverage\n",
        "def calculate_sum(a, b):\n",
        "    return a + b\n",
        "\n",
        "# Suggested test case\n",
        "assert calculate_sum(3, 4) == 7\n"
      ],
      "metadata": {
        "id": "kqFvAjAXsvAC"
      },
      "id": "kqFvAjAXsvAC",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "------\n"
      ],
      "metadata": {
        "id": "MkCi-WWYsQXy"
      },
      "id": "MkCi-WWYsQXy"
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Working with YAML Files in Python: Reading and Writing Data"
      ],
      "metadata": {
        "id": "br6ON1oLFH2k"
      },
      "id": "br6ON1oLFH2k"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Description:"
      ],
      "metadata": {
        "id": "HonY6Ux4H-Ah"
      },
      "id": "HonY6Ux4H-Ah"
    },
    {
      "cell_type": "markdown",
      "source": [
        "In this tutorial, you will learn how to work with `YAML` files in Python. `YAML` files are widely used for data serialization and configuration purposes, offering a human-readable format for storing hierarchical data. I'll cover the basics of reading and writing `YAML` files in Python and explore methods for parsing and manipulating `YAML` data. Discover the power of Python's libraries, such as `PyYAML`, for seamless handling of `YAML` files. Whether you're new to `YAML` or looking to enhance your skills, this tutorial will provide you with the essential knowledge to effectively work with `YAML` files in your Python projects. Join us as we delve into `YAML` data representation, file format intricacies, and best practices for managing YAML structures. Get ready to unlock the potential of YAML and streamline your data workflows in Python!\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "yx-jdi2IGEUb"
      },
      "id": "yx-jdi2IGEUb"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## What is YAML?"
      ],
      "metadata": {
        "id": "zm5iJRzIHedk"
      },
      "id": "zm5iJRzIHedk"
    },
    {
      "cell_type": "markdown",
      "source": [
        "A YAML (YAML Ain't Markup Language) file is a human-readable data serialization format.\n",
        "It is often used for\n",
        "* configuration files,\n",
        "* data interchange, and\n",
        "* storing hierarchical data.\n",
        "\n",
        "YAML files use indentation and a simple syntax to represent data structures like `lists`, `dictionaries`, and `scalar values`.\n",
        "\n",
        "In Python, you can work with YAML files using the `pyyaml` library.\n",
        "\n",
        "Here's an example of the Python syntax for working with YAML:\n",
        "\n"
      ],
      "metadata": {
        "id": "OQfvV19rHcYV"
      },
      "id": "OQfvV19rHcYV"
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 1. Installing the `pyyaml` library:"
      ],
      "metadata": {
        "id": "2q9eEACDNKZs"
      },
      "id": "2q9eEACDNKZs"
    },
    {
      "cell_type": "code",
      "source": [
        "#!pip install pyyaml"
      ],
      "metadata": {
        "id": "diLp3dFTFG_7"
      },
      "id": "diLp3dFTFG_7",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 2. Importing the `yaml` module:"
      ],
      "metadata": {
        "id": "xUwATC8yNXQQ"
      },
      "id": "xUwATC8yNXQQ"
    },
    {
      "cell_type": "code",
      "source": [
        "# first import the yaml module\n",
        "import yaml"
      ],
      "metadata": {
        "id": "SBEfZ-BqNoeU"
      },
      "id": "SBEfZ-BqNoeU",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 3. Writing a yaml file"
      ],
      "metadata": {
        "id": "iLf2fJBhPFI-"
      },
      "id": "iLf2fJBhPFI-"
    },
    {
      "cell_type": "code",
      "source": [
        "# Writing a YAML file\n",
        "data = {\n",
        "    'name': 'Asibeh Tenager',\n",
        "    'age': 30,\n",
        "    'email': 'ast@epythonlab.com'\n",
        "}\n",
        "\n",
        "with open('output.yaml', 'w') as file:\n",
        "    yaml.dump(data, file)"
      ],
      "metadata": {
        "id": "R0HYTSqkPU4O"
      },
      "id": "R0HYTSqkPU4O",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "To write a YAML file, we create a dictionary data with some sample data.\n",
        "\n",
        "We open a file in write mode using `open()`, and then we use `yaml.dump()` to write the dictionary data as YAML to the file."
      ],
      "metadata": {
        "id": "UnW8qlNLSlFr"
      },
      "id": "UnW8qlNLSlFr"
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 4. Reading YAML data from a file:"
      ],
      "metadata": {
        "id": "QBemFNh4NtSC"
      },
      "id": "QBemFNh4NtSC"
    },
    {
      "cell_type": "code",
      "source": [
        "# reading yaml data\n",
        "\n",
        "with open('output.yaml', 'r') as file:\n",
        "    data = yaml.load(file, Loader=yaml.SafeLoader)\n",
        "    print(data)"
      ],
      "metadata": {
        "id": "LXwu3affN0y7",
        "outputId": "2625cb40-77c0-42bd-a01a-f23e3f5c30ec",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "id": "LXwu3affN0y7",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'age': 30, 'email': 'ast@epythonlab.com', 'name': 'Asibeh Tenager'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "To read a YAML file, we use the `open()` function to open the file in read mode,\n",
        "and then we use `yaml.load()` to load the YAML data.\n",
        "\n",
        "The `Loader=yaml.FullLoader` argument is used to specify the loader for the YAML data."
      ],
      "metadata": {
        "id": "Nh7oIEvoS-dj"
      },
      "id": "Nh7oIEvoS-dj"
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Note:** The `yaml.load()` function is generally safe for loading YAML from trusted sources. However, if you're working with untrusted input, you should use the `SafeLoader` instead of `FullLoader` to mitigate potential security risks."
      ],
      "metadata": {
        "id": "WXYhCe7YTG8E"
      },
      "id": "WXYhCe7YTG8E"
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Conclusion:\n"
      ],
      "metadata": {
        "id": "sCDGCzDENnh7"
      },
      "id": "sCDGCzDENnh7"
    },
    {
      "cell_type": "markdown",
      "source": [
        "These are some basic examples of how to work with YAML in Python using the `pyyaml` library.\n",
        "\n",
        "YAML is known for its **simplicity, readability, and ease of use**, making it suitable for various applications such as configuration files, data serialization, and more.\n",
        "\n",
        "Remember to handle file operations carefully and use appropriate error handling techniques when you're working with files or parsing YAML data."
      ],
      "metadata": {
        "id": "HzxaLpTfmcM4"
      },
      "id": "HzxaLpTfmcM4"
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "1MfS56jmTu7T"
      },
      "id": "1MfS56jmTu7T"
    },
    {
      "cell_type": "markdown",
      "source": [
        "# The end\n",
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "O7-0jUFhme8H"
      },
      "id": "O7-0jUFhme8H"
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 5 Mistakes Every Python Developer Should Avoid"
      ],
      "metadata": {
        "id": "Pp0JeLhMP8jV"
      },
      "id": "Pp0JeLhMP8jV"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 1. Avoid using global variables\n",
        "> accessible and can be modified globaly"
      ],
      "metadata": {
        "id": "LTdApfKXQHu2"
      },
      "id": "LTdApfKXQHu2"
    },
    {
      "cell_type": "code",
      "source": [
        "# bad - using global variables\n",
        "age = 23;\n",
        "def getAge():\n",
        "  global age\n",
        "  age += 1; # add 1 every year\n",
        "  return age\n"
      ],
      "metadata": {
        "id": "gZLvKUrAQHI3"
      },
      "id": "gZLvKUrAQHI3",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# good - using local variables\n",
        "def myAge(age):\n",
        "  age += 1 # increase by 1 every year\n",
        "  return age"
      ],
      "metadata": {
        "id": "A7jqzupOQ5At"
      },
      "id": "A7jqzupOQ5At",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 2. Avoid blocking I/O operations\n",
        "> make your code slower and less responsive"
      ],
      "metadata": {
        "id": "5bR7FG5qRN2N"
      },
      "id": "5bR7FG5qRN2N"
    },
    {
      "cell_type": "code",
      "source": [
        "# bad - blocking I/O\n",
        "import requests\n",
        "response = requests.get('https://epythonlab.github.io/myportfolio')\n",
        "response.text"
      ],
      "metadata": {
        "id": "fuhAbx85Rt7B",
        "outputId": "477d0531-7af9-4f65-a19f-d513c14bda83",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "id": "fuhAbx85Rt7B",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<Response [200]>"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# good - non-blocking I/O\n",
        "import async\n",
        "import aiohttp\n",
        "\n",
        "async def fetch(session, url):\n",
        "  async with session.get(url) as response:\n",
        "    return await response.text()\n",
        "\n",
        "async def main():\n",
        "  async with aiohttp.ClientSession() as session:\n",
        "    html = await fetch(session, 'https://epythonlab.github.io/myportfolio')\n",
        "    print(html)\n",
        "\n",
        "async.run(main())"
      ],
      "metadata": {
        "id": "VlbsPhY1SV7F"
      },
      "id": "VlbsPhY1SV7F",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 3. Avoid using `eval()` and `exec()`\n",
        "> make your code less secure"
      ],
      "metadata": {
        "id": "Ky6F9eOIT8Nw"
      },
      "id": "Ky6F9eOIT8Nw"
    },
    {
      "cell_type": "code",
      "source": [
        "# bad - using eval()\n",
        "my_var = '1 + 2'\n",
        "result = eval(my_var)\n",
        "print(result)"
      ],
      "metadata": {
        "id": "PA45-wWqUHdf",
        "outputId": "c2d0a0d8-1e72-4e03-84ca-d8e5aa3b4596",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "id": "PA45-wWqUHdf",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# good - use ast.literal_eval() to savely evaluate literals\n",
        "import ast\n",
        "x = ast.literal_eval('2')\n",
        "y = ast.literal_eval('4')\n",
        "result = x + y\n",
        "print(result)"
      ],
      "metadata": {
        "id": "rTiub8BkUbzo",
        "outputId": "f273ebd9-1a13-45af-b24b-6cc60d5deed7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "id": "rTiub8BkUbzo",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "6\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 4. Avoid using mutable default arguments\n",
        "> can cause unexpected behaviour\n"
      ],
      "metadata": {
        "id": "YUqHoJ8sVvfz"
      },
      "id": "YUqHoJ8sVvfz"
    },
    {
      "cell_type": "code",
      "source": [
        "# bad - using mutable default arguments\n",
        "def my_func1(my_list = []):\n",
        "  my_list.append(1)\n",
        "  return my_list\n",
        "result1 = my_func1()\n",
        "print(result1) # [1]\n",
        "result2 = my_func1()\n",
        "print(result2) # [1, 1]"
      ],
      "metadata": {
        "id": "bxwPnF2aV7L_",
        "outputId": "d647e2ff-83c2-4ea7-8578-c1b4e625f25a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "id": "bxwPnF2aV7L_",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1]\n",
            "[1, 1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# good - using immutable default arguments\n",
        "def my_function(my_list = None):\n",
        "  if my_list is None:\n",
        "    my_list = []\n",
        "\n",
        "  my_list.append(1)\n",
        "  return my_list\n",
        "\n",
        "res1 = my_function()\n",
        "print(res1) #[1]\n",
        "res2 = my_function()\n",
        "print(res2) # [1]"
      ],
      "metadata": {
        "id": "A-QgwZVrW1p_",
        "outputId": "17a7480b-9a22-46fd-9a48-b7f9ed076965",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "id": "A-QgwZVrW1p_",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1]\n",
            "[1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 5. Avoid using `*args` and `**kwargs` excessively\n",
        "\n",
        "> harder to understand and maintain"
      ],
      "metadata": {
        "id": "B--t-WozXnRw"
      },
      "id": "B--t-WozXnRw"
    },
    {
      "cell_type": "code",
      "source": [
        "# bad - using *args and **kwargs\n",
        "def my_func2(*args, **kwargs):\n",
        "  arg1 = args[0]\n",
        "  arg2 = kwargs.get('arg2' , 'default_value')\n",
        "  return arg1, arg2\n",
        "\n",
        "my_func2('value1', arg2 = 'value2')"
      ],
      "metadata": {
        "id": "VcP8N8JvXyJm",
        "outputId": "2d9f0274-96e1-49f2-f6c1-8ae5abaed9e9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "id": "VcP8N8JvXyJm",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "('value1', 'value2')"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# good - using named arguments\n",
        "def my_func3(arg1, arg2='default_value'):\n",
        "  return arg1, arg2\n",
        "\n",
        "my_func3('value1', arg2='value2')"
      ],
      "metadata": {
        "id": "23DOmexxYcSz",
        "outputId": "955132a0-efc9-4e5d-8a05-e8264159666a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "id": "23DOmexxYcSz",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "('value1', 'value2')"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# How to use NumPy's `any()` and `all()` methods"
      ],
      "metadata": {
        "id": "k6CIT7BL_tDr"
      },
      "id": "k6CIT7BL_tDr"
    },
    {
      "cell_type": "markdown",
      "source": [
        "NumPy's `any()` and `all()` methods are used to check whether any or all elements in an array satisfy a certain condition.\n",
        "\n",
        "* `any()` returns `True` if any element in the array satisfy the condition, and `False` otherwise.\n",
        "* `all()` returns `True` if all elements in an array satisfy a condition, and `False` otherwise."
      ],
      "metadata": {
        "id": "GEjNwz3F_2VC"
      },
      "id": "GEjNwz3F_2VC"
    },
    {
      "cell_type": "markdown",
      "source": [
        "For example, the following code will return `True` because all of the elements in the array are greater than 0:"
      ],
      "metadata": {
        "id": "BKSRXiZcAZ5T"
      },
      "id": "BKSRXiZcAZ5T"
    },
    {
      "cell_type": "code",
      "source": [
        "# first, import numpy as np\n",
        "import numpy as np"
      ],
      "metadata": {
        "id": "SFVpncluA90_"
      },
      "id": "SFVpncluA90_",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# example 1\n",
        "np.all(np.array([1, 2, 3]) > 0)"
      ],
      "metadata": {
        "id": "Sq_Nf3kBBEDT",
        "outputId": "7d9160e9-8cf8-409f-a38f-5dd535f9aead",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "id": "Sq_Nf3kBBEDT",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "For example, the following code will return `True` because at least one element in the array is greater than 0:"
      ],
      "metadata": {
        "id": "or8LAn-KBYZa"
      },
      "id": "or8LAn-KBYZa"
    },
    {
      "cell_type": "code",
      "source": [
        "# example 2:\n",
        "np.any(np.array([1, 2, 3]) < 0)"
      ],
      "metadata": {
        "id": "QkzB41DlBXno",
        "outputId": "4fc15027-6a4d-4735-847b-c5736b879ce6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "id": "QkzB41DlBXno",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Both `all()` and `any()` can take a boolean expression as an argument. For example, the following code will return `True` because all of the elements in the array are even:"
      ],
      "metadata": {
        "id": "wXpClzAsDAjb"
      },
      "id": "wXpClzAsDAjb"
    },
    {
      "cell_type": "code",
      "source": [
        "np.all(np.array([2, 4, 6]) % 2 == 0)"
      ],
      "metadata": {
        "id": "M4wfgiF7DUgF",
        "outputId": "a9ae3ab5-20f3-418e-e4f0-db1a3323069d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "id": "M4wfgiF7DUgF",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The following code will return `True` because at least one element in the array is even:\n"
      ],
      "metadata": {
        "id": "Ui278gPmDdF6"
      },
      "id": "Ui278gPmDdF6"
    },
    {
      "cell_type": "code",
      "source": [
        "np.any(np.array([1, 2, 3, 4]) % 2 == 0)"
      ],
      "metadata": {
        "id": "FsW9fziaDopk"
      },
      "id": "FsW9fziaDopk",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## More examples with 2D array"
      ],
      "metadata": {
        "id": "NFhNE5N2C2Fi"
      },
      "id": "NFhNE5N2C2Fi"
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `any()` and `all()` methods can also be used with an optional `axis` argument, which specifies the `axis` along which to perform the test. If `axis` is not specified, the test is performed over all `axes`."
      ],
      "metadata": {
        "id": "lp4X2QZfEI_j"
      },
      "id": "lp4X2QZfEI_j"
    },
    {
      "cell_type": "markdown",
      "source": [
        "For example, get the rows whose all values are fewer than 4:"
      ],
      "metadata": {
        "id": "wMto4_UpDxQD"
      },
      "id": "wMto4_UpDxQD"
    },
    {
      "cell_type": "code",
      "source": [
        "# example of 2D array with axis=1\n",
        "arr = np.array([[1, 2, 4, 5],\n",
        "               [4, 5, 6, 4],\n",
        "               [2, 3, 1, -1]])"
      ],
      "metadata": {
        "id": "ANCFXLUCEvJV"
      },
      "id": "ANCFXLUCEvJV",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# test code\n",
        "mask_all = (arr < 4).all(axis=1)\n",
        "arr[mask_all]"
      ],
      "metadata": {
        "id": "eNDiLNcsFFlw",
        "outputId": "fd9bd9ec-ff62-4ee3-f81b-29e72d0e2b21",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "id": "eNDiLNcsFFlw",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 2,  3,  1, -1]])"
            ]
          },
          "metadata": {},
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "2. Get the rows whose at least one value is fewer than 4:"
      ],
      "metadata": {
        "id": "-OcV7Ts2FHWu"
      },
      "id": "-OcV7Ts2FHWu"
    },
    {
      "cell_type": "code",
      "source": [
        "# test code\n",
        "mask_any = (arr < 4).any(axis=1)\n",
        "arr[mask_any]"
      ],
      "metadata": {
        "id": "TAkfN7HYFRqg",
        "outputId": "25ced954-5e69-4f9a-d3b0-3fbd939ef835",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "id": "TAkfN7HYFRqg",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 1,  2,  4,  5],\n",
              "       [ 2,  3,  1, -1]])"
            ]
          },
          "metadata": {},
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Conclusion:\n",
        "* the main difference between the two methods is that:\n",
        "  *  `any()` returns `True` if any element in the array satisfy the condition, otherwise `False`,\n",
        "\n",
        "  * while `all()` returns `True` if all elements in the array are satisfy the condition, otherwise `False`.\n",
        "\n",
        "* Both methods can take a boolean expression as an argument  and evaluates to `True` or `False`\n",
        "\n",
        "* Both method can be used to check a variety of conditions\n",
        "  \n",
        "* They are the most powerful methods for working with Numpy arrays"
      ],
      "metadata": {
        "id": "v0dhHxN2FYPy"
      },
      "id": "v0dhHxN2FYPy"
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Word cloud generator"
      ],
      "metadata": {
        "id": "a9vO3dnEK_aG"
      },
      "id": "a9vO3dnEK_aG"
    },
    {
      "cell_type": "code",
      "source": [
        "# create sample text data\n",
        "words = ['chatgpt', 'chat gpt', 'AI', 'generative AI',\n",
        "         'bardAI', 'bardAI','chatgpt', 'chat gpt', 'AI',\n",
        "         'generative AI', 'bardAI', 'bardAI' 'chatgpt',\n",
        "         'chat gpt', 'AI', 'generative AI', 'bardAI', 'bardAI']\n",
        "from wordcloud import WordCloud\n",
        "from matplotlib import pyplot as plt\n",
        "# join all words together\n",
        "all_words = ' '.join([word for word in words])\n",
        "# generate word cloud\n",
        "word_cloud = WordCloud(width=200,\n",
        "                       height=160,\n",
        "                       random_state=2,\n",
        "                       max_font_size=180).\\\n",
        "                       generate(all_words)\n",
        "# plot the word_cloud using matplotlib\n",
        "plt.figure(figsize=(10, 4))\n",
        "plt.imshow(word_cloud, interpolation='bilinear')\n",
        "plt.axis('off')\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 363
        },
        "id": "h2F9hrCyK92h",
        "outputId": "39da28e6-285c-4dfd-8c6c-5a74557698d4"
      },
      "id": "h2F9hrCyK92h",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(-0.5, 199.5, 159.5, -0.5)"
            ]
          },
          "metadata": {},
          "execution_count": 10
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x400 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Simulation and randomness: Random digit tables\n",
        "\n",
        "We can simulate events involving randomness like picking names out of a hat using tables of random digits. Tables of random digits can be used to simulate a lot of different real-world situations. Here's 2 lines of random digits we'll use in this worksheet:\n",
        "\n",
        "Line 1: 96565\n",
        "\n",
        "\n",
        "05007\n",
        "\n",
        "\n",
        "16605\n",
        "\n",
        "\n",
        "81194\n",
        "\n",
        "\n",
        "14873\n",
        "\n",
        "\n",
        "04197\n",
        "\n",
        "\n",
        "85576\n",
        "\n",
        "\n",
        "45195\n",
        "\n",
        "Line 2: 11169\n",
        "\n",
        "\n",
        "15529\n",
        "\n",
        "\n",
        "33241\n",
        "\n",
        "\n",
        "83594\n",
        "\n",
        "\n",
        "01727\n",
        "\n",
        "\n",
        "86595\n",
        "\n",
        "\n",
        "65723\n",
        "\n",
        "\n",
        "82322\n",
        "\n",
        "Things to know about random digit tables:\n",
        "* Each digit is equally likely to be any of the\n",
        "10 digits 0 through 9.\n",
        "* The digits are independent of each other. Knowing about one part of the table doesn't give away information about another part.\n",
        "* The digits are put in groups of\n",
        "just to make them easier to read. The groups and rows have no special meaning. They are just a long list of random digits."
      ],
      "metadata": {
        "id": "R4MXUXPSmD4J"
      },
      "id": "R4MXUXPSmD4J"
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Problem 1: Getting a random sample\n",
        "\n",
        "There are\n",
        "90 students in a lunch period, and\n",
        "5 of them will be selected at random for cleaning duty every week. Each student receives a number 01−90 and the school uses a random digit table to pick the\n",
        "5 students as follows:\n",
        "\n",
        "\n",
        "\n",
        "*  Start at the left of Line 1 in the random digits provided.\n",
        "\n",
        "* Look at\n",
        "2-digit groupings of numbers.\n",
        "\n",
        "* If the 2-digit number is anything between\n",
        "01 and\n",
        "90, that student is assigned lunch duty. Skip any other\n",
        "2-digit number.\n",
        "* Skip a\n",
        "2-digit number if it has already been chosen.\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "Line\n",
        "1: 96565\n",
        "\n",
        "\n",
        "05007\n",
        "\n",
        "\n",
        "16605\n",
        "\n",
        "\n",
        "81194\n",
        "\n",
        "\n",
        "14873\n",
        "\n",
        "\n",
        "04197\n",
        "\n",
        "\n",
        "85576\n",
        "\n",
        "\n",
        "45195\n",
        "\n",
        "Which 5 students should be assigned cleaning duty?"
      ],
      "metadata": {
        "id": "e9_Xrcx2mG1d"
      },
      "id": "e9_Xrcx2mG1d"
    },
    {
      "cell_type": "code",
      "source": [
        "import textwrap\n",
        "def assigned_duty(line1):\n",
        "  # make all together\n",
        "  digits = ''.join(line1)\n",
        "  # make two digits grouping\n",
        "  two_digits_grouping = textwrap.wrap(digits, 2)\n",
        "\n",
        "  assigned_students = []\n",
        "  for digit in two_digits_grouping:\n",
        "    if digit >= '01' and digit <= '90':\n",
        "      if digit not in assigned_students:\n",
        "        assigned_students.append(digit)\n",
        "\n",
        "\n",
        "  return assigned_students[:5]\n",
        "\n",
        "# testing code\n",
        "line1 = ['96565', '05007', '16605', '81194','14873', '04197', '85576', '45195']\n",
        "assigned_duty(line1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NSCOgFHSeyN7",
        "outputId": "869da1d8-18a4-4713-950e-8c2c7ff13d9e"
      },
      "id": "NSCOgFHSeyN7",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['56', '50', '07', '16', '60']"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Battery low notification"
      ],
      "metadata": {
        "id": "f7A02a1Ce7Cc"
      },
      "id": "f7A02a1Ce7Cc"
    },
    {
      "cell_type": "code",
      "source": [
        "# how to get notified when battery low\n",
        "# pip install psutil\n",
        "import psutil\n",
        "# get battery status\n",
        "battery = psutil.sensors_battery()\n",
        "is_plugged = battery.power_plugged\n",
        "percent = battery.percent\n",
        "# send notification when battery getting low\n",
        "if percent <= 100 and is_plugged != True:\n",
        "    # pip install plyer\n",
        "    from plyer import notification\n",
        "    import time\n",
        "    notification.notify(\n",
        "        title='Battery status',\n",
        "        message='Battery low! Plugin the charger.',\n",
        "        timeout=10\n",
        "    )\n"
      ],
      "metadata": {
        "id": "86WSqR1UQQS1"
      },
      "id": "86WSqR1UQQS1",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Alternative `len()` in Python"
      ],
      "metadata": {
        "id": "7gNchv8l8S_t"
      },
      "id": "7gNchv8l8S_t"
    },
    {
      "cell_type": "code",
      "source": [
        "# define alt_len() take input as a paramater\n",
        "def alt_len(input):\n",
        "  # define count variable to count the item\n",
        "  count = 0\n",
        "  if isinstance(input, str):  # check the input type is str\n",
        "    for _ in list(input):\n",
        "      count += 1 # increment the counter\n",
        "  # check the input type is list, tuple, set or dict\n",
        "  elif isinstance(input, (tuple, set, dict, list)):\n",
        "    for _ in input:\n",
        "      count += 1\n",
        "  else:\n",
        "    return('''Type error. Did you mean that the input is str, tuple, set, dict or list?''')\n",
        "  # return the counted value as a result\n",
        "  return count\n",
        "\n",
        "# testing the code\n",
        "input_string = \"python\"\n",
        "print(alt_len(input_string))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mIenq5e-6JGC",
        "outputId": "557e9b94-17ab-43a6-9d63-e7952279a722"
      },
      "id": "mIenq5e-6JGC",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "6\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "4e7bbd39-ed3d-451b-a4b5-e435f81c015d",
      "metadata": {
        "tags": [],
        "id": "4e7bbd39-ed3d-451b-a4b5-e435f81c015d",
        "outputId": "48ef5b47-4804-41c6-cb25-05fd1f4fab98"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[2, 3, 4, 5]\n"
          ]
        }
      ],
      "source": [
        "# get overlapping values in two lists\n",
        "list1 = [1,2,3,4,5]\n",
        "list2 = [2,3,4,5,6]\n",
        "overlaps = []\n",
        "for x in list1:\n",
        "    for y in list2:\n",
        "        if x == y:\n",
        "            overlaps.append(x)\n",
        "print(overlaps)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "537ad485-fb57-47be-af90-fcbc6cdd4015",
      "metadata": {
        "tags": [],
        "id": "537ad485-fb57-47be-af90-fcbc6cdd4015",
        "outputId": "7fe35184-f40f-4ea4-e345-8ac05def8e8b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[2, 3, 4, 5]\n"
          ]
        }
      ],
      "source": [
        "# get overlapping values in two lists\n",
        "list1 = [1,2,3,4,5]\n",
        "list2 = [2,3,4,5,6]\n",
        "overlaps = set(list1) & set(list2)\n",
        "print(list(overlaps))"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "1ffeb329-4c36-45bf-84cb-cfa2cf9e959f",
      "metadata": {
        "id": "1ffeb329-4c36-45bf-84cb-cfa2cf9e959f"
      },
      "source": [
        "# Iterables vs Iterators in Python"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "4e1b8cf3-b052-485c-bf29-0ba1f8ad68d4",
      "metadata": {
        "jp-MarkdownHeadingCollapsed": true,
        "tags": [],
        "id": "4e1b8cf3-b052-485c-bf29-0ba1f8ad68d4"
      },
      "source": [
        "## What is iteration protocol?\n",
        "> the iteration protocol is used by all iteration tools in python.\n",
        "\n",
        "> implemented by various object types such as\n",
        "> - `for loops, comprehensions, maps, generator etc`"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "651cda92-65d1-4cc0-a9cb-c08e2dd72bcc",
      "metadata": {
        "tags": [],
        "id": "651cda92-65d1-4cc0-a9cb-c08e2dd72bcc"
      },
      "source": [
        "## What is iterable?\n",
        "> An iterable is anything you can loop over its elements.\n",
        "\n",
        "> Iterables can be looped over, and anything that can be looped over is an iterable.\n",
        "\n",
        "> In Python, an Iterable is an object that implements the `__iter__()` method and returns an iterator object or an object that implements `__getitem__()`\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "87d9fd14-1b51-4b1c-872e-9245b407d54e",
      "metadata": {
        "tags": [],
        "id": "87d9fd14-1b51-4b1c-872e-9245b407d54e"
      },
      "source": [
        "## What is iterator?\n",
        ">The iterator is an object which produces values during the iteration.\n",
        "\n",
        "> it also being returned by the iterable object.\n",
        "\n",
        "> On the other hand, an Iterator in Python is an object that implements the `__next__()` method in a way that"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "01f15778-6bb7-4e0e-8915-a2720995a87a",
      "metadata": {
        "tags": [],
        "id": "01f15778-6bb7-4e0e-8915-a2720995a87a"
      },
      "source": [
        "### Python Iterables and Iterators with example"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "bc7b7642-53e0-4870-8259-c594237e33b3",
      "metadata": {
        "tags": [],
        "id": "bc7b7642-53e0-4870-8259-c594237e33b3"
      },
      "source": [
        "# note that every Iterator is also an Iterable, but not every Iterable is an Iterator"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "0d674ee4-ee36-4b2a-a665-489af43c16ea",
      "metadata": {
        "tags": [],
        "id": "0d674ee4-ee36-4b2a-a665-489af43c16ea",
        "outputId": "88625e8c-e1df-4bc7-efcb-93fe6005cbda"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2\n",
            "1\n",
            "4\n",
            "5\n"
          ]
        }
      ],
      "source": [
        "# let say sequence of numbers\n",
        "nums = [2, 1, 4, 5] # iterable\n",
        "# iterate over the nums using for loop\n",
        "for num in nums:\n",
        "    print(num)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "3ec6ad01-b500-4247-a864-f264aff1cfe7",
      "metadata": {
        "tags": [],
        "id": "3ec6ad01-b500-4247-a864-f264aff1cfe7"
      },
      "outputs": [],
      "source": [
        "# let say list of numbers\n",
        "nums = [2, 1, 4, 5]\n",
        "for num in nums:\n",
        "    num"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "4137715e-92fd-4d80-ab46-2a30fd17f3d1",
      "metadata": {
        "id": "4137715e-92fd-4d80-ab46-2a30fd17f3d1"
      },
      "source": [
        "# Which is the correct?\n",
        "`A. num is iterator B. nums is iterator`\n",
        "\n",
        "`C. nums is iterable D. num is iterable`\n",
        "\n",
        "`E. all except B & D`\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "df6d8e4d-39fb-436b-9acd-1edf49e7e888",
      "metadata": {
        "tags": [],
        "id": "df6d8e4d-39fb-436b-9acd-1edf49e7e888"
      },
      "source": [
        "# Convert Roman to Integer"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "7088a898-68eb-4985-824b-1bcd6facb3e6",
      "metadata": {
        "tags": [],
        "id": "7088a898-68eb-4985-824b-1bcd6facb3e6"
      },
      "source": [
        "### Suppose you have Roman literals; you wanna convert them into an integer.\n",
        "\n",
        "roman numerals are represented by seven different symbols\n",
        "i.e: `I V X L C D and M`\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f145817d-5f40-443a-a389-0395fbaf925d",
      "metadata": {
        "id": "f145817d-5f40-443a-a389-0395fbaf925d"
      },
      "source": [
        "<table>\n",
        "    <th> Roman </th>\n",
        "    <th> Integer </th>\n",
        "    <tr>\n",
        "        <td>I</td>\n",
        "        <td>1</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "        <td>V</td>\n",
        "        <td>5</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "        <td>X</td>\n",
        "        <td>10</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "        <td>L</td>\n",
        "        <td>50</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "        <td>C</td>\n",
        "        <td>100</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "        <td>D</td>\n",
        "        <td>500</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "        <td>M</td>\n",
        "        <td>1000</td>\n",
        "    </tr>\n",
        "</table>"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "9c0a445f-53fb-48ac-8f03-6411e47f5cab",
      "metadata": {
        "tags": [],
        "id": "9c0a445f-53fb-48ac-8f03-6411e47f5cab"
      },
      "source": [
        "### example:"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "af06dd7d-6f25-4eac-95bd-ce6e76ec1bd1",
      "metadata": {
        "tags": [],
        "id": "af06dd7d-6f25-4eac-95bd-ce6e76ec1bd1"
      },
      "source": [
        "For example: `3` is written as` III` in Roman numeral, so this is `3`, there are three `‘I’s` are added together\n",
        "\n",
        "for `13` is written as `XIII`, which is `X + III`\n",
        " and the number `27` is written as `XXVII`, which is `X + X + V + II`\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "fa42b4b1-169b-4918-b07b-d64ea6d250b5",
      "metadata": {
        "tags": [],
        "id": "fa42b4b1-169b-4918-b07b-d64ea6d250b5"
      },
      "source": [
        "### solution"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "cef5dcc0-c9a0-4330-ae04-4803034949f2",
      "metadata": {
        "tags": [],
        "id": "cef5dcc0-c9a0-4330-ae04-4803034949f2"
      },
      "outputs": [],
      "source": [
        "# let's define a dictionary to store a roman numeral and integer number as a key-value pair\n",
        "romanInt = {\n",
        "    'I': 1,\n",
        "    'V': 5,\n",
        "    'X': 10,\n",
        "    'L': 50,\n",
        "    'C': 100,\n",
        "    'D': 500,\n",
        "    'M': 1000\n",
        "}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "c2182b7b-b816-4ff8-867e-8adb7683426c",
      "metadata": {
        "tags": [],
        "id": "c2182b7b-b816-4ff8-867e-8adb7683426c",
        "outputId": "07d81b80-14be-4b03-9bfd-10c48f9b127e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "3\n",
            "663\n",
            "58\n"
          ]
        }
      ],
      "source": [
        "# now, define the function to convert the roman to integer\n",
        "def romanToInt(s):\n",
        "\n",
        "    value = 0\n",
        "    for i in range(len(s)):\n",
        "        if i+1 < len(s) and s[i:i+2] in romanInt:\n",
        "            value += romanInt[s[i:i+2]]\n",
        "        else:\n",
        "            value += romanInt[s[i]]\n",
        "    return value\n",
        "\n",
        "# test the code\n",
        "# input 1: 'III' => 3\n",
        "# input 2: 'CDXLIII' => 100+500+10+50+3= 663\n",
        "# input 3: 'LVIII' => 50+5+3 = 58\n",
        "\n",
        "input1 = romanToInt('III')\n",
        "input2 = romanToInt('CDXLIII')\n",
        "input3 = romanToInt('LVIII')\n",
        "\n",
        "print(input1)\n",
        "print(input2)\n",
        "print(input3)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "09d36d58-770c-4e59-9fa3-e6eea5e4d39e",
      "metadata": {
        "tags": [],
        "id": "09d36d58-770c-4e59-9fa3-e6eea5e4d39e"
      },
      "source": [
        "## How to Build ChatGPT with GPT-3 in Python\n",
        "\n",
        "#!pip install openai"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "2d2d4d29-259a-4280-b616-a6960568aacf",
      "metadata": {
        "id": "2d2d4d29-259a-4280-b616-a6960568aacf",
        "outputId": "b670bb59-fbb6-46e0-84b0-123c6f32398e"
      },
      "outputs": [
        {
          "ename": "ModuleNotFoundError",
          "evalue": "No module named 'openai'",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
            "Cell \u001b[0;32mIn[3], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mopenai\u001b[39;00m\n\u001b[1;32m      2\u001b[0m openai\u001b[38;5;241m.\u001b[39mapi_key \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124msk-jeZMiCYHVb7R4mNk1QqGT3BlbkFJuvKqCO9NAv9ea0oIwdId\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m      4\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mchatBot\u001b[39m(prompt):\n",
            "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'openai'"
          ]
        }
      ],
      "source": [
        "import openai\n",
        "openai.api_key = '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'\n",
        "\n",
        "def chatBot(prompt):\n",
        "\n",
        "    completion = openai.Completion.create(\n",
        "        model = 'text-davinci-003',\n",
        "        prompt=prompt,\n",
        "        max_tokens=1024,\n",
        "        n=1,\n",
        "        temperature=0.5,\n",
        "        stop=None\n",
        "    )\n",
        "\n",
        "    response = completion.choices[0].text\n",
        "\n",
        "    return response\n",
        "# test code\n",
        "while True:\n",
        "    prompt = input()\n",
        "    print(chatBot(prompt))\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "2dd379dc-aa6a-4b23-a89b-c6f928e85ae4",
      "metadata": {
        "tags": [],
        "id": "2dd379dc-aa6a-4b23-a89b-c6f928e85ae4"
      },
      "source": [
        "## How to format a number as currency in Python"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "2a429155-f0a1-4341-b84f-613edd024376",
      "metadata": {
        "jp-MarkdownHeadingCollapsed": true,
        "tags": [],
        "id": "2a429155-f0a1-4341-b84f-613edd024376"
      },
      "source": [
        "In this tutorial, I'm going to show you how to format a number as currency in two different ways"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "85aac66c-c82b-4b6b-975a-79b9ba82955a",
      "metadata": {
        "id": "85aac66c-c82b-4b6b-975a-79b9ba82955a"
      },
      "outputs": [],
      "source": [
        "# number example\n",
        "number = 1238745.65"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "33cf0683-40ef-4092-97f2-3e6897e8bab2",
      "metadata": {
        "tags": [],
        "id": "33cf0683-40ef-4092-97f2-3e6897e8bab2"
      },
      "source": [
        "### Method 1: Format a number as currency with the `format()` method."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "26d3da8b-4abd-40e9-97e0-ffd3ef3e763c",
      "metadata": {
        "id": "26d3da8b-4abd-40e9-97e0-ffd3ef3e763c",
        "outputId": "b7d55f35-1299-49dc-b8ca-9a118ab69585"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "$ 1,238,745.65\n"
          ]
        }
      ],
      "source": [
        "# show example here\n",
        "curr = \"{:,}\".format(number)\n",
        "\n",
        "print('$', curr)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "c5b3ca8e-4fe3-481d-8019-841300308bcf",
      "metadata": {
        "tags": [],
        "id": "c5b3ca8e-4fe3-481d-8019-841300308bcf"
      },
      "source": [
        "### Method 2: Format Numbers as Currency using the `locale` module:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "7f32aa27-c782-4f2f-8f14-23aa4645b31d",
      "metadata": {
        "id": "7f32aa27-c782-4f2f-8f14-23aa4645b31d",
        "outputId": "6f6be153-0bbf-4acc-c1bb-6014f5175d19"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "$1,238,745.65\n"
          ]
        }
      ],
      "source": [
        "# show example here\n",
        "import locale\n",
        "locale.setlocale(locale.LC_ALL, '')\n",
        "\n",
        "print(locale.currency(number, grouping=True))\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "8f31cbc3-d002-4a2b-9484-ec6d02d689d7",
      "metadata": {
        "tags": [],
        "id": "8f31cbc3-d002-4a2b-9484-ec6d02d689d7"
      },
      "source": [
        "### Note"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "c1fb5aea-2ca6-40a9-a12b-b65349c680c6",
      "metadata": {
        "tags": [],
        "id": "c1fb5aea-2ca6-40a9-a12b-b65349c680c6"
      },
      "source": [
        "- This method helps you to write a single set of codes and not worry about which region you run the code. Python will automatically detect the region and serve your application data based on your localization."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "0a9da246-23ff-408a-91a9-79bb4840b9af",
      "metadata": {
        "tags": [],
        "id": "0a9da246-23ff-408a-91a9-79bb4840b9af"
      },
      "source": [
        "## How to replace all occurrences of a string with another string"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "a11f79e3-fc7f-4e9c-aa4a-f4b7c54a59c1",
      "metadata": {
        "id": "a11f79e3-fc7f-4e9c-aa4a-f4b7c54a59c1"
      },
      "source": [
        "I'm going to show you two different methods to replace a string"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "2cee5f98-2b54-4106-b8c6-ab292931d413",
      "metadata": {
        "tags": [],
        "id": "2cee5f98-2b54-4106-b8c6-ab292931d413"
      },
      "source": [
        "### Method 1: using `replace()` method"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "d93c4585-01bb-40ab-8d1d-7acdde763dfa",
      "metadata": {
        "id": "d93c4585-01bb-40ab-8d1d-7acdde763dfa"
      },
      "source": [
        "The `replace()` method of string class accepts a string value as input and returns the modified string as output.\n",
        "\n",
        "- It has 2 mandatory parameters and 1 optional parameter.\n",
        "\n",
        "`string.replace(oldvalue, newvalue, count)`\n",
        "\n",
        "- **oldvalue** − The substring that you want to replace.\n",
        "\n",
        "- **newvalue** − This represents the substring with which you want to replace.\n",
        "\n",
        "- **count** − This is an optional parameter; it is used to specify the number of old values you want to replace with new values."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "3348fe83-0f51-4a28-a9ea-d995f44a9693",
      "metadata": {
        "tags": [],
        "id": "3348fe83-0f51-4a28-a9ea-d995f44a9693"
      },
      "source": [
        "#### Example 1: replace without specifying count parameter"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "175eeafc-6a69-4ac4-83e7-c2819cf1dfbe",
      "metadata": {
        "id": "175eeafc-6a69-4ac4-83e7-c2819cf1dfbe",
        "outputId": "3229f8fa-26b7-4d91-d6c5-d183deb4446a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "String before replacing: Welcome to epythonlab\n",
            "String after replacing: Welcome do epydhonlab\n"
          ]
        }
      ],
      "source": [
        "# replace a letter t with d\n",
        "string = 'Welcome to epythonlab'\n",
        "\n",
        "print('String before replacing:', string)\n",
        "\n",
        "string = string.replace('t', 'd')\n",
        "\n",
        "print('String after replacing:', string)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "48f2fddb-6950-41ed-a286-3bae5b310931",
      "metadata": {
        "tags": [],
        "id": "48f2fddb-6950-41ed-a286-3bae5b310931"
      },
      "source": [
        "#### Example 2: replace with count parameter"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "97997237-00ab-4276-a6ba-245a2ae4f39e",
      "metadata": {
        "id": "97997237-00ab-4276-a6ba-245a2ae4f39e",
        "outputId": "4c5af968-35f9-40ae-efa3-f41db5e3b39c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "String before replacing: Welcome to epythonlab\n",
            "String after replacing: Welcdme td epythonlab\n"
          ]
        }
      ],
      "source": [
        "# replace 2 occurences of letter o with d\n",
        "string ='Welcome to epythonlab'\n",
        "\n",
        "print('String before replacing:', string)\n",
        "\n",
        "string = string.replace('o', 'd', 2)\n",
        "\n",
        "print('String after replacing:', string)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "45bac66b-690c-423c-a1e2-b8f92aab2512",
      "metadata": {
        "tags": [],
        "id": "45bac66b-690c-423c-a1e2-b8f92aab2512"
      },
      "source": [
        "### Method 2: using `re.sub()` method"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "53fd8d3c-43fc-465f-a4b1-d2313b5fb7c6",
      "metadata": {
        "id": "53fd8d3c-43fc-465f-a4b1-d2313b5fb7c6"
      },
      "source": [
        "You can also use **Python regular expressions** to replace all occurrences of a string with another string.\n",
        "\n",
        "- The `sub()` method of python `re` replaces an existing letter in the given string with a new letter.\n",
        "\n",
        "`re.sub(old, new, string)`\n",
        "\n",
        "- **old** − The sub string that you want to replace.\n",
        "\n",
        "- **new** − The new sub string with which you want to replace.\n",
        "\n",
        "- **string** − The source string."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6ec384c6-647d-4eaf-a872-8f0ec43c35bd",
      "metadata": {
        "tags": [],
        "id": "6ec384c6-647d-4eaf-a872-8f0ec43c35bd"
      },
      "source": [
        "#### Example 1: replace the letter 't' with 'd'"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "8c703c13-949b-4a0a-ad0c-33994086495f",
      "metadata": {
        "id": "8c703c13-949b-4a0a-ad0c-33994086495f",
        "outputId": "2c446b80-27a3-4f4f-a020-a1d406978dc0"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "String before replacing: Welcome to epythonlab\n",
            "String after replacing: Welcome do epydhonlab\n"
          ]
        }
      ],
      "source": [
        "# replace letter 't' with 'd'\n",
        "import re\n",
        "\n",
        "string = 'Welcome to epythonlab'\n",
        "\n",
        "print('String before replacing:', string)\n",
        "\n",
        "string = re.sub('t', 'd', string)\n",
        "\n",
        "print('String after replacing:', string)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "530853db-6295-46bf-b84c-9c410b8c27c9",
      "metadata": {
        "id": "530853db-6295-46bf-b84c-9c410b8c27c9"
      },
      "source": [
        "> ## How to Convert Letters into Numbers"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "83c18366-15c6-454f-b07f-ed873b7fbd92",
      "metadata": {
        "id": "83c18366-15c6-454f-b07f-ed873b7fbd92"
      },
      "source": [
        "We use `ord()` method to convert Letters into numbers\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "c2829db7-960b-4312-8e23-60f67667b721",
      "metadata": {
        "id": "c2829db7-960b-4312-8e23-60f67667b721"
      },
      "outputs": [],
      "source": [
        "# Show some example here\n",
        "\"\"\"\n",
        "    the ord() method takes a single character as an input and\n",
        "    return an integer\n",
        "    representing the Unicode character\n",
        "\"\"\"\n",
        "import string\n",
        "alphabets = string.ascii_uppercase\n",
        "\n",
        "res = {ch: ord(ch) for ch in alphabets}\n",
        "print(res)\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "92324d30-61b2-4e5d-bbb4-b1fcf2100e6e",
      "metadata": {
        "id": "92324d30-61b2-4e5d-bbb4-b1fcf2100e6e"
      },
      "source": [
        "### Practical Exercise\n",
        "\n",
        "You've heard somewhere that a word is more powerful than an action. You decided to put this statement at a test by assigning a power value to each action and each word. To begin somewhere, you defined a power of a word as the sum of powers of its characters, where power of a character is equal to its 1-based index in the plaintext alphabet."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "279242e7-279a-4438-9b9c-7f1e0d8b598f",
      "metadata": {
        "tags": [],
        "id": "279242e7-279a-4438-9b9c-7f1e0d8b598f"
      },
      "source": [
        "Given a `word`, calculate its power."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "69705cc1-b471-49d1-b960-09ca9aa47072",
      "metadata": {
        "id": "69705cc1-b471-49d1-b960-09ca9aa47072"
      },
      "source": [
        "Example\n",
        "\n",
        "For `word = \"hello\"`, the output should be\n",
        "`power(word) = 52`.\n",
        "\n",
        "Letters `'h', 'e', 'l' and 'o'`have powers `8, 5, 12 and 15`, respectively. Thus, the total power of the word is `8 + 5 + 12 + 12 + 15 = 52`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "7d1ee3f2-4cc5-4e68-aaa2-caafb4e1964d",
      "metadata": {
        "id": "7d1ee3f2-4cc5-4e68-aaa2-caafb4e1964d"
      },
      "outputs": [],
      "source": [
        "# solution here\n",
        "def power(word):\n",
        "    '''\n",
        "         The string can be iterated through for loop and use an ord()\n",
        "         method to convert each letter into number.\n",
        "    '''\n",
        "    num = {ch: ord(ch)-96 for ch in word.lower()}\n",
        "\n",
        "    res = [num[ch] for ch in word]\n",
        "\n",
        "    return sum(res)\n",
        "\n",
        "\n",
        "# testing\n",
        "word = 'hello'\n",
        "print(power(word))\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "3a985563-7641-498b-84a0-b94de820f033",
      "metadata": {
        "id": "3a985563-7641-498b-84a0-b94de820f033"
      },
      "source": [
        "> # Extended Iterable Unpacking\n",
        "\n",
        "What is unpacking?\n",
        "\n",
        "**Unpacking** in Python refers to an operation that consists of assigning an iterable of values to a `tuple (or list )` of variables in a single assignment statement.\n",
        "\n",
        "- As a complement, the term packing can be used when we collect several values in a single variable using the iterable unpacking operator, `*`\n",
        "\n",
        "\n",
        "\n",
        "This was introduced in **PEP 3132**.\n",
        "\n",
        "It was proposed a changes to iterable unpacking syntax, allowing to specify a **“catch-all”** name which will be assigned a list of all items not assigned to a **“regular”** name.\n",
        "\n",
        "- Many algorithms require splitting a sequence in a “first, rest” pair.\n",
        "\n",
        "    `first, rest = seq[0], seq[1:]`, but with the new syntax,\n",
        "    \n",
        " - is replaced by the cleaner and probably more efficient:\n",
        "\n",
        "     `first, *rest = seq`\n",
        "\n",
        "The `*` operator is known, in this context, as the tuple (or iterable) unpacking operator.\n",
        "\n",
        "It extends the unpacking functionality to allow us to collect or pack multiple values in a single variable.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "2bb7aaad-dc29-46fb-9612-088777617e4e",
      "metadata": {
        "id": "2bb7aaad-dc29-46fb-9612-088777617e4e"
      },
      "source": [
        "For example, if `seq` is a sliceable sequence, all the following assignments are equivalent if `seq` has at least two elements:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "21dc5f7c-1c8e-4745-a84e-b4cf19f6af15",
      "metadata": {
        "id": "21dc5f7c-1c8e-4745-a84e-b4cf19f6af15"
      },
      "outputs": [],
      "source": [
        "a, b, c = seq[0], list(seq[1:-1]), seq[-1] # instead of using\n",
        "\n",
        "a, *b, c = seq # more efficient way\n",
        "\n",
        "[a, *b, c] = seq # in a list\n",
        "\n",
        "(a, *b, c) = seq # in a tuple"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "c074fa8f-9bc9-4a7b-a925-004b0548bd81",
      "metadata": {
        "id": "c074fa8f-9bc9-4a7b-a925-004b0548bd81"
      },
      "source": [
        "It is an error (as it is currently) if the iterable doesn’t contain enough items to assign to all the mandatory expressions.\n",
        "\n",
        "It is also an error to use the starred expression as a lone assignment target, as in"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "037e1f7f-0bd7-4f26-b06d-cc317d7bce90",
      "metadata": {
        "id": "037e1f7f-0bd7-4f26-b06d-cc317d7bce90"
      },
      "outputs": [],
      "source": [
        "*a = range(5) # error"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "3723c1b6-74ac-4538-b0c3-f4800d875e69",
      "metadata": {
        "id": "3723c1b6-74ac-4538-b0c3-f4800d875e69",
        "outputId": "600aa48f-475b-499a-b152-27bf24b115a6"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[0, 1, 2, 3, 4]"
            ]
          },
          "execution_count": 1,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# however this is a valid\n",
        "*a, = range(5)\n",
        "a"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "120d8af9-5603-438c-ba72-807e7a8816d9",
      "metadata": {
        "id": "120d8af9-5603-438c-ba72-807e7a8816d9"
      },
      "source": [
        "Example"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "27bcf0f1-7776-4dc7-9be2-e76bb9d954b5",
      "metadata": {
        "id": "27bcf0f1-7776-4dc7-9be2-e76bb9d954b5",
        "outputId": "d7aa049e-238e-460d-acdf-ed175669d82f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "0\n",
            "4\n",
            "[1, 2, 3]\n"
          ]
        }
      ],
      "source": [
        "# extended iterable unpacking\n",
        "a, *b, c = range(5)\n",
        "print(a)\n",
        "print(c)\n",
        "print(b)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "41991a87-d101-431f-a228-853ce4ac3173",
      "metadata": {
        "id": "41991a87-d101-431f-a228-853ce4ac3173"
      },
      "source": [
        "**Exercise**:"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "95d7e3ce-eae4-4e79-a793-c7b7c042d599",
      "metadata": {
        "id": "95d7e3ce-eae4-4e79-a793-c7b7c042d599"
      },
      "source": [
        "Let's call a list `beautiful` if its **first element** is equal to its **last element**, or if a list is **empty**.\n",
        "\n",
        "Given a list `a`, your task is to chop off its first and its last element until it becomes beautiful.\n",
        "\n",
        "Implement a function that will make the given a beautiful as described, and return the resulting list as an answer.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "a9d401c4-1701-40e1-adb8-d42a6f954fc8",
      "metadata": {
        "id": "a9d401c4-1701-40e1-adb8-d42a6f954fc8"
      },
      "source": [
        "For example  `a = [3, 4, 2, 4, 38, 4, 5, 3, 2]`, the output should be\n",
        "`beautiful(a) = [4, 38, 4]`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "2bc2e3fd-bd58-4898-9a83-b98ed5380900",
      "metadata": {
        "id": "2bc2e3fd-bd58-4898-9a83-b98ed5380900"
      },
      "outputs": [],
      "source": [
        "a = [3, 4, 2, 4, 38, 4, 5, 3, 2]\n",
        "\n",
        "res = a[:]\n",
        "while res and res[0] != res[-1]:\n",
        "    first, *res, last = res\n",
        "\n",
        "res"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "8a2ce2fb-fd8d-4c2b-8932-b56f661f45bb",
      "metadata": {
        "id": "8a2ce2fb-fd8d-4c2b-8932-b56f661f45bb"
      },
      "source": [
        "> # Sort Dictionary By key & value"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "8e794821-98b7-4f5c-9fe3-018d648af21b",
      "metadata": {
        "id": "8e794821-98b7-4f5c-9fe3-018d648af21b"
      },
      "outputs": [],
      "source": [
        "# let's have list of fruit prices per kg\n",
        "fruits_info = {\n",
        "    'mango': 13.5,\n",
        "    'bannana': 10.4,\n",
        "    'orange': 8.9,\n",
        "    'avocado': 12.5,\n",
        "    'ananas' : 11.7\n",
        "}"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "25863fb6-9825-4dc7-a99a-2afa388ddd39",
      "metadata": {
        "id": "25863fb6-9825-4dc7-a99a-2afa388ddd39"
      },
      "source": [
        "> 1. Sort by key"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "ec016364-7809-460c-970f-36739632576d",
      "metadata": {
        "id": "ec016364-7809-460c-970f-36739632576d",
        "outputId": "5290128c-13d9-497b-9695-916597e83d5c"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "['ananas', 'avocado', 'bannana', 'mango', 'orange']"
            ]
          },
          "execution_count": 2,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "sorted(fruits_info.keys())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "47e21c5f-2e05-4c7a-9145-87a2908c9c7d",
      "metadata": {
        "id": "47e21c5f-2e05-4c7a-9145-87a2908c9c7d",
        "outputId": "37910da9-2291-4901-bd74-43f86f2f354b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "11.7\n",
            "12.5\n",
            "10.4\n",
            "13.5\n",
            "8.9\n"
          ]
        }
      ],
      "source": [
        "for key in sorted(fruits_info):\n",
        "    print(fruits_info[key])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "da0c28b9-f927-4069-aba5-20cec80774fc",
      "metadata": {
        "id": "da0c28b9-f927-4069-aba5-20cec80774fc"
      },
      "outputs": [],
      "source": [
        "fruits_info"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "565d23ec-2c2d-4578-b77b-18324e6acbb7",
      "metadata": {
        "id": "565d23ec-2c2d-4578-b77b-18324e6acbb7",
        "outputId": "7825026f-fda8-414d-c0c1-354ac3ad8875"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "['ananas', 'avocado', 'bannana', 'mango', 'orange']"
            ]
          },
          "execution_count": 5,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "sorted(fruits_info)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "61d95d2e-99fd-4d22-9073-a2e40fbd2e3f",
      "metadata": {
        "id": "61d95d2e-99fd-4d22-9073-a2e40fbd2e3f",
        "outputId": "7e460650-9776-40f7-920f-bc0454c6ddbf"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "['orange', 'mango', 'bannana', 'avocado', 'ananas']"
            ]
          },
          "execution_count": 6,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "sorted(fruits_info, reverse=True)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "0fe40372-3bcd-4a52-a45f-d652d3e5bd28",
      "metadata": {
        "id": "0fe40372-3bcd-4a52-a45f-d652d3e5bd28",
        "outputId": "a6c15ebf-ccdc-412c-e215-bca455cee7d9"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "{'ananas': 11.7, 'avocado': 12.5, 'bannana': 10.4, 'mango': 13.5, 'orange': 8.9}\n"
          ]
        }
      ],
      "source": [
        "# show code here\n",
        "# Method 1: Using loop\n",
        "sorted_fruits = {key:fruits_info[key] for key in sorted(fruits_info, reverse=False)} # dictionary comprehension\n",
        "\n",
        "print(sorted_fruits)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "794ede50-d6cd-490d-855a-412bfec965db",
      "metadata": {
        "id": "794ede50-d6cd-490d-855a-412bfec965db"
      },
      "source": [
        "> 2. Sort by values"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "03a4bbca-a241-455e-9b65-d739746e10c3",
      "metadata": {
        "id": "03a4bbca-a241-455e-9b65-d739746e10c3"
      },
      "outputs": [],
      "source": [
        "for item in sorted(fruits_info.items()):\n",
        "    print(item)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "933062a5-7901-4bec-b4af-5fb9142f5f3f",
      "metadata": {
        "id": "933062a5-7901-4bec-b4af-5fb9142f5f3f"
      },
      "outputs": [],
      "source": [
        "# show code here\n",
        "# Mehtod 1: Using lambda function\n",
        "\n",
        "sorted_fruits_by_value = dict(sorted(fruits_info.items(), key = lambda item: item[1], reverse=True))\n",
        "print(sorted_fruits_by_value)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "144dab6d-a002-4c08-82ef-2706f11569c6",
      "metadata": {
        "id": "144dab6d-a002-4c08-82ef-2706f11569c6"
      },
      "source": [
        "> # String Formatting"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "67d536d5-0dc5-4e6d-91c7-ad566cb634bc",
      "metadata": {
        "id": "67d536d5-0dc5-4e6d-91c7-ad566cb634bc"
      },
      "source": [
        "String formatting is also known as **String interpolation**.\n",
        "\n",
        "It is the process of **inserting a custom string or variable**in predefined text."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "c74b615b-9145-4f40-8026-6401957b3560",
      "metadata": {
        "id": "c74b615b-9145-4f40-8026-6401957b3560"
      },
      "source": [
        "There are three commonly used string formatting:\n",
        "\n",
        "1. Formatting with `%` Operator.\n",
        "2. Formatting with `format()` string method.\n",
        "3. Formatting with string literals, called `f-strings`."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "bb8ba694-7dbe-4d43-b339-4cc941cae4e9",
      "metadata": {
        "id": "bb8ba694-7dbe-4d43-b339-4cc941cae4e9"
      },
      "source": [
        "### Using `%` Operator"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "681e5bb4-1986-4302-8021-f27af89deaa2",
      "metadata": {
        "id": "681e5bb4-1986-4302-8021-f27af89deaa2"
      },
      "outputs": [],
      "source": [
        "# show example here\n",
        "name = 'Asibeh'\n",
        "age = 32\n",
        "print('My name is %s. I am %d years old'%(name, age))"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "1aec576b-dbed-4c50-843d-3d9945fd36d1",
      "metadata": {
        "id": "1aec576b-dbed-4c50-843d-3d9945fd36d1"
      },
      "source": [
        "**Note** : `%s` is used for string, `%d` is for integer and `%f` is for floating-point values."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "601cd7be-87ec-4c2f-98d2-756fc356b937",
      "metadata": {
        "id": "601cd7be-87ec-4c2f-98d2-756fc356b937"
      },
      "source": [
        "### Float precision with the placeholder method\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "d25381a9-165e-4661-a701-1342c3f0d9a7",
      "metadata": {
        "id": "d25381a9-165e-4661-a701-1342c3f0d9a7"
      },
      "outputs": [],
      "source": [
        "# show example here\n",
        "pi = 3.123456\n",
        "print('The pi %0.3f'%pi)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "93637bde-5f42-449f-89c8-38887c1152c6",
      "metadata": {
        "id": "93637bde-5f42-449f-89c8-38887c1152c6"
      },
      "source": [
        "**Note**: `%a.bf` is used to format floating-point values"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "00360174-b581-48f5-90ef-3c85b70bc9f7",
      "metadata": {
        "id": "00360174-b581-48f5-90ef-3c85b70bc9f7"
      },
      "source": [
        "## using `format()` method"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "577f955e-7930-445d-926f-40f9142a7d0b",
      "metadata": {
        "id": "577f955e-7930-445d-926f-40f9142a7d0b"
      },
      "source": [
        "`Syntax: ‘String here {} then also {}’.format(‘something1′,’something2’)`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "88a39556-7896-4204-9303-9034d28553a3",
      "metadata": {
        "id": "88a39556-7896-4204-9303-9034d28553a3"
      },
      "outputs": [],
      "source": [
        "# show example here\n",
        "name = 'Asibeh'\n",
        "age = 32\n",
        "print('My name is {}. I am {} years old.'.format(name, age))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "a66be579-d567-46ac-9118-18f4d64218a6",
      "metadata": {
        "id": "a66be579-d567-46ac-9118-18f4d64218a6"
      },
      "outputs": [],
      "source": [
        "a = 2.3456\n",
        "b = 1.655\n",
        "print('{0:.0f} + {1:.0f}'.format(a, b))"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "d973bd78-a7aa-4003-a184-8069c4555329",
      "metadata": {
        "id": "d973bd78-a7aa-4003-a184-8069c4555329"
      },
      "source": [
        "## using `F-strings`\n",
        "This string formatter was introduced in **PEP 498** know as **Literal String Interpolation** or more commonly as **F-strings**\n",
        "\n",
        "- because of the leading `f` character preceding the string literal\n",
        "\n",
        "\n",
        "- The idea behind f-strings is to make string interpolation simpler."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "26c99d9c-eff2-4915-a6f4-a31225e6e7f8",
      "metadata": {
        "id": "26c99d9c-eff2-4915-a6f4-a31225e6e7f8"
      },
      "outputs": [],
      "source": [
        "# show example here\n",
        "name = 'Asibeh'\n",
        "age = 32\n",
        "print(f'My name is {name}. I am {age} years old.')"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "b55b6f4f-ea13-4d72-8578-a5cba5d2fb14",
      "metadata": {
        "id": "b55b6f4f-ea13-4d72-8578-a5cba5d2fb14"
      },
      "source": [
        "> ## Manipulating Files and Directories in Python"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "2d0952ee-0b18-4372-bfab-ed5f5b7bc432",
      "metadata": {
        "tags": [],
        "id": "2d0952ee-0b18-4372-bfab-ed5f5b7bc432"
      },
      "source": [
        "# `os` module"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e93f272c-e384-4c5e-b386-0ed63542e394",
      "metadata": {
        "id": "e93f272c-e384-4c5e-b386-0ed63542e394"
      },
      "outputs": [],
      "source": [
        "import os"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "cd2619df-e03e-4742-bd67-ca75fdba260c",
      "metadata": {
        "id": "cd2619df-e03e-4742-bd67-ca75fdba260c"
      },
      "source": [
        "1. Getting the current working directory"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "6fe3ee86-7f28-42a9-a5c7-23bdbc3ccccc",
      "metadata": {
        "id": "6fe3ee86-7f28-42a9-a5c7-23bdbc3ccccc"
      },
      "outputs": [],
      "source": [
        "os.getcwd() # C:\\Home/Desktop/"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "abccd3e8-1368-4a0d-8b2f-088911dd90fd",
      "metadata": {
        "id": "abccd3e8-1368-4a0d-8b2f-088911dd90fd"
      },
      "source": [
        "2. Create new directory"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "3303d204-7436-4613-9c0c-1d3657a19077",
      "metadata": {
        "id": "3303d204-7436-4613-9c0c-1d3657a19077"
      },
      "outputs": [],
      "source": [
        "os.mkdir('python')"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ae5eccdf-aa05-4bbf-8d2b-65612211731b",
      "metadata": {
        "id": "ae5eccdf-aa05-4bbf-8d2b-65612211731b"
      },
      "source": [
        "3. Change the current working directory to 'python'"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "f1bf6ade-4d68-4070-ad94-02e203976bee",
      "metadata": {
        "id": "f1bf6ade-4d68-4070-ad94-02e203976bee"
      },
      "outputs": [],
      "source": [
        "os.chdir('python') #/home/Desktop/"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "628b2704-c9ea-4a5d-ae1d-2533b437424c",
      "metadata": {
        "id": "628b2704-c9ea-4a5d-ae1d-2533b437424c"
      },
      "outputs": [],
      "source": [
        "os.getcwd()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "1b8b3d68-6a20-49c8-ad6f-592ca07f8550",
      "metadata": {
        "id": "1b8b3d68-6a20-49c8-ad6f-592ca07f8550"
      },
      "outputs": [],
      "source": [
        "os.mkdir('p2')"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "2716c9ee-9b2b-4e75-8d0c-0c4ec2e88036",
      "metadata": {
        "id": "2716c9ee-9b2b-4e75-8d0c-0c4ec2e88036"
      },
      "source": [
        "4. remove the directory"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e1935cfd-cc6f-43c7-baa4-474e5ec0d5e0",
      "metadata": {
        "id": "e1935cfd-cc6f-43c7-baa4-474e5ec0d5e0"
      },
      "outputs": [],
      "source": [
        "os.rmdir('p2')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "5496d064-365e-4cb5-887f-6d0201e6cef6",
      "metadata": {
        "id": "5496d064-365e-4cb5-887f-6d0201e6cef6"
      },
      "outputs": [],
      "source": [
        "if not os.path.exists('p3'):\n",
        "    os.mkdir('p3')\n",
        "else:\n",
        "    print('The directory exists.')\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ba7c16d7-70b9-41a9-8be0-9eee86854d2b",
      "metadata": {
        "id": "ba7c16d7-70b9-41a9-8be0-9eee86854d2b"
      },
      "source": [
        "5. List the contents of the directory"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "6497518f-45e7-4980-befc-82df484d6d41",
      "metadata": {
        "id": "6497518f-45e7-4980-befc-82df484d6d41"
      },
      "outputs": [],
      "source": [
        "list_dir = os.listdir() # 'C:\\Home\\Des'\n",
        "for dr in list_dir:\n",
        "    print(dr)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e722b25c-7aa9-4e29-888b-c6d4eceeee96",
      "metadata": {
        "id": "e722b25c-7aa9-4e29-888b-c6d4eceeee96"
      },
      "outputs": [],
      "source": [
        "os.chdir('p2')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "9f953c00-c942-47a1-92b2-a4dbc759a3cc",
      "metadata": {
        "id": "9f953c00-c942-47a1-92b2-a4dbc759a3cc"
      },
      "outputs": [],
      "source": [
        "os.getcwd()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "140f109e-34a7-42ff-a23f-500212999bfb",
      "metadata": {
        "id": "140f109e-34a7-42ff-a23f-500212999bfb"
      },
      "outputs": [],
      "source": [
        "#os.chdir('/home/noh/Desktop/python/')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "5b95e33a-835f-44eb-a399-8e3d4b169a2e",
      "metadata": {
        "id": "5b95e33a-835f-44eb-a399-8e3d4b169a2e"
      },
      "outputs": [],
      "source": [
        "with open('f1.txt', 'w') as f:\n",
        "    f.write(f'A file is create at {os.getcwd()}')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "5a13c69e-de27-427e-8f0c-05a0098993fb",
      "metadata": {
        "id": "5a13c69e-de27-427e-8f0c-05a0098993fb"
      },
      "outputs": [],
      "source": [
        "os.remove('f1.txt') #os.rmdir('')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "81f7e155-06de-482f-81ab-a838fe05c88a",
      "metadata": {
        "id": "81f7e155-06de-482f-81ab-a838fe05c88a"
      },
      "outputs": [],
      "source": [
        "os.rmdir('/home/noh/Desktop/python/p2')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "ac3d7204-2ae3-4361-87f2-54652493a47d",
      "metadata": {
        "id": "ac3d7204-2ae3-4361-87f2-54652493a47d"
      },
      "outputs": [],
      "source": [
        "os.chdir('p3')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "7e740617-2a60-44ca-9579-edced51bc271",
      "metadata": {
        "id": "7e740617-2a60-44ca-9579-edced51bc271"
      },
      "outputs": [],
      "source": [
        "os.getcwd()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "a2cca0f4-4bc1-4aae-834e-1cebe15ccee7",
      "metadata": {
        "id": "a2cca0f4-4bc1-4aae-834e-1cebe15ccee7"
      },
      "source": [
        "> # Python's Type Hinting"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "57df487e-5bc6-4140-947e-03b20aee35c9",
      "metadata": {
        "id": "57df487e-5bc6-4140-947e-03b20aee35c9"
      },
      "source": [
        "Python uses dynamic typing, in which variables, parameters, and return values of a function can be any type.\n",
        "\n",
        "- Python’s type hints provide you with optional static typing to leverage the best of both static and dynamic typing.\n",
        "\n",
        "- Type hinting is a formal solution to statically indicate the type of a value within your Python code.\n",
        "- It was specified in **PEP 484** and introduced in **Python 3.5**.\n",
        "#\n",
        "\n",
        "Example: here's an example of a function that returns values without adding type hinting"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "96d32382-6014-434d-b3bb-cc1a704f17b0",
      "metadata": {
        "id": "96d32382-6014-434d-b3bb-cc1a704f17b0"
      },
      "outputs": [],
      "source": [
        "def greeting1(name):\n",
        "\n",
        "    return f'Hi, nice to meeting you {name}'\n",
        "\n",
        "greeting1('Asibeh')"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "88b8859b-0d93-47f9-9118-4db6fbf5b9f5",
      "metadata": {
        "id": "88b8859b-0d93-47f9-9118-4db6fbf5b9f5"
      },
      "source": [
        "Here's a syntax for adding type hinting to a parameter and returns a function\n",
        "\n",
        "`parameter:type`\n",
        "`->type`\n",
        "\n",
        "#"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "040590ea-f075-467a-9d76-af315ac99508",
      "metadata": {
        "id": "040590ea-f075-467a-9d76-af315ac99508"
      },
      "source": [
        "Here's an example of adding type information to a function `greeting2()` and you annotate the arguments and return values\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "04c509c3-2dba-4a68-8110-d634634e34fd",
      "metadata": {
        "id": "04c509c3-2dba-4a68-8110-d634634e34fd"
      },
      "outputs": [],
      "source": [
        "def greeting2(name:str)->str:\n",
        "\n",
        "    return f'Hi, nice to meet you {name}'\n",
        "\n",
        "greeting2('Asibeh')\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "9d6835ce-c343-4fee-9f1b-86245ed4c11b",
      "metadata": {
        "id": "9d6835ce-c343-4fee-9f1b-86245ed4c11b"
      },
      "source": [
        "<h3 background='green'>Note: You can also use other built-in types such as <code>int, float, bool</code> etc </h3>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "1653dd51-0944-4bb9-974f-9f6bd96f9619",
      "metadata": {
        "id": "1653dd51-0944-4bb9-974f-9f6bd96f9619"
      },
      "outputs": [],
      "source": [
        "from typing import Union\n",
        "\n",
        "def addNumber(num1:Union[int,float], num2:Union[int, float])->Union[float, int]:\n",
        "    return num1 + num2\n",
        "\n",
        "addNumber(4.2, 2.3)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "32f75e29-2c00-468d-bfbc-18c859c38023",
      "metadata": {
        "tags": [],
        "id": "32f75e29-2c00-468d-bfbc-18c859c38023"
      },
      "source": [
        "Here's another example of the function turns a text string into a **headline** by adding proper **capitalization and a decorative** line:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "16016a63-a769-457b-bb31-b3eb9ef3e99e",
      "metadata": {
        "id": "16016a63-a769-457b-bb31-b3eb9ef3e99e"
      },
      "outputs": [],
      "source": [
        "def headline(text, align=True):\n",
        "\n",
        "    if align:\n",
        "\n",
        "        return f\"{text.title()}\\n{'-' * len(text)}\"\n",
        "    else:\n",
        "        return f\" {text.title()} \".center(50, '*')\n",
        "\n",
        "print(headline('python type hinting tutorial.'))\n",
        "print(headline('python type checking', align=False))"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "3b8082ff-cc97-4aeb-844c-7f8bdcddd2ec",
      "metadata": {
        "id": "3b8082ff-cc97-4aeb-844c-7f8bdcddd2ec"
      },
      "source": [
        "##\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "032a3208-5fc1-4d01-9127-4d738d86cb95",
      "metadata": {
        "id": "032a3208-5fc1-4d01-9127-4d738d86cb95"
      },
      "source": [
        "Let's add type hints to the function `headline()` by annotating the arguments and the return value as follows:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "bebf207f-8b42-4948-9406-df3cbc81896e",
      "metadata": {
        "id": "bebf207f-8b42-4948-9406-df3cbc81896e"
      },
      "outputs": [],
      "source": [
        "def headline(text: str, align: bool = True)-> str:\n",
        "\n",
        "    if align:\n",
        "\n",
        "        return f\"{text.title()}\\n{'-' * len(text)}\"\n",
        "    else:\n",
        "        return f\" {text.title()} \".center(50, '*')\n",
        "\n",
        "print(headline('python type checking', align='left'))\n",
        "print(headline('python type checking', align=False))"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "45f3c16b-9778-44ac-9807-5f8b490fd9bb",
      "metadata": {
        "id": "45f3c16b-9778-44ac-9807-5f8b490fd9bb"
      },
      "source": [
        "#\n",
        "\n",
        "## According to PEP 8, I recommend that you:\n",
        "\n",
        "- Use normal rules for colons, that is, no space before and one space after a colon (text: str).\n",
        "- Use spaces around the = sign when combining an argument annotation with a default value (align: bool = True).\n",
        "- Use spaces around the -> arrow (def headline(...) -> str)."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "2b43c1f9-5dc6-490f-aa58-8216dd735719",
      "metadata": {
        "id": "2b43c1f9-5dc6-490f-aa58-8216dd735719"
      },
      "source": [
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "2dcc9fec-0b6b-4583-bdd3-683048936299",
      "metadata": {
        "id": "2dcc9fec-0b6b-4583-bdd3-683048936299"
      },
      "source": [
        "## Testing Your Code Before Deployment\n",
        ">Testing your code is essential before deployment."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f04051a5-8ec8-4ad5-8e7b-e6462b5009fd",
      "metadata": {
        "id": "f04051a5-8ec8-4ad5-8e7b-e6462b5009fd"
      },
      "source": [
        "## Unit tests"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "d198b736-107b-4c45-a922-3dbcb858c0c9",
      "metadata": {
        "id": "d198b736-107b-4c45-a922-3dbcb858c0c9"
      },
      "source": [
        "The advantage of unit tests is that  \n",
        "- they are isolated from the rest of your program, and thus no dependencies are involved.\n",
        "- they don't require access to databases, APIs, or other external sources of information.\n",
        "\n",
        "- However, passing unit tests isn’t always enough to prove that your program is working successfully.\n",
        "\n",
        "The disadvantage of unit tests is that\n",
        "\n",
        "- In large program, all parts of the program not work properly, communicating, and transfering data between them correctly\n",
        "- however, when you start building larger programs, you will want to use integration tests as well."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "7f489db8-5dc2-44e9-993c-b1c739d80384",
      "metadata": {
        "id": "7f489db8-5dc2-44e9-993c-b1c739d80384"
      },
      "source": [
        "#### install pytest library for unit-testing\n",
        "\n",
        "example in the model directory"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "21e40a82-ca08-4cec-bf37-4e4a31bec90d",
      "metadata": {
        "id": "21e40a82-ca08-4cec-bf37-4e4a31bec90d"
      },
      "outputs": [],
      "source": [
        "# uncomment, the following line to install pytest\n",
        "#!pip install pytest"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "5928b5e5-60be-4362-850a-4e3caf387656",
      "metadata": {
        "id": "5928b5e5-60be-4362-850a-4e3caf387656"
      },
      "source": [
        "## Find Common Elements in Two Lists in Python"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "976c2280-be54-453e-922b-55d332ac1296",
      "metadata": {
        "id": "976c2280-be54-453e-922b-55d332ac1296",
        "outputId": "9f0f02a1-9b52-447e-f972-b43c2f2eddb3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "8\n",
            "9\n"
          ]
        }
      ],
      "source": [
        "\"\"\"\n",
        "    Let's assume you have two lists\n",
        "     each list contains list of numbers\n",
        "     You want to find common elements from the\n",
        "     two lists using three ways\n",
        "\n",
        "\"\"\"\n",
        "list_one = [3, 10, 25, 35, 20, 30, 40, 50]\n",
        "\n",
        "list_two = [20, 40, 22, 16, 30, 60, 5, 70, 100]\n",
        "\n",
        "# check the number of elements of both lists\n",
        "print(len(list_one))\n",
        "print(len(list_two))\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "9876a9e9-ce29-49c4-8378-32ffb1ff0c9b",
      "metadata": {
        "id": "9876a9e9-ce29-49c4-8378-32ffb1ff0c9b"
      },
      "source": [
        "### 1. using `intersection()`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "f1d80c32-6dd1-4bba-8639-71c4025ba256",
      "metadata": {
        "id": "f1d80c32-6dd1-4bba-8639-71c4025ba256",
        "outputId": "972b5403-37f7-44aa-b5f5-3ba624eab43f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "{40, 20, 30}\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "[40, 20, 30]"
            ]
          },
          "execution_count": 2,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# testing code here\n",
        "common_elements = set(list_one).intersection(list_two)\n",
        "print(common_elements)\n",
        "list(common_elements)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "72e61b4f-54f8-484b-8428-e7b98fdcf23e",
      "metadata": {
        "id": "72e61b4f-54f8-484b-8428-e7b98fdcf23e"
      },
      "source": [
        "### 2. using list comprehension"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "109eb521-8006-4bb3-bed3-22d9b605e381",
      "metadata": {
        "id": "109eb521-8006-4bb3-bed3-22d9b605e381"
      },
      "outputs": [],
      "source": [
        "# your code here\n",
        "common_elements = [i for i in list_one if i in list_two]\n",
        "print(common_elements)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "2635315a-ba5d-4d5d-8583-5098335a4f50",
      "metadata": {
        "id": "2635315a-ba5d-4d5d-8583-5098335a4f50",
        "outputId": "dcd63f4b-1f25-480b-b7f0-d8109392e50f"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "range(20, 40, 3)"
            ]
          },
          "execution_count": 3,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# let's say\n",
        "lst1 = [2, 3, 40, 10, 30, 12, 37, 17]\n",
        "lst1 = [2, 3, 40, 19, 17, 20, 40, 24, 13]"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "cbb127e0-20f6-4562-a701-7066c4a55bdc",
      "metadata": {
        "id": "cbb127e0-20f6-4562-a701-7066c4a55bdc"
      },
      "source": [
        "### 3. using `&` operator"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "b6e7f7ab-f516-4ae4-a925-ef0fc6318e78",
      "metadata": {
        "id": "b6e7f7ab-f516-4ae4-a925-ef0fc6318e78"
      },
      "outputs": [],
      "source": [
        "# your code here\n",
        "\n",
        "set_one = set(list_one)\n",
        "set_two = set(list_two)\n",
        "\n",
        "if set_one & set_two:\n",
        "    print(set_one & set_two)\n",
        "else:\n",
        "    print(\"No common elements\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "1f997a6d-344d-4f8b-b1c2-c2e09eb6d54b",
      "metadata": {
        "id": "1f997a6d-344d-4f8b-b1c2-c2e09eb6d54b"
      },
      "source": [
        "### Python's `reduce()` vs `accumulate()` function"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "0e35c07f-9a73-4da1-a109-cd8960476269",
      "metadata": {
        "id": "0e35c07f-9a73-4da1-a109-cd8960476269"
      },
      "source": [
        "`reduce()` function iterates over each item in a list, or any other iterable data type, and returns a single value.\n",
        "- It's one of the methods of the built-in `functools` class of Python."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "07d31698-7d19-4d51-b854-843e3ec6a793",
      "metadata": {
        "id": "07d31698-7d19-4d51-b854-843e3ec6a793"
      },
      "source": [
        "Here's an example of how to use reduce:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "dc490c54-044d-408b-a132-2849db78ccab",
      "metadata": {
        "id": "dc490c54-044d-408b-a132-2849db78ccab"
      },
      "outputs": [],
      "source": [
        "from functools import reduce\n",
        "\n",
        "a = [2, 3, 4, 5, 1, 3]\n",
        "result = reduce(lambda x, y: x+y, a)\n",
        "\n",
        "print(result)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "a9ae5bcb-575c-4f7d-bc31-b292f49ec8e1",
      "metadata": {
        "id": "a9ae5bcb-575c-4f7d-bc31-b292f49ec8e1"
      },
      "source": []
    },
    {
      "cell_type": "markdown",
      "id": "5b1b3270-8ff4-4ff9-8deb-dc754416be99",
      "metadata": {
        "id": "5b1b3270-8ff4-4ff9-8deb-dc754416be99"
      },
      "source": [
        "## <code><b style=\"color:'#345678';\">enumerate()</b></code> function in Python\n",
        "\n",
        "- It returns the length of an iterable and loops through its items simultaneously.\n",
        "\n",
        "- Thus, while printing each item in an iterable data type, it simultaneously outputs its index.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6ea96fda-5a15-4c61-8116-fb91463954ca",
      "metadata": {
        "id": "6ea96fda-5a15-4c61-8116-fb91463954ca"
      },
      "source": [
        "Example: Assume that you want a user to see the list of items available in your database. You can pass them into a list and use the enumerate() function to return this as a numbered list.\n",
        "\n",
        "Here's how you can achieve this using the `enumerate()` method:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "64b23a75-ddb2-403f-8050-31709814d57c",
      "metadata": {
        "tags": [],
        "id": "64b23a75-ddb2-403f-8050-31709814d57c"
      },
      "outputs": [],
      "source": [
        "# list of fruits\n",
        "fruits = ['Apple', 'Orange', 'Mango', 'Avocado', 'Banana']\n",
        "\n",
        "# you want to print the items along with its index as a numbered list\n",
        "for index, item in enumerate(fruits, start=1 ):\n",
        "    print(index, item)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "efc06d8e-7cd3-41a4-9936-2fa67b2686c9",
      "metadata": {
        "id": "efc06d8e-7cd3-41a4-9936-2fa67b2686c9"
      },
      "source": [
        "An alternative way to print the items and their index using for loop\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "3eca6669-3e81-4139-9639-d8ee847d3339",
      "metadata": {
        "tags": [],
        "id": "3eca6669-3e81-4139-9639-d8ee847d3339"
      },
      "outputs": [],
      "source": [
        "for i in range(len(fruits)):\n",
        "    print(i+1, fruits[i])"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "52d1b663-54ca-446f-a2b4-cd44c5a4742a",
      "metadata": {
        "id": "52d1b663-54ca-446f-a2b4-cd44c5a4742a"
      },
      "source": [
        "## `eval()` function"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "64edfeb1-737a-4150-9b89-bdb38d0dc9ff",
      "metadata": {
        "id": "64edfeb1-737a-4150-9b89-bdb38d0dc9ff"
      },
      "source": [
        "`eval()` function uses to perform mathematical operations on integers or floats, even in their string forms.\n",
        "\n",
        "It's often helpful if a mathematical calculation is in a string format."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "a85c566a-a1d1-4c46-9ff9-e5176e90c36f",
      "metadata": {
        "id": "a85c566a-a1d1-4c46-9ff9-e5176e90c36f"
      },
      "source": [
        "Example: Here's how it works"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "57a675ba-8534-41d6-88d1-758ff8a25747",
      "metadata": {
        "tags": [],
        "id": "57a675ba-8534-41d6-88d1-758ff8a25747"
      },
      "outputs": [],
      "source": [
        "\"\"\"\n",
        "Let's assume you have a mathematical expression in\n",
        "string format\n",
        "and you wanna perform the result of the expression\n",
        "using eval()\n",
        "\"\"\"\n",
        "x = \"3+2**2\" # 3.2+4 = 7.2\n",
        "# when you print x as it is\n",
        "\n",
        "print(x)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "bd9ec049-8b4c-4e36-8d75-6495b62db0c4",
      "metadata": {
        "tags": [],
        "id": "bd9ec049-8b4c-4e36-8d75-6495b62db0c4"
      },
      "outputs": [],
      "source": [
        "# using eval()\n",
        "re = eval(x) # convert the string into interger or float\n",
        "print(re)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "27f5c171-8dd4-4633-9afc-b3a1bb4beca6",
      "metadata": {
        "id": "27f5c171-8dd4-4633-9afc-b3a1bb4beca6"
      },
      "source": [
        "## `map()` in Python"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "c8b4cf26-2953-44af-b999-70fdd2759ad0",
      "metadata": {
        "id": "c8b4cf26-2953-44af-b999-70fdd2759ad0"
      },
      "source": [
        "`map()` function returns a map object(which is an iterator) of the results after applying the given function to each item of a given iterable `(list, tuple etc.)`"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "55cec5d9-9cba-4ec9-96d3-703ff46b4497",
      "metadata": {
        "id": "55cec5d9-9cba-4ec9-96d3-703ff46b4497"
      },
      "source": [
        "Syntax :\n",
        "\n",
        "`map(fun, iter)`"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "bae3ad37-64d5-499a-93a3-15b2593754c5",
      "metadata": {
        "id": "bae3ad37-64d5-499a-93a3-15b2593754c5"
      },
      "source": [
        "Example: Add two lists using `map()` and `lambda` function\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "d14bd1b1-e7de-480d-9b4a-2dae0bece0ac",
      "metadata": {
        "tags": [],
        "id": "d14bd1b1-e7de-480d-9b4a-2dae0bece0ac",
        "outputId": "cab4ef3e-26c2-486a-ceff-4f43a840d915"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[5, 7, 9]\n"
          ]
        }
      ],
      "source": [
        "def add_lists(lst1, lst2):\n",
        "\n",
        "    result = map(lambda x, y : x + y , lst1, lst2)\n",
        "\n",
        "    return result\n",
        "\n",
        "# call the function\n",
        "numbers1 = [1, 2, 3, 7]\n",
        "numbers2 = [4, 5, 6]\n",
        "result = add_lists(numbers1, numbers2)\n",
        "print(list(result))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "9c851e85-814e-48e7-9cd2-0db89cfe1e33",
      "metadata": {
        "tags": [],
        "id": "9c851e85-814e-48e7-9cd2-0db89cfe1e33",
        "outputId": "6a10f53d-60eb-462f-d856-c237a6d2d86d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[]\n"
          ]
        }
      ],
      "source": [
        "print(list(result))"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "61e34bca-6517-4c23-86a9-5d8ff340fe2e",
      "metadata": {
        "id": "61e34bca-6517-4c23-86a9-5d8ff340fe2e"
      },
      "source": [
        "# Python Top Tip : `reduce()` function"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "e5070f64-6ea4-463f-a6cb-e0a743c07d44",
      "metadata": {
        "id": "e5070f64-6ea4-463f-a6cb-e0a743c07d44"
      },
      "source": [
        "The `reduce(fun,seq)` function is used to apply a particular function passed in its argument to all of the list elements mentioned in the sequence passed along.\n",
        "\n",
        "This function is defined in `functools` module."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "41000b18-4ca1-4cbe-a95b-fd3166371a20",
      "metadata": {
        "id": "41000b18-4ca1-4cbe-a95b-fd3166371a20"
      },
      "source": [
        "Example: Demonstrate working of `reduce()`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "2751fcd8-a259-4106-a3ec-e241e53fde20",
      "metadata": {
        "tags": [],
        "id": "2751fcd8-a259-4106-a3ec-e241e53fde20"
      },
      "outputs": [],
      "source": [
        "import functools\n",
        "\n",
        "# initilize the list\n",
        "lst = [2, 3, 5, 7, 1, 4, 8, 9, 11, 34, 16]\n",
        "\n",
        "# find the sum of the sequence of the list\n",
        "\n",
        "sum_seq = functools.reduce(lambda x, y: x+y, lst)\n",
        "\n",
        "print(\"The sum of the list elements is:\", sum_seq)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "67edefa9-cbf1-4ca0-b0be-86a7a754d52e",
      "metadata": {
        "tags": [],
        "id": "67edefa9-cbf1-4ca0-b0be-86a7a754d52e"
      },
      "outputs": [],
      "source": [
        "# find the maximum element from the list\n",
        "max_el = functools.reduce(lambda x, y: x if x>y else y, lst)\n",
        "\n",
        "print(\"The max element is :\", max_el)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "acbf89e5-cf59-4449-9a85-c379051fba97",
      "metadata": {
        "tags": [],
        "id": "acbf89e5-cf59-4449-9a85-c379051fba97"
      },
      "outputs": [],
      "source": [
        "# find the minimum element from the list\n",
        "min_el = functools.reduce(lambda x,y: x if x<y else y, lst)\n",
        "\n",
        "print(\"The min element is :\", min_el)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "7b5c5850-fd87-40dd-b71c-dd11e65a5898",
      "metadata": {
        "tags": [],
        "id": "7b5c5850-fd87-40dd-b71c-dd11e65a5898"
      },
      "source": [
        "##\n",
        "\n",
        "# Python Top Tips:\n",
        "> `yield` keyword in Python\n",
        "##"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "af86b360-5b0a-4ea6-bcfc-2fa46a3cd80f",
      "metadata": {
        "tags": [],
        "id": "af86b360-5b0a-4ea6-bcfc-2fa46a3cd80f"
      },
      "source": [
        "What is `yield` in Python?\n",
        "\n",
        "The `yield` keyword in Python is similar to a return statement used for returning values or objects in Python.\n",
        "\n",
        "However, there is a slight difference.\n",
        "\n",
        "- The yield statement returns a generator object to the one who calls the function which contains yield, instead of simply returning a value."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "707c16a7-e16a-4fb0-8893-ee7174a0529e",
      "metadata": {
        "id": "707c16a7-e16a-4fb0-8893-ee7174a0529e"
      },
      "source": [
        "##\n",
        "\n",
        "Example: how to demonstrate the working of `yield`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "3d1c1022-dad8-449c-9fa5-c06bd07a4c2e",
      "metadata": {
        "tags": [],
        "id": "3d1c1022-dad8-449c-9fa5-c06bd07a4c2e"
      },
      "outputs": [],
      "source": [
        "def filter_even(numbers):\n",
        "\n",
        "       for number in range(numbers):\n",
        "\n",
        "            if(number%2==0):\n",
        "\n",
        "                yield number\n",
        "\n",
        "\n",
        "# call the function\n",
        "even_numbers = filter_even(20)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "03a5ecbf-ad39-4374-92d3-8ceea4c74af5",
      "metadata": {
        "tags": [],
        "id": "03a5ecbf-ad39-4374-92d3-8ceea4c74af5"
      },
      "outputs": [],
      "source": [
        "lst = [i for i in even_numbers]\n",
        "lst"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "0214dd90-74b9-4f8f-8e7e-a35bc09330ac",
      "metadata": {
        "tags": [],
        "id": "0214dd90-74b9-4f8f-8e7e-a35bc09330ac"
      },
      "outputs": [],
      "source": [
        "print(next(even_numbers))"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "0bf2ee35-edaa-44a3-ac35-fabf1deaffa9",
      "metadata": {
        "tags": [],
        "id": "0bf2ee35-edaa-44a3-ac35-fabf1deaffa9"
      },
      "source": [
        "## Difference between `pop()` and `remove()`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "8e123b3e-97d5-451e-a741-9f893ec3cfc2",
      "metadata": {
        "id": "8e123b3e-97d5-451e-a741-9f893ec3cfc2"
      },
      "outputs": [],
      "source": [
        "lists_number = [2, 3, 4, 3, 6, 7]\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "1913ea1e-a7b1-46b8-90e2-70fa7445c865",
      "metadata": {
        "id": "1913ea1e-a7b1-46b8-90e2-70fa7445c865"
      },
      "outputs": [],
      "source": [
        "lists_number"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "eb890d61-5b48-4680-8435-2b7fcdd63f15",
      "metadata": {
        "id": "eb890d61-5b48-4680-8435-2b7fcdd63f15"
      },
      "outputs": [],
      "source": [
        "lists_number.pop(2)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "ff4cba3c-c12e-4193-a783-8d1ab00fdb6f",
      "metadata": {
        "id": "ff4cba3c-c12e-4193-a783-8d1ab00fdb6f"
      },
      "outputs": [],
      "source": [
        "lists_number"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "cee6e466-5a52-44ad-8ad1-ff955f1d7526",
      "metadata": {
        "id": "cee6e466-5a52-44ad-8ad1-ff955f1d7526"
      },
      "outputs": [],
      "source": [
        "lists_number.remove(4)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "a231f6f4-2ad4-40a7-b494-b304b3187ec8",
      "metadata": {
        "id": "a231f6f4-2ad4-40a7-b494-b304b3187ec8"
      },
      "outputs": [],
      "source": [
        "lists_number"
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.11.2"
    },
    "colab": {
      "provenance": [],
      "include_colab_link": true
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}