Training_Basics_of_Python.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EZXUX76P88Hz"
      },
      "source": [
        "This is a hands on tutorial for python (3). This tutorial designed for beginners with examples of basic and most frequently used python practices. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9jizU6zs0xOy"
      },
      "source": [
        "**What is Programming?**\n",
        "\n",
        "Programming is a way to “instruct the computer to perform various tasks”.\n",
        "\n",
        "\n",
        "**What is Programming Language?**\n",
        "\n",
        "A programming language provides a way for a programmer to express a task so that it could be understood and executed by a computer.\n",
        "\n",
        "Ex: Python, C, C++, Java, etc."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iPYvgrig96Qd"
      },
      "source": [
        "**Introduction to python**\n",
        "\n",
        "Python is an interpreted, interactive, object-oriented, high-level programming language. \n",
        "\n",
        "It was created by Guido van Rossum during 1985- 1990\n",
        "\n",
        "**Why to Learn Python**\n",
        "\n",
        "- Easy to understand and program\n",
        "- Easy to maintain\n",
        "- Standard libraries and frameworks\n",
        "- Versatility\n",
        "- Large community\n",
        "- High demand\n",
        "\n",
        "The official and detailed documentation to python (3) is found here <a href=\"docs.python.org/3/\">Documentation</a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F0XEqnst-HlH"
      },
      "source": [
        "**What is colab?**\n",
        "\n",
        "Colabaratory, simply colab, and *google colab* after hosted by google\n",
        "\n",
        "Cloud-based interactive development environment that allows you to write, execute, and share Python code in a web browser\n",
        "\n",
        "Can save the notebooks to Google drive.\n",
        "\n",
        "Free access to computing resources such as CPU(Central Processing Unit) , GPU(Graphics Processing Unit), and TPU(Tensor Processing Unit) for running code\n",
        "\n",
        "Can upload and download data to colab from our local systems and also can mount the google drive account as a file system.\n",
        "\n",
        "Pre-installed python libraries and tools\n",
        "\n",
        "sign in: https://colab.research.google.com\n",
        "\n",
        "overview: https://colab.research.google.com/notebooks/basic_features_overview.ipynb#scrollTo=Id6tDF1HQSHD\n",
        "\n",
        "**More about colab**\n",
        "\n",
        "Colab has two types of cells: text and code. \n",
        "\n",
        "Text cells are formatted using a simple **markup language** called Markdown\n",
        "\n",
        "markdown guide: https://colab.research.google.com/notebooks/markdown_guide.ipynb\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kzLN2NiU9lk5"
      },
      "source": [
        "# **LET'S GET STARTED**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##**Python Version**"
      ],
      "metadata": {
        "id": "Zn4NHqgDuowv"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dG_VZRZ_9kVO",
        "outputId": "b2f1b585-58f1-488b-940e-1919d8f12dd4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "!python --version  #command to check python version"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Python 3.9.16\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##**Print Function**\n"
      ],
      "metadata": {
        "id": "9xCVVYRkuyn_"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h9CQ4r5U8tN1",
        "outputId": "474da26e-5dbd-4e45-b428-3114691594a0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "print(\"hello world\")  # built-in function that is used to display output"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "hello world\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lH5jHrKm-QqT",
        "outputId": "01937f34-bf1e-469c-c41e-a32efe5e28ad",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "name = input(\"What is your name?\")\n",
        "print(\"Welcome\", name)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "What is your name?rabina\n",
            "Welcome rabina\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        " # Different way to print a message\n",
        " name = \"Rabina\"\n",
        " country=\"Nepal\"\n",
        " print(\"Welcome\", name, \"from\", country, '!') # multiple arguments, separated by commas, Each argument is printed to the console with a space between them\n",
        " print(f\"Welcome {name} from {country}!\") #using f-string, variables are embeded directly into a string using {},  more concise and readable way\n",
        " print((\"Welcome \"+name+ \" from \"+ country+ '!'))  # string concatenation using '+' operator\n",
        " print(\"Welcome {} from {}!\".format(name,country)) # using placholders\n",
        " print(\"Welcome {0} from {1}!\".format(name,country)) # using placholders with argument indexing\n",
        " print(\"Welcome {1} from {0}!\".format(name,country))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KjYhUMHMvMYw",
        "outputId": "f7bca89a-ce15-455b-c7f7-a233fe7a7b2f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Welcome Rabina from Nepal !\n",
            "Welcome Rabina from Nepal!\n",
            "Welcome Rabina from Nepal!\n",
            "Welcome Rabina from Nepal!\n",
            "Welcome Rabina from Nepal!\n",
            "Welcome Nepal from Rabina!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1lKQBOqeANw9"
      },
      "source": [
        "##**Comments**\n",
        " \n",
        "Comment is a text that are ignored during the execution  and used to explain the code or provide additional information to the programmer.\n",
        "\n",
        "**Two ways to write comments in Python**\n",
        "1. Single-line comments\n",
        "2. Multi-line comments"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-VOiIpxSANKr",
        "outputId": "4980bfc9-19d5-453b-b9d4-6914d84176a4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        " \n",
        "# This is a single line comment \n",
        "# This is also a single line comment\n",
        "\n",
        "'''\n",
        "This is a multi-line comments\n",
        "This spans multiple lines.\n",
        "It is enclosed in triple quotes.\n",
        "'''\n",
        "\n",
        "print(\"Above comments won't display in the system output\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Above comments won't display in the system output\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##**Indentation**\n",
        "Indentation refers to the spaces at the beginning of a code line\n",
        "\n",
        "It is used to indicate blocks of code. \n",
        "\n",
        "It is an important aspect of the language's syntax and is used to define the scope of control statements, functions, loops, and classes.\n",
        "\n",
        "The Python language uses whitespace to define block boundaries, which means that code within the same block must be indented to the same level"
      ],
      "metadata": {
        "id": "awmIsCvq4WQR"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yGOxZ_292_y3"
      },
      "source": [
        "##**Identifiers**\n",
        "\n",
        "Identifier is a name given to a variable, function, class, module, or other object in a program.\n",
        "\n",
        "In Python, identifiers must follow following rules:\n",
        "\n",
        "Rule 1:They can only contain letters(A-Z, a-z), digits(0 to 9), and underscores (_).\n",
        "\n",
        "Rule 2: They cannot start with a digit.\n",
        "\n",
        "Rule 3: They are case sensitive\n",
        "\n",
        "Rule 4: They cannot be a reserved keyword, such as \"if\", \"else\", \"while\", etc.\n",
        "\n",
        "Rule 4: You can not use special character such as  ‘.’, ‘!’, ‘@’, ‘#’, ‘$’, ‘%’ etc.\n",
        "\n",
        "Rule 6: The identifier can be of any length.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ic_00l2l7xK5",
        "outputId": "ae53a6af-d1d4-46f7-9ea7-ca5f5217ad55",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "a = \"sriram\"\n",
        "A = 2\n",
        "\n",
        "print(a, A)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "sriram 2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jtaTnWJftRqZ"
      },
      "source": [
        "##**Keywords**\n",
        "\n",
        "Keywords are pre-defined and reserved words that have special meaning.\n",
        "\n",
        "Keywords help in defining the syntax. \n",
        "\n",
        "They cannot used as identifier, variable,constants, function or any other names.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hxEjjbYJ6Rcl",
        "outputId": "4f1f7cf0-2196-48a4-b9a6-17e61125c3b7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "import keyword\n",
        "\n",
        "print(keyword.kwlist)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aIGOH2Wes2-X"
      },
      "source": [
        "##**Variables**\n",
        "\n",
        "A variable is a name given to a memory location. It is the basic unit of storage in a program.\n",
        "\n",
        "When you created a variable, you reserve some memory space\n",
        "\n",
        "A variable is created (if not created earlier in the program) the moment we first assign a value to it. \n",
        "\n",
        "Variables can hold different types of data such as integers, floating-point numbers, strings, and objects.\n",
        "\n",
        "The value stored in a variable can be changed during program execution.\n",
        "\n",
        "Variables in python are case-sensitive.\n",
        "\n",
        "Variables do not need explicit declaration"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7pdSOWUEtJiR"
      },
      "source": [
        "# **DATA TYPES**\n",
        "\n",
        "Data can be any kind information that can be formated and provided in system readable way.\n",
        "\n",
        "The basic data types in python are, numbers (integer and float), booleans (True and Flase), containers (lists, dictionaries, sets, and tuples)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vC24CEHvtPmn"
      },
      "source": [
        "##**Numbers**\n",
        "\n",
        "Used to store numeric data\n",
        "\n",
        "Three types of numeric data: int,long, float,complex\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rFc3CU4aAFQ_"
      },
      "source": [
        "x = 3 # x is an integer now\n",
        "print(x, type(x))\n",
        "\n",
        "\n",
        "y = 4.5 # y is a float\n",
        "print(y, type(y))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I0GhWRhYtnWM"
      },
      "source": [
        "##**Booleans**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nu_2dv_3tpAU",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "377ce44c-b8d7-40d9-c30e-e8583885b55f"
      },
      "source": [
        "a = True\n",
        "b = False\n",
        "\n",
        "print(a, type(a))\n",
        "print(b, type(b))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True <class 'bool'>\n",
            "False <class 'bool'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3Il0N-M6t-Sh"
      },
      "source": [
        "##**Strings**\n",
        "\n",
        "Used to store sequence of characters.\n",
        "\n",
        "Enclosed in either single quotes ('...') or double quotes (\"...\")"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SgOP7ijbuLgu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "73f90726-2d81-40fb-b094-8bc32e6e36d3"
      },
      "source": [
        "# ''\n",
        "# \"\"\n",
        "\n",
        "firstname = 'Jaqen' # a-z, A-Z, 0-9, and @#$$%^&*.\n",
        "print(type(firstname), firstname)\n",
        "\n",
        "secondname = 'Hgar'\n",
        "print(type(secondname), secondname)\n",
        "\n",
        "print(\"doesn't\")  #'doesn\\'t'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'str'> Jaqen\n",
            "<class 'str'> Hgar\n",
            "doesn't\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dmCknnbNtEub",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f788cc42-3f03-423c-d65e-8e881d1c101c"
      },
      "source": [
        "#string concatenation\n",
        "fullname = firstname+' '+secondname\n",
        "print(fullname, len(fullname), type(fullname))\n",
        "\n",
        "print('<' + 'word '*5 + '>')\n",
        "print('Rabina''Twayana')  #automatically concatenated\n",
        "\n",
        "#What is the last index of fullname?"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Jaqen Hgar 10 <class 'str'>\n",
            "<word word word word word >\n",
            "RabinaTwayana\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**String slicing** (sub-string)\n",
        "\n",
        "syntax string: [start_index:end_index:step]\n",
        "\n",
        "start_index: index of the first character to be included\n",
        "\n",
        "end_index: index of the first character to be excluded\n",
        "\n",
        "step is an optional argument that specifies the increment between the characters"
      ],
      "metadata": {
        "id": "TZY5HU0LGLcR"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6_KxRCKouQQP",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0daf97f7-8b16-40aa-d069-90d48a1dfb76"
      },
      "source": [
        "x = \"UNIVERSIRY\"\n",
        "\n",
        "print(x)\n",
        "print(x[0])\n",
        "print(x[0:len(x):2])\n",
        "print(x[:len(x)])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "UNIVERSIRY\n",
            "U\n",
            "UIESR\n",
            "UNIVERSIRY\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#negative indices\n",
        "x = \"negative\"\n",
        "\n",
        "x[4:1:-1]  #slice is taken in reverse order\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "NvWECejgHLne",
        "outputId": "f41537c0-15a6-4af5-bf9e-b2eaf562c054"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'tag'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Strings are immutable\n",
        "word=\"HelpA\"\n",
        "#word[4]=\"B\" #not valid\n",
        "word2=word[:len(word)-1]+\"B\" #slices can help\n",
        "print(word2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EM6xoJRAMPIV",
        "outputId": "12d327ca-48f5-40d0-8f75-1d8481a9c2cc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n",
            "HelpB\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#string methods\n",
        "myCourse =\"Python Programming\"\n",
        "i_count=myCourse.count(\"m\") # count occurrences\n",
        "print(i_count,\"icount\")\n",
        "\n",
        "print(myCourse.find(\"pro\")) # returns first index\n",
        "\n",
        "print(myCourse.replace(\"programming\",\"course\"))\n",
        "\n",
        "print(myCourse.upper())\n",
        "\n",
        "print(myCourse.lower())\n",
        "print(myCourse.title())\n",
        "\n",
        "print(myCourse.swapcase())\n",
        "print(myCourse.startswith('Py'))\n",
        "print(myCourse.endswith('ing'))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "unHN5AJPNoNe",
        "outputId": "6f614980-3ef5-4272-e975-2856c4423118"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2 icount\n",
            "-1\n",
            "Python Programming\n",
            "PYTHON PROGRAMMING\n",
            "python programming\n",
            "Python Programming\n",
            "pYTHON pROGRAMMING\n",
            "True\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QrJ-TBDPMf3Q"
      },
      "source": [
        "##**Type casting** (converting data type)\n",
        "\n",
        "Changing the data type of a variable from one type to another"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a = 1\n",
        "\n",
        "a = float(a) # Converts a string or integer to a float.\n",
        "\n",
        "print(a, type(a))\n",
        "\n",
        "b = int(45.011) #Converts a string or float to an integer and result in data loss\n",
        "print(b, type(b))\n",
        "\n",
        "c=str(50)\n",
        "print(c, type(c))\n",
        "\n"
      ],
      "metadata": {
        "id": "y5nlZijFr-uz",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d70296ce-c910-4e6b-9558-82ce8fe21262"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1.0 <class 'float'>\n",
            "45 <class 'int'>\n",
            "50 <class 'str'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5bVntGZKPRLe"
      },
      "source": [
        "#**OPERATORS**\n",
        "\n",
        "Operators are used to perform operations on variables and values.\n",
        "Python divides the operators in the following groups:\n",
        "\n",
        "<ul>\n",
        "<li>Arithmetic operators</li>\n",
        "<li>Assignment operators</li>\n",
        "<li>Comparison operators</li>\n",
        "<li>Logical operators</li>\n",
        "<li>Identity operators</li>\n",
        "<li>Membership operators</li>\n",
        "<li>Bitwise operators</li>\n",
        "</ul>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HAfVXcucEbot"
      },
      "source": [
        "##**Arithmetic operators**\n",
        "\n",
        "Perform mathematical operations on numerical values\n",
        "\n",
        "\n",
        "<table class=\"ws-table-all notranslate\">\n",
        "<tbody><tr>\n",
        "<th style=\"width:25%\">Operator</th>\n",
        "<th style=\"width:35%\">Name</th>\n",
        "<th style=\"width:30%\">Example</th>\n",
        "</tr>\n",
        "<tr>\n",
        "<td>+</td>\n",
        "<td>Addition</td>\n",
        "<td>x + y</td>\n",
        "</tr>\n",
        "<tr>\n",
        "<td>-</td>\n",
        "<td>Subtraction</td>\n",
        "<td>x - y</td>\n",
        "</tr>\n",
        "<tr>\n",
        "<td>*</td>\n",
        "<td>Multiplication</td>\n",
        "<td>x * y</td>\n",
        "</tr>\n",
        "<tr>\n",
        "<td>/</td>\n",
        "<td>Division</td>\n",
        "<td>x / y</td>\n",
        "</tr>\n",
        "<tr>\n",
        "<td>%</td>\n",
        "<td>Modulus</td>\n",
        "<td>x % y</td>\n",
        "</tr>\n",
        "  <tr>\n",
        "<td>**</td>\n",
        "<td>Exponentiation</td>\n",
        "<td>x ** y</td>\n",
        "  </tr>\n",
        "<tr>\n",
        "<td>//</td>\n",
        "<td>Floor division</td>\n",
        "<td>x // y</td>\n",
        "</tr>\n",
        "</tbody></table>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZxQ4M8L-Ea__",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8fff80a3-40d0-40f4-ca18-6bf59d70a450"
      },
      "source": [
        "a = -21\n",
        "b = 10  #10.00 -10  implicit or automatic conversion of a value from one data type to another data type \n",
        "\n",
        "# Addition\n",
        "print (\"a + b : \", a + b)\n",
        "\n",
        "# Subtraction\n",
        "print (\"a - b : \", a - b)\n",
        "\n",
        "# Multiplication\n",
        "print (\"a * b : \", a * b)\n",
        "\n",
        "# Division\n",
        "print (\"a / b : \", a / b)\n",
        "\n",
        "# Modulus : returns the remainder (in case if negative )\n",
        "print (\"a % b : \", -21 % 10)\n",
        "\n",
        "# Exponentiation\n",
        "print (\"a ** b : \", a ** b)\n",
        "\n",
        "# Floor Division: returns the quotient rounded down to the nearest integer\n",
        "print (\"a // b : \", a // b)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "a + b :  -11\n",
            "a - b :  -31\n",
            "a * b :  -210\n",
            "a / b :  -2.1\n",
            "a % b :  9\n",
            "a ** b :  16679880978201\n",
            "a // b :  -3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ojcFv_tedwYR"
      },
      "source": [
        "##**Assignment operators(=)**\n",
        "\n",
        "Assign a value to a variable\n",
        "\n",
        "variable= expression\n",
        "\n",
        "Eg: addition assignment, bitwise AND, shift operator  etc\n",
        "\n",
        "<table class=\"ws-table-all notranslate\">\n",
        "<tbody><tr>\n",
        "<th style=\"width:25%\">Operator</th>\n",
        "<th style=\"width:20%\">Example</th>\n",
        "<th style=\"width:20%\">Same As</th>\n",
        "</tr>\n",
        "<tr>\n",
        "<td>=</td>\n",
        "<td>x = 5</td>\n",
        "<td>x = 5</td>\n",
        "</tr>\n",
        "  <tr>\n",
        "<td>+=</td>\n",
        "<td>x += 3</td>\n",
        "<td>x = x + 3</td>\n",
        "  </tr>\n",
        "  <tr>\n",
        "<td>-=</td>\n",
        "<td>x -= 3</td>\n",
        "<td>x = x - 3</td>\n",
        "  </tr>\n",
        "  <tr>\n",
        "<td>*=</td>\n",
        "<td>x *= 3</td>\n",
        "<td>x = x * 3</td>\n",
        "  </tr>\n",
        "  <tr>\n",
        "<td>/=</td>\n",
        "<td>x /= 3</td>\n",
        "<td>x = x / 3</td>\n",
        "  </tr>\n",
        "  <tr>\n",
        "<td>%=</td>\n",
        "<td>x %= 3</td>\n",
        "<td>x = x % 3</td>\n",
        "  </tr>\n",
        "  <tr>\n",
        "<td>//=</td>\n",
        "<td>x //= 3</td>\n",
        "<td>x = x // 3</td>\n",
        "  </tr>\n",
        "  <tr>\n",
        "<td>**=</td>\n",
        "<td>x **= 3</td>\n",
        "<td>x = x ** 3</td>\n",
        "  </tr>\n",
        "  <tr>\n",
        "<td>&amp;=</td>\n",
        "<td>x &amp;= 3</td>\n",
        "<td>x = x &amp; 3</td>\n",
        "  </tr>\n",
        "  <tr>\n",
        "<td>|=</td>\n",
        "<td>x |= 3</td>\n",
        "<td>x = x | 3</td>\n",
        "  </tr>\n",
        "<tr>\n",
        "<td>^=</td>\n",
        "<td>x ^= 3</td>\n",
        "<td>x = x ^ 3</td>\n",
        "</tr>\n",
        "</tbody></table>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x = 5\n",
        "\n",
        "x += 2\n",
        "\n",
        "print(x)"
      ],
      "metadata": {
        "id": "WPQ1IEklJQg1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5c75edac-4c10-472a-d516-64ec7ce27dbb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "7\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5JKFRcdAfLOP"
      },
      "source": [
        "##**Comparison Operators**\n",
        "\n",
        "Comparision of the values and result is boolean\n",
        "\n",
        "<table class=\"ws-table-all notranslate\">\n",
        "<tbody><tr>\n",
        "<th style=\"width:25%\">Operator</th>\n",
        "<th style=\"width:35%\">Name</th>\n",
        "<th style=\"width:30%\">Example</th>\n",
        "</tr>\n",
        "<tr>\n",
        "<td>==</td>\n",
        "<td>Equal</td>\n",
        "<td>x == y</td>\n",
        "</tr>\n",
        "<tr>\n",
        "<td>!=</td>\n",
        "<td>Not equal</td>\n",
        "<td>x != y</td>\n",
        "</tr>\n",
        "<tr>\n",
        "<td>&gt;</td>\n",
        "<td>Greater than</td>\n",
        "<td>x &gt; y</td>\n",
        "</tr>\n",
        "<tr>\n",
        "<td>&lt;</td>\n",
        "<td>Less than</td>\n",
        "<td>x &lt; y</td>\n",
        "</tr>\n",
        "  <tr>\n",
        "<td>&gt;=</td>\n",
        "<td>Greater than or equal to</td>\n",
        "<td>x &gt;= y</td>\n",
        "  </tr>\n",
        "<tr>\n",
        "<td>&lt;=</td>\n",
        "<td>Less than or equal to</td>\n",
        "<td>x &lt;= y</td>\n",
        "</tr>\n",
        "</tbody></table>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-l2WAZGrfYcq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9a527059-a481-4933-9032-5d4f47b1832b"
      },
      "source": [
        "# Try comparision operators\n",
        "a = 4\n",
        "c=4\n",
        "b = a<3\n",
        "\n",
        "print(b)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "shyuMrP5fbgE"
      },
      "source": [
        "##**Logical operators**\n",
        "\n",
        "Combines multiple Boolean expressions and evaluate them as a single boolean result\n",
        "\n",
        "<table class=\"ws-table-all notranslate\">\n",
        "<tbody><tr>\n",
        "<th style=\"width:25%\">Operator</th>\n",
        "<th style=\"width:35%\">Description</th>\n",
        "<th style=\"width:30%\">Example</th>\n",
        "</tr>\n",
        "<tr>\n",
        "<td>and&nbsp;</td>\n",
        "<td>Returns True if both statements are true</td>\n",
        "<td>x &lt; 5 and&nbsp; x &lt; 10</td>\n",
        "</tr>\n",
        "<tr>\n",
        "<td>or</td>\n",
        "<td>Returns True if one of the statements is true</td>\n",
        "<td>x &lt; 5 or x &lt; 4</td>\n",
        "</tr>\n",
        "<tr>\n",
        "<td>not</td>\n",
        "<td>Reverse the result, returns False if the result is true</td>\n",
        "<td>not(x &lt; 5 and x &lt; 10)</td>\n",
        "</tr>\n",
        "</tbody></table>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x = 5\n",
        "\n",
        "print (not(x%2==1 and x > 2))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Fw30u4ED5bS7",
        "outputId": "6b633487-3a9f-4f6b-a400-5af6e566726a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JDdMvXWmFqE7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "211146bd-df6e-4d14-957a-ef015ddba5c9"
      },
      "source": [
        "# we can build logic gates using boolean variables\n",
        "a = True\n",
        "b = False\n",
        "\n",
        "print(a and b)  # False\n",
        "print(a or b) # True\n",
        "print(not b) # False\n",
        "# print(a == b) # False\n",
        "# print(a != b) # True"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False\n",
            "True\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3tXOtA7UfrBU"
      },
      "source": [
        "##**Identity Operators**\n",
        "\n",
        "Compares the memory location of two objects.\n",
        "\n",
        "<table class=\"ws-table-all notranslate\">\n",
        "<tbody><tr>\n",
        "<th style=\"width:25%\">Operator</th>\n",
        "<th style=\"width:35%\">Description</th>\n",
        "<th style=\"width:30%\">Example</th>\n",
        "</tr>\n",
        "<tr>\n",
        "<td>is&nbsp;</td>\n",
        "<td>Returns True if both variables points to the same object in memory</td>\n",
        "<td>x is y</td>\n",
        "</tr>\n",
        "<tr>\n",
        "<td>is not</td>\n",
        "<td>Returns True if both variables do not point to the same object in memory</td>\n",
        "<td>x is not y</td>\n",
        "</tr>\n",
        "</tbody></table>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x = [1, 2, 3]\n",
        "y = [1, 2, 3]\n",
        "z = x\n",
        "\n",
        "print(x is y)       # Output: False\n",
        "print(x is z)       # Output: True\n",
        "print(x is not y)   # Output: True\n",
        "print(x is not z)   # Output: False\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "W6Gr4oAzk00V",
        "outputId": "0d64c744-ebe2-44c6-8af4-3d0aa616a651"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False\n",
            "True\n",
            "True\n",
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oOkKadDpgVV_"
      },
      "source": [
        "##**Bitwise Operators**\n",
        "\n",
        "Work on bits and performs bit by bit operation\n",
        "\n",
        "Each operand(decimal values) is converted into its binary representation, then  bits are compared and combined based on the operator used\n",
        "\n",
        "<table class=\"ws-table-all notranslate\">\n",
        "<tbody><tr>\n",
        "<th style=\"width:10%\">Operator</th>\n",
        "<th style=\"width:15%\">Name</th>\n",
        "<th style=\"width:75%\">Description</th>\n",
        "</tr>\n",
        "  <tr>\n",
        "<td>&amp;&nbsp;</td>\n",
        "<td>AND</td>\n",
        "<td>Sets each bit to 1 if both bits are 1</td>\n",
        "  </tr>\n",
        "  <tr>\n",
        "<td>|</td>\n",
        "<td>OR</td>\n",
        "<td>Sets each bit to 1 if one of two bits is 1</td>\n",
        "  </tr>\n",
        "  <tr>\n",
        "<td>&nbsp;^</td>\n",
        "<td>XOR</td>\n",
        "<td>Sets each bit to 1 if only one of two bits is 1</td>\n",
        "  </tr>\n",
        "<tr>\n",
        "<td>~&nbsp;</td>\n",
        "<td>NOT</td>\n",
        "<td>Inverts all the bits</td>\n",
        "</tr>\n",
        "<!-- <tr>\n",
        "<td>&lt;&lt;</td>\n",
        "<td>Zero fill left shift</td>\n",
        "<td>Shift left by pushing zeros in from the right and let the leftmost bits fall \n",
        "off</td>\n",
        "</tr>\n",
        "<tr>\n",
        "<td>&gt;&gt;</td>\n",
        "<td>Signed right shift</td>\n",
        "<td>Shift right by pushing copies of the leftmost bit in from the left, and let \n",
        "the rightmost bits fall off</td>\n",
        "</tr> -->\n",
        "</tbody></table>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1iARUjbqskUq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f9adc4bd-d447-4fe9-bea7-7a912f6a3c51"
      },
      "source": [
        "\n",
        "\n",
        "#10 >> 0000 1010\n",
        "#-10>> 1111 0101 +1 = 1111 0110 #to calculate bin value -of negative number\n",
        "\n",
        "a = 10 # 1010  \n",
        "b = 9  # 1001\n",
        "\n",
        "c = a & b #1000\n",
        "print(c)\n",
        "\n",
        "d = a | b # 1011\n",
        "print(d)\n",
        "\n",
        "e = a ^ b # 0011\n",
        "print(e)\n",
        "\n",
        "f = ~a # 11110101\n",
        "print(f)\n",
        "\n",
        "x = 10  # 0000 1010 \n",
        "y = -10 # 1111 0110\n",
        "\n",
        "# numbers\n",
        "\n",
        "#print(bin(10))\n",
        "#print(bin(-10 & 0xf))\n",
        "# print(10 and -10)\n",
        "# print(9 & -9)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "8\n",
            "11\n",
            "3\n",
            "-11\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#string formatting for binary representation\n",
        "a = 10\n",
        "print(\"{0:b}\".format(a))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aZI_dOFj96P5",
        "outputId": "228cc75d-20de-4bc4-8efc-bd374ebc7881"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1010\n",
            "-1011\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a = 123\n",
        "print(bin(10))\n",
        "print(bin(~10)) "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k9lCoBpUgQZA",
        "outputId": "4800cc62-ecfc-4718-fc62-09fce50bc628"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0b1010\n",
            "-0b1011\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w_19aODYf6iA"
      },
      "source": [
        "##**Membership operators**\n",
        "\n",
        "Test for the membership in a sequence such as string, list or tuples\n",
        "\n",
        "<table class=\"ws-table-all notranslate\">\n",
        "<tbody><tr>\n",
        "<th style=\"width:25%\">Operator</th>\n",
        "<th style=\"width:35%\">Description</th>\n",
        "<th style=\"width:30%\">Example</th>\n",
        "</tr>\n",
        "<tr>\n",
        "<td>in&nbsp;</td>\n",
        "<td>Returns True if it finds specified value in a given sequence </td>\n",
        "<td>x in y</td>\n",
        "</tr>\n",
        "<tr>\n",
        "<td>not in</td>\n",
        "<td>Returns True if specified value not present in a given sequence</td>\n",
        "<td>x not in y</td>\n",
        "</tr>\n",
        "</tbody></table>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a = [1,2]\n",
        "1 not in a"
      ],
      "metadata": {
        "id": "VDpKOzLDyVJb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9672a173-fb42-4f8f-ae36-c0a87fd8e3f7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "59UzsBM42lRi"
      },
      "source": [
        "#**EXERCISE**\n",
        "\n",
        "**Exercise 1**\n",
        "\n",
        "Write code to evaluate a equation : 2X^5 + 5X^4 + 4*X^2 + 14 at X = 15\n",
        "\n",
        "**Exercise 2**\n",
        "\n",
        "Create a simple code to input 3 strings and return string that concatenating those 3 inputs\n",
        "\n",
        "**Exercise 3**\n",
        "\n",
        "Create a simple code to input 2 values and return summation of those 2 values\n",
        "\n",
        "**Exercise 4**\n",
        "\n",
        "Create a simple code to input a radius of a circle and return the area and circumference of that circle\n",
        "\n",
        "**Exercise 5**\n",
        "\n",
        "Create a simple code to convert 24 hour clock to 12 hour clock. (No need to print AM, PM, just print hour in 12 hour clock)\n",
        "\n",
        "Example: input 16 output 4"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QvxcId-ouzey"
      },
      "source": [
        "#**CONTAINERS**\n",
        "\n",
        "*   Lists\n",
        "*   Sets\n",
        "*   Dictionaries\n",
        "*   Tuples"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z2SAqJdCQsEC"
      },
      "source": [
        "##**Lists**\n",
        "\n",
        "Lists are used to store colletion of items in a single variable.\n",
        "\n",
        "Lists are created by enclosing a comma-separated sequence of items square brackets.\n",
        "\n",
        "Lists are **mutable** and most versatile datatype"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "data_list=[]\n",
        "data_list2=list()\n",
        "a = [1, 2, 3.0, 'apple']\n",
        "\n",
        "print(a, len(a), type(a))\n"
      ],
      "metadata": {
        "id": "rrqsr7APu2QE",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 235
        },
        "outputId": "b06de5fd-a77f-462b-cfbc-0d46bcd52fc1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-2-c97af7486e44>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mdata_list\u001b[0m\u001b[0;34m=\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[0;32m----> 2\u001b[0;31m \u001b[0mdata_list2\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\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[1;32m      3\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3.0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'apple'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\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[0;31mTypeError\u001b[0m: list expected at most 1 argument, got 3"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a = [1, 1.0, 2, 0]\n",
        "#indexing in list\n",
        "print(a[0])\n",
        "print(a[-1])\n",
        "print(a[0:])\n",
        "\n",
        "#updating values in list\n",
        "a[0]=a[0]+1\n",
        "print(a)"
      ],
      "metadata": {
        "id": "Frd-sRl9vglz",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ec80402e-e89f-402c-85c9-e4606e58ab3a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "0\n",
            "[1, 1.0, 2, 0]\n",
            "[2, 1.0, 2, 0]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a = [1, 1.0, 2, 0]\n",
        "\n",
        "#built-in list methods \n",
        "a.sort()\n",
        "a.reverse() #reverse the elements of list\n",
        "\n",
        "a.append(\"ad\")  # add an item to the end of list\n",
        "\n",
        "a.remove(1)  # remove the first item from the list which matches the value\n",
        "\n",
        "a.pop()\n",
        "b=a.pop() #removes and returns the last element in the list\n",
        "c=a.pop(0) # removes first element \n",
        "\n",
        "a.extend([3,4]) #extend the list by appending all the items in the given list\n",
        "\n",
        "total_items=a.count(1) # return the number of times value appears in list\n",
        "\n",
        "max_value=max(a)\n",
        "\n",
        "print(max_value)\n",
        "\n"
      ],
      "metadata": {
        "id": "UQTpvCvxId5d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e4d50a59-1c61-47e5-9ba4-2a9941594e2f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J2sKWFqyTHVR"
      },
      "source": [
        "##**Tuples**\n",
        "\n",
        "Tuples are used to store multiple items in a single variable. \n",
        "\n",
        "A tuple is a collection which is **ordered** and **immutable**. \n",
        "\n",
        "Tuples are created by enclosing a comma-separated sequence of items in parentheses ((...)).\n",
        "\n",
        "It can be thought as read-only list"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oEsn-t5cSeJu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bbf2fced-4d32-42a0-ef40-798b39bd3774"
      },
      "source": [
        "t = (1,2,3.1,'abc')\n",
        "print(t, type(t))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(1, 2, 3.1, 'abc') <class 'tuple'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uCaMA4DgBdOm",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "25c97888-e87a-4124-b7c1-40820b978ded"
      },
      "source": [
        "# tuples allow duplicates\n",
        "t = (1,2,'a',1)\n",
        "print(t, type(t))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(1, 2, 'a', 1) <class 'tuple'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a = (1,2,3) #tuples allow indexing \n",
        "print(a[0:]) #allow slicing\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YbhR0sNlML0W",
        "outputId": "aac8137f-7ac9-494e-beb4-8aaf5f225e87"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(1, 2, 3)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a = (1,2) #tuples are immutable\n",
        "a.append(12)\n",
        "a[0]=11"
      ],
      "metadata": {
        "id": "SrZqW9DT3Q4x",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 200
        },
        "outputId": "c7cfe995-9f89-4f51-9592-ba700e245b10"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "AttributeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-4-f2f1fb631dcc>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m#tuples are immutable\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m12\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m11\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mAttributeError\u001b[0m: 'tuple' object has no attribute 'append'"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##**Sets**\n",
        "\n",
        "Sets are used to store collection of unique items in a single variable. \n",
        "\n",
        "A set is a collection which is **unordered**, **unchangeable**, and **unindexed**.\n",
        "\n",
        "Sets are created by enclosing a comma-separated sequence of items in curly braces ({...})."
      ],
      "metadata": {
        "id": "hx8AyoLANoYV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = set()\n",
        "print(a, type(a))"
      ],
      "metadata": {
        "id": "ZFwJ9ilSFM0v",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "de8a1265-9390-45b4-e71e-51f08d0db580"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "set() <class 'set'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a = {1,4,2,3,3}  #removes any duplicate elements and orders the remaining elements in an arbitrary order\n",
        "print(a)\n",
        "\n",
        "a.add(5) # add only if it is not present in set\n",
        "print(a, type(a), len(a))\n",
        "\n",
        "a.remove(3)\n",
        "print(a)"
      ],
      "metadata": {
        "id": "pStQcOaIFpES",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1caef559-3638-449a-80fd-a97477bd5811"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1, 2, 3, 4}\n",
            "{1, 2, 3, 4, 5} <class 'set'> 5\n",
            "{1, 2, 4, 5}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "x0aq47ygxBO9"
      },
      "source": [
        "# Task:\n",
        "# create a list or set called 'fruits'\n",
        "# check if 'banana' is in fruits\n",
        "\n",
        "# print(fruits)\n",
        "# print('dragon' in fruits)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fIjAG2vXQlte"
      },
      "source": [
        "##**Dictionaries**\n",
        "\n",
        "Dictionaries are used to store data in key:value pairs. \n",
        "\n",
        "A dictionary is a collection which is ordered*, changeable and do not allow duplicates.\n",
        "\n",
        "As of Python version 3.7, dictionaries are ordered. In Python 3.6 and earlier, dictionaries are unordered.\n",
        "\n",
        "Dictionaries are created by enclosing a comma-separated sequence of key-value pairs in curly braces ({key1: value1, key2: value2, ...}).\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "info={}\n",
        "b = {1: \"rabina\", 3: \"prakash\", 2: \"others\"}\n",
        "print(b, type(b))\n",
        "print(type(info))\n"
      ],
      "metadata": {
        "id": "5Pn3They0YvT",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ebb7c436-1d3c-475c-98e6-2d44f36ef3ff"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1: 'rabina', 3: 'prakash', 2: 'others'} <class 'dict'>\n",
            "<class 'dict'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "b[4] = \"new\"\n",
        "b"
      ],
      "metadata": {
        "id": "TjLOC95C06UP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8L3mk3IBRd2s",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f62a17a8-c15a-424c-8bc7-e282239573a4"
      },
      "source": [
        "d = {'1': '1233',\n",
        "     'Title': 'Mr.',\n",
        "     'age': 25,\n",
        "     'name': 'jaqen'\n",
        "     }\n",
        "\n",
        "print(d.get('mobile','NA'))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "NA\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Qzb6SA4fx0uY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ac4704ee-caca-4774-8219-315e68d5d16d"
      },
      "source": [
        "d['mobile'] = '123456789'  # dictionaries use a key to store value\n",
        "print(d.get('mobile', 'N/A'))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "123456789\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "del d['mobile'] #removing an item\n",
        "print(d)\n",
        "del d #delete dictionary\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RH7bf-RR93lW",
        "outputId": "bbbf82c4-7701-4e48-948a-9d949114f939"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'1': '1233', 'Title': 'Mr.', 'age': 25, 'name': 'jaqen'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Dictionary Methods\n",
        "\n",
        "print(d.keys()) # returns a list of keys\n",
        "print(d.values())\n",
        "print(d.items())  #returns the key:value pairs as a list of tuples: [(key, value),(key, value), ...]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZH1SxpxR8tVp",
        "outputId": "8a88da73-c029-422e-c303-9184f5dc2761"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "dict_keys(['1', 'Title', 'age', 'name', 'mobile'])\n",
            "dict_values(['1233', 'Mr.', 25, 'jaqen', '123456789'])\n",
            "dict_items([('1', '1233'), ('Title', 'Mr.'), ('age', 25), ('name', 'jaqen'), ('mobile', '123456789')])\n",
            "1\n",
            "Title\n",
            "age\n",
            "name\n",
            "mobile\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LfI3nuXcz_UK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "56b0e7a3-129d-498e-b5e5-e660154a6da5"
      },
      "source": [
        "#Summary\n",
        "list = [1,2,'sriram', 8, 9, 8]\n",
        "print(list, type(list))\n",
        "\n",
        "set = {1,2,'sriram', 8, 9, 8}\n",
        "print(set, type(set))\n",
        "\n",
        "tuple = (1,2,'sriram', 8, 9, 8)\n",
        "print(tuple, type(tuple))\n",
        "\n",
        "dict = {\"a\":1, \"b\":2}\n",
        "print(dict, type(dict))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 'sriram', 8, 9, 8] <class 'list'>\n",
            "{1, 2, 8, 9, 'sriram'} <class 'set'>\n",
            "(1, 2, 'sriram', 8, 9, 8) <class 'tuple'>\n",
            "{'a': 1, 'b': 2} <class 'dict'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e2VkTogbPN_3"
      },
      "source": [
        "# **Control flow**\n",
        "\n",
        "Statements are executed or skipped under certain conditions \n",
        "\n",
        "*   'if' statements \n",
        "*   'while' loops\n",
        "*   'for' loop"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#'if' statemnet is used to execute a block of code if a certain condition is true\n",
        "if 0==0:\n",
        "  print(\"this is zero\")"
      ],
      "metadata": {
        "id": "f1bHZ9nrD6Fz",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cef4611e-5112-4f47-ba65-3446861a9b97"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "this is zero\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a = 17\n",
        "if a%2 == 0:\n",
        "  print(\"Divisible by 2\")\n",
        "elif a%3 == 0:\n",
        "  print(\"Divisible by 3\")\n",
        "else:\n",
        "  print(\"Not divisibe by 2 or 3\")\n"
      ],
      "metadata": {
        "id": "Xm5hAmE3BeI_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "593ae3e2-e5dd-4bdd-e015-30d3a1b2b15f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Not divisibe by 2 or 3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4_ndd6domsuf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a71aeab8-513e-47ff-83b6-a8fedd484924"
      },
      "source": [
        "x=30\n",
        "y=30\n",
        "\n",
        "if y > x:\n",
        "  print(\"y is greater than x\")\n",
        "elif y < x:\n",
        "  print(\"x is greater than y\")\n",
        "else:\n",
        "  print(\" x and y are equal\")\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            " x and y are equal\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oZ_bACBer-Jn",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2b68c4d5-62a5-4f54-cca8-6c87d99b83c5"
      },
      "source": [
        "# while loop is used to execute a block of code as long as a condition is true\n",
        "\n",
        "# syntax:\n",
        "\n",
        "# while (condition):\n",
        "#     statement\n",
        "\n",
        "x = 1\n",
        "while x < 10:\n",
        "  print(x)\n",
        "  x += 1   #x=x+1\n",
        "else:\n",
        "  print(\"finished\")\n",
        "  print(x)\n",
        "\n",
        "print(\"done\")\n"
      ],
      "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",
            "finished\n",
            "10\n",
            "done\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Loop controls statements\n",
        "#break: Terminates the loop statement \n",
        "#continue: skip the remainder of its body and immediately retest its condition prior to reiterating\n",
        "#pass:if you do not want any command or code to execute\n",
        "\n",
        "a = 1\n",
        "while a <= 10:\n",
        "  print(a,\"before\")\n",
        "  a=a+1\n",
        "  if a == 7:\n",
        "    break  \n",
        "  if a == 5:\n",
        "    continue\n",
        "  print(a,\"after\")\n",
        "  # else:\n",
        "  #   a+=1\n",
        "  #   print(a)"
      ],
      "metadata": {
        "id": "imDoAgCZPdF4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d748f66b-6a97-43a1-a8d4-bc9dff345268"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1 before\n",
            "2 after\n",
            "2 before\n",
            "3 after\n",
            "3 before\n",
            "4 after\n",
            "4 before\n",
            "5 before\n",
            "6 after\n",
            "6 before\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_dQ7ZF_S8Q3W",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "71263326-6a07-413a-da73-d4f2cd3899bb"
      },
      "source": [
        "#multiplication table using while loop\n",
        "a = 2\n",
        "b = 1\n",
        "\n",
        "while b <= 10:\n",
        "  # print(\"iteration no:\", b)\n",
        "  print(a, '*', b, '=', a*b)\n",
        "  b += 1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2 * 1 = 2\n",
            "2 * 2 = 4\n",
            "2 * 3 = 6\n",
            "2 * 4 = 8\n",
            "2 * 5 = 10\n",
            "2 * 6 = 12\n",
            "2 * 7 = 14\n",
            "2 * 8 = 16\n",
            "2 * 9 = 18\n",
            "2 * 10 = 20\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_p-X5K1Stjxj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e700f4ee-e116-4976-8f69-c68b34f2138e"
      },
      "source": [
        "# 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",
        "# fruits = ['apple', 'banana', 'pineapple']\n",
        "# fruits = ('apple', 'banana', 'pineapple')\n",
        "fruits = {'apple', 'banana', 'pineapple',\"apple\"}\n",
        "\n",
        "for fruit in fruits:\n",
        "  print(fruit)\n",
        "  # if fruit == 'banana':\n",
        "  #   # pass\n",
        "  #   # break\n",
        "  #   continue\n",
        "  #   # print(fruit)\n",
        "  # else:\n",
        "  #   print(fruit)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "apple\n",
            "banana\n",
            "pineapple\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "fruits_dict = {1:\"apple\", 2:\"banana\", 3:\"mango\"}\n",
        "# for key in fruits_dict.keys():\n",
        "#   print(key)\n",
        "# for value in fruits_dict.values():\n",
        "#   print(value)\n",
        "for fruit in fruits_dict.items():\n",
        "  print(fruit)\n",
        "  print(fruit[0],fruit[1])\n"
      ],
      "metadata": {
        "id": "2Ia9NGFjHhJt",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "47358a4c-4138-4a8d-b759-0927b0dfeb95"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(1, 'apple')\n",
            "1 apple\n",
            "(2, 'banana')\n",
            "2 banana\n",
            "(3, 'mango')\n",
            "3 mango\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for letter in \"UNIVERSITY\":\n",
        "  print(letter)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "h_PEEbQ-ah84",
        "outputId": "b3878d64-7308-4247-ac4b-dad85e3665eb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "U\n",
            "N\n",
            "I\n",
            "V\n",
            "E\n",
            "R\n",
            "S\n",
            "I\n",
            "T\n",
            "Y\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a=[]\n",
        "for i in range(1,20,2):  #(range(start index,stop index,step))\n",
        "  a.append(i)\n",
        "print(\"a:\",a)\n",
        "\n",
        "# b = [i*2 for i in range(10)] #list comprehension\n",
        "# print(\"b:\", b)\n",
        "\n"
      ],
      "metadata": {
        "id": "K6BmZtM190YZ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "635d2759-91a4-4c62-f70c-e0319b8628f4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "a: [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qpuYU0_hTcI-"
      },
      "source": [
        "# **Functions**\n",
        "\n",
        "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."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QoNkQXnbTbxy",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "464fcf93-affd-423b-9777-7220e08d72fc"
      },
      "source": [
        "def num(a=2,b=2):  #'def' keyword and 'return' statement\n",
        "  # a = 1\n",
        "  val = a*b\n",
        "  return val\n",
        "\n",
        "output=num()\n",
        "print(output)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def check_odd_even(a):\n",
        "  if a%2 == 0:\n",
        "    return \"Even\"\n",
        "  else:\n",
        "    return \"Odd\"\n"
      ],
      "metadata": {
        "id": "ZVNRT7k-mecE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(check_odd_even(10))"
      ],
      "metadata": {
        "id": "tJPOFkG8m4SD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3df1d217-7f6a-4a70-e7c4-9dc25d5a8203"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Even\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FmS_OYOJTqzM",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "352a7b9c-c296-4d60-f038-d9f31ac77ba7"
      },
      "source": [
        "b = check_odd_even(3)\n",
        "print(b)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Odd\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q-ZbD0C9Tt2_"
      },
      "source": [
        "def addition(first, second):\n",
        "  return first+second\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ucRcfpH4A3OP",
        "outputId": "402a46ab-df1c-4d75-8fa8-ca977a7b89a1"
      },
      "source": [
        "print(addition(3,4))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "7\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1UraJPRQxqQp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c234e9c8-5fbe-4957-c529-45cabfb13e7e"
      },
      "source": [
        "print(addition('python', 'course'))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "pythoncourse\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def even_data_filter(data_list):\n",
        "  result = []\n",
        "  for data in data_list:\n",
        "    if data%2 == 0:\n",
        "      result.append(data)\n",
        "  return result"
      ],
      "metadata": {
        "id": "9fY3Hi0PpWhu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a = [1,2,3,4,5]\n",
        "\n",
        "result_data=even_data_filter(a)\n",
        "print(result_data)"
      ],
      "metadata": {
        "id": "RikfvX_Ip58s",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e6931810-2cc1-4acb-e489-3ac97aebee55"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[2, 4]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def max_of_3(a,b,c):\n",
        "  if a>=b and a>=c:\n",
        "    max = a\n",
        "  elif b>=a and b>=c:\n",
        "    max = b\n",
        "  else:\n",
        "    max=c\n",
        "  return max"
      ],
      "metadata": {
        "id": "ERgcbbiaq_pP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "max_value=max_of_3(7,7,3)\n",
        "print(max_value)"
      ],
      "metadata": {
        "id": "PToC4ze0whIR",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d871a4b1-dd0b-4b31-e92f-fcf21c1ab021"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "7\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "08eC_E_HydS7"
      },
      "source": [
        "# Ex: Create a simple code to convert 24 hour clock to 12 hour clock. (No need to print AM, PM, just print hour in 12 hour clock)\n",
        "\n",
        "# Example: input 16 output 4\n",
        "\n",
        "\n",
        "def convert_clock(hours):\n",
        "  if hours <= 12:\n",
        "    print(hours)\n",
        "  else:\n",
        "    hours -= 12\n",
        "    print(hours)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hdF3f9Cg06nU"
      },
      "source": [
        "def print_fruit(fruit_list):\n",
        "  for fruit in fruit_list:\n",
        "    print(fruit)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2UcEwdg31Qv7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d9c53635-ac3b-4989-ca36-f6bc840558c6"
      },
      "source": [
        "fruits = ['banana', 'apple', 'pineapple']\n",
        "\n",
        "print_fruit(fruits)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "banana\n",
            "apple\n",
            "pineapple\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UOgHz_xpzacO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9a830dfc-8ca3-4e7a-b837-44c1a214ef11"
      },
      "source": [
        "coonver_clock(hours=22)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gMWV3PGpGu3b"
      },
      "source": [
        "# **Classes**\n",
        "Python is an object oriented programming language.\n",
        "\n",
        "A Class is blueprint or template for creating objects.\n",
        "\n",
        "It defines a set of attributes and methods that the objects created from the class will have\n",
        "\n",
        "The __init__ method is a special method that is called when an object of the class is created, and it initializes the object's attributes with the values passed as arguments.\n",
        "\n",
        "**self** parameter is always the first parameter, and it is used to refer to the current object and  is automatically passed by python"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class Chair:\n",
        "  def __init__(self, c, h, w,u):\n",
        "    self.color=c\n",
        "    self.height=h\n",
        "    self.width=w\n",
        "    self.unit=u\n",
        "    self.c_type=\"Furniture\""
      ],
      "metadata": {
        "id": "Zqs1PusTQ-Ey"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "chair1 = Chair(\"Blue\", 10, 5,'m')"
      ],
      "metadata": {
        "id": "9fORgaSvRQV7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(chair1.color)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IMpVLFwyRrsr",
        "outputId": "567f2a56-8b0c-4f46-aa97-bcc76f1d7b95"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Blue\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "chair2 = Chair(\"red\", 7, 3,\"cm\")\n"
      ],
      "metadata": {
        "id": "2-z4Q4WdUgyL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "chair2.height"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xcJwhRAuUmyM",
        "outputId": "6551050f-a8aa-4f4d-f5b1-7f3064666ebc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "7"
            ]
          },
          "metadata": {},
          "execution_count": 100
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M6XOknjLsPXq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "13cffb05-2db2-4a4d-fe42-a00d6861f34d"
      },
      "source": [
        "class Fruit:\n",
        "  def __init__(self,a):\n",
        "    self.name = 'apple'\n",
        "    self.grade = 'A'\n",
        "\n",
        "print(Fruit)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class '__main__.Fruit'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xvzVi2s4rQP0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6e22f28f-709a-4903-f727-daff36031e06"
      },
      "source": [
        "a = Fruit(\"a\")\n",
        "print(a.name)\n",
        "print(a.grade)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "apple\n",
            "A\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 183
        },
        "id": "Nlw73JaACqbv",
        "outputId": "5ef69869-49bc-432e-9898-d224f58356a2"
      },
      "source": [
        "b = Fruit()\n",
        "print(b.grade)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-105-718f1ce8984e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mFruit\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[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgrade\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mTypeError\u001b[0m: __init__() missing 1 required positional argument: 'a'"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "b.grade = \"D\""
      ],
      "metadata": {
        "id": "KXuHdnZVSdIQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(b.grade)\n"
      ],
      "metadata": {
        "id": "NS2La2v6Sgyo",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 165
        },
        "outputId": "ec89c93b-6b53-4b79-8b42-c8ec5cc631c5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "AttributeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-106-135e47d1a912>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgrade\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m: 'str' object has no attribute 'grade'"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class Monitor():\n",
        "\n",
        "  def __init__(self):\n",
        "    self.color=None\n",
        "    self.height=10\n",
        "    self.width=10\n",
        "    self.brightness=33\n",
        "    self.volume=25\n",
        "    self.maintab=None\n",
        "\n",
        "  def setscreen(self, tab_name):\n",
        "    self.maintab = tab_name\n",
        "\n",
        "  def increase_volume(self, n):\n",
        "    self.volume += n"
      ],
      "metadata": {
        "id": "dCF51Y6JSt_k"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "m1 = Monitor()"
      ],
      "metadata": {
        "id": "MEctN_37WPly"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "m1.setscreen(\"home\")\n",
        "m1.maintab"
      ],
      "metadata": {
        "id": "vwl_dJtyWdDw",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "728eeb9f-b7d2-4b07-cee9-2f8748d54cb9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'home'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 111
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "m1.volume"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "x1F6hOHJYQdn",
        "outputId": "4431d66d-8db2-452c-85df-a73913e76f08"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "25"
            ]
          },
          "metadata": {},
          "execution_count": 111
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "m1.increase_volume(10)\n",
        "m1.volume"
      ],
      "metadata": {
        "id": "MjdArqekXxc3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "82849829-d469-4954-9a28-4b51568ab23f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "65"
            ]
          },
          "metadata": {},
          "execution_count": 115
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class torch:\n",
        "\n",
        "  def __init__(self, status):\n",
        "    self.status = status\n",
        "\n",
        "  def on_off(self,status):\n",
        "    # self.status= not status\n",
        "    return not status\n",
        "\n",
        "torch1 = torch(False)\n",
        "\n",
        "print(torch1.on_off(False))\n",
        "\n",
        "print(torch1.status)"
      ],
      "metadata": {
        "id": "n1jARxEKgXI5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3ce01fa7-b425-4c31-ca7a-90acd024c990"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J4feF7sjOWxs",
        "outputId": "f3fbb1d5-04ba-4044-ac4b-ea66f12cbb09"
      },
      "source": [
        "class Fruit:\n",
        "  def __init__(self, name, count):\n",
        "    self.name = name\n",
        "    self.count = count\n",
        "\n",
        "  def fruitfun(self):\n",
        "    print(self.name + \" count is:\" + str(self.count))\n",
        "\n",
        "a = Fruit(\"apple\", 5)\n",
        "a.fruitfun()\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "apple count is:5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YGjRn1IFD8EB"
      },
      "source": [
        "b = Fruit(\"pineapple\", 11)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3I8HMgtsEAIh",
        "outputId": "5fe7e8b1-cbb2-4dd8-f116-bfc69843ab4a"
      },
      "source": [
        "b.fruitfun()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "pineapple count is:11\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ns1AR9Rcvufo"
      },
      "source": [
        "# **File Handling**\n",
        "\n",
        "The key function for working with files in Python is the open() function.\n",
        "\n",
        "The open() built-in function takes two parameters; filename, and mode.\n",
        "\n",
        "There are four different methods (modes) for opening a file:\n",
        "\n",
        "\"r\" - Read - Default value. Opens a file for reading, error if the file does not exist\n",
        "\n",
        "\"a\" - Append - Opens a file for appending, creates the file if it does not exist\n",
        "\n",
        "\"w\" - Write - Opens a file for writing, creates the file if it does not exist and if the file already exists, its contents will be deleted before writing to it\n",
        "\n",
        "\"x\" - Create - Creates the specified file, returns an error if the file exists\n",
        "\n",
        "In addition you can specify if the file should be handled as binary or text mode\n",
        "\n",
        "\"t\" - Text - Default value. Text mode\n",
        "\n",
        "\"b\" - Binary - Binary mode (e.g. images)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UI2ZOQFevvqM"
      },
      "source": [
        "f = open(\"sample11.txt\", \"w\")\n",
        "f.write(\"Hello, its a sample file, third time!\")\n",
        "f.close()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kj4yPgYRFXKR"
      },
      "source": [
        "f = open(\"sample_apend.txt\", \"a\")\n",
        "f.write(\"\\n this is from append content! \")\n",
        "f.close()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9oQAakAKF1ZH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5463e8cf-daef-43d9-d252-cec64f4692e4"
      },
      "source": [
        "reader = open(\"sample.txt\", \"r\")\n",
        "rr = reader.read()\n",
        "print(rr)\n",
        "reader.close()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello, its a sample file, third time!\n",
            " this is from append content! \n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "f = open(\"sample_new.txt\", \"x\")\n",
        "f.write(\"\\n this is from third day! \\n\")\n",
        "f.write(\"\\n this is from third day! \\n\")\n",
        "f.close()"
      ],
      "metadata": {
        "id": "eiDQC7ZinEfr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XO5DMCwX0Qko"
      },
      "source": [
        "# **Inbuilt Libraries**\n",
        "\n",
        "*   os\n",
        "*   math\n",
        "*   random\n",
        "*   datetime\n",
        "*   pytz\n",
        "\n",
        "os: Provides a way of using operating system dependent functionality like reading or writing to the file system, getting environment variables, etc.\n",
        "\n",
        "sys: Provides access to some variables used or maintained by the interpreter and to functions that interact strongly with the interpreter.\n",
        "\n",
        "math: Provides access to the mathematical functions defined by the C standard.\n",
        "\n",
        "random: Provides functions for generating random numbers.\n",
        "\n",
        "datetime: Provides classes for working with dates and times.\n",
        "\n",
        "time: Provides functions for working with time, including time zones and time stamps.\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RxUWkhm6Gzyq"
      },
      "source": [
        "import os"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "os.getcwd() #This function returns the current working directory."
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "teOPFXDlYqZV",
        "outputId": "a5ffa0fa-6017-412a-e933-3c3241dfbe70"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'/content'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 149
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "os.chdir('/content/') #This function changes the current working directory to the path specified."
      ],
      "metadata": {
        "id": "9PgUMyxRYxzF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "os.listdir() #/path='./sample_data\""
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YlFManzuY1__",
        "outputId": "142c6164-9f52-4e58-8698-aa43dbe85fb0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['README.md',\n",
              " 'anscombe.json',\n",
              " 'sample11.txt',\n",
              " 'sample.txt',\n",
              " 'mnist_test.csv',\n",
              " 'california_housing_test.csv',\n",
              " 'mnist_train_small.csv',\n",
              " 'california_housing_train.csv']"
            ]
          },
          "metadata": {},
          "execution_count": 147
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "os.mkdir(\"new_dir\")  #This function creates a new directory with the specified path."
      ],
      "metadata": {
        "id": "j-uDH6_coykd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "os.remove('/content/sample.txt')  #This function removes the file with the specified path."
      ],
      "metadata": {
        "id": "xBKs9rySaDk9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "os.rmdir(\"/content/new_dir\") #This function removes the directory with the specified path."
      ],
      "metadata": {
        "id": "WSlpB_fraQJc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "os.rename(\"/content/sample_apend.txt\", \"/content/sample_rename.txt\") # This function renames the file or directory from the source path to the destination path."
      ],
      "metadata": {
        "id": "XQiuH5WIaP-b"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NHXV9PNiHE3S"
      },
      "source": [
        "import random \n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "random.random() #This function returns a random floating-point number between 0 and 1."
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BTjbSRB2ecAB",
        "outputId": "c511d831-acc4-46ad-a8b4-8ee7ec0aeb51"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.09868449516456967"
            ]
          },
          "metadata": {},
          "execution_count": 157
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "random.randint(-500, 500) #This function returns a random integer between a and b, inclusive."
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dMb-cYTbemzY",
        "outputId": "e5e6a357-dac7-477b-b82a-c06211d7ae72"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "128"
            ]
          },
          "metadata": {},
          "execution_count": 158
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "random.uniform(-5, 0)  #This function returns a random floating-point number between a and b, including both endpoints"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lcd1QCNcfaj4",
        "outputId": "6cc49c45-79c0-4e58-a1d4-61381a40cff8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "-1.5883405073978523"
            ]
          },
          "metadata": {},
          "execution_count": 159
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import math\n"
      ],
      "metadata": {
        "id": "WZF-Pyp8f_2p"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "math.ceil(3.1) #This function returns the smallest integer greater than or equal to x.\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3i_kqei1f_y3",
        "outputId": "7d54887f-ef25-4533-bfb3-a5a68c94ef15"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "metadata": {},
          "execution_count": 161
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "math.floor(3.6) #This function returns the largest integer less than or equal to x.\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m4cEkOOjf_u6",
        "outputId": "7be142a1-c9e9-4d6a-a593-2ac3df02df36"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {},
          "execution_count": 162
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "math.sqrt(9.05) #This function returns the square root of x.\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nb3n54wLf_mj",
        "outputId": "5251fac9-90e5-4ae5-c852-0e8b86bd56a2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3.0083217912982647"
            ]
          },
          "metadata": {},
          "execution_count": 165
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "math.exp(2) #This function returns the exponential value of x."
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "o1-YHX1Df_YI",
        "outputId": "663ac90f-5cff-467e-dfa0-f83fd7d78861"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "7.38905609893065"
            ]
          },
          "metadata": {},
          "execution_count": 191
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import datetime\n",
        "print(datetime.date.today()) # returns a datetime object representing the todays date and time\n",
        "print(datetime.datetime.now())\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J25TDy-OVZoG",
        "outputId": "9cfae086-3600-4dde-a743-afa40906c299"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2023-03-13\n",
            "2023-03-13 08:56:47.483906\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import pytz\n",
        "\n",
        "# define the timezone\n",
        "tz = pytz.timezone('Asia/Bangkok')\n",
        "\n",
        "# get the current date and time in the defined timezone\n",
        "now = datetime.datetime.now(tz)  \n",
        "print(now)\n",
        "\n",
        "date_str = now.strftime(f'Date:%Y-%m-%d Time: %H:%M:%S')  # format the date and time as a string #convert a datetime object into a string representation\n",
        "\n",
        "\n",
        "print(date_str)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Kl-G0nEqZXaH",
        "outputId": "d9d9211c-eef7-40af-c732-dd53720e40b2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2023-03-13 15:59:59.619345+07:00\n",
            "Date:2023-03-13 Time: 15:59:59\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import zoneinfo\n",
        "zoneinfo.available_timezones()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nW0WsJ7ha43A",
        "outputId": "3de7b4fd-bde1-451e-bac7-6fadeba8f3e9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'Africa/Abidjan',\n",
              " 'Africa/Accra',\n",
              " 'Africa/Addis_Ababa',\n",
              " 'Africa/Algiers',\n",
              " 'Africa/Asmara',\n",
              " 'Africa/Asmera',\n",
              " 'Africa/Bamako',\n",
              " 'Africa/Bangui',\n",
              " 'Africa/Banjul',\n",
              " 'Africa/Bissau',\n",
              " 'Africa/Blantyre',\n",
              " 'Africa/Brazzaville',\n",
              " 'Africa/Bujumbura',\n",
              " 'Africa/Cairo',\n",
              " 'Africa/Casablanca',\n",
              " 'Africa/Ceuta',\n",
              " 'Africa/Conakry',\n",
              " 'Africa/Dakar',\n",
              " 'Africa/Dar_es_Salaam',\n",
              " 'Africa/Djibouti',\n",
              " 'Africa/Douala',\n",
              " 'Africa/El_Aaiun',\n",
              " 'Africa/Freetown',\n",
              " 'Africa/Gaborone',\n",
              " 'Africa/Harare',\n",
              " 'Africa/Johannesburg',\n",
              " 'Africa/Juba',\n",
              " 'Africa/Kampala',\n",
              " 'Africa/Khartoum',\n",
              " 'Africa/Kigali',\n",
              " 'Africa/Kinshasa',\n",
              " 'Africa/Lagos',\n",
              " 'Africa/Libreville',\n",
              " 'Africa/Lome',\n",
              " 'Africa/Luanda',\n",
              " 'Africa/Lubumbashi',\n",
              " 'Africa/Lusaka',\n",
              " 'Africa/Malabo',\n",
              " 'Africa/Maputo',\n",
              " 'Africa/Maseru',\n",
              " 'Africa/Mbabane',\n",
              " 'Africa/Mogadishu',\n",
              " 'Africa/Monrovia',\n",
              " 'Africa/Nairobi',\n",
              " 'Africa/Ndjamena',\n",
              " 'Africa/Niamey',\n",
              " 'Africa/Nouakchott',\n",
              " 'Africa/Ouagadougou',\n",
              " 'Africa/Porto-Novo',\n",
              " 'Africa/Sao_Tome',\n",
              " 'Africa/Timbuktu',\n",
              " 'Africa/Tripoli',\n",
              " 'Africa/Tunis',\n",
              " 'Africa/Windhoek',\n",
              " 'America/Adak',\n",
              " 'America/Anchorage',\n",
              " 'America/Anguilla',\n",
              " 'America/Antigua',\n",
              " 'America/Araguaina',\n",
              " 'America/Argentina/Buenos_Aires',\n",
              " 'America/Argentina/Catamarca',\n",
              " 'America/Argentina/ComodRivadavia',\n",
              " 'America/Argentina/Cordoba',\n",
              " 'America/Argentina/Jujuy',\n",
              " 'America/Argentina/La_Rioja',\n",
              " 'America/Argentina/Mendoza',\n",
              " 'America/Argentina/Rio_Gallegos',\n",
              " 'America/Argentina/Salta',\n",
              " 'America/Argentina/San_Juan',\n",
              " 'America/Argentina/San_Luis',\n",
              " 'America/Argentina/Tucuman',\n",
              " 'America/Argentina/Ushuaia',\n",
              " 'America/Aruba',\n",
              " 'America/Asuncion',\n",
              " 'America/Atikokan',\n",
              " 'America/Atka',\n",
              " 'America/Bahia',\n",
              " 'America/Bahia_Banderas',\n",
              " 'America/Barbados',\n",
              " 'America/Belem',\n",
              " 'America/Belize',\n",
              " 'America/Blanc-Sablon',\n",
              " 'America/Boa_Vista',\n",
              " 'America/Bogota',\n",
              " 'America/Boise',\n",
              " 'America/Buenos_Aires',\n",
              " 'America/Cambridge_Bay',\n",
              " 'America/Campo_Grande',\n",
              " 'America/Cancun',\n",
              " 'America/Caracas',\n",
              " 'America/Catamarca',\n",
              " 'America/Cayenne',\n",
              " 'America/Cayman',\n",
              " 'America/Chicago',\n",
              " 'America/Chihuahua',\n",
              " 'America/Ciudad_Juarez',\n",
              " 'America/Coral_Harbour',\n",
              " 'America/Cordoba',\n",
              " 'America/Costa_Rica',\n",
              " 'America/Creston',\n",
              " 'America/Cuiaba',\n",
              " 'America/Curacao',\n",
              " 'America/Danmarkshavn',\n",
              " 'America/Dawson',\n",
              " 'America/Dawson_Creek',\n",
              " 'America/Denver',\n",
              " 'America/Detroit',\n",
              " 'America/Dominica',\n",
              " 'America/Edmonton',\n",
              " 'America/Eirunepe',\n",
              " 'America/El_Salvador',\n",
              " 'America/Ensenada',\n",
              " 'America/Fort_Nelson',\n",
              " 'America/Fort_Wayne',\n",
              " 'America/Fortaleza',\n",
              " 'America/Glace_Bay',\n",
              " 'America/Godthab',\n",
              " 'America/Goose_Bay',\n",
              " 'America/Grand_Turk',\n",
              " 'America/Grenada',\n",
              " 'America/Guadeloupe',\n",
              " 'America/Guatemala',\n",
              " 'America/Guayaquil',\n",
              " 'America/Guyana',\n",
              " 'America/Halifax',\n",
              " 'America/Havana',\n",
              " 'America/Hermosillo',\n",
              " 'America/Indiana/Indianapolis',\n",
              " 'America/Indiana/Knox',\n",
              " 'America/Indiana/Marengo',\n",
              " 'America/Indiana/Petersburg',\n",
              " 'America/Indiana/Tell_City',\n",
              " 'America/Indiana/Vevay',\n",
              " 'America/Indiana/Vincennes',\n",
              " 'America/Indiana/Winamac',\n",
              " 'America/Indianapolis',\n",
              " 'America/Inuvik',\n",
              " 'America/Iqaluit',\n",
              " 'America/Jamaica',\n",
              " 'America/Jujuy',\n",
              " 'America/Juneau',\n",
              " 'America/Kentucky/Louisville',\n",
              " 'America/Kentucky/Monticello',\n",
              " 'America/Knox_IN',\n",
              " 'America/Kralendijk',\n",
              " 'America/La_Paz',\n",
              " 'America/Lima',\n",
              " 'America/Los_Angeles',\n",
              " 'America/Louisville',\n",
              " 'America/Lower_Princes',\n",
              " 'America/Maceio',\n",
              " 'America/Managua',\n",
              " 'America/Manaus',\n",
              " 'America/Marigot',\n",
              " 'America/Martinique',\n",
              " 'America/Matamoros',\n",
              " 'America/Mazatlan',\n",
              " 'America/Mendoza',\n",
              " 'America/Menominee',\n",
              " 'America/Merida',\n",
              " 'America/Metlakatla',\n",
              " 'America/Mexico_City',\n",
              " 'America/Miquelon',\n",
              " 'America/Moncton',\n",
              " 'America/Monterrey',\n",
              " 'America/Montevideo',\n",
              " 'America/Montreal',\n",
              " 'America/Montserrat',\n",
              " 'America/Nassau',\n",
              " 'America/New_York',\n",
              " 'America/Nipigon',\n",
              " 'America/Nome',\n",
              " 'America/Noronha',\n",
              " 'America/North_Dakota/Beulah',\n",
              " 'America/North_Dakota/Center',\n",
              " 'America/North_Dakota/New_Salem',\n",
              " 'America/Nuuk',\n",
              " 'America/Ojinaga',\n",
              " 'America/Panama',\n",
              " 'America/Pangnirtung',\n",
              " 'America/Paramaribo',\n",
              " 'America/Phoenix',\n",
              " 'America/Port-au-Prince',\n",
              " 'America/Port_of_Spain',\n",
              " 'America/Porto_Acre',\n",
              " 'America/Porto_Velho',\n",
              " 'America/Puerto_Rico',\n",
              " 'America/Punta_Arenas',\n",
              " 'America/Rainy_River',\n",
              " 'America/Rankin_Inlet',\n",
              " 'America/Recife',\n",
              " 'America/Regina',\n",
              " 'America/Resolute',\n",
              " 'America/Rio_Branco',\n",
              " 'America/Rosario',\n",
              " 'America/Santa_Isabel',\n",
              " 'America/Santarem',\n",
              " 'America/Santiago',\n",
              " 'America/Santo_Domingo',\n",
              " 'America/Sao_Paulo',\n",
              " 'America/Scoresbysund',\n",
              " 'America/Shiprock',\n",
              " 'America/Sitka',\n",
              " 'America/St_Barthelemy',\n",
              " 'America/St_Johns',\n",
              " 'America/St_Kitts',\n",
              " 'America/St_Lucia',\n",
              " 'America/St_Thomas',\n",
              " 'America/St_Vincent',\n",
              " 'America/Swift_Current',\n",
              " 'America/Tegucigalpa',\n",
              " 'America/Thule',\n",
              " 'America/Thunder_Bay',\n",
              " 'America/Tijuana',\n",
              " 'America/Toronto',\n",
              " 'America/Tortola',\n",
              " 'America/Vancouver',\n",
              " 'America/Virgin',\n",
              " 'America/Whitehorse',\n",
              " 'America/Winnipeg',\n",
              " 'America/Yakutat',\n",
              " 'America/Yellowknife',\n",
              " 'Antarctica/Casey',\n",
              " 'Antarctica/Davis',\n",
              " 'Antarctica/DumontDUrville',\n",
              " 'Antarctica/Macquarie',\n",
              " 'Antarctica/Mawson',\n",
              " 'Antarctica/McMurdo',\n",
              " 'Antarctica/Palmer',\n",
              " 'Antarctica/Rothera',\n",
              " 'Antarctica/South_Pole',\n",
              " 'Antarctica/Syowa',\n",
              " 'Antarctica/Troll',\n",
              " 'Antarctica/Vostok',\n",
              " 'Arctic/Longyearbyen',\n",
              " 'Asia/Aden',\n",
              " 'Asia/Almaty',\n",
              " 'Asia/Amman',\n",
              " 'Asia/Anadyr',\n",
              " 'Asia/Aqtau',\n",
              " 'Asia/Aqtobe',\n",
              " 'Asia/Ashgabat',\n",
              " 'Asia/Ashkhabad',\n",
              " 'Asia/Atyrau',\n",
              " 'Asia/Baghdad',\n",
              " 'Asia/Bahrain',\n",
              " 'Asia/Baku',\n",
              " 'Asia/Bangkok',\n",
              " 'Asia/Barnaul',\n",
              " 'Asia/Beirut',\n",
              " 'Asia/Bishkek',\n",
              " 'Asia/Brunei',\n",
              " 'Asia/Calcutta',\n",
              " 'Asia/Chita',\n",
              " 'Asia/Choibalsan',\n",
              " 'Asia/Chongqing',\n",
              " 'Asia/Chungking',\n",
              " 'Asia/Colombo',\n",
              " 'Asia/Dacca',\n",
              " 'Asia/Damascus',\n",
              " 'Asia/Dhaka',\n",
              " 'Asia/Dili',\n",
              " 'Asia/Dubai',\n",
              " 'Asia/Dushanbe',\n",
              " 'Asia/Famagusta',\n",
              " 'Asia/Gaza',\n",
              " 'Asia/Harbin',\n",
              " 'Asia/Hebron',\n",
              " 'Asia/Ho_Chi_Minh',\n",
              " 'Asia/Hong_Kong',\n",
              " 'Asia/Hovd',\n",
              " 'Asia/Irkutsk',\n",
              " 'Asia/Istanbul',\n",
              " 'Asia/Jakarta',\n",
              " 'Asia/Jayapura',\n",
              " 'Asia/Jerusalem',\n",
              " 'Asia/Kabul',\n",
              " 'Asia/Kamchatka',\n",
              " 'Asia/Karachi',\n",
              " 'Asia/Kashgar',\n",
              " 'Asia/Kathmandu',\n",
              " 'Asia/Katmandu',\n",
              " 'Asia/Khandyga',\n",
              " 'Asia/Kolkata',\n",
              " 'Asia/Krasnoyarsk',\n",
              " 'Asia/Kuala_Lumpur',\n",
              " 'Asia/Kuching',\n",
              " 'Asia/Kuwait',\n",
              " 'Asia/Macao',\n",
              " 'Asia/Macau',\n",
              " 'Asia/Magadan',\n",
              " 'Asia/Makassar',\n",
              " 'Asia/Manila',\n",
              " 'Asia/Muscat',\n",
              " 'Asia/Nicosia',\n",
              " 'Asia/Novokuznetsk',\n",
              " 'Asia/Novosibirsk',\n",
              " 'Asia/Omsk',\n",
              " 'Asia/Oral',\n",
              " 'Asia/Phnom_Penh',\n",
              " 'Asia/Pontianak',\n",
              " 'Asia/Pyongyang',\n",
              " 'Asia/Qatar',\n",
              " 'Asia/Qostanay',\n",
              " 'Asia/Qyzylorda',\n",
              " 'Asia/Rangoon',\n",
              " 'Asia/Riyadh',\n",
              " 'Asia/Saigon',\n",
              " 'Asia/Sakhalin',\n",
              " 'Asia/Samarkand',\n",
              " 'Asia/Seoul',\n",
              " 'Asia/Shanghai',\n",
              " 'Asia/Singapore',\n",
              " 'Asia/Srednekolymsk',\n",
              " 'Asia/Taipei',\n",
              " 'Asia/Tashkent',\n",
              " 'Asia/Tbilisi',\n",
              " 'Asia/Tehran',\n",
              " 'Asia/Tel_Aviv',\n",
              " 'Asia/Thimbu',\n",
              " 'Asia/Thimphu',\n",
              " 'Asia/Tokyo',\n",
              " 'Asia/Tomsk',\n",
              " 'Asia/Ujung_Pandang',\n",
              " 'Asia/Ulaanbaatar',\n",
              " 'Asia/Ulan_Bator',\n",
              " 'Asia/Urumqi',\n",
              " 'Asia/Ust-Nera',\n",
              " 'Asia/Vientiane',\n",
              " 'Asia/Vladivostok',\n",
              " 'Asia/Yakutsk',\n",
              " 'Asia/Yangon',\n",
              " 'Asia/Yekaterinburg',\n",
              " 'Asia/Yerevan',\n",
              " 'Atlantic/Azores',\n",
              " 'Atlantic/Bermuda',\n",
              " 'Atlantic/Canary',\n",
              " 'Atlantic/Cape_Verde',\n",
              " 'Atlantic/Faeroe',\n",
              " 'Atlantic/Faroe',\n",
              " 'Atlantic/Jan_Mayen',\n",
              " 'Atlantic/Madeira',\n",
              " 'Atlantic/Reykjavik',\n",
              " 'Atlantic/South_Georgia',\n",
              " 'Atlantic/St_Helena',\n",
              " 'Atlantic/Stanley',\n",
              " 'Australia/ACT',\n",
              " 'Australia/Adelaide',\n",
              " 'Australia/Brisbane',\n",
              " 'Australia/Broken_Hill',\n",
              " 'Australia/Canberra',\n",
              " 'Australia/Currie',\n",
              " 'Australia/Darwin',\n",
              " 'Australia/Eucla',\n",
              " 'Australia/Hobart',\n",
              " 'Australia/LHI',\n",
              " 'Australia/Lindeman',\n",
              " 'Australia/Lord_Howe',\n",
              " 'Australia/Melbourne',\n",
              " 'Australia/NSW',\n",
              " 'Australia/North',\n",
              " 'Australia/Perth',\n",
              " 'Australia/Queensland',\n",
              " 'Australia/South',\n",
              " 'Australia/Sydney',\n",
              " 'Australia/Tasmania',\n",
              " 'Australia/Victoria',\n",
              " 'Australia/West',\n",
              " 'Australia/Yancowinna',\n",
              " 'Brazil/Acre',\n",
              " 'Brazil/DeNoronha',\n",
              " 'Brazil/East',\n",
              " 'Brazil/West',\n",
              " 'CET',\n",
              " 'CST6CDT',\n",
              " 'Canada/Atlantic',\n",
              " 'Canada/Central',\n",
              " 'Canada/Eastern',\n",
              " 'Canada/Mountain',\n",
              " 'Canada/Newfoundland',\n",
              " 'Canada/Pacific',\n",
              " 'Canada/Saskatchewan',\n",
              " 'Canada/Yukon',\n",
              " 'Chile/Continental',\n",
              " 'Chile/EasterIsland',\n",
              " 'Cuba',\n",
              " 'EET',\n",
              " 'EST',\n",
              " 'EST5EDT',\n",
              " 'Egypt',\n",
              " 'Eire',\n",
              " 'Etc/GMT',\n",
              " 'Etc/GMT+0',\n",
              " 'Etc/GMT+1',\n",
              " 'Etc/GMT+10',\n",
              " 'Etc/GMT+11',\n",
              " 'Etc/GMT+12',\n",
              " 'Etc/GMT+2',\n",
              " 'Etc/GMT+3',\n",
              " 'Etc/GMT+4',\n",
              " 'Etc/GMT+5',\n",
              " 'Etc/GMT+6',\n",
              " 'Etc/GMT+7',\n",
              " 'Etc/GMT+8',\n",
              " 'Etc/GMT+9',\n",
              " 'Etc/GMT-0',\n",
              " 'Etc/GMT-1',\n",
              " 'Etc/GMT-10',\n",
              " 'Etc/GMT-11',\n",
              " 'Etc/GMT-12',\n",
              " 'Etc/GMT-13',\n",
              " 'Etc/GMT-14',\n",
              " 'Etc/GMT-2',\n",
              " 'Etc/GMT-3',\n",
              " 'Etc/GMT-4',\n",
              " 'Etc/GMT-5',\n",
              " 'Etc/GMT-6',\n",
              " 'Etc/GMT-7',\n",
              " 'Etc/GMT-8',\n",
              " 'Etc/GMT-9',\n",
              " 'Etc/GMT0',\n",
              " 'Etc/Greenwich',\n",
              " 'Etc/UCT',\n",
              " 'Etc/UTC',\n",
              " 'Etc/Universal',\n",
              " 'Etc/Zulu',\n",
              " 'Europe/Amsterdam',\n",
              " 'Europe/Andorra',\n",
              " 'Europe/Astrakhan',\n",
              " 'Europe/Athens',\n",
              " 'Europe/Belfast',\n",
              " 'Europe/Belgrade',\n",
              " 'Europe/Berlin',\n",
              " 'Europe/Bratislava',\n",
              " 'Europe/Brussels',\n",
              " 'Europe/Bucharest',\n",
              " 'Europe/Budapest',\n",
              " 'Europe/Busingen',\n",
              " 'Europe/Chisinau',\n",
              " 'Europe/Copenhagen',\n",
              " 'Europe/Dublin',\n",
              " 'Europe/Gibraltar',\n",
              " 'Europe/Guernsey',\n",
              " 'Europe/Helsinki',\n",
              " 'Europe/Isle_of_Man',\n",
              " 'Europe/Istanbul',\n",
              " 'Europe/Jersey',\n",
              " 'Europe/Kaliningrad',\n",
              " 'Europe/Kiev',\n",
              " 'Europe/Kirov',\n",
              " 'Europe/Kyiv',\n",
              " 'Europe/Lisbon',\n",
              " 'Europe/Ljubljana',\n",
              " 'Europe/London',\n",
              " 'Europe/Luxembourg',\n",
              " 'Europe/Madrid',\n",
              " 'Europe/Malta',\n",
              " 'Europe/Mariehamn',\n",
              " 'Europe/Minsk',\n",
              " 'Europe/Monaco',\n",
              " 'Europe/Moscow',\n",
              " 'Europe/Nicosia',\n",
              " 'Europe/Oslo',\n",
              " 'Europe/Paris',\n",
              " 'Europe/Podgorica',\n",
              " 'Europe/Prague',\n",
              " 'Europe/Riga',\n",
              " 'Europe/Rome',\n",
              " 'Europe/Samara',\n",
              " 'Europe/San_Marino',\n",
              " 'Europe/Sarajevo',\n",
              " 'Europe/Saratov',\n",
              " 'Europe/Simferopol',\n",
              " 'Europe/Skopje',\n",
              " 'Europe/Sofia',\n",
              " 'Europe/Stockholm',\n",
              " 'Europe/Tallinn',\n",
              " 'Europe/Tirane',\n",
              " 'Europe/Tiraspol',\n",
              " 'Europe/Ulyanovsk',\n",
              " 'Europe/Uzhgorod',\n",
              " 'Europe/Vaduz',\n",
              " 'Europe/Vatican',\n",
              " 'Europe/Vienna',\n",
              " 'Europe/Vilnius',\n",
              " 'Europe/Volgograd',\n",
              " 'Europe/Warsaw',\n",
              " 'Europe/Zagreb',\n",
              " 'Europe/Zaporozhye',\n",
              " 'Europe/Zurich',\n",
              " 'Factory',\n",
              " 'GB',\n",
              " 'GB-Eire',\n",
              " 'GMT',\n",
              " 'GMT+0',\n",
              " 'GMT-0',\n",
              " 'GMT0',\n",
              " 'Greenwich',\n",
              " 'HST',\n",
              " 'Hongkong',\n",
              " 'Iceland',\n",
              " 'Indian/Antananarivo',\n",
              " 'Indian/Chagos',\n",
              " 'Indian/Christmas',\n",
              " 'Indian/Cocos',\n",
              " 'Indian/Comoro',\n",
              " 'Indian/Kerguelen',\n",
              " 'Indian/Mahe',\n",
              " 'Indian/Maldives',\n",
              " 'Indian/Mauritius',\n",
              " 'Indian/Mayotte',\n",
              " 'Indian/Reunion',\n",
              " 'Iran',\n",
              " 'Israel',\n",
              " 'Jamaica',\n",
              " 'Japan',\n",
              " 'Kwajalein',\n",
              " 'Libya',\n",
              " 'MET',\n",
              " 'MST',\n",
              " 'MST7MDT',\n",
              " 'Mexico/BajaNorte',\n",
              " 'Mexico/BajaSur',\n",
              " 'Mexico/General',\n",
              " 'NZ',\n",
              " 'NZ-CHAT',\n",
              " 'Navajo',\n",
              " 'PRC',\n",
              " 'PST8PDT',\n",
              " 'Pacific/Apia',\n",
              " 'Pacific/Auckland',\n",
              " 'Pacific/Bougainville',\n",
              " 'Pacific/Chatham',\n",
              " 'Pacific/Chuuk',\n",
              " 'Pacific/Easter',\n",
              " 'Pacific/Efate',\n",
              " 'Pacific/Enderbury',\n",
              " 'Pacific/Fakaofo',\n",
              " 'Pacific/Fiji',\n",
              " 'Pacific/Funafuti',\n",
              " 'Pacific/Galapagos',\n",
              " 'Pacific/Gambier',\n",
              " 'Pacific/Guadalcanal',\n",
              " 'Pacific/Guam',\n",
              " 'Pacific/Honolulu',\n",
              " 'Pacific/Johnston',\n",
              " 'Pacific/Kanton',\n",
              " 'Pacific/Kiritimati',\n",
              " 'Pacific/Kosrae',\n",
              " 'Pacific/Kwajalein',\n",
              " 'Pacific/Majuro',\n",
              " 'Pacific/Marquesas',\n",
              " 'Pacific/Midway',\n",
              " 'Pacific/Nauru',\n",
              " 'Pacific/Niue',\n",
              " 'Pacific/Norfolk',\n",
              " 'Pacific/Noumea',\n",
              " 'Pacific/Pago_Pago',\n",
              " 'Pacific/Palau',\n",
              " 'Pacific/Pitcairn',\n",
              " 'Pacific/Pohnpei',\n",
              " 'Pacific/Ponape',\n",
              " 'Pacific/Port_Moresby',\n",
              " 'Pacific/Rarotonga',\n",
              " 'Pacific/Saipan',\n",
              " 'Pacific/Samoa',\n",
              " 'Pacific/Tahiti',\n",
              " 'Pacific/Tarawa',\n",
              " 'Pacific/Tongatapu',\n",
              " 'Pacific/Truk',\n",
              " 'Pacific/Wake',\n",
              " 'Pacific/Wallis',\n",
              " 'Pacific/Yap',\n",
              " 'Poland',\n",
              " 'Portugal',\n",
              " 'ROC',\n",
              " 'ROK',\n",
              " 'Singapore',\n",
              " 'SystemV/AST4',\n",
              " 'SystemV/AST4ADT',\n",
              " 'SystemV/CST6',\n",
              " 'SystemV/CST6CDT',\n",
              " 'SystemV/EST5',\n",
              " 'SystemV/EST5EDT',\n",
              " 'SystemV/HST10',\n",
              " 'SystemV/MST7',\n",
              " 'SystemV/MST7MDT',\n",
              " 'SystemV/PST8',\n",
              " 'SystemV/PST8PDT',\n",
              " 'SystemV/YST9',\n",
              " 'SystemV/YST9YDT',\n",
              " 'Turkey',\n",
              " 'UCT',\n",
              " 'US/Alaska',\n",
              " 'US/Aleutian',\n",
              " 'US/Arizona',\n",
              " 'US/Central',\n",
              " 'US/East-Indiana',\n",
              " 'US/Eastern',\n",
              " 'US/Hawaii',\n",
              " 'US/Indiana-Starke',\n",
              " 'US/Michigan',\n",
              " 'US/Mountain',\n",
              " 'US/Pacific',\n",
              " 'US/Samoa',\n",
              " 'UTC',\n",
              " 'Universal',\n",
              " 'W-SU',\n",
              " 'WET',\n",
              " 'Zulu',\n",
              " 'localtime'}"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**pip**\n",
        "\n",
        "pip stands for \"Package Installer for Python\". It is powerful tool that makes easy to manage Python packages and dependencies in python project. \n",
        "\n",
        "* pip install <package>: installs a package from PyPI or a local archive.\n",
        "* pip uninstall <package>: removes a package from your system.\n",
        "* pip freeze: generates a list of installed packages and their versions.\n",
        "* pip show <package>: displays information about a specific package, such as its version and dependencies."
      ],
      "metadata": {
        "id": "1_RHQpgDkA8l"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip  uninstall pandas"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "g__f-P3HNVaR",
        "outputId": "7d6e97d4-5dfe-4639-c9fd-1b6ebcb38244"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found existing installation: pandas 1.3.5\n",
            "Uninstalling pandas-1.3.5:\n",
            "  Would remove:\n",
            "    /usr/local/lib/python3.9/dist-packages/pandas-1.3.5.dist-info/*\n",
            "    /usr/local/lib/python3.9/dist-packages/pandas/*\n",
            "Proceed (Y/n)? Y\n",
            "  Successfully uninstalled pandas-1.3.5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C--597DuHoa-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4d48870b-28ce-4980-b2e6-778aa92f23a3"
      },
      "source": [
        "!pip freeze"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "absl-py==1.4.0\n",
            "aeppl==0.0.33\n",
            "aesara==2.7.9\n",
            "alabaster==0.7.13\n",
            "albumentations==1.2.1\n",
            "altair==4.2.2\n",
            "argon2-cffi==21.3.0\n",
            "argon2-cffi-bindings==21.2.0\n",
            "arviz==0.12.1\n",
            "astropy==4.3.1\n",
            "astunparse==1.6.3\n",
            "atomicwrites==1.4.1\n",
            "attrs==22.2.0\n",
            "audioread==3.0.0\n",
            "autograd==1.5\n",
            "Babel==2.12.1\n",
            "backcall==0.2.0\n",
            "backports.zoneinfo==0.2.1\n",
            "beautifulsoup4==4.6.3\n",
            "bleach==6.0.0\n",
            "blis==0.7.9\n",
            "bokeh==2.4.3\n",
            "branca==0.6.0\n",
            "bs4==0.0.1\n",
            "CacheControl==0.12.11\n",
            "cachetools==5.3.0\n",
            "catalogue==2.0.8\n",
            "certifi==2022.12.7\n",
            "cffi==1.15.1\n",
            "cftime==1.6.2\n",
            "chardet==4.0.0\n",
            "click==8.1.3\n",
            "cloudpickle==2.2.1\n",
            "cmake==3.22.6\n",
            "cmdstanpy==1.1.0\n",
            "colorcet==3.0.1\n",
            "colorlover==0.3.0\n",
            "community==1.0.0b1\n",
            "confection==0.0.4\n",
            "cons==0.4.5\n",
            "contextlib2==0.5.5\n",
            "convertdate==2.4.0\n",
            "cufflinks==0.17.3\n",
            "cvxopt==1.3.0\n",
            "cvxpy==1.2.3\n",
            "cycler==0.11.0\n",
            "cymem==2.0.7\n",
            "Cython==0.29.33\n",
            "dask==2022.2.1\n",
            "datascience==0.17.6\n",
            "db-dtypes==1.0.5\n",
            "dbus-python==1.2.16\n",
            "debugpy==1.6.6\n",
            "decorator==4.4.2\n",
            "defusedxml==0.7.1\n",
            "distributed==2022.2.1\n",
            "dlib==19.24.0\n",
            "dm-tree==0.1.8\n",
            "dnspython==2.3.0\n",
            "docutils==0.16\n",
            "dopamine-rl==1.0.5\n",
            "earthengine-api==0.1.343\n",
            "easydict==1.10\n",
            "ecos==2.0.12\n",
            "editdistance==0.5.3\n",
            "en-core-web-sm @ https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-3.4.1/en_core_web_sm-3.4.1-py3-none-any.whl\n",
            "entrypoints==0.4\n",
            "ephem==4.1.4\n",
            "et-xmlfile==1.1.0\n",
            "etils==1.0.0\n",
            "etuples==0.3.8\n",
            "fastai==2.7.11\n",
            "fastcore==1.5.28\n",
            "fastdownload==0.0.7\n",
            "fastjsonschema==2.16.3\n",
            "fastprogress==1.0.3\n",
            "fastrlock==0.8.1\n",
            "filelock==3.9.0\n",
            "firebase-admin==5.3.0\n",
            "fix-yahoo-finance==0.0.22\n",
            "Flask==2.2.3\n",
            "flatbuffers==23.3.3\n",
            "folium==0.12.1.post1\n",
            "fonttools==4.39.0\n",
            "fsspec==2023.3.0\n",
            "future==0.16.0\n",
            "gast==0.4.0\n",
            "GDAL==3.3.2\n",
            "gdown==4.4.0\n",
            "gensim==3.6.0\n",
            "geographiclib==1.52\n",
            "geopy==1.17.0\n",
            "gin-config==0.5.0\n",
            "glob2==0.7\n",
            "google==2.0.3\n",
            "google-api-core==2.11.0\n",
            "google-api-python-client==2.70.0\n",
            "google-auth==2.16.2\n",
            "google-auth-httplib2==0.1.0\n",
            "google-auth-oauthlib==0.4.6\n",
            "google-cloud-bigquery==3.4.2\n",
            "google-cloud-bigquery-storage==2.19.0\n",
            "google-cloud-core==2.3.2\n",
            "google-cloud-datastore==2.11.1\n",
            "google-cloud-firestore==2.7.3\n",
            "google-cloud-language==2.6.1\n",
            "google-cloud-storage==2.7.0\n",
            "google-cloud-translate==3.8.4\n",
            "google-colab @ file:///colabtools/dist/google-colab-1.0.0.tar.gz\n",
            "google-crc32c==1.5.0\n",
            "google-pasta==0.2.0\n",
            "google-resumable-media==2.4.1\n",
            "googleapis-common-protos==1.58.0\n",
            "googledrivedownloader==0.4\n",
            "graphviz==0.10.1\n",
            "greenlet==2.0.2\n",
            "grpcio==1.51.3\n",
            "grpcio-status==1.48.2\n",
            "gspread==3.4.2\n",
            "gspread-dataframe==3.0.8\n",
            "gym==0.25.2\n",
            "gym-notices==0.0.8\n",
            "h5py==3.1.0\n",
            "HeapDict==1.0.1\n",
            "hijri-converter==2.2.4\n",
            "holidays==0.21\n",
            "holoviews==1.14.9\n",
            "html5lib==1.0.1\n",
            "httpimport==0.5.18\n",
            "httplib2==0.17.4\n",
            "humanize==0.5.1\n",
            "hyperopt==0.1.2\n",
            "idna==2.10\n",
            "imageio==2.9.0\n",
            "imagesize==1.4.1\n",
            "imbalanced-learn==0.8.1\n",
            "imblearn==0.0\n",
            "imgaug==0.4.0\n",
            "importlib-metadata==6.0.0\n",
            "importlib-resources==5.12.0\n",
            "imutils==0.5.4\n",
            "inflect==2.1.0\n",
            "intel-openmp==2023.0.0\n",
            "ipykernel==5.3.4\n",
            "ipython==7.9.0\n",
            "ipython-genutils==0.2.0\n",
            "ipython-sql==0.3.9\n",
            "ipywidgets==7.7.1\n",
            "itsdangerous==2.1.2\n",
            "jax==0.4.4\n",
            "jaxlib @ https://storage.googleapis.com/jax-releases/cuda11/jaxlib-0.4.4+cuda11.cudnn82-cp39-cp39-manylinux2014_x86_64.whl\n",
            "jieba==0.42.1\n",
            "Jinja2==3.1.2\n",
            "joblib==1.2.0\n",
            "jsonschema==4.3.3\n",
            "jupyter-client==6.1.12\n",
            "jupyter-console==6.1.0\n",
            "jupyter_core==5.2.0\n",
            "jupyterlab-pygments==0.2.2\n",
            "jupyterlab-widgets==3.0.5\n",
            "kaggle==1.5.13\n",
            "keras==2.11.0\n",
            "keras-vis==0.4.1\n",
            "kiwisolver==1.4.4\n",
            "korean-lunar-calendar==0.3.1\n",
            "langcodes==3.3.0\n",
            "libclang==15.0.6.1\n",
            "librosa==0.8.1\n",
            "lightgbm==2.2.3\n",
            "llvmlite==0.39.1\n",
            "locket==1.0.0\n",
            "logical-unification==0.4.5\n",
            "LunarCalendar==0.0.9\n",
            "lxml==4.9.2\n",
            "Markdown==3.4.1\n",
            "MarkupSafe==2.1.2\n",
            "matplotlib==3.5.3\n",
            "matplotlib-venn==0.11.9\n",
            "miniKanren==1.0.3\n",
            "missingno==0.5.2\n",
            "mistune==0.8.4\n",
            "mizani==0.8.1\n",
            "mkl==2019.0\n",
            "mlxtend==0.14.0\n",
            "more-itertools==9.1.0\n",
            "moviepy==0.2.3.5\n",
            "mpmath==1.2.1\n",
            "msgpack==1.0.4\n",
            "multipledispatch==0.6.0\n",
            "multitasking==0.0.11\n",
            "murmurhash==1.0.9\n",
            "music21==5.5.0\n",
            "natsort==5.5.0\n",
            "nbclient==0.7.2\n",
            "nbconvert==6.5.4\n",
            "nbformat==5.7.3\n",
            "netCDF4==1.6.3\n",
            "networkx==3.0\n",
            "nibabel==3.0.2\n",
            "nltk==3.7\n",
            "notebook==6.3.0\n",
            "numba==0.56.4\n",
            "numexpr==2.8.4\n",
            "numpy==1.22.4\n",
            "oauth2client==4.1.3\n",
            "oauthlib==3.2.2\n",
            "opencv-contrib-python==4.6.0.66\n",
            "opencv-python==4.6.0.66\n",
            "opencv-python-headless==4.7.0.72\n",
            "openpyxl==3.0.10\n",
            "opt-einsum==3.3.0\n",
            "osqp==0.6.2.post0\n",
            "packaging==23.0\n",
            "palettable==3.3.0\n",
            "pandas-datareader==0.9.0\n",
            "pandas-gbq==0.17.9\n",
            "pandas-profiling==1.4.1\n",
            "pandocfilters==1.5.0\n",
            "panel==0.14.4\n",
            "param==1.12.3\n",
            "parso==0.8.3\n",
            "partd==1.3.0\n",
            "pathlib==1.0.1\n",
            "pathy==0.10.1\n",
            "patsy==0.5.3\n",
            "pep517==0.13.0\n",
            "pexpect==4.8.0\n",
            "pickleshare==0.7.5\n",
            "Pillow==8.4.0\n",
            "pip-tools==6.6.2\n",
            "platformdirs==3.1.0\n",
            "plotly==5.5.0\n",
            "plotnine==0.10.1\n",
            "pluggy==0.7.1\n",
            "pooch==1.7.0\n",
            "portpicker==1.3.9\n",
            "prefetch-generator==1.0.3\n",
            "preshed==3.0.8\n",
            "prettytable==3.6.0\n",
            "progressbar2==3.38.0\n",
            "prometheus-client==0.16.0\n",
            "promise==2.3\n",
            "prompt-toolkit==2.0.10\n",
            "prophet==1.1.2\n",
            "proto-plus==1.22.2\n",
            "protobuf==3.19.6\n",
            "psutil==5.4.8\n",
            "psycopg2==2.9.5\n",
            "ptyprocess==0.7.0\n",
            "py==1.11.0\n",
            "pyarrow==9.0.0\n",
            "pyasn1==0.4.8\n",
            "pyasn1-modules==0.2.8\n",
            "pycocotools==2.0.6\n",
            "pycparser==2.21\n",
            "pyct==0.5.0\n",
            "pydantic==1.10.5\n",
            "pydata-google-auth==1.7.0\n",
            "pydot==1.3.0\n",
            "pydot-ng==2.0.0\n",
            "pydotplus==2.0.2\n",
            "PyDrive==1.3.1\n",
            "pyerfa==2.0.0.1\n",
            "Pygments==2.6.1\n",
            "PyGObject==3.36.0\n",
            "pymc==4.1.4\n",
            "PyMeeus==0.5.12\n",
            "pymongo==4.3.3\n",
            "pymystem3==0.2.0\n",
            "PyOpenGL==3.1.6\n",
            "pyparsing==3.0.9\n",
            "pyrsistent==0.19.3\n",
            "PySocks==1.7.1\n",
            "pytest==3.6.4\n",
            "python-apt==0.0.0\n",
            "python-dateutil==2.8.2\n",
            "python-louvain==0.16\n",
            "python-slugify==8.0.1\n",
            "python-utils==3.5.2\n",
            "pytz==2022.7.1\n",
            "pytz-deprecation-shim==0.1.0.post0\n",
            "pyviz-comms==2.2.1\n",
            "PyWavelets==1.4.1\n",
            "PyYAML==6.0\n",
            "pyzmq==23.2.1\n",
            "qdldl==0.1.5.post3\n",
            "qudida==0.0.4\n",
            "regex==2022.6.2\n",
            "requests==2.25.1\n",
            "requests-oauthlib==1.3.1\n",
            "requests-unixsocket==0.2.0\n",
            "resampy==0.4.2\n",
            "rpy2==3.5.5\n",
            "rsa==4.9\n",
            "scikit-image==0.19.3\n",
            "scikit-learn==1.2.1\n",
            "scipy==1.10.1\n",
            "screen-resolution-extra==0.0.0\n",
            "scs==3.2.2\n",
            "seaborn==0.11.2\n",
            "Send2Trash==1.8.0\n",
            "shapely==2.0.1\n",
            "six==1.15.0\n",
            "sklearn-pandas==2.2.0\n",
            "smart-open==6.3.0\n",
            "snowballstemmer==2.2.0\n",
            "sortedcontainers==2.4.0\n",
            "soundfile==0.12.1\n",
            "spacy==3.4.4\n",
            "spacy-legacy==3.0.12\n",
            "spacy-loggers==1.0.4\n",
            "Sphinx==3.5.4\n",
            "sphinxcontrib-applehelp==1.0.4\n",
            "sphinxcontrib-devhelp==1.0.2\n",
            "sphinxcontrib-htmlhelp==2.0.1\n",
            "sphinxcontrib-jsmath==1.0.1\n",
            "sphinxcontrib-qthelp==1.0.3\n",
            "sphinxcontrib-serializinghtml==1.1.5\n",
            "SQLAlchemy==1.4.46\n",
            "sqlparse==0.4.3\n",
            "srsly==2.4.6\n",
            "statsmodels==0.13.5\n",
            "sympy==1.7.1\n",
            "tables==3.7.0\n",
            "tabulate==0.8.10\n",
            "tblib==1.7.0\n",
            "tenacity==8.2.2\n",
            "tensorboard==2.11.2\n",
            "tensorboard-data-server==0.6.1\n",
            "tensorboard-plugin-wit==1.8.1\n",
            "tensorflow==2.11.0\n",
            "tensorflow-datasets==4.8.3\n",
            "tensorflow-estimator==2.11.0\n",
            "tensorflow-gcs-config==2.11.0\n",
            "tensorflow-hub==0.12.0\n",
            "tensorflow-io-gcs-filesystem==0.31.0\n",
            "tensorflow-metadata==1.12.0\n",
            "tensorflow-probability==0.19.0\n",
            "termcolor==2.2.0\n",
            "terminado==0.17.1\n",
            "text-unidecode==1.3\n",
            "textblob==0.15.3\n",
            "thinc==8.1.8\n",
            "threadpoolctl==3.1.0\n",
            "tifffile==2023.2.28\n",
            "tinycss2==1.2.1\n",
            "toml==0.10.2\n",
            "tomli==2.0.1\n",
            "toolz==0.12.0\n",
            "torch @ https://download.pytorch.org/whl/cu116/torch-1.13.1%2Bcu116-cp39-cp39-linux_x86_64.whl\n",
            "torchaudio @ https://download.pytorch.org/whl/cu116/torchaudio-0.13.1%2Bcu116-cp39-cp39-linux_x86_64.whl\n",
            "torchsummary==1.5.1\n",
            "torchtext==0.14.1\n",
            "torchvision @ https://download.pytorch.org/whl/cu116/torchvision-0.14.1%2Bcu116-cp39-cp39-linux_x86_64.whl\n",
            "tornado==6.2\n",
            "tqdm==4.65.0\n",
            "traitlets==5.7.1\n",
            "tweepy==3.10.0\n",
            "typer==0.7.0\n",
            "typing_extensions==4.5.0\n",
            "tzdata==2022.7\n",
            "tzlocal==4.2\n",
            "uritemplate==4.1.1\n",
            "urllib3==1.26.14\n",
            "vega-datasets==0.9.0\n",
            "wasabi==0.10.1\n",
            "wcwidth==0.2.6\n",
            "webencodings==0.5.1\n",
            "Werkzeug==2.2.3\n",
            "widgetsnbextension==3.6.2\n",
            "wordcloud==1.8.2.2\n",
            "wrapt==1.15.0\n",
            "xarray==2022.12.0\n",
            "xarray-einstats==0.5.1\n",
            "xgboost==1.7.4\n",
            "xkit==0.0.0\n",
            "xlrd==1.2.0\n",
            "xlwt==1.3.0\n",
            "yellowbrick==1.5\n",
            "zict==2.2.0\n",
            "zipp==3.15.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!pip show promise\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Uvso9JRZlGgd",
        "outputId": "c45b8bea-b45c-4656-cb2a-b9af7bc44dea"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Name: promise\n",
            "Version: 2.3\n",
            "Summary: Promises/A+ implementation for Python\n",
            "Home-page: https://github.com/syrusakbary/promise\n",
            "Author: Syrus Akbary\n",
            "Author-email: me@syrusakbary.com\n",
            "License: MIT\n",
            "Location: /usr/local/lib/python3.9/dist-packages\n",
            "Requires: six\n",
            "Required-by: tensorflow-datasets\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "help()"
      ],
      "metadata": {
        "id": "Y69xAlX_h2kh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gDjyP1680jfr"
      },
      "source": [
        "**Exercise**\n",
        "\n",
        "Prepare a chart for fruits and their prices \n",
        "\n",
        "apple 30\n",
        "banana 20\n",
        "Guaua 40\n",
        "\n",
        "write a function to takes fruit names and quantity as input and print the bill as follows as output.\n",
        "\n",
        "Input: Bill('apple', 2, 'banana', 1) /br\n",
        "Output:\n",
        "\n",
        "fruit quanity price /br\n",
        "apple 2       60 /br\n",
        "banana 1      20 /br\n",
        "\n",
        "Total         80"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZlkrpqDgNsZq"
      },
      "source": [
        "#summary\n",
        "\n",
        "x = 2\n",
        "y = 2.2\n",
        "\n",
        "a = True\n",
        "b = False\n",
        "\n",
        "s = \"Sriram\"\n",
        "\n",
        "\n",
        "list = [1,2,3,4]\n",
        "set = {19,2,3,4}\n",
        "tuple = (1,2,3,4)\n",
        "\n",
        "\n",
        "dict = [\"1\":1,\"2\":2]\n",
        "\n",
        "x*y\n",
        "\n",
        "if x<y:\n",
        "  print(x)\n",
        "elif y<x:\n",
        "  print(x)\n",
        "else:\n",
        "  print(y)\n",
        "\n",
        "\n",
        "while x<10:\n",
        "  print(x)\n",
        "  x += 1\n",
        "\n",
        "for i in list:\n",
        "  print(i)\n",
        "\n",
        "\n",
        "def fun():\n",
        "  print(\"hey!!!!!\")\n",
        "\n",
        "\n",
        "class Greet:\n",
        "  def __init__(self, name)\n",
        "    self.name = name\n",
        "  def wish(self):\n",
        "    print(\"hello!!!\", self.name)\n",
        "\n",
        "\n",
        "s = Greet(\"sriram\")\n",
        "s.wish()"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}