python_basics.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/iamr7d/python-basics/blob/main/python_basics.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Python - Format - Strings**"
      ],
      "metadata": {
        "id": "uoZdZKh7QibQ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### F-Strings"
      ],
      "metadata": {
        "id": "t8OMrzVDQo_3"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "To specify a string as an f-string, simply put an f in front of the string literal, and add curly brackets **{ }** as placeholders for variables and other operations."
      ],
      "metadata": {
        "id": "QFBTdahoQxWA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "age = 36\n",
        "txt = f\"My name is John, I am {age}\"\n",
        "print(txt)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tMGq0ABBQx4I",
        "outputId": "6ef3eae8-c208-4f4b-dbc9-5304e1cbf5ee"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "My name is John, I am 36\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "price = 550\n",
        "txt = f\"price of the car is {price} $\"\n",
        "print(txt)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uOzfCSd_Q5hU",
        "outputId": "7d05077c-c1f7-4919-a16a-457f38acbc2c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "price of the car is 550 $\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Placeholders and Modifiers**"
      ],
      "metadata": {
        "id": "xijgE7LARI-z"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "A placeholder can include a modifier to format the value.\n",
        "\n",
        "A modifier is included by adding a colon : followed by a legal formatting type, like .2f which means fixed point number with 2 decimals:"
      ],
      "metadata": {
        "id": "gbSjH3-8RLw6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "price = 59\n",
        "txt = f\"The price is {price:.0f} dollars\"\n",
        "print(txt)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oX2QPuIIRNTr",
        "outputId": "09f61658-0552-4977-b933-f4480d036ec0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The price is 59 dollars\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "price = 59\n",
        "txt = f\"The price is {price:.1f} dollars\"\n",
        "print(txt)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WoGkQwGWRaV7",
        "outputId": "dcea7be0-e73f-4929-b8f0-1904736c0914"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The price is 59.0 dollars\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "price = 59\n",
        "txt = f\"The price is {price:.2f} dollars\"\n",
        "print(txt)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "B7ikgt6xRbvj",
        "outputId": "1521db77-d7a9-4f88-8e4e-3ac3b8eb8a1b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The price is 59.00 dollars\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "price = 59\n",
        "txt = f\"The price is {price:.3f} dollars\"\n",
        "print(txt)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XeqEvefnRda_",
        "outputId": "88d645ce-da33-4f8e-9523-e1e9983f4909"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The price is 59.000 dollars\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "price = 59\n",
        "txt = f\"The price is {price:.8f} dollars\"\n",
        "print(txt)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MYpAjLkPRelN",
        "outputId": "1ee320d6-cd24-4896-ba16-c0fedb413872"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The price is 59.00000000 dollars\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "price = 59\n",
        "txt = f\"The price is {price:.1000f} dollars\"\n",
        "print(txt)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Qau6F7KCRguA",
        "outputId": "b521370c-6abe-4051-ee5b-98d0f1208627"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The price is 59.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 dollars\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "price = 85.564\n",
        "txt = f\"price of the car is {price:.1f} dollars\"\n",
        "print(txt)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uW6HPLjNRj3V",
        "outputId": "028143c3-22bd-4304-9765-c79d79c0cba1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "price of the car is 85.6 dollars\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "price = 85.564\n",
        "txt = f\"price of the car is {price:.3f} dollars\"\n",
        "print(txt)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C4E0AAI_R1kL",
        "outputId": "bc5c0737-f449-4b62-91f8-7d0396a598f4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "price of the car is 85.564 dollars\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "A placeholder can contain Python code, like math operations:"
      ],
      "metadata": {
        "id": "Ww2tIzVJR5Pm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "txt = f\"The price is {20 * 59} dollars\"\n",
        "print(txt)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tkTtGotJR5kv",
        "outputId": "306ad48c-17dc-41a8-8237-8f1ebf754318"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The price is 1180 dollars\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "txt = f\"The price is {100/20} dollars\"\n",
        "print(txt)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cc6ZKUbVR7cP",
        "outputId": "a9222812-f870-4789-adf9-48ec42e4209b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The price is 5.0 dollars\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Python - Escape Characters**"
      ],
      "metadata": {
        "id": "UuN3pKr0SXV0"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "To insert characters that are illegal in a string, use an escape character.\n",
        "\n",
        "An escape character is a backslash \\ followed by the character you want to insert."
      ],
      "metadata": {
        "id": "zS_wsQCxTKJ4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "txt = \"We are the so-called \\\"Vikings\\\" from the north.\"\n",
        "print(txt)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3xS02amKSYCa",
        "outputId": "03deb05a-6953-4f0e-e1c3-3671cb1b77a7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "We are the so-called \"Vikings\" from the north.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "![image.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "v7JZSyDBTb3q"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Python Booleans**"
      ],
      "metadata": {
        "id": "tp3RVrVKTiYs"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "In programming you often need to know if an expression is True or False.\n",
        "\n",
        "You can evaluate any expression in Python, and get one of two answers, True or False."
      ],
      "metadata": {
        "id": "p4xdyWumT1oG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(10 > 9)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MPbOdVPyT3w2",
        "outputId": "f1c7dafd-2ebd-47e8-f498-308d6b70324c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(10 == 9)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yFUOxnduT6NO",
        "outputId": "dc66f519-8a38-463d-ba67-276e452efd9d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(10 < 9)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bywhOKIwT7Q-",
        "outputId": "137d5d92-2f4f-402d-83ba-c134406e81d7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "When you run a condition in an if statement, Python returns True or False:"
      ],
      "metadata": {
        "id": "dIKL01cMUCHf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = 200\n",
        "b = 33\n",
        "\n",
        "if b > a:\n",
        "  print(\"b is greater than a\")\n",
        "else:\n",
        "  print(\"b is not greater than a\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HzGwMbVSUBT3",
        "outputId": "5714a6ff-341f-40f7-b8af-0dad88acd421"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "b is not greater than a\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Evaluate Values and Variables**"
      ],
      "metadata": {
        "id": "rA7RvU4bUGNv"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The bool() function allows you to evaluate any value, and give you True or False in return,"
      ],
      "metadata": {
        "id": "6ciwQ9BYUMVA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(bool(\"Hello\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yWbwANjsUHoH",
        "outputId": "dea4e7b7-ff9e-436d-a9d5-605490074760"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(bool(105))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-5Ikk8znUKYQ",
        "outputId": "5e4c0919-aa2b-487f-b610-93bcfe1a6cc8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x = \"Hello\"\n",
        "y = 15\n",
        "\n",
        "print(bool(x))\n",
        "print(bool(y))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fCgAIEBiUQqJ",
        "outputId": "b1315da6-3505-472e-9653-8feb7b48dff0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "***Most Values are True***\n",
        "\n",
        "\n",
        "* Almost any value is evaluated to True if it has some sort of content.\n",
        "\n",
        "* Any string is True, except empty strings.\n",
        "\n",
        "* Any number is True, except 0.\n",
        "\n",
        "* Any list, tuple, set, and dictionary are True, except empty ones."
      ],
      "metadata": {
        "id": "gM9u-lmlUX3A"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "bool(\"abc\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ObnOSwm2UZCp",
        "outputId": "221e21ba-b23f-4ed2-a80e-6f4a2b531dfe"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "bool(123)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RZOkpymLUx9K",
        "outputId": "da321249-428e-4189-c177-28b244919bf3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "bool([\"apple\", \"cherry\", \"banana\"])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Cn_KMbwlUzvf",
        "outputId": "993d1b37-91cc-4358-e603-a2573771dea3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "* In fact, there are not many values that evaluate to False, except empty values, such as (), [], {}, \"\", the number 0, and the value None. And of course the value False evaluates to False."
      ],
      "metadata": {
        "id": "NKk2laJqU--W"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "bool(False)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5sxlV8tsVAh-",
        "outputId": "fb6f2e5b-3621-4d60-dee7-c14a9cb79f7d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "bool(None)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qNPCfl3QVDLJ",
        "outputId": "2b510a89-0e97-412d-9b1e-c407a127b24e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "bool(0)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8dVGejJ9VEwx",
        "outputId": "9203e2ab-09ec-4bf6-c7cd-70d065984b72"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "bool(\"\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ma4iDnXNVGXi",
        "outputId": "ebe989d0-dc6e-425d-dda6-f4e98a0436b2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "bool(())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QhVMWkN0VH26",
        "outputId": "720fb4bd-6b07-4e65-cea2-5874b61d938a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "bool([])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zxQuDbRxVJUr",
        "outputId": "27f8d194-7c5d-4a78-e42c-9d866298a041"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "bool({})"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EnPzJb-ZVLDS",
        "outputId": "565d3c9f-f5d9-4bfb-91a4-c43fc0ca4668"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Functions can Return a Boolean**\n",
        "\n",
        "* You can create functions that returns a Boolean Value:"
      ],
      "metadata": {
        "id": "xZ7hLBk_VUwQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def myFunction() :\n",
        "  return True\n",
        "\n",
        "print(myFunction())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J-PiPR7cVX2g",
        "outputId": "39b4ace4-ff0e-4ba4-8b77-11041a434d4a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**isinstance()**\n",
        "\n",
        "* Python also has many built-in functions that return a boolean value, like the isinstance() function, which can be used to determine if an object is of a certain data type:"
      ],
      "metadata": {
        "id": "xlTm-WjiVhIp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = 200\n",
        "print(isinstance(x, int))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yABXuk2aVlsO",
        "outputId": "8ca5c860-12f0-4aeb-f915-802bcf769a58"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x = 200\n",
        "print(isinstance(x, str))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ejwYxpkCVoi3",
        "outputId": "a4216686-dbc3-4025-a37a-cd42853dd41a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x = \"200\"\n",
        "print(isinstance(x, str))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xpEkjGL8Vqlv",
        "outputId": "362c063d-9493-47d1-e663-2ee9662d6542"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x = 200\n",
        "print(isinstance(x, float))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UtrfxQjsVso7",
        "outputId": "5b033580-d096-4cf4-a84e-5c5e3b3fe747"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x = 200\n",
        "print(isinstance(x, bool))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LI6zZfJ6Vua4",
        "outputId": "a2cefacd-95e2-4216-a04e-402773d5c290"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Python String Formatting**"
      ],
      "metadata": {
        "id": "TBYjm5yyWgnx"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Return \"Expensive\" if the price is over 50, otherwise return \"Cheap\":"
      ],
      "metadata": {
        "id": "uqTQeuz4Wq55"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "price = 49\n",
        "txt = f\"It is very {'Expensive' if price>50 else 'Cheap'}\"\n",
        "\n",
        "print(txt)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3heWJeVfWizY",
        "outputId": "39ee2148-c773-4e5e-cde6-9bc0239f2755"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "It is very Cheap\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "price = 49\n",
        "txt = f\"it is {'good to buy' if price<50 else 'not good'}\"\n",
        "print(txt)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DmV3MK6PWt6B",
        "outputId": "e509d7db-16ca-4c1b-f3f7-a962b3f34a05"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "it is good to buy\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Use the string method **upper()** to convert a value into upper case letters:"
      ],
      "metadata": {
        "id": "T6lWWZMCXKut"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "fruit = \"apples\"\n",
        "txt = f\"I love {fruit.upper()}\"\n",
        "print(txt)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ckTXI9vDXKjN",
        "outputId": "58290022-a61f-494e-d29c-ae2561e5e8b0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "I love APPLES\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The function does not have to be a built-in Python method,\n",
        "\n",
        "you can create your own functions and use them:"
      ],
      "metadata": {
        "id": "NdJrBGknXRiF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def myconverter(x):\n",
        "  return x * 0.3048\n",
        "\n",
        "txt = f\"The plane is flying at a {myconverter(30000)} meter altitude\"\n",
        "print(txt)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YePewuqNXQgW",
        "outputId": "aab7776e-f2a5-448c-c0bb-67166d91d93e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The plane is flying at a 9144.0 meter altitude\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def sum(a,b):\n",
        "  return a+b\n",
        "txt = f\"sum of 5 and 4 is {sum(5,4)}.\"\n",
        "print(txt)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TpjXrPXQXiwE",
        "outputId": "f61d4425-678e-42d2-cea9-f28d3785e4a2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "sum of 5 and 4 is 9.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "price = 59000\n",
        "txt = f\"The price is {price:,} dollars\"\n",
        "print(txt)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AOwSlrGYYHk0",
        "outputId": "d04074c2-c0c2-4bc7-d796-b5030df3ebe1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The price is 59,000 dollars\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **String format()**"
      ],
      "metadata": {
        "id": "u_1V9okgYPBU"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* The format() method also uses curly brackets as placeholders {}, but the syntax is slightly different:"
      ],
      "metadata": {
        "id": "X2LXlHsHYYyZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "price = 49\n",
        "txt = \"The price is {} dollars\"\n",
        "print(txt.format(price))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0qR92J8jYQYM",
        "outputId": "beb098a7-a893-41de-92ce-0192581f172b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The price is 49 dollars\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "txt = \"The price is {:.2f} dollars\"\n",
        "print(txt.format(price))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kfqHC9nCYa2-",
        "outputId": "22df333b-0edf-4b0a-9b64-62294b5823bb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The price is 49.00 dollars\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "quantity = 3\n",
        "itemno = 567\n",
        "price = 49\n",
        "myorder = \"I want {} pieces of item number {} for {:.2f} dollars.\"\n",
        "print(myorder.format(quantity, itemno, price))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "l58LUie4YjGm",
        "outputId": "46210426-78d2-4157-e42b-50dcfd29cf6a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "I want 3 pieces of item number 567 for 49.00 dollars.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Index Numbers**"
      ],
      "metadata": {
        "id": "j9ZSLclrYt4H"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* You can use index numbers (a number inside the curly brackets {0}) to be sure the values are placed in the correct placeholders:"
      ],
      "metadata": {
        "id": "evGTqcuHYvjp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "quantity = 3\n",
        "itemno = 567\n",
        "price = 49\n",
        "myorder = \"I want {0} pieces of item number {1} for {2:.2f} dollars.\"\n",
        "print(myorder.format(quantity, itemno, price))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7Z3JocQxYung",
        "outputId": "284a4daf-583d-4c39-ba0b-8f8ac3c55121"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "I want 3 pieces of item number 567 for 49.00 dollars.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Also, if you want to refer to the same value more than once, use the index number:"
      ],
      "metadata": {
        "id": "Mrzwox_XY7gh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "age = 36\n",
        "name = \"John\"\n",
        "txt = \"His name is {1}. {1} is {0} years old.\"\n",
        "print(txt.format(age, name))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0sQc4Nf_Y0G5",
        "outputId": "693c40dd-9949-4892-9397-6ad91672e531"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "His name is John. John is 36 years old.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Named Indexes**\n",
        "* You can also use named indexes by entering a name inside the curly brackets {carname}, but then you must use names when you pass the parameter values txt.format(carname = \"Ford\"):"
      ],
      "metadata": {
        "id": "5C4274YmY9cS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "myorder = \"I have a {carname}, it is a {model}.\"\n",
        "print(myorder.format(carname = \"Ford\", model = \"Mustang\"))"
      ],
      "metadata": {
        "id": "OE7xgNkhY8Ey",
        "outputId": "070bb54f-c94d-4c47-fecb-b94d6fd4274d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "I have a Ford, it is a Mustang.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **LIST**"
      ],
      "metadata": {
        "id": "Y51ynJFg64kq"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Lists are used to store multiple items in a single variable.\n",
        "\n",
        "* Lists are one of 4 built-in data types in Python used to store collections of data, the other 3 are Tuple, Set, and Dictionary, all with different qualities and usage.\n",
        "\n",
        "* Lists are created using square brackets:"
      ],
      "metadata": {
        "id": "QWCBEhLP66cG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Create a List:"
      ],
      "metadata": {
        "id": "gzQaVS8P7EXg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
        "print(thislist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "80i-hf6H66Kr",
        "outputId": "257fed47-482d-4e31-beae-77258c41665c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'banana', 'cherry']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **List Items**\n",
        "* List items are ordered, changeable, and allow duplicate values.\n",
        "\n",
        "* List items are indexed, the first item has index [0], the second item has index [1] etc."
      ],
      "metadata": {
        "id": "cp_5I3eO7Jz5"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Ordered**\n",
        "\n",
        "* When we say that lists are ordered, it means that the items have a defined order, and that order will not change.\n",
        "\n",
        "* If you add new items to a list, the new items will be placed at the end of the list."
      ],
      "metadata": {
        "id": "leH7DMrd7SRi"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Changeable**\n",
        "\n",
        "* The list is changeable, meaning that we can change, add, and remove items in a list after it has been created."
      ],
      "metadata": {
        "id": "rKBqHn-57cCk"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Allow Duplicates**\n",
        "\n",
        "* Since lists are indexed, lists can have items with the same value:"
      ],
      "metadata": {
        "id": "VluNAQHX7faK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"apple\", \"banana\", \"cherry\", \"apple\", \"cherry\"]\n",
        "print(thislist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CTEmj_hV7iuB",
        "outputId": "46d83f35-1351-43d5-ac8a-9ac075edff69"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'banana', 'cherry', 'apple', 'cherry']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **List Length**\n",
        "\n",
        "* To determine how many items a list has, use the len() function:"
      ],
      "metadata": {
        "id": "IVCukDyQ7k2L"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
        "print(len(thislist))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QcCW5t-Q7n-j",
        "outputId": "5d9cd323-cb95-4ddf-f6f6-42f5ff4063ef"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **List Items - Data Types**\n",
        "* List items can be of any data type:"
      ],
      "metadata": {
        "id": "-R0P6iXt_Y5m"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "list1 = [\"apple\", \"banana\", \"cherry\"]\n",
        "list2 = [1, 5, 7, 9, 3]\n",
        "list3 = [True, False, False]"
      ],
      "metadata": {
        "id": "00A1aD7T_cZW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "* A list can contain different data types:"
      ],
      "metadata": {
        "id": "p0veLawE_eJ2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "list1 = [\"abc\", 34, True, 40, \"male\"]"
      ],
      "metadata": {
        "id": "QwbyqN5V_gju"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "mylist = [\"apple\", \"banana\", \"cherry\"]\n",
        "print(type(mylist))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "g4SjbRpUBZiL",
        "outputId": "fd5863a1-f65b-40e8-92fd-7ffeb617fecb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'list'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **The list() Constructor**\n",
        "\n",
        "* It is also possible to use the list() constructor when creating a new list."
      ],
      "metadata": {
        "id": "3K1sIdGNBf1S"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = list((\"apple\", \"banana\", \"cherry\")) # note the double round-brackets\n",
        "print(thislist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yDGMrpzHBc0r",
        "outputId": "43599fbf-d8f6-498c-f857-3a4241f0e876"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'banana', 'cherry']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "![image.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "a2hdo9QuCOfB"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Python - Access List Items**"
      ],
      "metadata": {
        "id": "l15MfnvCCk-E"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
        "print(thislist[1])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zDnDa7IZCPTP",
        "outputId": "af4dc521-9803-4804-c470-e49756551282"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "banana\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Negative Indexing**\n",
        "* Negative indexing means start from the end\n",
        "\n",
        "* -1 refers to the last item, -2 refers to the second last item etc."
      ],
      "metadata": {
        "id": "DqZdrQx4Cro9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
        "print(thislist[-1])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lR8GpOavCxZ9",
        "outputId": "f4323bba-5910-4628-a760-d888d8066f47"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "cherry\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Range of Indexes**\n",
        "\n",
        "* You can specify a range of indexes by specifying where to start and where to end the range.\n",
        "\n",
        "* When specifying a range, the return value will be a new list with the specified items."
      ],
      "metadata": {
        "id": "hSIsIqTCC0B1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"apple\", \"banana\", \"cherry\", \"orange\", \"kiwi\", \"melon\", \"mango\"]\n",
        "print(thislist[2:5])\n",
        "\n",
        "#The search will start at index 2 (included)\n",
        "#and end at index 5 (not included)."
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BEh9ILzTC4B2",
        "outputId": "32c146fc-54f1-4848-f0c2-8a28f9d373ee"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['cherry', 'orange', 'kiwi']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "* **By leaving out the start value, the range will start at the first item:**"
      ],
      "metadata": {
        "id": "YK0pwdPMEpR5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"apple\", \"banana\", \"cherry\", \"orange\", \"kiwi\", \"melon\", \"mango\"]\n",
        "print(thislist[:4])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "S6w0ePBaDDCW",
        "outputId": "cbe62232-519b-42dd-898c-c0822a361a69"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'banana', 'cherry', 'orange']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "* **By leaving out the end value, the range will go on to the end of the list:**"
      ],
      "metadata": {
        "id": "U4iHJzoCExFa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"apple\", \"banana\", \"cherry\", \"orange\", \"kiwi\", \"melon\", \"mango\"]\n",
        "print(thislist[2:])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BXKd7548EyXo",
        "outputId": "0284b7fe-6f00-4775-fcc2-b4c5774219b8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['cherry', 'orange', 'kiwi', 'melon', 'mango']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Range of Negative Indexes**\n",
        "* Specify negative indexes if you want to start the search from the end of the list:"
      ],
      "metadata": {
        "id": "johsvQwhE3bT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"apple\", \"banana\", \"cherry\", \"orange\", \"kiwi\", \"melon\", \"mango\"]\n",
        "print(thislist[-4:-1])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CEtwoFFHE14C",
        "outputId": "8c036c1a-dc4f-49bf-b720-c389234ef954"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['orange', 'kiwi', 'melon']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Check if Item Exists**\n",
        "* To determine if a specified item is present in a list use the in keyword:"
      ],
      "metadata": {
        "id": "rPLQavwBFQFW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
        "if \"apple\" in thislist:\n",
        "  print(\"Yes, 'apple' is in the fruits list\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "udYNYkesFSIG",
        "outputId": "0ccfe90f-183d-489f-a6e6-bb0174d5d319"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Yes, 'apple' is in the fruits list\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Change List Items**\n",
        "* To change the value of a specific item, refer to the index number:"
      ],
      "metadata": {
        "id": "ThcnK-dOG-lR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
        "thislist[1] = \"blackcurrant\"\n",
        "print(thislist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dlda_StOHB1w",
        "outputId": "a8a262e6-bdbd-4560-de2f-159b5ef818a2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'blackcurrant', 'cherry']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Change a Range of Item Values**\n",
        "\n",
        "* To change the value of items within a specific range, define a list with the new values, and refer to the range of index numbers where you want to insert the new values:"
      ],
      "metadata": {
        "id": "othLctGrHE_L"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"apple\", \"banana\", \"cherry\", \"orange\", \"kiwi\", \"mango\"]\n",
        "thislist[1:3] = [\"blackcurrant\", \"watermelon\"]\n",
        "print(thislist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JD7JFX0sHHib",
        "outputId": "86b6b9d2-1dc3-47a5-9e9c-b5c7d2ebc781"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'blackcurrant', 'watermelon', 'orange', 'kiwi', 'mango']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "* If you insert more items than you replace, the new items will be inserted where you specified, and the remaining items will move accordingly:"
      ],
      "metadata": {
        "id": "MrvZfXdjHOAs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
        "thislist[1:2] = [\"blackcurrant\", \"watermelon\"]\n",
        "print(thislist)\n",
        "\n",
        "# The length of the list will change when the number of items inserted\n",
        "# does not match the number of items replaced."
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1nj3K8slHOmE",
        "outputId": "5143bdb8-2bc1-46f0-acc1-860bcb14b42e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'blackcurrant', 'watermelon', 'cherry']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "* If you insert less items than you replace, the new items will be inserted where you specified, and the remaining items will move accordingly:"
      ],
      "metadata": {
        "id": "iUer6WOHHe5V"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
        "thislist[1:3] = [\"watermelon\"]\n",
        "print(thislist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "egHBwwdtHeeP",
        "outputId": "460be2ac-b379-48ce-f687-ab8601974fc6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'watermelon']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Insert Items**\n",
        "* To insert a new list item, without replacing any of the existing values, we can use the insert() method.\n",
        "\n",
        "* The insert() method inserts an item at the specified index:"
      ],
      "metadata": {
        "id": "cKhOorBxHtz-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
        "thislist.insert(2, \"watermelon\")\n",
        "print(thislist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tuoZi9NJHxv3",
        "outputId": "fbc20b68-7469-4647-c196-b108e50f6e8f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'banana', 'watermelon', 'cherry']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Append Items**\n",
        "To add an item to the end of the list, use the append() method:"
      ],
      "metadata": {
        "id": "9JMpE_XaNFVK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
        "thislist.append(\"orange\")\n",
        "print(thislist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MXtxXw8nNG26",
        "outputId": "53a5275b-f861-4e7c-c0b8-b6cf360fd5cf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'banana', 'cherry', 'orange']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Insert Items**\n",
        "To insert a list item at a specified index, use the insert() method."
      ],
      "metadata": {
        "id": "SQeNhIRTNK_z"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
        "thislist.insert(1, \"orange\")\n",
        "print(thislist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FUUQJZziNNCF",
        "outputId": "f8be9db8-05c0-41fb-ca35-f8ec836a431a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'orange', 'banana', 'cherry']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Extend List**\n",
        "To append elements from another list to the current list, use the extend() method."
      ],
      "metadata": {
        "id": "TL9Ny4sSNRk0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
        "tropical = [\"mango\", \"pineapple\", \"papaya\"]\n",
        "thislist.extend(tropical)\n",
        "print(thislist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i_p0EPz4NTEk",
        "outputId": "020efebd-df9b-4310-8a9a-11c92f1a2e02"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'banana', 'cherry', 'mango', 'pineapple', 'papaya']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Add Any Iterable**\n",
        "The extend() method does not have to append lists, you can add any iterable object (tuples, sets, dictionaries etc.)."
      ],
      "metadata": {
        "id": "9JvMFoIJNZIF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
        "thistuple = (\"kiwi\", \"orange\")\n",
        "thislist.extend(thistuple)\n",
        "print(thislist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "A0prebXLNas-",
        "outputId": "085f78f4-04b1-49bf-906f-6d9eceffd380"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'banana', 'cherry', 'kiwi', 'orange']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Remove List Items**"
      ],
      "metadata": {
        "id": "O1cVNAlTOJ4q"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Remove Specified Item**\n",
        "* The remove() method removes the specified item."
      ],
      "metadata": {
        "id": "2EiZWS9pONEy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
        "thislist.remove(\"banana\")\n",
        "print(thislist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1gJHRmIeORcb",
        "outputId": "1eb557d4-ba5a-42db-bbfc-74921dadb690"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'cherry']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "* If there are more than one item with the specified value, the remove() method removes the first occurrence:"
      ],
      "metadata": {
        "id": "sDjr54YvOXJV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"apple\", \"banana\", \"cherry\", \"banana\", \"kiwi\"]\n",
        "thislist.remove(\"banana\")\n",
        "print(thislist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ooTIeFXCOYRU",
        "outputId": "1f4d7a92-e3c4-42a5-94c4-997e8996be1b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'cherry', 'banana', 'kiwi']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Remove Specified Index**\n",
        "* The pop() method removes the specified index."
      ],
      "metadata": {
        "id": "vyivS8oKOc3t"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
        "thislist.pop(1)\n",
        "print(thislist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EUoVfoIHOfqV",
        "outputId": "d67363a0-bfff-4003-f818-4afd0b9f0841"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'cherry']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "* If you do not specify the index, the pop() method removes the last item."
      ],
      "metadata": {
        "id": "AC_ujmpnOmfH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
        "thislist.pop()\n",
        "print(thislist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AWE1_BlROnYA",
        "outputId": "1e6815a0-dc9c-4ccd-c861-427172a05c65"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'banana']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "* The del keyword also removes the specified index:"
      ],
      "metadata": {
        "id": "aroyUSUROp5G"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
        "del thislist[0]\n",
        "print(thislist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vYCaczSfOqs2",
        "outputId": "8c50fc25-aa1c-47a5-eaff-3fab197c14a7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['banana', 'cherry']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "* The del keyword can also delete the list completely."
      ],
      "metadata": {
        "id": "Z23EfHulOySw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
        "del thislist"
      ],
      "metadata": {
        "id": "EUlzBKqmOw6n"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Clear the List**\n",
        "* The clear() method empties the list.\n",
        "\n",
        "* The list still remains, but it has no content."
      ],
      "metadata": {
        "id": "gt8KkBUtO5-l"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
        "thislist.clear()\n",
        "print(thislist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pizYQzUyO_Lx",
        "outputId": "d938d349-b81e-4423-a893-efa78d67f5ea"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Python - Loop Lists**\n",
        "## **Loop Through a List**\n",
        "You can loop through the list items by using a for loop:"
      ],
      "metadata": {
        "id": "D8ovb8ilPWpT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
        "for x in thislist:\n",
        "  print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "K9o-GuPkPe-U",
        "outputId": "fccaf4f7-fb9b-458e-9825-a788d5b37efe"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "apple\n",
            "banana\n",
            "cherry\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Loop Through the Index Numbers**\n",
        "* You can also loop through the list items by referring to their index number.\n",
        "\n",
        "* Use the range() and len() functions to create a suitable iterable."
      ],
      "metadata": {
        "id": "wbpD-uq5Pjct"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
        "for i in range(len(thislist)):\n",
        "  print(thislist[i])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cO05Nlh6PmE-",
        "outputId": "c2a36604-e8c9-4424-d99c-10582c1e57e7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "apple\n",
            "banana\n",
            "cherry\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Using a While Loop**\n",
        "* You can loop through the list items by using a while loop.\n",
        "\n",
        "* Use the len() function to determine the length of the list, then start at 0 and loop your way through the list items by referring to their indexes.\n",
        "\n",
        "* Remember to increase the index by 1 after each iteration."
      ],
      "metadata": {
        "id": "Cd8CBptyPvWG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
        "i = 0\n",
        "while i < len(thislist):\n",
        "  print(thislist[i])\n",
        "  i = i + 1"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "y-bDvO6UP2Fn",
        "outputId": "2626c801-c315-4e96-a22d-4a5d555ff8f5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "apple\n",
            "banana\n",
            "cherry\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Looping Using List Comprehension**\n",
        "* List Comprehension offers the shortest syntax for looping through lists:"
      ],
      "metadata": {
        "id": "Geaie1txP65X"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
        "[print(x) for x in thislist]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i9yDxtbNP9XQ",
        "outputId": "958b8618-cdad-43ec-a756-73867d0cc46c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "apple\n",
            "banana\n",
            "cherry\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[None, None, None]"
            ]
          },
          "metadata": {},
          "execution_count": 82
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "* List comprehension offers a shorter syntax when you want to create a new list based on the values of an existing list."
      ],
      "metadata": {
        "id": "nuaseqDQR9Qu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "fruits = [\"apple\", \"banana\", \"cherry\", \"kiwi\", \"mango\"]\n",
        "newlist = []\n",
        "\n",
        "for x in fruits:\n",
        "  if \"an\" in x:\n",
        "    newlist.append(x)\n",
        "\n",
        "print(newlist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8H4iuB8CR-4u",
        "outputId": "07f027b6-dd32-48eb-8c45-5820b0b81be6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['banana', 'mango']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "* With list comprehension you can do all that with only one line of code:"
      ],
      "metadata": {
        "id": "Hbjw7izQSIof"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "fruits = [\"apple\", \"banana\", \"cherry\", \"kiwi\", \"mango\"]\n",
        "\n",
        "newlist = [x for x in fruits if \"a\" in x]\n",
        "\n",
        "print(newlist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5GQFjQu-SKLX",
        "outputId": "724129b1-eaab-4f2c-edcd-5a0d719e0b84"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'banana', 'mango']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "fruits = [\"apple\", \"banana\", \"cherry\", \"kiwi\", \"mango\"]\n",
        "newlist = [x.upper() for x in fruits]\n",
        "print(newlist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Kp8CouZlS8pV",
        "outputId": "7544d83d-eea7-4e89-a02b-c59dea79a092"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['APPLE', 'BANANA', 'CHERRY', 'KIWI', 'MANGO']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Python - Sort Lists**"
      ],
      "metadata": {
        "id": "yNTQcyn7T1kD"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Sort List Alphanumerically**\n",
        "\n",
        "* List objects have a sort() method that will sort the list alphanumerically, ascending, by default:"
      ],
      "metadata": {
        "id": "-Gb569SdT21K"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"orange\", \"mango\", \"kiwi\", \"pineapple\", \"banana\"]\n",
        "thislist.sort()\n",
        "print(thislist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8fvIx-p-T2nC",
        "outputId": "7ebb0c64-71a4-4f5a-ddf2-1b8beb4f1c61"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['banana', 'kiwi', 'mango', 'orange', 'pineapple']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Sort the list numerically:"
      ],
      "metadata": {
        "id": "TjVX8LUAT_mz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [100, 50, 65, 82, 23]\n",
        "thislist.sort()\n",
        "print(thislist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "n0OiA6yLUAIz",
        "outputId": "9062cdb3-95fa-496d-e4e6-207a94cebd46"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[23, 50, 65, 82, 100]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Sort Descending**\n",
        "* To sort descending, use the keyword argument reverse = True:"
      ],
      "metadata": {
        "id": "2ihVkdU0UEYD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"orange\", \"mango\", \"kiwi\", \"pineapple\", \"banana\"]\n",
        "thislist.sort(reverse = True)\n",
        "print(thislist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qguEsPBMUHhk",
        "outputId": "be3b1671-ff7b-4ea5-d253-b19a8f4542f7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['pineapple', 'orange', 'mango', 'kiwi', 'banana']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"orange\", \"mango\", \"kiwi\", \"pineapple\", \"banana\"]\n",
        "thislist.sort()\n",
        "print(thislist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aHDzN0K5ULPc",
        "outputId": "0efc5047-5ca3-4d2b-e307-aa633801caaa"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['banana', 'kiwi', 'mango', 'orange', 'pineapple']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"orange\", \"mango\", \"kiwi\", \"pineapple\", \"banana\"]\n",
        "thislist.sort(reverse = False)\n",
        "print(thislist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iSjcsEWwUOjD",
        "outputId": "006e3bd4-c37c-4aa0-d3bd-54e850f0d2dd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['banana', 'kiwi', 'mango', 'orange', 'pineapple']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [100, 50, 65, 82, 23]\n",
        "thislist.sort(reverse = True)\n",
        "print(thislist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kg7gWfIoUUDt",
        "outputId": "9ddfe185-e7b7-404d-e704-ddc35b6fedca"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[100, 82, 65, 50, 23]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Customize Sort Function**\n",
        "* You can also customize your own function by using the keyword argument key = function.\n",
        "\n",
        "* The function will return a number that will be used to sort the list (the lowest number first):"
      ],
      "metadata": {
        "id": "2p7PcqTKUWKm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def myfunc(n):\n",
        "  return abs(n - 50)\n",
        "\n",
        "thislist = [100, 50, 65, 82, 23]\n",
        "\n",
        "for x in thislist:\n",
        "  print(myfunc(x))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nPkgtJTBUaIm",
        "outputId": "c8363bd2-a931-48c6-b58c-d9ba152ef295"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "50\n",
            "0\n",
            "15\n",
            "32\n",
            "27\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def myfunc(n):\n",
        "  return abs(n - 50)\n",
        "\n",
        "thislist = [100, 50, 65, 82, 23]\n",
        "thislist.sort(key = myfunc)\n",
        "print(thislist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XPDYmFGXVBvp",
        "outputId": "06bfb38f-50de-4d3c-85c5-9fb3a2f59d24"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[50, 65, 23, 82, 100]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Case Insensitive Sort**\n",
        "By default the sort() method is case sensitive, resulting in all capital letters being sorted before lower case letters:"
      ],
      "metadata": {
        "id": "OBbxEM0EVGhT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"banana\", \"Orange\", \"Kiwi\", \"cherry\"]\n",
        "thislist.sort()\n",
        "print(thislist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gxEtQNcHVINT",
        "outputId": "e2b8442d-3a0c-4db4-b209-b2fbafe2175c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['Kiwi', 'Orange', 'banana', 'cherry']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Luckily we can use built-in functions as key functions when sorting a list.\n",
        "\n",
        "* So if you want a case-insensitive sort function, use str.lower as a key function:"
      ],
      "metadata": {
        "id": "lleey7BWVP8r"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"banana\", \"Orange\", \"Kiwi\", \"cherry\"]\n",
        "thislist.sort(key = str.lower)\n",
        "print(thislist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZsiA4aULVRN7",
        "outputId": "1754552d-13f8-4100-f1a0-b8ad67b18bed"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['banana', 'cherry', 'Kiwi', 'Orange']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"banana\", \"Orange\", \"Kiwi\", \"cherry\"]\n",
        "thislist.reverse()\n",
        "print(thislist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dXRpqrmFVjkW",
        "outputId": "3ad37fc8-134a-4740-8f33-4963bbc0e52f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['cherry', 'Kiwi', 'Orange', 'banana']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Python - Copy Lists**"
      ],
      "metadata": {
        "id": "9TOfU3WpXCUy"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Copy a List**\n",
        "\n",
        "* You cannot copy a list simply by typing list2 = list1, because: list2 will only be a reference to list1, and changes made in list1 will automatically also be made in list2."
      ],
      "metadata": {
        "id": "xjuTWV6wXEJ7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
        "mylist = thislist.copy()\n",
        "print(mylist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "34ViDEXTXDzR",
        "outputId": "ae0f21b1-277c-4cd2-ffa6-bf96f0dd8ff4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'banana', 'cherry']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Use the list() method**\n",
        "* Another way to make a copy is to use the built-in method list()."
      ],
      "metadata": {
        "id": "cePLfg20XL8J"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
        "mylist = list(thislist)\n",
        "print(mylist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Y0oxxngyXO4E",
        "outputId": "6462d4c0-7a23-4d34-e214-a59801a36a6a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'banana', 'cherry']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Use the slice Operator**\n",
        "* You can also make a copy of a list by using the : (slice) operator."
      ],
      "metadata": {
        "id": "tN14V0WqXTCy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
        "mylist = thislist[:]\n",
        "print(mylist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ssC1gU2UXU1C",
        "outputId": "b870568f-0606-4f58-f1be-187a43931c32"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'banana', 'cherry']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
        "mylist = thislist[1]\n",
        "print(mylist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UdKSXjxiXfzF",
        "outputId": "cafe00d5-e635-45d1-9034-580a16e0f63d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "banana\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
        "mylist = thislist[1:2]\n",
        "print(mylist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bB1GQHfbXi8E",
        "outputId": "4aa9bf66-5773-4942-8953-7e7631a3c50c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['banana']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
        "mylist = thislist[:2]\n",
        "print(mylist)"
      ],
      "metadata": {
        "id": "aZ5yXLEEXlb0",
        "outputId": "72fb2c78-8af8-433f-dd6c-ada732ae4997",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'banana']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Join Lists**"
      ],
      "metadata": {
        "id": "8qRJoivJAMEr"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "There are several ways to join, or concatenate, two or more lists in Python.\n",
        "\n",
        "* One of the easiest ways are by using the + operator."
      ],
      "metadata": {
        "id": "9p4YJy1vAN4C"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "list1 = [\"a\", \"b\", \"c\"]\n",
        "list2 = [1, 2, 3]\n",
        "\n",
        "list3 = list1 + list2\n",
        "print(list3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ct1Tq6EBAQmz",
        "outputId": "1d3c0e8f-c5f9-48fb-a1d9-47d246fd7b82"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['a', 'b', 'c', 1, 2, 3]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Another way to join two lists is by appending all the items from list2 into list1, one by one:"
      ],
      "metadata": {
        "id": "jTGe8Vo1AU_s"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "list1 = [\"a\", \"b\" , \"c\"]\n",
        "list2 = [1, 2, 3]\n",
        "\n",
        "for x in list2:\n",
        "  list1.append(x)\n",
        "\n",
        "print(list1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rKaWEq8pAUxE",
        "outputId": "d56a277c-754b-4bbb-c3d6-3c66444d731e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['a', 'b', 'c', 1, 2, 3]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Or you can use the extend() method, where the purpose is to add elements from one list to another list:"
      ],
      "metadata": {
        "id": "lkaXgevMAXf7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "list1 = [\"a\", \"f\" , \"c\"]\n",
        "list2 = [1, 22, 3]\n",
        "list1.append(list2)\n",
        "print(list1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ojem1mADBHZa",
        "outputId": "b9b395bc-eaaf-463d-c4a4-9f3795d7ece7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['a', 'f', 'c', [1, 22, 3]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "list1 = [\"a\", \"b\" , \"c\"]\n",
        "list2 = [1, 2, 3]\n",
        "\n",
        "list1.extend(list2)\n",
        "print(list1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Y48qeXpAAZ8r",
        "outputId": "0e4d5b8c-cadd-447b-949c-e7c2bbb19aef"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['a', 'b', 'c', 1, 2, 3]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "![image.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "Uohh0LlBA-aH"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Tuples**"
      ],
      "metadata": {
        "id": "pm-Nqa6NCZNy"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Tuples are used to store multiple items in a single variable.\n",
        "\n",
        "* Tuple is one of 4 built-in data types in Python used to store collections of data, the other 3 are List, Set, and Dictionary, all with different qualities and usage.\n",
        "\n",
        "* A tuple is a collection which is ordered and unchangeable.\n",
        "\n",
        "* Tuples are written with round brackets."
      ],
      "metadata": {
        "id": "ZFbyjGYWCbN4"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Mnemonic Tricks:**\n",
        "\n",
        "* Tuple: \"T is for Tracked and Things that don't change\"\n",
        "\n",
        "  Use tuples when the order matters and you want an unchangeable sequence.\n",
        "\n",
        "* List: \"L is for Listing items flexibly\"\n",
        "\n",
        "  Use lists when you need to maintain order and might want to change the sequence, like a to-do list.\n",
        "\n",
        "* Set: \"S is for Single unique items\"\n",
        "\n",
        "  Use sets when you need a collection of unique items and don't care about the order, like tracking unique tags.\n",
        "\n",
        "* Dictionary: \"D is for Defined pairs and Diverse keys\"\n",
        "\n",
        "  Use dictionaries when you need to map keys to values, like a phone book or product catalog."
      ],
      "metadata": {
        "id": "0rehjnluE-6s"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thistuple = (\"apple\", \"banana\", \"cherry\")\n",
        "print(thistuple)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oLz8e2-MA_Rq",
        "outputId": "23a7d3c8-4e6e-477c-e9b6-96e66ff6581d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "('apple', 'banana', 'cherry')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Tuple Items**\n",
        "* Tuple items are ordered, unchangeable, and allow duplicate values.\n",
        "\n",
        "* Tuple items are indexed, the first item has index [0], the second item has index [1] etc."
      ],
      "metadata": {
        "id": "sWyG3ye9FZKm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Tuples allow duplicate values:\n",
        "\n",
        "thistuple = (\"apple\", \"banana\", \"cherry\", \"apple\", \"cherry\")\n",
        "print(thistuple)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cUQblx3AFdj9",
        "outputId": "99a7101b-2bfd-4436-a009-3784f2f72849"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "('apple', 'banana', 'cherry', 'apple', 'cherry')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Tuple Length**\n",
        "* To determine how many items a tuple has, use the len() function:"
      ],
      "metadata": {
        "id": "rZ7buuQuFgd-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thistuple = (\"apple\", \"banana\", \"cherry\")\n",
        "print(len(thistuple))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7h1yInhrFihn",
        "outputId": "e1709288-b5fa-4b2a-f247-f39e348402f7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Create Tuple With One Item**\n",
        "To create a tuple with only one item, you have to ***add a comma after the item***, otherwise Python will not recognize it as a tuple."
      ],
      "metadata": {
        "id": "M_-EG3H1FlH3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#NOT a tuple\n",
        "thistuple = (\"apple\")\n",
        "print(type(thistuple))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "d6SF9sPyFsFT",
        "outputId": "5ba4ae51-5377-4361-c222-50b3fc044c51"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'str'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "thistuple = (\"apple\",)\n",
        "print(type(thistuple))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2ZwT3_c5FnDf",
        "outputId": "f1d48c8a-e261-440f-c4c0-c65e43135787"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'tuple'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Tuple Items - Data Types**\n",
        "* Tuple items can be of any data type:"
      ],
      "metadata": {
        "id": "EPI_MuZgFx2f"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tuple1 = (\"apple\", \"banana\", \"cherry\")\n",
        "tuple2 = (1, 5, 7, 9, 3)\n",
        "tuple3 = (True, False, False)"
      ],
      "metadata": {
        "id": "tBDTX7kvFzzR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "tuple1 = (\"abc\", 34, True, 40, \"male\")"
      ],
      "metadata": {
        "id": "JyRLQ1CAF3d4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **The tuple() Constructor**\n",
        "* It is also possible to use the tuple() constructor to make a tuple."
      ],
      "metadata": {
        "id": "xDkg-XvNF8AI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thistuple = tuple((\"apple\", \"banana\", \"cherry\")) # note the double round-brackets\n",
        "print(thistuple)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Bi7LFb-OF-bC",
        "outputId": "070f92ae-e698-43bb-c9d0-f07e47cb5f28"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "('apple', 'banana', 'cherry')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Python Collections (Arrays)**\n",
        "There are four collection data types in the Python programming language:\n",
        "\n",
        "* List is a collection which is ordered and changeable. Allows duplicate members.\n",
        "* Tuple is a collection which is ordered and unchangeable. Allows duplicate members.\n",
        "* Set is a collection which is unordered, unchangeable*, and unindexed. No duplicate members.\n",
        "* Dictionary is a collection which is ordered** and changeable. No duplicate members."
      ],
      "metadata": {
        "id": "9RewTrR9GZa1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Access Tuple Items**\n",
        "You can access tuple items by referring to the index number, inside square brackets:"
      ],
      "metadata": {
        "id": "jn_Uf5o6PiTr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thistuple = (\"apple\", \"banana\", \"cherry\")\n",
        "print(thistuple[1])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XkWH5KHRGx-A",
        "outputId": "0d3ee87b-c778-4d6d-bed1-b6349197693d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "banana\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Negative Indexing**\n",
        "* Negative indexing means start from the end.\n",
        "\n",
        "* -1 refers to the last item, -2 refers to the second last item etc."
      ],
      "metadata": {
        "id": "K9N5nhcUPmnc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thistuple = (\"apple\", \"banana\", \"cherry\")\n",
        "print(thistuple[-1])"
      ],
      "metadata": {
        "id": "XrjA06IrPrLX",
        "outputId": "70b907be-01fd-409e-a12a-545f4dafe798",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "cherry\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Range of Indexes**\n",
        "* You can specify a range of indexes by specifying where to start and where to end the range.\n",
        "\n",
        "* When specifying a range, the return value will be a new tuple with the specified items."
      ],
      "metadata": {
        "id": "FyXZL99kZMSj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thistuple = (\"apple\", \"banana\", \"cherry\", \"orange\", \"kiwi\", \"melon\", \"mango\")\n",
        "print(thistuple[2:5])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2W_752aVZPRq",
        "outputId": "9ab08a0c-aaf4-416e-bdc6-bc1f7b43f35a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "('cherry', 'orange', 'kiwi')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "thistuple = (\"apple\", \"banana\", \"cherry\", \"orange\", \"kiwi\", \"melon\", \"mango\")\n",
        "print(thistuple[:4])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6W9C7u2zZWpr",
        "outputId": "b6769098-ed9d-4590-ebc4-2283c5eb5f5b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "('apple', 'banana', 'cherry', 'orange')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "thistuple = (\"apple\", \"banana\", \"cherry\", \"orange\", \"kiwi\", \"melon\", \"mango\")\n",
        "print(thistuple[2:])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6pz7mvrkZZ5E",
        "outputId": "40c32f7e-50fa-4cd8-8d89-49cce868804f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "('cherry', 'orange', 'kiwi', 'melon', 'mango')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Range of Negative Indexes**\n",
        "Specify negative indexes if you want to start the search from the end of the tuple:"
      ],
      "metadata": {
        "id": "snnZujFRZfDz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thistuple = (\"apple\", \"banana\", \"cherry\", \"orange\", \"kiwi\", \"melon\", \"mango\")\n",
        "print(thistuple[-4:-1])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XUUrs8sHZgcb",
        "outputId": "21a53a0e-9cce-407c-ef2b-8a3b53017bc9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "('orange', 'kiwi', 'melon')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Check if Item Exists**\n",
        "* To determine if a specified item is present in a tuple use the in keyword:"
      ],
      "metadata": {
        "id": "zc3T5nFYZmRU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thistuple = (\"apple\", \"banana\", \"cherry\")\n",
        "if \"apple\" in thistuple:\n",
        "  print(\"Yes, 'apple' is in the fruits tuple\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Kb0vvFLUZl2k",
        "outputId": "2d56e843-381b-4749-d9ed-10ae37723dc1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Yes, 'apple' is in the fruits tuple\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Change Tuple Values**\n",
        "* Once a tuple is created, you cannot change its values. Tuples are unchangeable, or immutable as it also is called.\n",
        "\n",
        "* But there is a workaround. You can convert the tuple into a list, change the list, and convert the list back into a tuple."
      ],
      "metadata": {
        "id": "XxQPf55eaIag"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = (\"apple\", \"banana\", \"cherry\")\n",
        "y = list(x)\n",
        "y[1] = \"kiwi\"\n",
        "x = tuple(y)\n",
        "\n",
        "print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9HprKRvXaKsS",
        "outputId": "caa900c3-121c-4775-dce1-857dfaf0dcc7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "('apple', 'kiwi', 'cherry')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Add Items**\n",
        "  Since tuples are immutable, they do not have a built-in append() method, but there are other ways to add items to a tuple.\n",
        "###  **1. Convert into a list:**\n",
        "\n",
        "Just like the workaround for changing a tuple, you can convert it into a list, add your item(s), and convert it back into a tuple."
      ],
      "metadata": {
        "id": "DLtoHuhgabSc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thistuple = (\"apple\", \"banana\", \"cherry\")\n",
        "y = list(thistuple)\n",
        "y.append(\"orange\")\n",
        "thistuple = tuple(y)\n",
        "thistuple"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a23TEpLyaoLr",
        "outputId": "c5a2e02b-bf4f-48fc-ccdc-b26db9071de2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "('apple', 'banana', 'cherry', 'orange')"
            ]
          },
          "metadata": {},
          "execution_count": 123
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **2. Add tuple to a tuple.**\n",
        "You are allowed to add tuples to tuples, so if you want to add one item, (or many), create a new tuple with the item(s), and add it to the existing tuple:"
      ],
      "metadata": {
        "id": "LWcwv_g_avLD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thistuple = (\"apple\", \"banana\", \"cherry\")\n",
        "y = (\"orange\",)\n",
        "thistuple += y\n",
        "\n",
        "print(thistuple)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_szNRix9ayVF",
        "outputId": "68de4dda-dca4-4d10-8f42-3c07665b118b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "('apple', 'banana', 'cherry', 'orange')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Note:** When creating a tuple with only one item, remember to include a comma after the item, otherwise it will not be identified as a tuple."
      ],
      "metadata": {
        "id": "LRaQvREGbBIG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Remove Items**"
      ],
      "metadata": {
        "id": "pmfo0grebDw2"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Tuples are ***unchangeable***, so you cannot remove items from it, but you can use the same workaround as we used for changing and adding tuple items:"
      ],
      "metadata": {
        "id": "HgRzjretbHLW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thistuple = (\"apple\", \"banana\", \"cherry\")\n",
        "y = list(thistuple)\n",
        "y.remove(\"apple\")\n",
        "thistuple = tuple(y)"
      ],
      "metadata": {
        "id": "9QqxLrF3bG6e"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Or you can **delete** the tuple completely:"
      ],
      "metadata": {
        "id": "2hU0dQKlbwQT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thistuple = (\"apple\", \"banana\", \"cherry\")\n",
        "del thistuple\n",
        "#print(thistuple) #this will raise an error because the tuple no longer exists"
      ],
      "metadata": {
        "id": "cyTmi1ZPbxbL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Unpacking a Tuple**\n",
        "When we create a tuple, we normally assign values to it. This is called \"packing\" a tuple:"
      ],
      "metadata": {
        "id": "nRujFdqscVRI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "fruits = (\"apple\", \"banana\", \"cherry\")"
      ],
      "metadata": {
        "id": "OKZW_8HrcXzA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "fruits = (\"apple\", \"banana\", \"cherry\")\n",
        "\n",
        "(green, yellow, red) = fruits\n",
        "\n",
        "print(green)\n",
        "print(yellow)\n",
        "print(red)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BU74wFIkcaxw",
        "outputId": "ce6b2540-44e5-4535-e131-10d7f3b05b7b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "apple\n",
            "banana\n",
            "cherry\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### **Using Asterisk** **( * )**\n",
        "\n",
        "If the number of variables is less than the number of values, you can add an * to the variable name and the values will be assigned to the variable as a list:"
      ],
      "metadata": {
        "id": "UA8QeKxFdPep"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "fruits = (\"apple\", \"banana\", \"cherry\", \"strawberry\", \"raspberry\")\n",
        "\n",
        "(green, yellow, *red) = fruits\n",
        "\n",
        "print(green)\n",
        "print(yellow)\n",
        "print(red)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LHSNBCiqdhkp",
        "outputId": "76765346-eea8-494a-b054-4cec69fc5251"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "apple\n",
            "banana\n",
            "['cherry', 'strawberry', 'raspberry']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "If the asterisk is added to another variable name than the last, Python will assign values to the variable until the number of values left matches the number of variables left."
      ],
      "metadata": {
        "id": "PtLuxRPSdrgY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "fruits = (\"apple\", \"mango\", \"papaya\", \"pineapple\", \"cherry\")\n",
        "\n",
        "(green, *tropic, red) = fruits\n",
        "\n",
        "print(green)\n",
        "print(tropic)\n",
        "print(red)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bcN1PDmOdwTZ",
        "outputId": "abb8c007-12b4-4db1-a60c-8a9eb3d7eea7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "apple\n",
            "['mango', 'papaya', 'pineapple']\n",
            "cherry\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Loop Tuples**"
      ],
      "metadata": {
        "id": "YND2vzW1hvUk"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Loop Through a Tuple**\n",
        "You can loop through the tuple items by using a for loop."
      ],
      "metadata": {
        "id": "fRuz389dhxrl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thistuple = (\"apple\", \"banana\", \"cherry\")\n",
        "for x in thistuple:\n",
        "  print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2-XH9f-Dhzlm",
        "outputId": "e0fa5cd1-0264-48da-bf41-4ad7dfd68d90"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "apple\n",
            "banana\n",
            "cherry\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Loop Through the Index Numbers**\n",
        "* You can also loop through the tuple items by referring to their index number.\n",
        "\n",
        "* Use the range() and len() functions to create a suitable iterable."
      ],
      "metadata": {
        "id": "mP9SENzDh2WO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thistuple = (\"apple\", \"banana\", \"cherry\")\n",
        "for i in range(len(thistuple)):\n",
        "  print(thistuple[i])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Hh7F0Fhvh5mm",
        "outputId": "3d3b6654-943c-4f91-b432-76bb14999fd1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "apple\n",
            "banana\n",
            "cherry\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Using a While Loop**\n",
        "* You can loop through the tuple items by using a while loop.\n",
        "\n",
        "* Use the len() function to determine the length of the tuple, then start at 0 and loop your way through the tuple items by referring to their indexes.\n",
        "\n",
        "* Remember to increase the index by 1 after each iteration."
      ],
      "metadata": {
        "id": "CQANVtlKiSs1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thistuple = (\"apple\", \"banana\", \"cherry\")\n",
        "i = 0\n",
        "while i < len(thistuple):\n",
        "  print(thistuple[i])\n",
        "  i = i + 1"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BNML9R7ciWrh",
        "outputId": "f6f5d824-80a3-498d-de4a-1b5f22250179"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "apple\n",
            "banana\n",
            "cherry\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "thistuple = (\"apple\", \"banana\", \"cherry\")\n",
        "i = 0\n",
        "while i < len(thistuple):\n",
        "  print(thistuple[i])\n",
        "  i = i+1"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oRAY36hQicX_",
        "outputId": "9bd2148e-1851-43b0-f994-04d25be6a252"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "apple\n",
            "banana\n",
            "cherry\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Join Two Tuples**\n",
        "\n",
        "To join two or more tuples you can use the + operator:"
      ],
      "metadata": {
        "id": "HHpr4-0dr5M-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tuple1 = (\"a\", \"b\" , \"c\")\n",
        "tuple2 = (1, 2, 3)\n",
        "\n",
        "tuple3 = tuple1 + tuple2\n",
        "print(tuple3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bhyEYIkur8l2",
        "outputId": "25499dd3-44ca-486e-9f92-d5e53f40fc1d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "('a', 'b', 'c', 1, 2, 3)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Multiply Tuples**\n",
        "If you want to multiply the content of a tuple a given number of times, you can use the * operator:"
      ],
      "metadata": {
        "id": "gxEo9CX8r_kl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "fruits = (\"apple\", \"banana\", \"cherry\")\n",
        "mytuple = fruits * 2\n",
        "\n",
        "print(mytuple)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7HirsaubsBvV",
        "outputId": "46144674-a1ce-4735-e832-38c05fa03dd0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "('apple', 'banana', 'cherry', 'apple', 'banana', 'cherry')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Set**\n",
        "* Sets are used to store multiple items in a single variable.\n",
        "\n",
        "* Set is one of 4 built-in data types in Python used to store collections of data, the other 3 are List, Tuple, and Dictionary, all with different qualities and usage.\n",
        "\n",
        "* A set is a collection which is unordered, unchangeable*, and unindexed."
      ],
      "metadata": {
        "id": "bXx1npY_snCK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thisset = {\"apple\", \"banana\", \"cherry\"}\n",
        "print(thisset)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sDBIS9x1sznb",
        "outputId": "a331d1d8-f153-405f-ab12-72474a74d1bb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'apple', 'cherry', 'banana'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Set Items**\n",
        "* Set items are unordered, unchangeable, and do not allow duplicate values.\n",
        "\n",
        "**Unordered**\n",
        "* Unordered means that the items in a set do not have a defined order.\n",
        "\n",
        "* Set items can appear in a different order every time you use them, and cannot be referred to by index or key.\n",
        "\n",
        "**Unchangeable**\n",
        "* Set items are unchangeable, meaning that we cannot change the items after the set has been created.\n",
        "\n",
        "**Duplicates Not Allowed**\n",
        "* Sets cannot have two items with the same value."
      ],
      "metadata": {
        "id": "IX4n-IiTs4e0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thisset1 = {\"apple\", \"banana\", \"cherry\", \"apple\"}\n",
        "\n",
        "print(thisset1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UuKUtZk3tJAN",
        "outputId": "5580d782-4134-4d65-9505-d3f3f752163c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'apple', 'cherry', 'banana'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "* The values True and 1 are considered the same value in sets, and are treated as duplicates:"
      ],
      "metadata": {
        "id": "I_iV_RqGtZ6H"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thisset = {\"apple\", \"banana\", \"cherry\", True, 1, 2}\n",
        "\n",
        "print(thisset)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2Hb1PkoNtfng",
        "outputId": "0836e7f7-2380-4ca6-c9e5-56d893a4023d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{True, 2, 'apple', 'cherry', 'banana'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "* The values False and 0 are considered the same value in sets, and are treated as duplicates"
      ],
      "metadata": {
        "id": "AfwSF9Yitx9B"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thisset = {\"apple\", \"banana\", \"cherry\", False, True, 0}\n",
        "\n",
        "print(thisset)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GEpdjHnJt03p",
        "outputId": "a3a3a5b4-cb7b-41c2-9aa8-a8ae905bc1d8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{False, True, 'apple', 'cherry', 'banana'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Get the Length of a Set**\n",
        "* To determine how many items a set has, use the len() function."
      ],
      "metadata": {
        "id": "glF_0E1tt7KC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thisset = {\"apple\", \"banana\", \"cherry\"}\n",
        "\n",
        "print(len(thisset))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dWFWpQQ2t_5D",
        "outputId": "88f6053b-0988-42c7-ec6d-96476f68eca2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Set Items - Data Types**\n",
        "Set items can be of any data type:"
      ],
      "metadata": {
        "id": "OS8Vprh4uCHM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "set1 = {\"apple\", \"banana\", \"cherry\"}\n",
        "set2 = {1, 5, 7, 9, 3}\n",
        "set3 = {True, False, False}\n",
        "set4 = {\"abc\", 34, True, 40, \"male\"}"
      ],
      "metadata": {
        "id": "nOO2hzVSuDis"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "myset = {\"apple\", \"banana\", \"cherry\"}\n",
        "print(type(myset))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6yYSgDxGuM5U",
        "outputId": "6e17c8c4-fb69-4351-9f38-b0dba6a84b34"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'set'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **The set() Constructor**\n",
        "It is also possible to use the set() constructor to make a set."
      ],
      "metadata": {
        "id": "5GaKnq4BuPoN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thisset = set((\"apple\", \"banana\", \"cherry\")) # note the double round-brackets\n",
        "print(thisset)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J4tvGuOPuR4l",
        "outputId": "4236fb07-42ba-4721-9c86-da0240084ffd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'apple', 'cherry', 'banana'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "thisset = set([\"apple1\", \"banana2\", \"cherry3\"]) # note the double round-brackets\n",
        "print(thisset)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wyxuK8gMuU_t",
        "outputId": "49c4f011-b193-4eeb-e9f7-073129383af6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'apple1', 'cherry3', 'banana2'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Python Collections (Arrays)**\n",
        "There are four collection data types in the Python programming language:\n",
        "\n",
        "1. List is a collection which is ordered and changeable. Allows duplicate members.\n",
        "2.Tuple is a collection which is ordered and unchangeable. Allows duplicate members.\n",
        "3. Set is a collection which is unordered, unchangeable*, and unindexed. No duplicate members.\n",
        "4. Dictionary is a collection which is ordered** and changeable. No duplicate members."
      ],
      "metadata": {
        "id": "ElmcjdlvugBu"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Set items are unchangeable, but you can remove items and add new items."
      ],
      "metadata": {
        "id": "rjGp4G3Au2wm"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Access Items**\n",
        "* You cannot access items in a set by referring to an index or a key.\n",
        "\n",
        "* But you can loop through the set items using a for loop, or ask if a specified value is present in a set, by using the in keyword."
      ],
      "metadata": {
        "id": "5DmI0z0du8K5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thisset = {\"apple\", \"banana\", \"cherry\"}\n",
        "\n",
        "for x in thisset:\n",
        "  print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "epia5dR8u2Er",
        "outputId": "af3e8443-7ce4-470c-e32b-539aa95073f5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "apple\n",
            "cherry\n",
            "banana\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "thisset = {\"apple\", \"banana\", \"cherry\"}\n",
        "\n",
        "print(\"banana\" in thisset)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TrNnMWlsvCZ0",
        "outputId": "d1f4cd22-2e3b-465f-f115-f533e995c29e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "thisset = {\"apple\", \"banana\", \"cherry\"}\n",
        "\n",
        "print(\"banana\" not in thisset)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PHwXGiLDvEQj",
        "outputId": "cc2e65a8-ce78-4024-c336-f824deb37ca4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Change Items**\n",
        "Once a set is created, you ***cannot change*** its items, but you can add new items."
      ],
      "metadata": {
        "id": "FFxPOCiVvHaD"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### **Add Items**"
      ],
      "metadata": {
        "id": "fFACDBgSvKhD"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Once a set is created, you cannot change its items, but you can add new items."
      ],
      "metadata": {
        "id": "ZSzkYIntvaOk"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* To add one item to a set use the add() method."
      ],
      "metadata": {
        "id": "4WqR75ZmvefN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thisset = {\"apple\", \"banana\", \"cherry\"}\n",
        "\n",
        "thisset.add(\"orange\")\n",
        "\n",
        "print(thisset)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oSqvi1nhvbb0",
        "outputId": "f04ed033-b03b-4d9b-e5a7-a0c3eb391daf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'apple', 'orange', 'cherry', 'banana'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### **Add Sets**\n",
        "* To add items from another set into the current set, use the update() method."
      ],
      "metadata": {
        "id": "KgZ-QYm9viFt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thisset = {\"apple\", \"banana\", \"cherry\"}\n",
        "tropical = {\"pineapple\", \"mango\", \"papaya\"}\n",
        "\n",
        "thisset.update(tropical)\n",
        "\n",
        "print(thisset)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "13ZJmKvevkBV",
        "outputId": "68ebb1ab-f611-42d0-c91d-c23930d87907"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'papaya', 'pineapple', 'mango', 'apple', 'cherry', 'banana'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### **Add Any Iterable**\n",
        "* The object in the update() method does not have to be a set, it can be any iterable object (tuples, lists, dictionaries etc.)."
      ],
      "metadata": {
        "id": "iwQHRdkDx0KM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thisset = {\"apple\", \"banana\", \"cherry\"}\n",
        "mylist = [\"kiwi\", \"orange\"]\n",
        "\n",
        "thisset.update(mylist)\n",
        "\n",
        "print(thisset)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Om_OkdQ3x2yu",
        "outputId": "0c39aa0a-a2d7-4290-8b02-e8a791a8d0f6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'kiwi', 'cherry', 'apple', 'orange', 'banana'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### **Remove Set Items**"
      ],
      "metadata": {
        "id": "4mMinLN1y3gj"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "To remove an item in a set, use the remove(), or the discard() method."
      ],
      "metadata": {
        "id": "FVY7Z6X4y6Yz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thisset = {\"apple\", \"banana\", \"cherry\"}\n",
        "\n",
        "thisset.remove(\"banana\")\n",
        "\n",
        "print(thisset)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Tu_F7c0Ny8Cc",
        "outputId": "0bc9ef3c-3742-402b-b948-79d0f7fd9029"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'apple', 'cherry'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Remove \"banana\" by using the discard() method:"
      ],
      "metadata": {
        "id": "CGTuPgEczK85"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thisset = {\"apple\", \"banana\", \"cherry\"}\n",
        "\n",
        "thisset.discard(\"banana\")\n",
        "\n",
        "print(thisset)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4vAgQ90ozLad",
        "outputId": "d320cddb-5678-4bf4-a16d-7ec6dea36453"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'apple', 'cherry'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "* You can also use the pop() method to remove an item, but this method will remove a random item, so you cannot be sure what item that gets removed.\n",
        "\n",
        "* The return value of the pop() method is the removed item."
      ],
      "metadata": {
        "id": "I6ZhU6JzzTU_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thisset = {\"apple\", \"banana\", \"cherry\"}\n",
        "\n",
        "x = thisset.pop()\n",
        "\n",
        "print(x)\n",
        "\n",
        "print(thisset)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SCy_No00zSHf",
        "outputId": "3a4900b0-60f9-451f-9f26-46275ea03c32"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "apple\n",
            "{'cherry', 'banana'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The clear() method empties the set:"
      ],
      "metadata": {
        "id": "-ezBs1eGzlUQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thisset = {\"apple\", \"banana\", \"cherry\"}\n",
        "\n",
        "thisset.clear()\n",
        "\n",
        "print(thisset)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "y6X84-iezlH2",
        "outputId": "a360a7e5-0ae9-43c1-e4ec-43aa26969797"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "set()\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The del keyword will delete the set completely:"
      ],
      "metadata": {
        "id": "qAY991iDzoUP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thisset = {\"apple\", \"banana\", \"cherry\"}\n",
        "\n",
        "del thisset\n",
        "\n",
        "# print(thisset)"
      ],
      "metadata": {
        "id": "gQ0SPsr_zorI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Loop Sets**"
      ],
      "metadata": {
        "id": "uqSDbDFQ0AmC"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "You can loop through the set items by using a for loop:"
      ],
      "metadata": {
        "id": "I3fshTUr0DDb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "thisset = {\"apple\", \"banana\", \"cherry\"}\n",
        "\n",
        "for x in thisset:\n",
        "  print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YXf-6Ng10EZ8",
        "outputId": "28d93e88-b46a-42b3-e446-8a318e991831"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "apple\n",
            "cherry\n",
            "banana\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Join Sets**\n",
        "There are several ways to join two or more sets in Python.\n",
        "\n",
        "* The union() and update() methods joins all items from both sets.\n",
        "\n",
        "* The intersection() method keeps ONLY the duplicates.\n",
        "\n",
        "* The difference() method keeps the items from the first set that are not in the other set(s).\n",
        "\n",
        "* The symmetric_difference() method keeps all items EXCEPT the duplicates."
      ],
      "metadata": {
        "id": "Rwff-I0s0UUm"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Union**\n",
        "The union() method returns a new set with all items from both sets."
      ],
      "metadata": {
        "id": "MzWrkZfn0aye"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "set1 = {\"a\", \"b\", \"c\"}\n",
        "set2 = {1, 2, 3}\n",
        "\n",
        "set3 = set1.union(set2)\n",
        "print(set3)"
      ],
      "metadata": {
        "id": "9qvOAQYd0dm2",
        "outputId": "d6b65316-289d-41f5-a693-5e478a5ab493",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1, 'a', 2, 3, 'b', 'c'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **LOOPS**"
      ],
      "metadata": {
        "id": "LwEemNNKn3tD"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Python has two primitive loop commands:\n",
        "\n",
        "**1. while loops :** With the while loop we can execute a set of statements as long as a condition is true.\n",
        "\n",
        "**2. for loops :** A for loop is used for iterating over a sequence (that is either a list, a tuple, a dictionary, a set, or a string).\n",
        "\n"
      ],
      "metadata": {
        "id": "u9qhajrvoMAx"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "This for loop iterates through numbers from 1 to 5 using the range() function and prints each number."
      ],
      "metadata": {
        "id": "T0Ba4fdzpXFH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Print numbers from 1 to 5\n",
        "for i in range(1, 6):\n",
        "    print(i)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kOJ_4OLgpWVq",
        "outputId": "fb36279e-910c-4794-bc64-330552313816"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "while loop does the same, printing numbers from 1 to 5, but it continues looping as long as the condition i <= 5 is True, and i is incremented after each iteration."
      ],
      "metadata": {
        "id": "zCK2xBJ-pczi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Print numbers from 1 to 5\n",
        "i = 1\n",
        "while i <= 5:\n",
        "    print(i)\n",
        "    i += 1"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rPIkdmebpezL",
        "outputId": "167a4968-3671-40b4-e1d6-e82502784276"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Sum of Even Numbers from 1 to 10**"
      ],
      "metadata": {
        "id": "YdoeaB9GptXj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for i in range(2,11,2):\n",
        "  print(i)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ImTto5gupuSv",
        "outputId": "e1be819e-4ada-45ba-ec96-a39a607fc654"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n",
            "4\n",
            "6\n",
            "8\n",
            "10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Initialize the sum\n",
        "sum_of_evens = 0\n",
        "\n",
        "# Loop through numbers 1 to 10\n",
        "for i in range(1, 11):\n",
        "    # Check if the number is even\n",
        "    if i % 2 == 0:\n",
        "        sum_of_evens += i #sum_of_evens = sum_of_evens + i\n",
        "\n",
        "#sum_of_evens gets updated in each iteration when an even number is found.\n",
        "#For example, when i = 2, sum_of_evens becomes 2; when i = 4, it becomes 6 (2 + 4), and so on.\n",
        "\n",
        "# Print the sum of even numbers\n",
        "print(\"Sum of even numbers from 1 to 10 is:\", sum_of_evens)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nfRonQwSp9Nr",
        "outputId": "25ee6d16-051a-4545-d71e-264c34391206"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sum of even numbers from 1 to 10 is: 30\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Step-by-Step Execution:**\n",
        "\n",
        "Iteration 1: i = 1 → Not even → sum_of_evens remains 0.\n",
        "\n",
        "Iteration 2: i = 2 → Even → sum_of_evens = 0 + 2 = 2.\n",
        "\n",
        "Iteration 3: i = 3 → Not even → sum_of_evens remains 2.\n",
        "\n",
        "Iteration 4: i = 4 → Even → sum_of_evens = 2 + 4 = 6.\n",
        "\n",
        "Iteration 5: i = 5 → Not even → sum_of_evens remains 6.\n",
        "\n",
        "Iteration 6: i = 6 → Even → sum_of_evens = 6 + 6 = 12.\n",
        "\n",
        "Iteration 7: i = 7 → Not even → sum_of_evens remains 12.\n",
        "\n",
        "Iteration 8: i = 8 → Even → sum_of_evens = 12 + 8 = 20.\n",
        "\n",
        "Iteration 9: i = 9 → Not even → sum_of_evens remains 20.\n",
        "\n",
        "Iteration 10: i = 10 → Even → sum_of_evens = 20 + 10 = 30."
      ],
      "metadata": {
        "id": "spv2xvCjr2qm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sum = 0\n",
        "for i in range(1,11):\n",
        "  if i%2==0:\n",
        "    sum = sum + i\n",
        "    print(sum)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dv7uvn7Aqlg3",
        "outputId": "7d85c68c-b9e4-43af-ece1-adcde41367af"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n",
            "6\n",
            "12\n",
            "20\n",
            "30\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "i = 1\n",
        "while i < 6:\n",
        "  print(i)\n",
        "  i += 1"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JQLODHeTsLZi",
        "outputId": "716b35b4-22c6-4398-8708-35e9525128f5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The variable i is initialized to 1. This will be the starting point for the while loop and will control how many times the loop runs."
      ],
      "metadata": {
        "id": "UDm6AOJ2sdvE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "i = 1"
      ],
      "metadata": {
        "id": "2Qhn8NkbsZ30"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "This while loop will continue to execute as long as the condition i < 6 is True. In other words, the loop will run while i is less than 6. Once i becomes 6 or greater, the loop will stop."
      ],
      "metadata": {
        "id": "Lkl8T1uGsir2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "while i < 6:\n",
        "  print(i)\n",
        "  i += 1"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Yb3q3dIRshuZ",
        "outputId": "b0e35fa7-8949-4b54-b63e-dbcbe4cbb9e7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Break**\n",
        "With the break statement we can stop the loop even if the while condition is true:"
      ],
      "metadata": {
        "id": "S2ipxTAHszig"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "i = 1\n",
        "while i < 6:\n",
        "  print(i)\n",
        "  if i == 3:\n",
        "    break\n",
        "  i += 1"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pwj8pOGks4CX",
        "outputId": "7912364a-b332-46ab-ccc4-d9bd7048a3bd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "i= 1\n",
        "while i <10:\n",
        "  if i == 6:\n",
        "    break\n",
        "  print(i)\n",
        "  i = i+1"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Kz5Rf-PhtaZr",
        "outputId": "027b8312-36e5-4433-bf7b-503db4efa7c0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **The continue Statement**\n",
        "\n",
        "With the continue statement we can stop the current iteration, and continue with the next:"
      ],
      "metadata": {
        "id": "5B5FWCBot-QH"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Continue to the next iteration if i is 3:"
      ],
      "metadata": {
        "id": "9nKJnLHhuDJY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "i = 0\n",
        "while i < 6:\n",
        "  i += 1\n",
        "  if i == 3:\n",
        "    continue\n",
        "  print(i)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cJctK70-t_8m",
        "outputId": "300e9d86-16ec-4c62-8061-cfaaf7243dac"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "4\n",
            "5\n",
            "6\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "i = 0\n",
        "while i <15:\n",
        "  i = 1+i\n",
        "  if i ==13:\n",
        "    continue\n",
        "  print(i)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5OVkVd6mundr",
        "outputId": "a658603f-87cc-48c4-bba0-9cb5be527800"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n",
            "10\n",
            "11\n",
            "12\n",
            "14\n",
            "15\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "i = 0\n",
        "\n",
        "while i < 6:\n",
        "    i += 1  # Increment i by 1\n",
        "    print(i)  # Print the current value of i\n",
        "else:\n",
        "    print(\"Loop completed without interruption.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_haiLwQB3_AH",
        "outputId": "d509ecd4-581e-4601-e656-9b2aff972c1a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "Loop completed without interruption.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **For Loops**\n",
        "* A for loop is used for iterating over a sequence (that is either a list, a tuple, a dictionary, a set, or a string).\n",
        "\n",
        "* This is less like the for keyword in other programming languages, and works more like an iterator method as found in other object-orientated programming languages. With the for loop we can execute a set of statements, once for each item in a list, tuple, set etc."
      ],
      "metadata": {
        "id": "5cmHk_eY4g_D"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
        "for x in fruits:\n",
        "  print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZZFlI7pA5KoW",
        "outputId": "ada7e3a9-0444-4717-8cec-b18a393fb8d2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "apple\n",
            "banana\n",
            "cherry\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The for loop does not require an indexing variable to set beforehand."
      ],
      "metadata": {
        "id": "2sF8Kw-r5cxI"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Looping Through a String**\n",
        "Even strings are iterable objects, they contain a sequence of characters:"
      ],
      "metadata": {
        "id": "lv-eupiy5fSp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for x in \"banana\":\n",
        "  print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lZ_F_sJe5dN-",
        "outputId": "266c5289-6d59-447c-ee68-13a4ae73dae9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "b\n",
            "a\n",
            "n\n",
            "a\n",
            "n\n",
            "a\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **The break Statement**\n",
        "With the break statement we can stop the loop before it has looped through all the items:"
      ],
      "metadata": {
        "id": "ptM5giI75l6x"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
        "for x in fruits:\n",
        "  print(x)\n",
        "  if x == \"banana\":\n",
        "    break"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EgNAqsvc5oGR",
        "outputId": "fd5e73c3-c5a4-485b-ff2c-302ae7ce5296"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "apple\n",
            "banana\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Exit the loop when x is \"banana\", but this time the break comes before the print:"
      ],
      "metadata": {
        "id": "DC1xqOIB57p7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
        "for x in fruits:\n",
        "  if x == \"banana\":\n",
        "    break\n",
        "  print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wDbKnadJ59nw",
        "outputId": "3fc825c5-d920-4bfe-fdf2-96d21b81967d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "apple\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "fruits = [\"sachin\", \"ramesh\",\"rohan\"]\n",
        "for x in fruits:\n",
        "  if x == \"ramesh\":\n",
        "    break\n",
        "  print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3AFkyoun7Det",
        "outputId": "fa9effcd-5ad2-431c-aac8-aa0756efe882"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "sachin\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **The continue Statement**\n",
        "With the continue statement we can stop the current iteration of the loop, and continue with the next:"
      ],
      "metadata": {
        "id": "dAV3ls7z6JmV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
        "for x in fruits:\n",
        "  if x == \"banana\":\n",
        "    continue\n",
        "  print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J4oqjT7G6MFV",
        "outputId": "23c7ec5d-05ec-4490-f8f7-98ea520a5ddc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "apple\n",
            "cherry\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "fruits = [\"sachin\", \"ramesh\",\"rohan\"]\n",
        "for x in fruits:\n",
        "  if x == \"ramesh\":\n",
        "    continue\n",
        "  print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "v1wwdQDR7Z_c",
        "outputId": "74526113-7d10-4905-8962-5076b227afcf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "sachin\n",
            "rohan\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **The range() Function**\n",
        "* To loop through a set of code a specified number of times, we can use the range() function,\n",
        "* The range() function returns a sequence of numbers, starting from 0 by default, and increments by 1 (by default), and ends at a specified number."
      ],
      "metadata": {
        "id": "gW0mthZW7h15"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for x in range(6):\n",
        "  print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1IhXOCqC7ms2",
        "outputId": "fd841ecd-5fec-4a2f-a622-f2372fb2c390"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The range() function defaults to 0 as a starting value, however it is possible to specify the starting value by adding a parameter: range(2, 6), which means values from 2 to 6 (but not including 6):"
      ],
      "metadata": {
        "id": "senqf_Zf7qa4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for x in range(2, 6):\n",
        "  print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UMHB87ii7qPG",
        "outputId": "166c585f-4be3-4f81-8d5e-85bdfd60daa5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n",
            "3\n",
            "4\n",
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The range() function defaults to increment the sequence by 1, however it is possible to specify the increment value by adding a third parameter: range(2, 30, 3):"
      ],
      "metadata": {
        "id": "N6V2rJbK7uv2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for x in range(2, 30, 3):\n",
        "  print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lanCSFl87vze",
        "outputId": "e5853101-b5f9-4fe8-8848-565c9a061d6f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n",
            "5\n",
            "8\n",
            "11\n",
            "14\n",
            "17\n",
            "20\n",
            "23\n",
            "26\n",
            "29\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Else in For Loop**\n",
        "The else keyword in a for loop specifies a block of code to be executed when the loop is finished:"
      ],
      "metadata": {
        "id": "xvIdqJ118hzs"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Print all numbers from 0 to 5, and print a message when the loop has ended:"
      ],
      "metadata": {
        "id": "qggZ2jCg8mYV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for x in range(6):\n",
        "  print(x)\n",
        "else:\n",
        "  print(\"Finally finished!\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "u0-sUjeo8jZ0",
        "outputId": "2262bdc0-0fc6-4a31-c466-da2a8c387944"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "Finally finished!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The else block will NOT be executed if the loop is stopped by a **break** statement."
      ],
      "metadata": {
        "id": "f6inH20d8uce"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for x in range(6):\n",
        "  if x == 3:\n",
        "    break\n",
        "  print(x)\n",
        "else:\n",
        "  print(\"Finally finished!\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ok-Cs5jM8wEf",
        "outputId": "78f71f9d-9222-47e5-cd5a-b5ceff2bca2c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n",
            "1\n",
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Nested Loops**\n",
        "* A nested loop is a loop inside a loop.\n",
        "\n",
        "* The \"inner loop\" will be executed one time for each iteration of the \"outer loop\":"
      ],
      "metadata": {
        "id": "t_knuSTg8_Yp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "adj = [\"red\", \"big\", \"tasty\"]\n",
        "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
        "\n",
        "for x in adj:\n",
        "  for y in fruits:\n",
        "    print(x, y)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VM2RZGS09CjH",
        "outputId": "f5ef4b9e-5597-4a6f-f2fd-59ec87221ff1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "red apple\n",
            "red banana\n",
            "red cherry\n",
            "big apple\n",
            "big banana\n",
            "big cherry\n",
            "tasty apple\n",
            "tasty banana\n",
            "tasty cherry\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "adj = [\"red\", \"big\", \"tasty\"]\n",
        "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
        "\n",
        "for x in adj:\n",
        "  for y in fruits:\n",
        "    print(2*x+\" \"+ 2*y)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VgBEZ4Ur-1I1",
        "outputId": "1c2dbe23-706c-4581-e1ce-ea904568817b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "redred appleapple\n",
            "redred bananabanana\n",
            "redred cherrycherry\n",
            "bigbig appleapple\n",
            "bigbig bananabanana\n",
            "bigbig cherrycherry\n",
            "tastytasty appleapple\n",
            "tastytasty bananabanana\n",
            "tastytasty cherrycherry\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **The pass Statement**\n",
        "for loops cannot be empty, but if you for some reason have a for loop with no content, put in the pass statement to avoid getting an error."
      ],
      "metadata": {
        "id": "cb5HA8yp_BKb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for x in [0, 1, 2]:\n",
        "  pass"
      ],
      "metadata": {
        "id": "EGSbvB38_DGl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Python Functions**"
      ],
      "metadata": {
        "id": "W9CFp0pyCbEy"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* A function is a block of code which only runs when it is called.\n",
        "\n",
        "* You can pass data, known as parameters, into a function.\n",
        "\n",
        "* A function can return data as a result."
      ],
      "metadata": {
        "id": "ECKHgF4RCeV1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Creating a Function**\n",
        "In Python a function is defined using the def keyword:"
      ],
      "metadata": {
        "id": "mQ-WpbQVCjcV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def my_function():\n",
        "  print(\"Hello from a function\")"
      ],
      "metadata": {
        "id": "0TwENXs7CcPD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "my_function()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2iq3Pp70Cnzt",
        "outputId": "916b1bf7-29d8-4da3-8675-d1b0be0ddfe2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello from a function\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Arguments**\n",
        "* Information can be passed into functions as arguments.\n",
        "\n",
        "* Arguments are specified after the function name, inside the parentheses. You can add as many arguments as you want, just separate them with a comma.\n",
        "\n",
        "* The following example has a function with one argument (fname). When the function is called, we pass along a first name, which is used inside the function to print the full name:"
      ],
      "metadata": {
        "id": "kL7mpi41Cp41"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def my_function(fname):\n",
        "  print(fname + \" Refsnes\")"
      ],
      "metadata": {
        "id": "1p5TsFSMC5vm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "my_function(\"Emil\")\n",
        "my_function(\"Tobias\")\n",
        "my_function(\"Linus\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "joVxmh4nC9ky",
        "outputId": "fe17d0d6-f95d-487a-9139-86b876a11105"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Emil Refsnes\n",
            "Tobias Refsnes\n",
            "Linus Refsnes\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Parameters or Arguments?**\n",
        "The terms parameter and argument can be used for the same thing: information that are passed into a function.\n",
        "\n",
        "* A parameter is the variable listed inside the parentheses in the function definition.\n",
        "\n",
        "* An argument is the value that is sent to the function when it is called."
      ],
      "metadata": {
        "id": "KmRwTTHhDBx4"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Number of Arguments**\n",
        "By default, a function must be called with the correct number of arguments. Meaning that if your function expects 2 arguments, you have to call the function with 2 arguments, not more, and not less."
      ],
      "metadata": {
        "id": "5_oR1nDeDIx5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def my_function(fname, lname):\n",
        "  print(fname + \" \" + lname)\n",
        "\n",
        "my_function(\"Emil\", \"Refsnes\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fv-kLZvVDMnp",
        "outputId": "a1b2bbfd-1f42-433e-9138-250e8a04d14a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Emil Refsnes\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "If you try to call the function with 1 or 3 arguments, you will get an error:"
      ],
      "metadata": {
        "id": "V0clBT-wDcgb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def my_function(fname, lname):\n",
        "  print(fname + \" \" + lname)\n",
        "\n",
        "my_function(\"Emil\",\"#\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GrY7Cz3fDc6S",
        "outputId": "33beec44-0e17-4a04-8f8b-6eade21db68d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Emil #\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Arbitrary Arguments, *args\n",
        "\n",
        "* If you do not know how many arguments that will be passed into your function, add a * before the parameter name in the function definition.\n",
        "\n",
        "* This way the function will receive a tuple of arguments, and can access the items accordingly:"
      ],
      "metadata": {
        "id": "iizuDvAMDlJT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def my_function(*kids):\n",
        "  print(\"The youngest child is \" + kids[2])\n",
        "\n",
        "my_function(\"Emil\", \"Tobias\", \"Linus\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XMTbdeuJDwHs",
        "outputId": "6ce6a048-61db-45b3-af2a-0018a1f6876f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The youngest child is Linus\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Arbitrary Arguments are often shortened to *args in Python documentations."
      ],
      "metadata": {
        "id": "lSBF4j6iD4Wa"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Keyword Arguments**\n",
        "* You can also send arguments with the key = value syntax.\n",
        "\n",
        "* This way the order of the arguments does not matter.\n",
        "\n",
        "* The phrase Keyword Arguments are often shortened to ***kwargs*** in Python documentations."
      ],
      "metadata": {
        "id": "oLEgzGxdED2O"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def my_function(child3, child2, child1):\n",
        "  print(\"The youngest child is \" + child3)\n",
        "\n",
        "my_function(child1 = \"Emil\", child2 = \"Tobias\", child3 = \"Linus\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_qBGyzYxEFm_",
        "outputId": "a4928597-38b1-43a6-a0ac-0f3caa912acb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The youngest child is Linus\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def my_function(**kid):\n",
        "  print(\"His last name is \" + kid[\"lname\"])\n",
        "\n",
        "my_function(fname = \"Tobias\", lname = \"Refsnes\")"
      ],
      "metadata": {
        "id": "QultW82qEPLf",
        "outputId": "f5f79e63-e5c0-4f8e-c9d2-c4e6620938cd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "His last name is Refsnes\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def add_numbers(a, b):\n",
        "    return a + b\n",
        "\n",
        "print(add_numbers(2, 3))  # This will output 5"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "v9PlwC4cdRDQ",
        "outputId": "df62843e-d743-4ef9-8ed4-cb841ff80582"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **What if we want a flexible number of inputs?**"
      ],
      "metadata": {
        "id": "OBT9xmN-c8RU"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Let’s imagine you want to write a function that can add any number of inputs (not just 2). For example, sometimes you might want to add 3 numbers, or 4, or 100!\n",
        "\n",
        "To solve this, we use *args.\n",
        "\n",
        "### **Step 3: What is** *args?\n",
        "The * symbol is like saying: “Hey, Python, I don’t know how many arguments (inputs) I’m going to get.”\n",
        "args is just a name (you can call it anything), but args is commonly used. It stands for arguments.\n",
        "How does *args work?\n",
        "When you use *args, all the extra inputs are packed into a tuple (which is like a box that holds multiple things). Let’s see it in action:\n",
        "\n",
        "Example with *args:"
      ],
      "metadata": {
        "id": "ovon9ULKc90r"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def add_numbers(*args):\n",
        "    total = 0\n",
        "    for number in args:\n",
        "        total += number\n",
        "    return total\n",
        "\n",
        "print(add_numbers(1, 2))            # This will output 3\n",
        "print(add_numbers(1, 2, 3, 4, 5))   # This will output 15\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "961EeyYkdUTt",
        "outputId": "7629dde6-3357-4dd0-8f60-e00bc8619274"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n",
            "15\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def multiply(*args):\n",
        "  total = 1\n",
        "  for number in args:\n",
        "    total = total * number\n",
        "  return total\n",
        "\n",
        "print(multiply(1,2))\n",
        "print(multiply(1,2,3))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AyUsqIzPdVAV",
        "outputId": "981136cc-5291-4693-b15a-9fb248eabec4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n",
            "6\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def multiply(*args):\n",
        "  total = 1\n",
        "  for number in args:\n",
        "    total = total * number\n",
        "  return total\n",
        "\n",
        "print(multiply(1,2,3,4,5))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-4q6M9zydwjN",
        "outputId": "adb23e5d-fec3-449d-a17c-6959a4418a95"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "120\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def myFun(arg1, *argv):\n",
        "    print(\"First argument :\", arg1)\n",
        "    for arg in argv:\n",
        "        print(\"Next argument through *argv :\", arg)\n",
        "\n",
        "\n",
        "myFun('Hello', 'Welcome', 'to', 'GeeksforGeeks')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p3aQiSXVfNLE",
        "outputId": "7d3a7e2d-9b83-410a-b5e9-900a5612267e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "First argument : Hello\n",
            "Next argument through *argv : Welcome\n",
            "Next argument through *argv : to\n",
            "Next argument through *argv : GeeksforGeeks\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Step 4: What is** **kwargs?\n",
        "Now let’s take it up a notch. What if, instead of just values, you also want to give names to your inputs? This is where **kwargs comes in.\n",
        "\n",
        "* The ** symbol means: “Hey, Python, I’m going to give you inputs with names (key-value pairs).”\n",
        "\n",
        "* kwargs stands for keyword arguments (because each input has a keyword, or name, like \"age\" or \"name\").\n",
        "* How does **kwargs work?\n",
        "  \n",
        "  When you use **kwargs, all the named inputs are packed into a dictionary (a box that holds things with labels, like \"name\": \"Alice\")."
      ],
      "metadata": {
        "id": "hI9CJrUjeEhZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def introduce(**kwargs):\n",
        "    for key, value in kwargs.items():\n",
        "        print(f\"{key}: {value}\")\n",
        "\n",
        "introduce(name=\"Alice\", age=10, hobby=\"drawing\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pEAiObd6eWTD",
        "outputId": "6e2e855f-5a54-46ed-8362-d851e0211355"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "name: Alice\n",
            "age: 10\n",
            "hobby: drawing\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def student_profile(**kwargs):\n",
        "    print(\"Student Profile:\")\n",
        "    for key, value in kwargs.items():\n",
        "        print(f\"{key.capitalize()}: {value}\")\n",
        "\n",
        "student_profile(name=\"John\", age=15, grade=\"10th\", hobby=\"painting\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZIPN4SM4egAG",
        "outputId": "9603a910-3a3a-4a93-db84-79f3427daa06"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Student Profile:\n",
            "Name: John\n",
            "Age: 15\n",
            "Grade: 10th\n",
            "Hobby: painting\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def student(**kwargs):\n",
        "  print(\"profile\")\n",
        "  for key, value in kwargs.items():\n",
        "    print(f\"{key}:{value}\")\n",
        "student(name=\"John\", age=15, grade=\"10th\", hobby=\"painting\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AXx69jTaf6Ce",
        "outputId": "beaff8f5-5b4e-4d87-c05c-74345ef4987a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "profile\n",
            "name:John\n",
            "age:15\n",
            "grade:10th\n",
            "hobby:painting\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def myFun(arg1, arg2, arg3):\n",
        "    print(\"arg1:\", arg1)\n",
        "    print(\"arg2:\", arg2)\n",
        "    print(\"arg3:\", arg3)\n",
        "\n",
        "# Now we can use *args or **kwargs to\n",
        "# pass arguments to this function :\n",
        "args = (\"Geeks\", \"for\", \"Geeks\")\n",
        "myFun(*args)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PhLWy_Y_guwA",
        "outputId": "c8b10cb6-b887-482e-c630-39f2ef9e61fe"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "arg1: Geeks\n",
            "arg2: for\n",
            "arg3: Geeks\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "kwargs = {\"arg1\": \"Geeks\", \"arg2\": \"for\", \"arg3\": \"Geeks\"}\n",
        "myFun(**kwargs)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "34T66q_fg8H0",
        "outputId": "e0c0ade4-3e39-4dc4-8f0f-74039f5cbb87"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "arg1: Geeks\n",
            "arg2: for\n",
            "arg3: Geeks\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Python Iterators**"
      ],
      "metadata": {
        "id": "cCAx6OUNn9mk"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* An iterator is an *object that contains a countable number of values*.\n",
        "\n",
        "* An iterator is an object that can be iterated upon, meaning that you can traverse through all the values.\n",
        "\n",
        "* Technically, in Python, an iterator is an object which implements the iterator protocol, which consist of the methods __iter__() and __next__()."
      ],
      "metadata": {
        "id": "BBqSZ8_Ln_HF"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### **Iterator vs Iterable**\n",
        "* Lists, tuples, dictionaries, and sets are all iterable objects. They are iterable containers which you can get an iterator from.\n",
        "\n",
        "* All these objects have a iter() method which is used to get an iterator:"
      ],
      "metadata": {
        "id": "WwC7ozqmoI1U"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mytuple = (\"apple\", \"banana\", \"cherry\")\n",
        "myit = iter(mytuple)\n",
        "\n",
        "print(next(myit))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-8IAvKNKn-q7",
        "outputId": "63de2189-3a59-4f1f-b20d-83453e393c26"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "apple\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(next(myit))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OZKIIdWMoUHf",
        "outputId": "c018f4c3-ae3f-4e9a-d5ed-0cc293ee333d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "banana\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(next(myit))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OSqJOQyDoV26",
        "outputId": "578a5990-034a-4eb7-976d-707721b222f5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "cherry\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Even strings are iterable objects, and can return an iterator:"
      ],
      "metadata": {
        "id": "x9qh9SGyp9wQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mystr = \"banana\"\n",
        "myit = iter(mystr)"
      ],
      "metadata": {
        "id": "IikKKC7Mp-My"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(next(myit))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_VnMjef5qAWh",
        "outputId": "3e8b1f65-3088-475f-d8e0-d4f393b31648"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "b\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(next(myit))\n",
        "print(next(myit))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "F89rulE6qEVi",
        "outputId": "2c351e9e-7bb8-40c1-e510-6ee410c34b40"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "a\n",
            "n\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(next(myit))\n",
        "print(next(myit))\n",
        "print(next(myit))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jzkLeK2IqF4a",
        "outputId": "b6a221bc-fa76-4a4d-d24b-7e63e3028fe0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "a\n",
            "n\n",
            "a\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### **Looping Through an Iterator**\n",
        "We can also use a for loop to iterate through an iterable object:"
      ],
      "metadata": {
        "id": "H1S-C9kZqKSa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mytuple = (\"apple\", \"banana\", \"cherry\")\n",
        "\n",
        "for x in mytuple:\n",
        "  print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JTWVLcUTqL4q",
        "outputId": "eaca8727-4340-4635-f4f5-d6751b88b3d8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "apple\n",
            "banana\n",
            "cherry\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "mystr = \"banana\"\n",
        "\n",
        "for x in mystr:\n",
        "  print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mLPN4hG3qSRK",
        "outputId": "1d4c7710-3da2-4bd8-d2dd-728983c47568"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "b\n",
            "a\n",
            "n\n",
            "a\n",
            "n\n",
            "a\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The for loop actually creates an iterator object and executes the next() method for each loop."
      ],
      "metadata": {
        "id": "QiPf96KOqUtL"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Create an Iterator**\n",
        "* To create an object/class as an iterator you have to implement the methods __iter__() and __next__() to your object.\n",
        "\n",
        "* As you have learned in the Python Classes/Objects chapter, all classes have a function called __init__(), which allows you to do some initializing when the object is being created.\n",
        "\n",
        "* The __iter__() method acts similar, you can do operations (initializing etc.), but must always return the iterator object itself.\n",
        "\n",
        "* The __next__() method also allows you to do operations, and must return the next item in the sequence."
      ],
      "metadata": {
        "id": "K-B9UXoYT9Nd"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Create an iterator that returns numbers, starting with 1, and each sequence will increase by one (returning 1,2,3,4,5 etc.):"
      ],
      "metadata": {
        "id": "PYY4Ogwbo3Z9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class MyNumbers:\n",
        "  def __iter__(self):\n",
        "    self.a = 1\n",
        "    return self\n",
        "\n",
        "  def __next__(self):\n",
        "    x = self.a\n",
        "    self.a += 1\n",
        "    return x\n",
        "\n",
        "myclass = MyNumbers()\n",
        "myiter = iter(myclass)\n",
        "\n",
        "print(next(myiter))\n",
        "print(next(myiter))\n",
        "print(next(myiter))\n",
        "print(next(myiter))\n",
        "print(next(myiter))"
      ],
      "metadata": {
        "id": "ZKs4_0IrqVN7",
        "outputId": "be83928b-91c8-4bc7-a5e9-dd361a6e8f4a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **StopIteration**\n",
        "\n",
        "The example above would continue forever if you had enough next() statements, or if it was used in a for loop.\n",
        "\n",
        "To prevent the iteration from going on forever, we can use the StopIteration statement.\n",
        "\n",
        "In the __next__() method, we can add a terminating condition to raise an error if the iteration is done a specified number of times:"
      ],
      "metadata": {
        "id": "1rOQoNFzo6Kl"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Stop after 20 iterations:"
      ],
      "metadata": {
        "id": "0ba5qamto_DH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class MyNumbers:\n",
        "  def __iter__(self):\n",
        "    self.a = 1\n",
        "    return self\n",
        "\n",
        "  def __next__(self):\n",
        "    if self.a <= 20:\n",
        "      x = self.a\n",
        "      self.a += 1\n",
        "      return x\n",
        "    else:\n",
        "      raise StopIteration\n",
        "\n",
        "myclass = MyNumbers()\n",
        "myiter = iter(myclass)\n",
        "\n",
        "for x in myiter:\n",
        "  print(x)"
      ],
      "metadata": {
        "id": "bVViju4xo982",
        "outputId": "15263b0f-2d63-40b8-cec7-5ede74f06b67",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n",
            "10\n",
            "11\n",
            "12\n",
            "13\n",
            "14\n",
            "15\n",
            "16\n",
            "17\n",
            "18\n",
            "19\n",
            "20\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Return Values**\n",
        "To let a function return a value, use the return statement:"
      ],
      "metadata": {
        "id": "VjjDSLGWT7KN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def my_function(x):\n",
        "  return 5 * x\n",
        "\n",
        "print(my_function(3))\n",
        "print(my_function(5))\n",
        "print(my_function(9))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iox5rwvaT-aS",
        "outputId": "765ca9de-1764-4d0a-9f56-358481b0609f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "15\n",
            "25\n",
            "45\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **The pass Statement**\n",
        "function definitions cannot be empty, but if you for some reason have a function definition with no content, put in the pass statement to avoid getting an error."
      ],
      "metadata": {
        "id": "ExVr2u1DUBtz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def myfunction():\n",
        "  pass"
      ],
      "metadata": {
        "id": "60U2gdmTUGB8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Positional-Only Arguments**\n",
        "\n",
        "* You can specify that a function can have ONLY positional arguments, or ONLY keyword arguments.\n",
        "\n",
        "* To specify that a function can have only positional arguments, add , / after the arguments:"
      ],
      "metadata": {
        "id": "gUP4VXVRUKak"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def my_function(x, /):\n",
        "  print(x)\n",
        "\n",
        "my_function(3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QRYYj4ZeUMr8",
        "outputId": "c6f3309a-89a6-4f7a-d60d-fc4a883b2d33"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Without the , / you are actually allowed to use keyword arguments even if the function expects positional arguments:"
      ],
      "metadata": {
        "id": "IiI3ovYdUcu2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def my_function(x):\n",
        "  print(x)\n",
        "\n",
        "my_function(x = 3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ruypo3lmUcfm",
        "outputId": "3a14b13f-9b21-42ec-d518-32816c73c220"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "But when adding the , / you will get an error if you try to send a keyword argument:"
      ],
      "metadata": {
        "id": "KXdWGWwwUp8A"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def my_function(x, /):\n",
        "  print(x)\n",
        "\n",
        "#my_function(x = 3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 200
        },
        "id": "Swsh5gTEUqf7",
        "outputId": "ba631ec2-5c4c-4491-c984-94c807af1038"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "my_function() got some positional-only arguments passed as keyword arguments: 'x'",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-219-403196941e2c>\u001b[0m in \u001b[0;36m<cell line: 4>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m   \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mmy_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: my_function() got some positional-only arguments passed as keyword arguments: 'x'"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Keyword-Only Arguments**\n",
        "To specify that a function can have only keyword arguments, add *, before the arguments:"
      ],
      "metadata": {
        "id": "0LvhhqOwU5Ko"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def my_function(*, x):\n",
        "  print(x)\n",
        "\n",
        "my_function(x = 3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CXZcphj1U6mA",
        "outputId": "a04377c6-2fb6-462e-c359-8bda34d976fa"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Without the *, you are allowed to use positionale arguments even if the function expects keyword arguments:"
      ],
      "metadata": {
        "id": "urot-y3fU-VZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def my_function(x):\n",
        "  print(x)\n",
        "\n",
        "my_function(3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "H3KltdOYU-0I",
        "outputId": "7fa68cb5-00ea-4a8d-a217-a5a8f68827d4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "But when adding the *, / you will get an error if you try to send a positional argument:"
      ],
      "metadata": {
        "id": "XHUL_qeTVCMK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def my_function(*, x):\n",
        "  print(x)\n",
        "\n",
        "#my_function(3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 182
        },
        "id": "kTFjfVhmVCw7",
        "outputId": "f36645fd-4be8-4cd0-b9d8-7884d2816df6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "my_function() takes 0 positional arguments but 1 was given",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-224-8de31a03b1a9>\u001b[0m in \u001b[0;36m<cell line: 4>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m   \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mmy_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: my_function() takes 0 positional arguments but 1 was given"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Combine Positional-Only and Keyword-Only**\n",
        "You can combine the two argument types in the same function.\n",
        "\n",
        "Any argument before the / , are positional-only, and any argument after the *, are keyword-only."
      ],
      "metadata": {
        "id": "RBueAqHnVGpC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def my_function(a, b, /, *, c, d):\n",
        "  print(a + b + c + d)\n",
        "\n",
        "my_function(5, 6, c = 7, d = 8)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "w_7NzDdIVLqb",
        "outputId": "26f22794-b087-4616-d20c-b88385b1f9c2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "26\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Recursion**\n",
        "\n",
        "Python also accepts function recursion, which means a defined function can call itself.\n",
        "\n",
        "Recursion is a common mathematical and programming concept. It means that a function calls itself. This has the benefit of meaning that you can loop through data to reach a result.\n",
        "\n",
        "The developer should be very careful with recursion as it can be quite easy to slip into writing a function which never terminates, or one that uses excess amounts of memory or processor power. However, when written correctly recursion can be a very efficient and mathematically-elegant approach to programming.\n",
        "\n",
        "In this example, tri_recursion() is a function that we have defined to call itself (\"recurse\"). We use the k variable as the data, which decrements (-1) every time we recurse. The recursion ends when the condition is not greater than 0 (i.e. when it is 0).\n",
        "\n",
        "To a new developer it can take some time to work out how exactly this works, best way to find out is by testing and modifying it."
      ],
      "metadata": {
        "id": "GkbYjBmiVQkc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def tri_recursion(k):\n",
        "  if(k > 0):\n",
        "    result = k + tri_recursion(k - 1)\n",
        "    print(result)\n",
        "  else:\n",
        "    result = 0\n",
        "  return result\n",
        "\n",
        "print(\"\\n\\nRecursion Example Results\")\n",
        "tri_recursion(6)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "q5iaeU4fVaBV",
        "outputId": "9c10e697-6cb4-4fe1-ad06-7c63531567d2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "\n",
            "Recursion Example Results\n",
            "1\n",
            "3\n",
            "6\n",
            "10\n",
            "15\n",
            "21\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "21"
            ]
          },
          "metadata": {},
          "execution_count": 226
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Python Lambda**"
      ],
      "metadata": {
        "id": "cAblnexhWSky"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* A lambda function is a small anonymous function.\n",
        "\n",
        "* A lambda function can take any number of arguments, but can only have one expression."
      ],
      "metadata": {
        "id": "ZAXBoSkmWT75"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Add 10 to argument a, and return the result:"
      ],
      "metadata": {
        "id": "Scs3WqdyWeGy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = lambda a : a + 10\n",
        "print(x(5))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LvANRwpIWTrJ",
        "outputId": "6a4b2ed9-1f2e-4a51-dea1-22a614583863"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "15\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Lambda functions can take any number of arguments:"
      ],
      "metadata": {
        "id": "cSQcMlr7W9A0"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **What is a Lambda Function?**\n",
        "\n",
        "Think of a lambda function as a mini-function you can create without giving it a name. It's a quick way to do something without having to write a full function using the def keyword.\n",
        "\n",
        "### **Why Use Lambda Functions?**\n",
        "\n",
        "* Simplicity: If you only need to use a function once or twice, making a full function might feel like too much work.\n",
        "\n",
        "* Readability: They can make your code cleaner and easier to read if used correctly.\n"
      ],
      "metadata": {
        "id": "cO5nWSm0Ez18"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![image.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "J9KmTAvrFGZW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# This is a lambda function that adds two numbers\n",
        "add = lambda x, y: x + y\n",
        "\n",
        "# Now we can use this function\n",
        "result = add(3, 4)\n",
        "print(result)  # Output: 7"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hxa9opkYW96O",
        "outputId": "c5341529-ff1d-4777-e21f-f6a24a6b7f27"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "7\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "![image.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "F_q5iTCjFSVH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "ten = lambda x: x+10\n",
        "print(ten(2))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Nyvn6OnQFTf_",
        "outputId": "eced8eb3-5cc4-495e-9b94-455119bb228d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "12\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "multi = lambda x,y : x*y\n",
        "print(multi(4,12))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "D_74nBr1FgLr",
        "outputId": "ce0c4bc7-45fe-4604-90e1-5d9b9913eeb6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "48\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "s = lambda y,z,w : y+z+w\n",
        "print(s(4,15,10))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Etv-BpQoFv0K",
        "outputId": "aa1bfccd-9ade-49e5-87ab-9e93535d1eda"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "29\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Why Use Lambda Functions?**\n",
        "\n",
        "* The power of lambda is better shown when you use them as an anonymous function inside another function.\n",
        "\n",
        "* Say you have a function definition that takes one argument, and that argument will be multiplied with an unknown number:"
      ],
      "metadata": {
        "id": "B0T-uYMhGGSe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def myfunc(n):\n",
        "  return lambda a : a * n"
      ],
      "metadata": {
        "id": "2tg8olRbGOd2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "myfunc(5)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Xo44T4sPGRNe",
        "outputId": "dda1c771-dbc9-4850-8d98-2f5927bffd43"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<function __main__.myfunc.<locals>.<lambda>(a)>"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def myfunc(n):\n",
        "  return lambda a : a * n\n",
        "\n",
        "mydoubler = myfunc(2)\n",
        "\n",
        "print(mydoubler(11))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BAIP6I6kGh5v",
        "outputId": "c9c06c0a-0f9a-40ab-efea-d90fad7c8370"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "22\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "![image.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "4h_tm4v-G5Jq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def func(n):\n",
        "  return lambda a : a**n\n",
        "fun = func(3)\n",
        "\n",
        "print(fun(5))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uwFdsQMoG74v",
        "outputId": "b7ada3d1-d6f7-474e-80bf-17d814f814b5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "125\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def myfunc(n):\n",
        "  return lambda a : a * n\n",
        "\n",
        "mytripler = myfunc(3)\n",
        "\n",
        "print(mytripler(11))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CFTyB_3sHYAF",
        "outputId": "211fd7f4-adfb-406e-f5a1-ff3743db9b92"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "33\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def myfunc(n):\n",
        "  return lambda a : a * n\n",
        "\n",
        "mydoubler = myfunc(2)\n",
        "mytripler = myfunc(3)\n",
        "\n",
        "print(mydoubler(11))\n",
        "print(mytripler(11))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "U4vku5cHHZx8",
        "outputId": "e3aa89b0-7143-437b-fecc-9ad7b704de38"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "22\n",
            "33\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### What is an Array?\n",
        "\n",
        "> An array is a special variable, which can hold more than one value at a time.\n",
        "\n",
        "\n",
        "If you have a list of items (a list of car names, for example), storing the cars in single variables could look like this:"
      ],
      "metadata": {
        "id": "Ba59ilvFIJt4"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "car1 = \"Ford\"\n",
        "\n",
        "car2 = \"Volvo\"\n",
        "\n",
        "car3 = \"BMW\""
      ],
      "metadata": {
        "id": "pofWKuFjIZfD"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "However, what if you want to loop through the cars and find a specific one? And what if you had not 3 cars, but 300?\n",
        "\n",
        "The solution is an array!\n",
        "\n",
        "An array can hold many values under a single name, and you can access the values by referring to an index number."
      ],
      "metadata": {
        "id": "H_s8KUlxId8s"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Access the Elements of an Array**"
      ],
      "metadata": {
        "id": "hfWWmrSHIvEV"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "You refer to an array element by referring to the index number."
      ],
      "metadata": {
        "id": "lorlJWI0NMHR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cars = [\"Ford\", \"Volvo\", \"BMW\"]"
      ],
      "metadata": {
        "id": "E_LBZTfvNRXo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "first_car = cars[0]  # This will return \"Ford\""
      ],
      "metadata": {
        "id": "oSxMoQQWNKvY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "cars[0] = \"Toyota\"  # The list is now [\"Toyota\", \"Volvo\", \"BMW\"]"
      ],
      "metadata": {
        "id": "dxtaepwfNlTS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Finding the Length of a List**\n",
        "\n",
        "To find out how many items are in a list, you can use the len() function:"
      ],
      "metadata": {
        "id": "s-GIbY90NpSx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "length = len(cars)  # This will return 3, as there are three cars in the list"
      ],
      "metadata": {
        "id": "LuXHed-xNq4C"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Looping Through a List**\n",
        "\n",
        "You can loop through the items in a list using a for loop:"
      ],
      "metadata": {
        "id": "Ckwk-nFZNvmD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for car in cars:\n",
        "    print(car)"
      ],
      "metadata": {
        "id": "c-D8fMwCNyKr",
        "outputId": "284dd390-1e27-4b59-c320-d331dbaec937",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Toyota\n",
            "Volvo\n",
            "BMW\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Adding Elements**\n",
        "\n",
        "To add new elements to a list, you can use the append() method:"
      ],
      "metadata": {
        "id": "WO77aZFlN1lc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cars.append(\"Honda\")  # The list is now [\"Toyota\", \"Volvo\", \"BMW\", \"Honda\"]"
      ],
      "metadata": {
        "id": "WCy-YCeQN3Fc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Removing Elements**\n",
        "\n",
        "To remove elements from a list, you can use either pop() or remove():"
      ],
      "metadata": {
        "id": "xmRW1811N7F8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cars.pop(1)  # This will remove \"Volvo\" from the list (index 1)"
      ],
      "metadata": {
        "id": "7sBwBVfuN88F",
        "outputId": "bdfaa0c0-fc30-4905-cb34-1f3da8e5dc59",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Volvo'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "cars.remove(\"BMW\")  # This will remove \"BMW\" from the list"
      ],
      "metadata": {
        "id": "-J8-HFDZN-cp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "| Method   | Description                                             |\n",
        "|----------|---------------------------------------------------------|\n",
        "| `append()` | Adds an element at the end of the list                |\n",
        "| `clear()`  | Removes all elements from the list                     |\n",
        "| `copy()`   | Returns a copy of the list                             |\n",
        "| `count()`  | Returns the number of elements with the specified value|\n",
        "| `extend()` | Adds elements from another list to the end of the list |\n",
        "| `index()`  | Returns the index of the first occurrence of a value   |\n",
        "| `insert()` | Adds an element at a specified position                |\n",
        "| `pop()`    | Removes the element at the specified position          |\n",
        "| `remove()` | Removes the first occurrence of a specified value      |\n",
        "| `reverse()`| Reverses the order of the list                         |\n",
        "| `sort()`   | Sorts the list                                        |\n"
      ],
      "metadata": {
        "id": "LTf__oO1OHxd"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# What is a Class?\n",
        "> A class is like a blueprint for creating objects. It defines the properties (attributes) and behaviors (methods) that the objects created from the class will have."
      ],
      "metadata": {
        "id": "ITdtUK22O7iz"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Think of a class like a recipe. A recipe tells you how to make something, but it’s not the actual dish itself. For example, if you have a recipe for making chocolate chip cookies, it tells you the ingredients you need and the steps to make the cookies, but it isn’t a cookie yet.\n",
        "\n",
        "In programming, a class is a blueprint or a template for creating things (which we call objects). It describes what properties (like color, size) and actions (like running, jumping) the things created from it can have."
      ],
      "metadata": {
        "id": "8p2_Fu0sPtBQ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Example: Defining a Class**\n",
        "\n",
        "Let's create a class called Dog:"
      ],
      "metadata": {
        "id": "6CskEs8xPIY2"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Example:\n",
        "\n",
        "* Class Name: Dog\n",
        "* Properties: Color, Size, Breed\n",
        "* Actions: Bark, Sit, Fetch"
      ],
      "metadata": {
        "id": "rSt9A7lIPvX0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Dog:\n",
        "    # Properties of the Dog class\n",
        "    species = \"Canis familiaris\"  # This is a class attribute\n",
        "\n",
        "    # The __init__ method initializes the object\n",
        "    def __init__(self, name, age):\n",
        "        self.name = name  # Instance attribute for the dog's name\n",
        "        self.age = age    # Instance attribute for the dog's age"
      ],
      "metadata": {
        "id": "JE8bb9Z7OIZQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **What is an Object?**\n",
        "An object is like the actual cookie you make from that recipe. When you follow the recipe to bake cookies, you end up with real cookies that you can eat.\n",
        "\n",
        "In programming, an object is a specific instance of a class. It has all the properties and can perform all the actions described in the class."
      ],
      "metadata": {
        "id": "GeYrNU--P2e8"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### ***Object Name: my_dog***\n",
        "\n",
        "**Properties:**\n",
        "\n",
        "* Color: Brown\n",
        "* Size: Medium\n",
        "* Breed: Labrador\n",
        "\n",
        "**Actions:**\n",
        "\n",
        "When you tell my_dog to bark, it makes a barking sound!"
      ],
      "metadata": {
        "id": "AuCAwzjFP81j"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        ">  Class is like a recipe (e.g., the instructions for making a Dog).\n",
        "Object is like the actual cookie you make (e.g., your specific dog named my_dog)."
      ],
      "metadata": {
        "id": "AQHn22WVQZGt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# This is our class (like a recipe)\n",
        "class Dog:\n",
        "    def bark(self):  # This is an action\n",
        "        return \"Woof!\"\n",
        "\n",
        "# This is how we create an object (like making a cookie)\n",
        "my_dog = Dog()  # Now we have a specific dog object\n",
        "print(my_dog.bark())  # When we call bark on my_dog, it barks!"
      ],
      "metadata": {
        "id": "wzEVNgksP4vh",
        "outputId": "8b3a34cd-5a1e-4824-f9dd-8bd256f341a0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Woof!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "Dog.bark()"
      ],
      "metadata": {
        "id": "EVShqdrBRCpY",
        "outputId": "444d3338-74e3-412e-d74f-2eb53145320d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 146
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "Dog.bark() missing 1 required positional argument: 'self'",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-18-a29fe8bea9bc>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mDog\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbark\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: Dog.bark() missing 1 required positional argument: 'self'"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Why Dog.bark() Doesn't Work**\n",
        "\n",
        "When you try to call Dog.bark(), Python looks for a method called bark in the Dog class. However, since bark is defined to take self as its first parameter (which represents the instance of the class), it expects to be called on an object.\n",
        "\n",
        "You would get an error if you try to run:"
      ],
      "metadata": {
        "id": "hdEp6d3ORW9S"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**How to Make It Work**\n",
        "\n",
        "If you want to call a method like bark without needing an instance, you would need to define it as a class method or static method. Here's how you can do that:"
      ],
      "metadata": {
        "id": "V7fOaLM7ReaT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Dog:\n",
        "    @classmethod\n",
        "    def bark(cls):  # Now it takes 'cls' instead of 'self'\n",
        "        return \"Woof!\"\n",
        "\n",
        "# Now you can call it like this:\n",
        "print(Dog.bark())  # This works!"
      ],
      "metadata": {
        "id": "Zv3-5EXuRgC0",
        "outputId": "862ee2dd-0c3e-44cf-fcd3-774f33d2ba4b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Woof!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class Dog:\n",
        "    @staticmethod\n",
        "    def bark():  # No 'self' or 'cls' needed\n",
        "        return \"Woof!\"\n",
        "\n",
        "# Now you can call it like this:\n",
        "print(Dog.bark())  # This works too!"
      ],
      "metadata": {
        "id": "wPCDnLTNRzds",
        "outputId": "24086766-5c7d-48da-fafd-6dfc83670045",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Woof!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Visual Analogy**\n",
        "\n",
        "Imagine you have:\n",
        "\n",
        "* A Toy Factory (the class) that makes different toys.\n",
        "* Teddy Bear and Action Figure are toys made in the factory (the objects).\n",
        "The factory has a plan for making toys, just like a class has a plan for creating objects. Each toy made can have its own features and actions.\n"
      ],
      "metadata": {
        "id": "_155w-3mQnzu"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **1. Instance Method**\n",
        "\n",
        "**What is it?**\n",
        "\n",
        "An instance method is a way for a specific dog (an object) to do something. It needs to know about the particular dog that is doing the barking.\n",
        "\n",
        "**How It Works:**\n",
        "\n",
        "When you create a dog from the Dog class, you get a specific dog (like a real dog with its own name and traits). This method uses self to know which dog is barking."
      ],
      "metadata": {
        "id": "cqN4bw83Sxh_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Dog:\n",
        "    def bark(self):  # This is an instance method\n",
        "        return \"Woof!\"\n",
        "\n",
        "# Now, let's create a specific dog!\n",
        "my_dog = Dog()  # Here we create a dog called my_dog\n",
        "\n",
        "# Now my_dog can bark!\n",
        "print(my_dog.bark())  # This will print: Woof!"
      ],
      "metadata": {
        "id": "mMIsnU8dTBEE",
        "outputId": "c06a00eb-6756-43e6-8c5e-102264903c58",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Woof!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Explanation:**\n",
        "\n",
        "* my_dog: This is our specific dog. When we call my_dog.bark(), it knows it's my_dog that is barking.\n",
        "\n",
        "* self: It’s like saying, “Hey, this method is for the dog that is calling it!” So when bark is called, it refers to my_dog."
      ],
      "metadata": {
        "id": "L8SsnqvATMOt"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **2. Class Method**\n",
        "\n",
        "* **What is it?**\n",
        "\n",
        "A class method is a way for the entire class to do something, not just one specific dog. This method knows about the class itself (like the whole dog family), not just one dog.\n",
        "\n",
        "* **How It Works:**\n",
        "\n",
        "Class methods use cls instead of self. This tells the method that it’s talking about the whole class of dogs, not just one."
      ],
      "metadata": {
        "id": "3jtpPm7bUaGO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Dog:\n",
        "    @classmethod\n",
        "    def bark(cls):  # This is a class method\n",
        "        return \"Woof from the whole class of dogs!\"\n",
        "\n",
        "# Now, let's call the class method directly from the class!\n",
        "print(Dog.bark())  # This will print: Woof from the whole class of dogs!"
      ],
      "metadata": {
        "id": "5SkW9C8EUorG",
        "outputId": "51efe26e-00e5-46ef-9914-c9b64e3adef2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Woof from the whole class of dogs!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Explanation:**\n",
        "\n",
        "> Dog.bark(): We call the bark method on the class itself. It’s like saying, “Hey all dogs, bark together!”\n",
        "\n",
        "> cls: This stands for the class itself, just like self is for a specific dog."
      ],
      "metadata": {
        "id": "JI73STCwUtCN"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "| **Concept**        | **Description**                                                                              | **Example Code**                                                                                                    | **Example Output**                          |\n",
        "|---------------------|----------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------|---------------------------------------------|\n",
        "| **Class**           | A blueprint for creating objects, like a recipe for cookies.                              | `class Cookie:`<br>`    def __init__(self, flavor, size):`                                                      | None (just defines the class)               |\n",
        "| **Object**          | A specific instance of a class, like a specific cookie made from the Cookie class.        | `cookie1 = Cookie(\"Chocolate Chip\", \"Large\")`<br>`cookie2 = Cookie(\"Oatmeal Raisin\", \"Medium\")`                | Creates two cookie objects                  |\n",
        "| **Self**            | Refers to the specific object being created or modified; used to access properties.       | `def describe(self):`<br>`    return f\"This is a {self.size} {self.flavor} cookie.\"`                            | None (part of the method definition)        |\n",
        "| **Properties**      | Attributes that define the object's characteristics, like flavor and size of cookies.     | `self.flavor = flavor`<br>`self.size = size`                                                                      | None (sets properties during object creation)|\n",
        "| **Instance Method** | A method that operates on an instance of the class; can access instance properties.       | `def describe(self):`<br>`    return f\"This is a {self.size} {self.flavor} cookie.\"`                            | None (part of the method definition)        |\n",
        "| **Class Method**    | A method that belongs to the class itself; can access class-level data.                   | `@classmethod`<br>`def get_total_cookies(cls):`<br>`    return cls.total_cookies`                                | None (part of the method definition)        |\n",
        "| **Static Method**   | A method that does not depend on class or instance data; can be called on the class.     | `@staticmethod`<br>`def baking_time():`<br>`    return \"Bake cookies for 10-12 minutes at 350°F.\"`             | None (part of the method definition)        |\n"
      ],
      "metadata": {
        "id": "cLzyp63iXHKG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Cookie:  # This is our cookie class (blueprint)\n",
        "    total_cookies = 0  # Class variable to keep track of the total number of cookies\n",
        "\n",
        "    def __init__(self, flavor, size):\n",
        "        self.flavor = flavor  # Each cookie has a flavor\n",
        "        self.size = size      # Each cookie has a size\n",
        "        Cookie.total_cookies += 1  # Increment the count whenever a new cookie is created\n",
        "\n",
        "    def describe(self):  # Method to describe the cookie\n",
        "        return f\"This is a {self.size} {self.flavor} cookie.\"  # Using self to access properties\n",
        "\n",
        "    @classmethod  # This decorator indicates a class method\n",
        "    def get_total_cookies(cls):\n",
        "        return cls.total_cookies  # Return the total number of cookies created\n",
        "\n",
        "    @staticmethod  # This decorator indicates a static method\n",
        "    def baking_time():\n",
        "        return \"Bake cookies for 10-12 minutes at 350°F.\"  # Instruction without needing any instance\n",
        "\n",
        "# Creating cookie objects\n",
        "cookie1 = Cookie(\"Chocolate Chip\", \"Large\")\n",
        "cookie2 = Cookie(\"Oatmeal Raisin\", \"Medium\")\n",
        "\n",
        "# Using the describe method\n",
        "print(cookie1.describe())  # Output: This is a Large Chocolate Chip cookie.\n",
        "print(cookie2.describe())  # Output: This is a Medium Oatmeal Raisin cookie.\n",
        "\n",
        "# Using the class method\n",
        "print(\"Total cookies made:\", Cookie.get_total_cookies())  # Output: Total cookies made: 2\n",
        "\n",
        "# Using the static method\n",
        "print(Cookie.baking_time())  # Output: Bake cookies for 10-12 minutes at 350°F.\n"
      ],
      "metadata": {
        "id": "RE625OmGXLuf",
        "outputId": "40eb3904-13d2-45be-9c50-22b1308171ba",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "This is a Large Chocolate Chip cookie.\n",
            "This is a Medium Oatmeal Raisin cookie.\n",
            "Total cookies made: 2\n",
            "Bake cookies for 10-12 minutes at 350°F.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "| Feature             | Self                                                                 | Class Method                                                                 | Static Method                                                            |\n",
        "|---------------------|----------------------------------------------------------------------|------------------------------------------------------------------------------|-------------------------------------------------------------------------|\n",
        "| **Definition**      | Refers to the instance of the class being created or modified.      | A method that belongs to the class, not the instance.                       | A method that does not depend on class or instance data.                |\n",
        "| **Usage**           | Used to access instance variables and methods.                       | Used to access class variables and methods.                                  | Used for utility functions that don't require access to class or instance data. |\n",
        "| **Declaration**     | No decorators needed; just the first parameter in instance methods.  | Declared with the `@classmethod` decorator.                                 | Declared with the `@staticmethod` decorator.                            |\n",
        "| **First Parameter** | Must always be `self`, referring to the current instance.           | Must always be `cls`, referring to the class.                               | No special first parameter; it can take any number of parameters.       |\n",
        "| **Access**          | Can access instance attributes and methods.                          | Can access class attributes and methods.                                     | Cannot access instance or class attributes directly.                    |\n",
        "| **Example Usage**   | `self.name` to access the name property of an instance.             | `@classmethod def total(cls): return cls.count`                             | `@staticmethod def bake(): return 'Bake at 350°F'`                    |\n"
      ],
      "metadata": {
        "id": "JxlmDEL9XiWm"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **1. Self**\n",
        "\n",
        "self is a special parameter used in instance methods. It refers to the current object of the class, allowing access to the object's attributes and methods.\n",
        "\n",
        "> Usage: When you create an instance of a class, you can use self to access properties and methods specific to that instance."
      ],
      "metadata": {
        "id": "NBnzuKiPYPV1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class dog:\n",
        "  def __init__(self,name):\n",
        "    self.name = name\n",
        "\n",
        "  def bark(self):\n",
        "    return f\"{self.name} says woof!\""
      ],
      "metadata": {
        "id": "IfEbMwASXjBa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Create an instance of Dog\n",
        "my_dog = dog(\"Buddy\")\n",
        "print(my_dog.bark())  # Output: Buddy says Woof!"
      ],
      "metadata": {
        "id": "YlBACfpXYlYP",
        "outputId": "53a72e10-b0ff-4d1b-e573-def65f054084",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Buddy says woof!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "```\n",
        "__init__\n",
        "``` is the constructor method where self.name is an instance variable. When you create my_dog, self refers to my_dog, allowing it to have a unique name."
      ],
      "metadata": {
        "id": "iz8SmXtyYpg_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **2. Class Method**\n",
        "\n",
        "A class method is a method that belongs to the class itself rather than any particular instance. It can access class variables and methods.\n",
        "\n",
        "> Usage: Use class methods when you need to perform operations that relate to the class as a whole rather than individual instances."
      ],
      "metadata": {
        "id": "2fON7cxyY9lR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Dog:\n",
        "    count = 0  # Class variable to keep track of number of dogs\n",
        "\n",
        "    def __init__(self, name):\n",
        "        self.name = name\n",
        "        Dog.count += 1  # Increment the count each time a new dog is created\n",
        "\n",
        "    @classmethod\n",
        "    def total_dogs(cls):  # Class method\n",
        "        return f\"Total dogs: {cls.count}\"  # Access class variable\n",
        "\n",
        "# Create instances of Dog\n",
        "dog1 = Dog(\"Buddy\")\n",
        "dog2 = Dog(\"Max\")\n",
        "\n",
        "# Call the class method\n",
        "print(Dog.total_dogs())  # Output: Total dogs: 2"
      ],
      "metadata": {
        "id": "gj80lZIOZK_C"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "The total_dogs method is a class method that can access the count class variable. It returns the total number of Dog instances created."
      ],
      "metadata": {
        "id": "iOvvRJdybk4i"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 3. Static Method\n",
        "\n",
        "A static method is a method that does not access or modify class or instance data. It behaves like a regular function but belongs to the class's namespace.\n",
        "\n",
        "> Usage: Use static methods when you have a utility function that is related to the class but does not need to access any class or instance variables."
      ],
      "metadata": {
        "id": "2v-3nV5XbtYs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Dog:\n",
        "    @staticmethod\n",
        "    def bark():  # Static method\n",
        "        return \"Woof!\"  # Does not access any instance or class data\n",
        "\n",
        "# Call the static method\n",
        "print(Dog.bark())  # Output: Woof!\n"
      ],
      "metadata": {
        "id": "qAFZ3B_6b19b",
        "outputId": "c42ad1dd-1f44-48bc-cfad-0c6536a2e2ad",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Woof!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "* The bark method does not require any information from the Dog class or its instances. It simply returns a string and can be called directly on the class without creating an instance."
      ],
      "metadata": {
        "id": "oTLdc5N1cLy9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "| **Feature**         | **Self**                                    | **Class Method**                            | **Static Method**                            |\n",
        "|---------------------|---------------------------------------------|---------------------------------------------|---------------------------------------------|\n",
        "| **Definition**       | Refers to the instance of the class.        | Belongs to the class, not to an instance.   | A method that doesn't access class or instance data. |\n",
        "| **Usage**            | Access instance variables and methods.      | Access class variables and methods.         | Utility functions that don't require class/instance data. |\n",
        "| **Declaration**      | No decorators needed; just the first parameter. | Declared with `@classmethod`.               | Declared with `@staticmethod`.              |\n",
        "| **First Parameter**  | Must be `self`.                             | Must be `cls`.                              | No special parameter needed.                |\n",
        "| **Access**           | Can access instance attributes and methods. | Can access class attributes and methods.    | Cannot access instance or class attributes directly. |\n",
        "| **Example Usage**    | `self.name` for instance variables.         | `@classmethod def total(cls)`               | `@staticmethod def bake()`                  |\n"
      ],
      "metadata": {
        "id": "pdHKnsRicXcP"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Python Classes/Objects\n",
        "Python is an object oriented programming language.\n",
        "\n",
        "Almost everything in Python is an object, with its properties and methods.\n",
        "\n",
        "A Class is like an object constructor, or a \"blueprint\" for creating objects."
      ],
      "metadata": {
        "id": "bf7WSG03ccJl"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Create a Class**\n",
        "To create a class, use the keyword class:"
      ],
      "metadata": {
        "id": "qvv7TlFAcftI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class MyClass:\n",
        "  x = 5"
      ],
      "metadata": {
        "id": "87mIpxescejf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### **Create Object**\n",
        "\n",
        "Now we can use the class named MyClass to create objects:"
      ],
      "metadata": {
        "id": "rB_D3o_wckLB"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Create an object named p1, and print the value of x:"
      ],
      "metadata": {
        "id": "fJpBwZI9cydR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "p1 = MyClass()\n",
        "print(p1.x)"
      ],
      "metadata": {
        "id": "Nz_zU3ULculZ",
        "outputId": "7c04e951-2677-4158-c385-55c29b9c70ca",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **The __init__() Function**\n",
        "\n",
        "* The examples above are classes and objects in their simplest form, and are not really useful in real life applications.\n",
        "\n",
        "* To understand the meaning of classes we have to understand the built-in __init__() function.\n",
        "\n",
        "* All classes have a function called __init__(), which is always executed when the class is being initiated.\n",
        "\n",
        "* Use the __init__() function to assign values to object properties, or other operations that are necessary to do when the object is being created:"
      ],
      "metadata": {
        "id": "mNUjXLMIc1ga"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Create a class named Person, use the __init__() function to assign values for name and age:"
      ],
      "metadata": {
        "id": "G4JCS4P0dF-r"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class person:\n",
        "  def __init__(self,name,age):\n",
        "    self.name = name\n",
        "    self.age = age"
      ],
      "metadata": {
        "id": "UHmgzsj2dGhz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "man = person(\"john\",36)"
      ],
      "metadata": {
        "id": "Y8Tcq91gdXMk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(man.name)\n",
        "print(man.age)"
      ],
      "metadata": {
        "id": "pT8Eq_6Jdipu",
        "outputId": "7aac277f-0a55-4d6b-8666-a11617f3ba6d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "john\n",
            "36\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "> Note: The __init__() function is called automatically every time the class is being used to create a new object."
      ],
      "metadata": {
        "id": "WeRQUuuqdv0B"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **The __str__() Function**\n",
        "\n",
        "> The `__str__()` function controls what should be returned when the class object is represented as a string.\n",
        "\n",
        "> If the __str__() function is not set, the string representation of the object is returned:"
      ],
      "metadata": {
        "id": "gfefCHTZdyjw"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The string representation of an object WITHOUT the __str__() function:"
      ],
      "metadata": {
        "id": "iUQSE4V0eOKE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Person:\n",
        "  def __init__(self, name, age):\n",
        "    self.name = name\n",
        "    self.age = age\n",
        "\n",
        "p1 = Person(\"John\", 36)\n",
        "\n",
        "print(p1)"
      ],
      "metadata": {
        "id": "kotIw0Y-dncJ",
        "outputId": "d7a2c97e-f869-4f7e-cb1f-93255b2605d5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<__main__.Person object at 0x7f3966229ba0>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The string representation of an object WITH the `__str__() `function:"
      ],
      "metadata": {
        "id": "JZYg6l9HeU93"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Person:\n",
        "  def __init__(self, name, age):\n",
        "    self.name = name\n",
        "    self.age = age\n",
        "\n",
        "  def __str__(self):\n",
        "    return f\"{self.name}({self.age})\"\n",
        "\n",
        "p1 = Person(\"John\", 36)\n",
        "\n",
        "print(p1)"
      ],
      "metadata": {
        "id": "iuQklVI3eW4N",
        "outputId": "a8ffab7f-2d14-4a4c-e52d-a3b8be0db774",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "John(36)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Object Methods**\n",
        "\n",
        "Objects can also contain methods. Methods in objects are functions that belong to the object.\n",
        "\n",
        "Let us create a method in the Person class:"
      ],
      "metadata": {
        "id": "5_nsslr2exwm"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "> Insert a function that prints a greeting, and execute it on the p1 object:"
      ],
      "metadata": {
        "id": "U9oxpgpye_Pf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Person:\n",
        "  def __init__(self, name, age):\n",
        "    self.name = name\n",
        "    self.age = age\n",
        "\n",
        "  def myfunc(self):\n",
        "    print(\"Hello my name is \" + self.name)\n",
        "\n",
        "p1 = Person(\"John\", 36)\n",
        "p1.myfunc()"
      ],
      "metadata": {
        "id": "pg7eyzBBe68v",
        "outputId": "4d348281-60f8-4b91-efa8-0ffc9e6d6c9f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello my name is John\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The self parameter is a reference to the current instance of the class, and is used to access variables that belong to the class."
      ],
      "metadata": {
        "id": "nRI9vzJvfVBp"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **The self Parameter**\n",
        "\n",
        "* The self parameter is a reference to the current instance of the class, and is used to access variables that belong to the class.\n",
        "\n",
        "* It does not have to be named self, you can call it whatever you like, but it has to be the first parameter of any function in the class:"
      ],
      "metadata": {
        "id": "RFJgT9DOfaax"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Use the words mysillyobject and abc instead of self:"
      ],
      "metadata": {
        "id": "BB7Fy-Lsfgpy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Person:\n",
        "  def __init__(mysillyobject, name, age):\n",
        "    mysillyobject.name = name\n",
        "    mysillyobject.age = age\n",
        "\n",
        "  def myfunc(abc):\n",
        "    print(\"Hello my name is \" + abc.name)\n",
        "\n",
        "p1 = Person(\"John\", 36)\n",
        "p1.myfunc()"
      ],
      "metadata": {
        "id": "t9_m8NtRfgFy",
        "outputId": "10a434f0-685d-49f2-eb35-2dd680c8dc42",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello my name is John\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Modify Object Properties**\n",
        "\n",
        "You can modify properties on objects like this:"
      ],
      "metadata": {
        "id": "ig5GPhL5hAkk"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Set the age of p1 to 40:"
      ],
      "metadata": {
        "id": "NMtxdnZWhFYE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "p1.age = 40"
      ],
      "metadata": {
        "id": "meX9z9pzhDEc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "x = p1.age\n",
        "print(x)"
      ],
      "metadata": {
        "id": "bNmtcpJDhID4",
        "outputId": "beecd11c-a9bb-48fa-fd59-f53d964ba02f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "40\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Delete Object Properties**\n",
        "\n",
        "You can delete properties on objects by using the del keyword:"
      ],
      "metadata": {
        "id": "eDUZrTQ_hPiQ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Delete the age property from the p1 object:"
      ],
      "metadata": {
        "id": "ITYxEx9ihYlX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "del p1.age"
      ],
      "metadata": {
        "id": "gXKr91yYhVG1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Delete Objects**\n",
        "\n",
        "You can delete objects by using the del keyword:"
      ],
      "metadata": {
        "id": "L1JPB5i7hZtM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "del p1"
      ],
      "metadata": {
        "id": "3ZB5HZOFheKf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **The pass Statement**\n",
        "\n",
        "class definitions cannot be empty, but if you for some reason have a class definition with no content, put in the pass statement to avoid getting an error."
      ],
      "metadata": {
        "id": "F74pr2QFhg4H"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Person:\n",
        "  pass"
      ],
      "metadata": {
        "id": "oWy0fRBahlX_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "VmSQcPctj2Fm"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Inheritance:**\n",
        "\n",
        "Imagine your parents have a set of LEGO blocks. They built cool things with them, like houses, cars, and robots. When you grow up, you get their LEGO set. Now, you can use the same blocks to build the same cool stuff, and you can add your own special LEGO pieces to make new things!\n",
        "\n",
        "> Parent Class: Your parent is the person who had the LEGO set first.\n",
        "\n",
        "> Child Class: You, as the child, get the LEGO set and can build things from the same instructions. You can also add new LEGO blocks or change things up if you want."
      ],
      "metadata": {
        "id": "d7CiBEcbjkvM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "* Inheritance allows us to define a class that inherits all the methods and properties from another class.\n",
        "\n",
        "* Parent class is the class being inherited from, also called base class.\n",
        "\n",
        "* Child class is the class that inherits from another class, also called derived class."
      ],
      "metadata": {
        "id": "ERNf_2EPjxpn"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Create a Parent Class**\n",
        "\n",
        "Any class can be a parent class, so the syntax is the same as creating any other class:"
      ],
      "metadata": {
        "id": "mzztRRzIj6rO"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Create a class named Person, with firstname and lastname properties, and a printname method:"
      ],
      "metadata": {
        "id": "EXxBD8ObkBH2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Person:\n",
        "  def __init__(self, fname, lname):\n",
        "    self.firstname = fname\n",
        "    self.lastname = lname\n",
        "\n",
        "  def printname(self):\n",
        "    print(self.firstname, self.lastname)\n",
        "\n",
        "#Use the Person class to create an object, and then execute the printname method:\n",
        "\n",
        "x = Person(\"John\", \"Doe\")\n",
        "x.printname()"
      ],
      "metadata": {
        "id": "nAkrgHAEj8he",
        "outputId": "bda17bb5-6896-4996-982f-1e74ad04f7e1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "John Doe\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Create a Child Class**\n",
        "To create a class that inherits the functionality from another class, send the parent class as a parameter when creating the child class:"
      ],
      "metadata": {
        "id": "o38qMZxhkDMn"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Create a class named Student, which will inherit the properties and methods from the Person class:"
      ],
      "metadata": {
        "id": "skNuUcLgkI0_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Student(Person):\n",
        "  pass"
      ],
      "metadata": {
        "id": "N1Lj7qK9kJ1C"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "> Note: Use the pass keyword when you do not want to add any other properties or methods to the class."
      ],
      "metadata": {
        "id": "9nPCmdp8kOy_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Use the Student class to create an object, and then execute the printname method:"
      ],
      "metadata": {
        "id": "_RFNW9IskTNP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = Student(\"Mike\", \"Olsen\")\n",
        "x.printname()"
      ],
      "metadata": {
        "id": "APf-wSnJkT1i",
        "outputId": "062a9172-95b4-42bb-ca8a-140c08d2838e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mike Olsen\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Add the __init__() Function**\n",
        "\n",
        "* So far we have created a child class that inherits the properties and methods from its parent.\n",
        "\n",
        "* We want to add the __init__() function to the child class (instead of the pass keyword).\n",
        "\n",
        "> Note: The __init__() function is called automatically every time the class is being used to create a new object."
      ],
      "metadata": {
        "id": "RpOgMLiCkbii"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Add the `__init__()` function to the Student class:"
      ],
      "metadata": {
        "id": "Qvr7_zzpknFi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Student(Person):\n",
        "  def __init__(self, fname, lname):\n",
        "    # add properties etc.\n",
        "    self.age = age\n",
        "    self.name = name"
      ],
      "metadata": {
        "id": "oWV1xA1Nkp4q"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "* When you add the `__init__() `function, the child class will **no longer** inherit the parent's `__init__() function.`\n",
        "\n",
        "* The child's __init__() function overrides the inheritance of the parent's __init__() function.\n",
        "\n",
        "* To keep the inheritance of the parent's __init__() function, add a call to the parent's __init__() function:\n"
      ],
      "metadata": {
        "id": "pKEjCycPk98k"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Student(Person):\n",
        "  def __init__(self, fname, lname):\n",
        "    Person.__init__(self, fname, lname)"
      ],
      "metadata": {
        "id": "EqbcdGCFk_Sm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Use the super() Function**\n",
        "\n",
        "Python also has a super() function that will make the child class inherit all the methods and properties from its parent:"
      ],
      "metadata": {
        "id": "A96CNpHOlZbf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Student(Person):\n",
        "  def __init__(self, fname, lname):\n",
        "    super().__init__(fname, lname)"
      ],
      "metadata": {
        "id": "F7zPcZHPlc-x"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "By using the super() function, you do not have to use the name of the parent element, it will automatically inherit the methods and properties from its parent."
      ],
      "metadata": {
        "id": "XlsR-gskmMBc"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Add Properties**"
      ],
      "metadata": {
        "id": "MNaZSCa7m66L"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Add a property called graduationyear to the Student class:"
      ],
      "metadata": {
        "id": "Uq8JeI9Km8pv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Student(Person):\n",
        "  def __init__(self, fname, lname):\n",
        "    super().__init__(fname, lname)\n",
        "    self.graduationyear = 2019"
      ],
      "metadata": {
        "id": "RLtF0O9zm97v"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "In the example below, the year 2019 should be a variable, and passed into the Student class when creating student objects. To do so, add another parameter in the __init__() function:"
      ],
      "metadata": {
        "id": "lJSIK7psnFUy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Student(Person):\n",
        "  def __init__(self, fname, lname, year):\n",
        "    super().__init__(fname, lname)\n",
        "    self.graduationyear = year\n",
        "\n",
        "x = Student(\"Mike\", \"Olsen\", 2019)"
      ],
      "metadata": {
        "id": "41eASCtgnF-o"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Add Methods**\n",
        "Add a method called welcome to the Student class:"
      ],
      "metadata": {
        "id": "GzLcxIavnMlE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Student(Person):\n",
        "  def __init__(self, fname, lname, year):\n",
        "    super().__init__(fname, lname)\n",
        "    self.graduationyear = year\n",
        "\n",
        "  def welcome(self):\n",
        "    print(\"Welcome\", self.firstname, self.lastname, \"to the class of\", self.graduationyear)"
      ],
      "metadata": {
        "id": "P2xjMuC9nP1b"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "If you add a method in the child class with the same name as a function in the parent class, the inheritance of the parent method will be overridden."
      ],
      "metadata": {
        "id": "NwtJp12Bn_g4"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "6_pO3oTl_nN0"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Python Scope**\n"
      ],
      "metadata": {
        "id": "S3jxHEfA9Lq6"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "> A variable is only available from inside the region it is created. This is called scope."
      ],
      "metadata": {
        "id": "iXLmNMdL_mMg"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Local Scope**\n",
        "\n",
        "A variable created inside a function belongs to the local scope of that function, and can only be used inside that function"
      ],
      "metadata": {
        "id": "xtSDP4uM_x6h"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def myfunc():\n",
        "  x = 300\n",
        "  print(x)\n",
        "\n",
        "myfunc()"
      ],
      "metadata": {
        "id": "TyTRCOVy_7H6",
        "outputId": "f2d8221d-504c-4642-9c07-1fa8b39afcb2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "300\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Function Inside Function**\n",
        "\n",
        "As explained in the example above, the variable x is not available outside the function, but it is available for any function inside the function:"
      ],
      "metadata": {
        "id": "__ldNIzWAHbq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def myfunc():\n",
        "  x = 300\n",
        "  def myinnerfunc():\n",
        "    print(x)\n",
        "  myinnerfunc()\n",
        "\n",
        "myfunc()"
      ],
      "metadata": {
        "id": "GCbWg0ZHAJpC",
        "outputId": "eaf579da-0aa1-43e3-a91e-c5d7d8f0cc9a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "300\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Global Scope**\n",
        "\n",
        "A variable created in the main body of the Python code is a global variable and belongs to the global scope.\n",
        "\n",
        "Global variables are available from within any scope, global and local."
      ],
      "metadata": {
        "id": "RcbUmGQtAKkj"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "> A variable created outside of a function is global and can be used by anyone:"
      ],
      "metadata": {
        "id": "IvwCR4CBATv7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = 300\n",
        "\n",
        "def myfunc():\n",
        "  print(x)\n",
        "\n",
        "myfunc()\n",
        "\n",
        "print(x)"
      ],
      "metadata": {
        "id": "E4gT4EshAVYv",
        "outputId": "5092b180-8630-41d8-a42d-0e64f1f8eccc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "300\n",
            "300\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Naming Variables**\n",
        "\n",
        "If you operate with the same variable name inside and outside of a function, Python will treat them as two separate variables ***one available in the global scope (outside the function) and one available in the local scope (inside the function)***"
      ],
      "metadata": {
        "id": "TsuuF2o-Aakc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = 300\n",
        "\n",
        "def myfunc():\n",
        "  x = 200\n",
        "  print(x)\n",
        "\n",
        "myfunc()\n",
        "\n",
        "print(x)"
      ],
      "metadata": {
        "id": "Uv4sd5dFAljm",
        "outputId": "a3f3cc77-0736-4c9f-e014-648070566576",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "200\n",
            "300\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Global Keyword**\n",
        "\n",
        "If you need to create a global variable, but are stuck in the local scope, you can use the global keyword.\n",
        "\n",
        "The global keyword makes the variable global."
      ],
      "metadata": {
        "id": "IhqVdbSUAvne"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def myfunc():\n",
        "  global x\n",
        "  x = 3\n",
        "\n",
        "myfunc()\n",
        "\n",
        "print(x)"
      ],
      "metadata": {
        "id": "ZtA8Ld8KAzUo",
        "outputId": "466d2476-ceb0-426f-9d58-16387050b1f2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "To change the value of a global variable inside a function, refer to the variable by using the global keyword:"
      ],
      "metadata": {
        "id": "i_rHZavdBm9V"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = 300\n",
        "\n",
        "def myfunc():\n",
        "  global x\n",
        "  x = 200\n",
        "\n",
        "myfunc()\n",
        "\n",
        "print(x)"
      ],
      "metadata": {
        "id": "WOVRJFGoBnYm",
        "outputId": "21b0ef36-40d2-4c2f-ca31-5af83874e017",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "200\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Nonlocal Keyword**\n",
        "\n",
        "The nonlocal keyword is used to work with variables inside nested functions.\n",
        "\n",
        "The nonlocal keyword makes the variable belong to the outer function."
      ],
      "metadata": {
        "id": "c2fyFeH-BvE0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def myfunc1():\n",
        "  x = \"Jane\"\n",
        "  def myfunc2():\n",
        "    nonlocal x\n",
        "    x = \"hello\"\n",
        "  myfunc2()\n",
        "  return x\n",
        "\n",
        "print(myfunc1())"
      ],
      "metadata": {
        "id": "0DOP9Fz0B0nO",
        "outputId": "e4c7d12f-4319-4159-e6c9-ca90a8253767",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "hello\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "arY7UwhVFj_d"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Python Modules**"
      ],
      "metadata": {
        "id": "WQ799kReFkwl"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**What is a Module?**\n",
        "\n",
        "Consider a module to be the same as a code library.\n",
        "\n",
        "A file containing a set of functions you want to include in your application."
      ],
      "metadata": {
        "id": "TnNHkQx0FmI9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Built-in Modules**\n",
        "\n",
        "There are several built-in modules in Python, which you can import whenever you like."
      ],
      "metadata": {
        "id": "pBM4BuLxRedB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import platform\n",
        "\n",
        "x = platform.system()\n",
        "print(x)"
      ],
      "metadata": {
        "id": "yXurc09rFlwN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9ce9f78d-2464-4dd5-b337-e01d53fe2857"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Linux\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Using the dir() Function**\n",
        "\n",
        "There is a built-in function to list all the function names (or variable names) in a module. The dir() function:"
      ],
      "metadata": {
        "id": "RpbCvehwRcqX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import platform\n",
        "\n",
        "x = dir(platform)\n",
        "print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "znDMna20RbFM",
        "outputId": "1d082e34-252e-47ef-d899-35e5ea54277f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['_Processor', '_WIN32_CLIENT_RELEASES', '_WIN32_SERVER_RELEASES', '__builtins__', '__cached__', '__copyright__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '__version__', '_comparable_version', '_component_re', '_default_architecture', '_follow_symlinks', '_get_machine_win32', '_ironpython26_sys_version_parser', '_ironpython_sys_version_parser', '_java_getprop', '_libc_search', '_mac_ver_xml', '_node', '_norm_version', '_os_release_cache', '_os_release_candidates', '_os_release_line', '_os_release_unescape', '_parse_os_release', '_platform', '_platform_cache', '_pypy_sys_version_parser', '_sys_version', '_sys_version_cache', '_sys_version_parser', '_syscmd_file', '_syscmd_ver', '_uname_cache', '_unknown_as_blank', '_ver_output', '_ver_stages', 'architecture', 'collections', 'freedesktop_os_release', 'functools', 'itertools', 'java_ver', 'libc_ver', 'mac_ver', 'machine', 'node', 'os', 'platform', 'processor', 'python_branch', 'python_build', 'python_compiler', 'python_implementation', 'python_revision', 'python_version', 'python_version_tuple', 're', 'release', 'subprocess', 'sys', 'system', 'system_alias', 'uname', 'uname_result', 'version', 'win32_edition', 'win32_is_iot', 'win32_ver']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Use a Module**\n",
        "\n",
        "Now we can use the module we just created, by using the import statement:"
      ],
      "metadata": {
        "id": "k6Go0w3LY0z9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import mymodule\n",
        "\n",
        "mymodule.greeting(\"Jonathan\")"
      ],
      "metadata": {
        "id": "qLOvYXmJY2CF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Variables in Module**\n",
        "\n",
        "The module can contain functions, as already described, but also variables of all types (arrays, dictionaries, objects etc):"
      ],
      "metadata": {
        "id": "xNtVand3Y7WW"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Save this code in the file mymodule.py"
      ],
      "metadata": {
        "id": "xXIvJpA_Y_QH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "person1 = {\n",
        "  \"name\": \"John\",\n",
        "  \"age\": 36,\n",
        "  \"country\": \"Norway\"\n",
        "}"
      ],
      "metadata": {
        "id": "Q3dnDmVjY96N"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Naming a Module**\n",
        "\n",
        "You can name the module file whatever you like, but it must have the file extension .py\n",
        "\n",
        "**Re-naming a Module**\n",
        "\n",
        "You can create an alias when you import a module, by using the as keyword:"
      ],
      "metadata": {
        "id": "A_rJkMTDZCnw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import mymodule as mx\n",
        "\n",
        "a = mx.person1[\"age\"]\n",
        "print(a)"
      ],
      "metadata": {
        "id": "ArsKy9LiZEhf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "snKbOgXmZKUh"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Python Datetime**"
      ],
      "metadata": {
        "id": "5W8PC0IFZLqP"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Python Dates**\n",
        "\n",
        "A date in Python is not a data type of its own, but we can import a module named datetime to work with dates as date objects."
      ],
      "metadata": {
        "id": "0jNwUVe9ZVPR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import datetime\n",
        "\n",
        "x = datetime.datetime.now()\n",
        "print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LMRczx8ZZX0C",
        "outputId": "df72f1b8-f84a-4319-e21b-7248fb704cee"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2024-10-20 19:27:38.074088\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Return the year and name of weekday:"
      ],
      "metadata": {
        "id": "0vekQ2hmZon6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import datetime  # Importing the datetime module\n",
        "\n",
        "x = datetime.datetime.now()  # Getting the current date and time\n",
        "\n",
        "print(x.year)  # Printing the current year\n",
        "print(x.strftime(\"%A\"))  # Printing the full name of the current weekday (like 'Monday', 'Tuesday')\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qXWWQB84ZpA6",
        "outputId": "534f7526-ae99-4242-bf4f-222a03941215"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2024\n",
            "Sunday\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Creating Date Objects**\n",
        "\n",
        "To create a date, we can use the datetime() class (constructor) of the datetime module.\n",
        "\n",
        "The datetime() class requires three parameters to create a date: year, month, day."
      ],
      "metadata": {
        "id": "e3GLI2V3aHiN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import datetime\n",
        "\n",
        "x = datetime.datetime(2020, 5, 17)\n",
        "\n",
        "print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_HQKqigpaKvN",
        "outputId": "505a55c0-0b16-4b27-d7e0-669d8ec7943d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2020-05-17 00:00:00\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The datetime() class also takes parameters for time and timezone (hour, minute, second, microsecond, tzone), but they are optional, and has a default value of 0, (None for timezone)."
      ],
      "metadata": {
        "id": "9m82TRAHaRVh"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**The strftime() Method**\n",
        "\n",
        "The datetime object has a method for formatting date objects into readable strings.\n",
        "\n",
        "The method is called strftime(), and takes one parameter, format, to specify the format of the returned string:"
      ],
      "metadata": {
        "id": "WmWMEftKaTRe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Display the name of the month:\n",
        "\n",
        "import datetime\n",
        "\n",
        "x = datetime.datetime(2018, 6, 1)\n",
        "\n",
        "print(x.strftime(\"%B\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KWLVx2hPaYUe",
        "outputId": "676f80a5-c206-498b-d468-87479b522dfd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "June\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "CEqXr7uTmNwZ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Python Math**"
      ],
      "metadata": {
        "id": "ghf0tGq8mOuS"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Python has a set of built-in math functions, including an extensive math module, that allows you to perform mathematical tasks on numbers."
      ],
      "metadata": {
        "id": "aUwG-fEXmREB"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "> Built-in Math Functions\n",
        "The min() and max() functions can be used to find the lowest or highest value in an iterable:"
      ],
      "metadata": {
        "id": "gbUJQsGkmUB6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = min(5, 10, 25)\n",
        "y = max(5, 10, 25)\n",
        "\n",
        "print(x)\n",
        "print(y)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vHr5TjnMmVv1",
        "outputId": "088f6af0-22d1-4714-a340-f36383b80d5d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n",
            "25\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x = [1,2,3,4,5,6,11,15,250]\n",
        "max(x) + min(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KHHGoyeQmY1Y",
        "outputId": "696a6925-da8a-4f60-d979-e7a8c453c669"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "251"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "> The abs() function returns the absolute (positive) value of the specified number:"
      ],
      "metadata": {
        "id": "pZNAsTR4mpN1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = abs(-7.25)\n",
        "\n",
        "print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7X4AT58cmrRZ",
        "outputId": "65c4b24c-15c7-4840-825f-c3c7ec9a8310"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "7.25\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "> The **pow(x, y)** function returns the value of x to the power of y (xy)."
      ],
      "metadata": {
        "id": "uLJ09XRsmvb2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = pow(4, 3)\n",
        "print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AG5l3VuOmyC0",
        "outputId": "b8fcec0a-bb20-4dc0-a9cb-6626f93ae689"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "64\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "2**5"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CoAU0RB0m0Kz",
        "outputId": "52f9329b-6491-4e90-fe28-31c39784a024"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "32"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**The Math Module**\n",
        "\n",
        "Python has also a built-in module called math, which extends the list of mathematical functions.\n",
        "\n",
        "To use it, you must import the math module:"
      ],
      "metadata": {
        "id": "liKTf0num5KW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import math"
      ],
      "metadata": {
        "id": "HrpuAqwIm7k3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "When you have imported the math module, you can start using methods and constants of the module.\n",
        "\n",
        "The math.sqrt() method for example, returns the square root of a number:"
      ],
      "metadata": {
        "id": "noIhv7Hem9nR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import math\n",
        "\n",
        "x = math.sqrt(64)\n",
        "\n",
        "print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "w-GkmYTbm9XG",
        "outputId": "c89dc23b-1a24-41a6-d1f3-4e87b1d9b23d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "8.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "> The **math.ceil()** method *rounds a number upwards to its nearest integer, and the math.*\n",
        "\n",
        "> **floor()** method *rounds a number downwards to its nearest integer*, and returns the result:"
      ],
      "metadata": {
        "id": "fQ0IcxHunDCQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import math\n",
        "x = math.ceil(1.4)\n",
        "print(x) # returns 2"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6dFvOO0tnLN1",
        "outputId": "aa152832-cabc-4f05-b8ca-4c7942bb8eba"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "y = math.floor(1.4)\n",
        "print(y) # returns 1"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wYR6XUmEnMP_",
        "outputId": "e5abba09-9f9d-41b2-a1cc-bb7339724eb3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The math.pi constant, returns the value of PI (3.14...):"
      ],
      "metadata": {
        "id": "eYifXPZxnTKg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import math\n",
        "x = math.pi\n",
        "print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QtgxBMFfnS73",
        "outputId": "008eacb3-5838-45a1-9057-5ccbede04423"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3.141592653589793\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "Nic5MQtpns4r"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Python JSON**"
      ],
      "metadata": {
        "id": "9Lauy-XMnuF0"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* JSON stands for JavaScript Object Notation\n",
        "\n",
        "* JSON is a lightweight format for storing and transporting data\n",
        "\n",
        "* JSON is often used when data is sent from a server to a web page\n",
        "\n",
        "* JSON is \"self-describing\" and easy to understand\n",
        "\n",
        "* JSON is a syntax for storing and exchanging data.\n",
        "\n",
        "* JSON is text, written with JavaScript object notation."
      ],
      "metadata": {
        "id": "5hKkVyPYoKRG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **JSON Syntax Rules**\n",
        "\n",
        "* Data is in name/value pairs\n",
        "\n",
        "* Data is separated by commas\n",
        "\n",
        "* Curly braces hold objects\n",
        "\n",
        "* Square brackets hold arrays\n"
      ],
      "metadata": {
        "id": "dnPfDFWUohzI"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "FtAaOhJZrfEc"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* https://www.w3schools.com/whatis/whatis_json.asp\n",
        "\n",
        "* https://www.w3schools.com/js/js_json_parse.asp"
      ],
      "metadata": {
        "id": "hwNiqwt2rN-w"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **JSON in Python**\n",
        "\n",
        "Python has a built-in package called json, which can be used to work with JSON data."
      ],
      "metadata": {
        "id": "0oU_E034nzEs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Import the json module:\n",
        "\n",
        "import json"
      ],
      "metadata": {
        "id": "zKfWbrUln2YM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Parse JSON - Convert from JSON to Python**\n",
        "\n",
        "If you have a JSON string, you can parse it by using the json.loads() method."
      ],
      "metadata": {
        "id": "J-xBGUBfn6i8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Convert from JSON to Python:\n",
        "\n",
        "import json\n",
        "\n",
        "# some JSON:\n",
        "x =  '{ \"name\":\"John\", \"age\":30, \"city\":\"New York\"}'\n",
        "\n",
        "# parse x:\n",
        "y = json.loads(x)\n",
        "\n",
        "# the result is a Python dictionary:\n",
        "print(y[\"age\"])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UQcTrmB0n-u0",
        "outputId": "4661b0ce-de9b-4340-955e-82a9d6744f58"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "30\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Convert from Python to JSON**\n",
        "\n",
        "If you have a Python object, you can convert it into a JSON string by using the json.dumps() method."
      ],
      "metadata": {
        "id": "HBrTHW8xrmNk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Convert from Python to JSON:\n",
        "\n",
        "import json\n",
        "\n",
        "# a Python object (dict):\n",
        "x = {\n",
        "  \"name\": \"John\",\n",
        "  \"age\": 30,\n",
        "  \"city\": \"New York\"\n",
        "}\n",
        "\n",
        "# convert into JSON:\n",
        "y = json.dumps(x)\n",
        "\n",
        "# the result is a JSON string:\n",
        "print(y)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "57m0g9BUrpxr",
        "outputId": "e16d145f-8e4f-4ab4-80a2-25efc34d63d0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{\"name\": \"John\", \"age\": 30, \"city\": \"New York\"}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "You can convert Python objects of the following types, into JSON strings:\n",
        "\n",
        "* dict\n",
        "* list\n",
        "* tuple\n",
        "* string\n",
        "* int\n",
        "* float\n",
        "* True\n",
        "* False\n",
        "* None\n"
      ],
      "metadata": {
        "id": "nW1NCS1KsZep"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import json\n",
        "\n",
        "print(json.dumps({\"name\": \"John\", \"age\": 30}))\n",
        "print(json.dumps([\"apple\", \"bananas\"]))\n",
        "print(json.dumps((\"apple\", \"bananas\")))\n",
        "print(json.dumps(\"hello\"))\n",
        "print(json.dumps(42))\n",
        "print(json.dumps(31.76))\n",
        "print(json.dumps(True))\n",
        "print(json.dumps(False))\n",
        "print(json.dumps(None))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e1Mq54eFtREV",
        "outputId": "6cf27b37-a69d-4e84-cf36-c1dcf0abbc25"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{\"name\": \"John\", \"age\": 30}\n",
            "[\"apple\", \"bananas\"]\n",
            "[\"apple\", \"bananas\"]\n",
            "\"hello\"\n",
            "42\n",
            "31.76\n",
            "true\n",
            "false\n",
            "null\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "> When you convert from Python to JSON, Python objects are converted into the JSON (JavaScript) equivalent:\n",
        "\n",
        "| Python  | JSON   |\n",
        "|---------|--------|\n",
        "| dict    | Object |\n",
        "| list    | Array  |\n",
        "| tuple   | Array  |\n",
        "| str     | String |\n",
        "| int     | Number |\n",
        "| float   | Number |\n",
        "| True    | true   |\n",
        "| False   | false  |\n",
        "| None    | null   |\n"
      ],
      "metadata": {
        "id": "ozscAf7JtY8e"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Format the Result**\n",
        "\n",
        "The example above prints a JSON string, but it is not very easy to read, with no indentations and line breaks.\n",
        "\n",
        "The json.dumps() method has parameters to make it easier to read the result:"
      ],
      "metadata": {
        "id": "nCsm7mIqtjkf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Qk4OWU5Qt4bR",
        "outputId": "befac956-e221-4394-a978-32b4110d6e6d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'name': 'John', 'age': 30, 'city': 'New York'}"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "json.dumps(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "E1l8PJv9t7d6",
        "outputId": "883edee8-f9e1-45f5-d352-51315fe0d839"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'{\"name\": \"John\", \"age\": 30, \"city\": \"New York\"}'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Use the indent parameter to define the numbers of indents:\n",
        "\n",
        "json.dumps(x, indent=4)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "YRl-pRLEtmIX",
        "outputId": "c162b7ca-2d89-449e-bb95-d813b6fc9a14"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'{\\n    \"name\": \"John\",\\n    \"age\": 30,\\n    \"city\": \"New York\"\\n}'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "You can also define the separators, default value is (\", \", \": \"), which means using a comma and a space to separate each object, and a colon and a space to separate keys from values:"
      ],
      "metadata": {
        "id": "wvuanzV7tpaq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Use the separators parameter to change the default separator:\n",
        "\n",
        "json.dumps(x, indent=4, separators=(\". \", \" = \"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "lQVBBah2tr0t",
        "outputId": "fc580ac1-d4a9-40f8-d5fc-6bc3ae34216d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'{\\n    \"name\" = \"John\". \\n    \"age\" = 30. \\n    \"city\" = \"New York\"\\n}'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The json.dumps() method has parameters to order the keys in the result:"
      ],
      "metadata": {
        "id": "B_GWbbIitur4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Use the sort_keys parameter to specify if the result should be sorted or not:\n",
        "\n",
        "json.dumps(x, indent=4, sort_keys=True)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "lAKCVEYatvQd",
        "outputId": "23737795-3507-449d-85be-1c65d011ab59"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'{\\n    \"age\": 30,\\n    \"city\": \"New York\",\\n    \"name\": \"John\"\\n}'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "xYgSU0kLLVpj"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Python Try Except**"
      ],
      "metadata": {
        "id": "dmBNkxR6LWo5"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* The **try** block lets you test a block of code for errors.\n",
        "\n",
        "* The **except** block lets you handle the error.\n",
        "\n",
        "* The **else** block lets you execute code when there is no error.\n",
        "\n",
        "* The **finally** block lets you execute code, regardless of the result of the try- and except blocks."
      ],
      "metadata": {
        "id": "1R9WErheLZVB"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Exception Handling**\n",
        "\n",
        "When an error occurs, or exception as we call it, Python will normally stop and generate an error message.\n",
        "\n",
        "These exceptions can be handled using the try statement:"
      ],
      "metadata": {
        "id": "qseEIdCaLkdb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "try:\n",
        "  print(x)\n",
        "except:\n",
        "  print(\"An exception occurred\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EXskxUuHLnZX",
        "outputId": "bf2cce9e-78c0-494e-c3fe-82a9aa52b0f7"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "An exception occurred\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Since the try block raises an error, the except block will be executed.\n",
        "\n",
        "Without the try block, the program will crash and raise an error:"
      ],
      "metadata": {
        "id": "f6_tyb4pLutz"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Many Exceptions**\n",
        "You can define as many exception blocks as you want, e.g. if you want to execute a special block of code for a special kind of error:"
      ],
      "metadata": {
        "id": "27cehknlL-Je"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 146
        },
        "id": "WxF_0uOXMUqp",
        "outputId": "f9fa6290-0b47-4093-cc44-bb3f7ab21d57"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "name 'x' is not defined",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-4-fc17d851ef81>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m: name 'x' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "try:\n",
        "  print(x)\n",
        "except NameError:\n",
        "  print(\"Variable x is not defined\")\n",
        "except:\n",
        "  print(\"Something else went wrong\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "voEyovUOL_2Y",
        "outputId": "7ffa8dbb-48b8-446e-adae-e64dcb2fe359"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Variable x is not defined\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Else**\n",
        "You can use the else keyword to define a block of code to be executed if no errors were raised:"
      ],
      "metadata": {
        "id": "5pu0REPXMhB6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "try:\n",
        "  print(\"Hello\")\n",
        "except:\n",
        "  print(\"Something went wrong\")\n",
        "else:\n",
        "  print(\"Nothing went wrong\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nGobdQ5fMjAh",
        "outputId": "100de134-343d-4999-8a6e-fe8c68d8ce69"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello\n",
            "Nothing went wrong\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Finally**\n",
        "The finally block, if specified, will be executed regardless if the try block raises an error or not."
      ],
      "metadata": {
        "id": "2Oln1prqMpZa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "try:\n",
        "  print(x)\n",
        "except:\n",
        "  print(\"Something went wrong\")\n",
        "finally:\n",
        "  print(\"The 'try except' is finished\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oteh9r6kMqyt",
        "outputId": "9134ba4d-4856-4372-81e4-5c0c2c75bf62"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Something went wrong\n",
            "The 'try except' is finished\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "try:\n",
        "  f = open(\"demofile.txt\")\n",
        "  try:\n",
        "    f.write(\"Lorum Ipsum\")\n",
        "  except:\n",
        "    print(\"Something went wrong when writing to the file\")\n",
        "  finally:\n",
        "    f.close()\n",
        "except:\n",
        "  print(\"Something went wrong when opening the file\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "y7ETGxEvMuWy",
        "outputId": "7db001e9-7106-42b4-a8d5-ad39d56ed5ff"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Something went wrong when opening the file\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Raise an exception**\n",
        "As a Python developer you can choose to throw an exception if a condition occurs.\n",
        "\n",
        "To throw (or raise) an exception, use the raise keyword."
      ],
      "metadata": {
        "id": "zzy2JCr2MyN7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = -1\n",
        "\n",
        "if x < 0:\n",
        "  raise Exception(\"Sorry, no numbers below zero\")"
      ],
      "metadata": {
        "id": "pGYY-l_lM1E9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "The raise keyword is used to raise an exception.\n",
        "\n",
        "You can define what kind of error to raise, and the text to print to the user."
      ],
      "metadata": {
        "id": "GzUpEw1hNAwv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = \"hello\"\n",
        "\n",
        "if not type(x) is int:\n",
        "  raise TypeError(\"Only integers are allowed\")"
      ],
      "metadata": {
        "id": "oFPxbYhYNDzp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "1rdTBHUwN-Fy"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Python File Open**"
      ],
      "metadata": {
        "id": "yeCqA2t0N-pS"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "File handling is an important part of any web application.\n",
        "\n",
        "Python has several functions for creating, reading, updating, and deleting files."
      ],
      "metadata": {
        "id": "_A53RrYhOBTM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **File Handling**\n",
        "\n",
        "* The key function for working with files in Python is the open() function.\n",
        "\n",
        "* The open() function takes two parameters; filename, and mode.\n",
        "\n",
        "* There are four different methods (modes) for opening a file:"
      ],
      "metadata": {
        "id": "OFePiQ_uOC9d"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![image.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "dhQ2SddaONk0"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![image.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "N2mgPLl5OQ_k"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Syntax**\n",
        "To open a file for reading it is enough to specify the name of the file:"
      ],
      "metadata": {
        "id": "5PskDG-MOVs7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "f = open(\"demofile.txt\")"
      ],
      "metadata": {
        "id": "4AoS4hDhOZpN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "f = open(\"demofile.txt\", \"rt\")"
      ],
      "metadata": {
        "id": "Hkw0ks55Oc0L"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}