class_01.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "class-01.ipynb",
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/tn-220/Python-I-II/blob/main/class_01.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JyG45Qk3qQLS"
      },
      "source": [
        "# Cells\n",
        "A notebook is a list of cells. Cells contain either explanatory text or executable code and its output. Click a cell to select it."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KR921S_OQSHG"
      },
      "source": [
        "## Code cells\n",
        "Below is a **code cell**. Once the toolbar button indicates CONNECTED, click in the cell to select it and execute the contents in the following ways:\n",
        "\n",
        "* Click the **Play icon** in the left gutter of the cell;\n",
        "* Type **Cmd/Ctrl+Enter** to run the cell in place;\n",
        "* Type **Shift+Enter** to run the cell and move focus to the next cell (adding one if none exists); or\n",
        "* Type **Alt+Enter** to run the cell and insert a new code cell immediately below it.\n",
        "\n",
        "There are additional options for running some or all cells in the **Runtime** menu.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "both",
        "id": "WUtu4316QSHL"
      },
      "outputs": [],
      "source": [
        "a = 10\n",
        "a"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Id6tDF1HQSHD"
      },
      "source": [
        "## Text cells\n",
        "This is a **text cell**. You can **double-click** to edit this cell. Text cells\n",
        "use markdown syntax. To learn more, see our [markdown\n",
        "guide](/notebooks/markdown_guide.ipynb).\n",
        "\n",
        "You can also add math to text cells using [LaTeX](http://www.latex-project.org/)\n",
        "to be rendered by [MathJax](https://www.mathjax.org). Just place the statement\n",
        "within a pair of **\\$** signs. For example `$\\sqrt{3x-1}+(1+x)^2$` becomes\n",
        "$\\sqrt{3x-1}+(1+x)^2.$\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R_J2bPrMWspS"
      },
      "source": [
        "##Creating a Comment\n",
        "Comments starts with a #, and Python will ignore them:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "both",
        "id": "5t5ThvzrWxDf"
      },
      "outputs": [],
      "source": [
        "#This is a comment\n",
        "print(\"Hello, World!\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U7y61Mz2X_1Z"
      },
      "source": [
        "##Python Data Types\n",
        "Variables can store data of different types.\n",
        "Python has the following data types built-in by default, in these categories:\n",
        "\n",
        "*   Text Type: **str**\n",
        "\n",
        ">>\\n : Line change.\n",
        ">>\n",
        ">>\\t : Tab.\n",
        ">>\n",
        ">>\\\\ : Backslash character.\n",
        ">>\n",
        ">>r : Carriage return.\n",
        ">>\n",
        ">>\\a : Bell.\n",
        ">>\n",
        ">>\\b : Back space.\n",
        "\n",
        "\n",
        "*   Numeric Types: **int, float, complex**\n",
        "*   Boolean Type: **bool**\n",
        "*   Sequence Types: **list, tuple, range**\n",
        "*   Mapping Type: **dict**\n",
        "*   Set Types: **set, frozenset**\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "both",
        "id": "F-9zGwSgX_1g"
      },
      "outputs": [],
      "source": [
        "print(\"type(´Hi´) : \", type(\"Hi!\"))"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"type(5) = \", type(5.0))"
      ],
      "metadata": {
        "id": "abXRYAziboF0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"type(0o123)\", type(0o123))   # Octal"
      ],
      "metadata": {
        "id": "IdkCrhSrboWc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"type(0xFFAA)\", type(0xFFAA)) # Hexadecimal"
      ],
      "metadata": {
        "id": "VDOalQ5GboaC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"type(5.3) : \", type(5.3))"
      ],
      "metadata": {
        "id": "-TTVrMIybodi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"type(1+5j) : \", type(1+5j))"
      ],
      "metadata": {
        "id": "wCIvC7qBbohi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"type(True) : \", type(True))"
      ],
      "metadata": {
        "id": "p_J0Jnilbok_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"type(False) : \", type(False))"
      ],
      "metadata": {
        "id": "5K5qNJLbcBzx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"type(range(2,6)) : \", type(range(2,6)), range(2,6))"
      ],
      "metadata": {
        "id": "sLUYS0blcFIR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"type([1 , 2, 2, 100.5]) : \", type([1 , 2, 2, 100.5]))"
      ],
      "metadata": {
        "id": "Mcz-Wx25bo_P"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"type((1 , 2, 2, 100.5)) : \", type((1 , 2, 2, 100.5)))"
      ],
      "metadata": {
        "id": "suzJGv3IdZmU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"type({1 , 2, 2, 100.5}) : \", type({1 , 2, 2, 100.5}))"
      ],
      "metadata": {
        "id": "zO-U59g2du2h"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"He said:\\n'Python is very easy'\")"
      ],
      "metadata": {
        "id": "YmIVfoT85HEO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print('He said, \"Python is very easy\"')"
      ],
      "metadata": {
        "id": "C03qYe3K5g7Z"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(3 + 6)"
      ],
      "metadata": {
        "id": "nF5O8DRqhrGW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(6 + 7.0)"
      ],
      "metadata": {
        "id": "DHRo3TiFhv76"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(4 * 7)"
      ],
      "metadata": {
        "id": "met61koch37f"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(49 / 7)  # division always returns float"
      ],
      "metadata": {
        "id": "CwCC6uTaiDS0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XfyU6xz0bA6q"
      },
      "source": [
        "##Python Arithmetic Operators\n",
        " \\+ : Addition\t\n",
        "> x + y\n",
        "\n",
        "\\- : Subtraction\n",
        "> x - y\t\n",
        "\n",
        "\\* : Multiplication\n",
        "> x * y\n",
        "\n",
        "/ : Division\n",
        "> x / y\t\n",
        "\n",
        "\\% : Modulus\n",
        "> x % y\t\n",
        "\n",
        "\\** : Exponentiation\n",
        "> x ** y\t\n",
        "\n",
        "\\// : Floor division\n",
        "> x // y\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "both",
        "id": "KygmTajkbA6y"
      },
      "outputs": [],
      "source": [
        "3 ** 2"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "9 ** 0.5"
      ],
      "metadata": {
        "id": "rq2TTe-u95LH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "9 ** (-1)"
      ],
      "metadata": {
        "id": "mBObWa5d-4XJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "69 / 2"
      ],
      "metadata": {
        "id": "pzq8700g97II"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "69 // 2"
      ],
      "metadata": {
        "id": "qA8lHVJi-TE8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "69 % 2"
      ],
      "metadata": {
        "id": "3rCVNReE-C8K"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Python string Concatenation (+) and Repetition (*)"
      ],
      "metadata": {
        "id": "63Nv4Pud_roJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "str1 = 'First string, '\n",
        "str2 = 'Second string.'\n",
        "str1 + str2"
      ],
      "metadata": {
        "id": "bHaUgKxfCB3E"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "str = 'Python '\n",
        "print(str * 3)\n",
        "a = 2\n",
        "x = \"5\"\n",
        "y = 5.0\n",
        "#print(a+x) \n",
        "print(type(a + y))"
      ],
      "metadata": {
        "id": "2ykPN3zWCF1q"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Python string Indexing and Slicing:\n",
        "\n",
        "* In Python, indices start from 0. So, the first character corresponds to the index 0!\n",
        "* Negative index means position from the end; index -1 corresponds to the last character. \n",
        "* An index range a:b includes a and excludes b.\n"
      ],
      "metadata": {
        "id": "ggRUWuFsCfJG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "str = 'Life is too short, You need Python!'\n",
        "print(str[5])\n",
        "str[5]"
      ],
      "metadata": {
        "id": "JFpqGZlkC6Dz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "str[3]"
      ],
      "metadata": {
        "id": "zscwUW0ODLFj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "str[-1]"
      ],
      "metadata": {
        "id": "pezDWtvLDObL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "str[4:8]"
      ],
      "metadata": {
        "id": "K22eHlMCDdW7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "str[:17]"
      ],
      "metadata": {
        "id": "bJ1Y7MlKDirq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "str[19:]"
      ],
      "metadata": {
        "id": "pb2f00jyDmRC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "##Some of the useful Python string methods:\n",
        "\n",
        "* **x.count(str)** : Count the string pattern.\n",
        "* **x.find(str)** : Position of  the first match. -1 if no match is found.\n",
        "* **x.index(str)** : Position of the first match. Error if no match is found.\n",
        "* **len(x)** : String length. This is not a string method but a built-in Python function.\n",
        "* **x.lstrip()**\tTrim left white spaces.\n",
        "* **x.rstrip()** : Trim right white spaces.\n",
        "* **x.strip()** : Trim white spaces from both sides.\n",
        "* **x.replace(str1, str2)** : Replace string from str1 to str2.\n",
        "* **x.join(str_list)** : Join the string list items using x as connector.\n",
        "* **x.split(y)** : Split a string by y.\n",
        "* **x.upper()** : Convert to the upper case.\n",
        "* **x.lower()** : Convert to the lower case.\n"
      ],
      "metadata": {
        "id": "qH_uI6jcB-8n"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = 'Python'\n",
        "len(x)\t\t\t\t# String length. This is a Python built-in function.\n"
      ],
      "metadata": {
        "id": "Zdp1XvQv-Kvc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "x.count('h')\t\t\t\t# Counts the 'h' character."
      ],
      "metadata": {
        "id": "AwEVtxEiEzyc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "x.upper()\t\t\t\t# Convert to the uppercase."
      ],
      "metadata": {
        "id": "MYvEgnLwE8VI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "x.lower()\t\t\t\t# Convert to the lowercase."
      ],
      "metadata": {
        "id": "fiYAJn7iFhMW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "x = 'Python'\n",
        "x.find('o')\t\t\t\t# Position of the 'o'.\n"
      ],
      "metadata": {
        "id": "lJ16EQUsFjhd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "x.find('w')\t\t\t\t# Look for the position of the 'w'. No match.\n"
      ],
      "metadata": {
        "id": "CtLYhp41FoEq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "x.index('o')\t\t\t\t# Look for the position of the 'o'.\n"
      ],
      "metadata": {
        "id": "kEnP0UebFqlM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "x.index('w')\t\t\t\t# Look for the position of the 'w'. No match."
      ],
      "metadata": {
        "id": "cU8GXk3eFtzZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "x = 'Life is too short, You need Python!'\n",
        "print(x.split(' '))                                                                      \t\t  # The output is a list (*).)\n",
        "print(x.split(\"o\"))"
      ],
      "metadata": {
        "id": "eFPTwzN5FzA0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "y = x.split(' ')\n",
        "print(\"y = \", y)\n",
        "a = ' '\n",
        "print(\"a.join(y) = \", a.join(y))\n"
      ],
      "metadata": {
        "id": "JtrDvLB7GJrz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Python Logical Operators\n",
        "* **and** : Returns True if both statements are true\t\n",
        "* **or** : Returns True if one of the statements is true\n",
        "* **not** : Reverse the result, returns False if the result is true\n"
      ],
      "metadata": {
        "id": "JwKDRrLHIkyC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "False and True"
      ],
      "metadata": {
        "id": "zfYS2tl1JCgO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\"h\" and False"
      ],
      "metadata": {
        "id": "8cyhwi50GNak"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "not(2 == 3)"
      ],
      "metadata": {
        "id": "izOaxufzKIEq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "not(2 >= 1)"
      ],
      "metadata": {
        "id": "PZWGEGpPKRsm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "5 < 4"
      ],
      "metadata": {
        "id": "3AChqtWoKV_R"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Python Variables\n",
        "\n",
        "* Variables are containers for storing data values.\n",
        "* Python has no command for declaring a variable.\n",
        "* A variable is created the moment you first assign a value to it (dynamic type).\n",
        "* Name of a variable can start with a letter or _\n",
        "* Variable names are case sensitive"
      ],
      "metadata": {
        "id": "ZSrRbLCvJ4tQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = 5\n",
        "print(type(x))"
      ],
      "metadata": {
        "id": "0YEt9hR_Pp9N"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "y = \"hello\"\n",
        "print(type(y))"
      ],
      "metadata": {
        "id": "Mh56j-_mP-1a"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "x = y\n",
        "print(type(x))"
      ],
      "metadata": {
        "id": "LuAG8Kn5QEYN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "x = 2\n",
        "y = 1.5\n",
        "x = x + y\n",
        "print(x)"
      ],
      "metadata": {
        "id": "5FGCqH1EQO1w"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Variable Naming Conventions\n",
        "\n",
        "* Snakecase: Words are delimited by an underscore.\n",
        "* Pascalcase: Words are delimited by capital letters.\n",
        "* Camelcase: Words are delimited by capital letters, except the initial word."
      ],
      "metadata": {
        "id": "bpvD__F8Q3Ul"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_age = 25  # snake case variable naming\n",
        "\n",
        "myAge = 24  # camel case variable naming\n",
        "\n",
        "MyAge = 23  # pascal case\n",
        "\n",
        "print(MyAge == myAge)\n",
        "print(MyAge)\n",
        "print(myAge)\n",
        "\n",
        "PI = 3.14  # used for constants"
      ],
      "metadata": {
        "id": "jFRiqcF3SO9x"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Follow practice steps on 'ex_0101.ipynb'\n",
        "## Follow practice steps on 'ex_0102.ipynb'"
      ],
      "metadata": {
        "id": "zt2SS-6ESvmI"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Composite Data Types in Python\n",
        "\n",
        "* **List**: stores multiple values that may or may not be of the same type.\n",
        "* **Tuple**: similar to the list with some restrictions. Tuples are immutable objects (*).\n",
        "* **Dictionary**: associative array.\n",
        "* **Set**: unordered collection of values without repetition. \n"
      ],
      "metadata": {
        "id": "C_YlFZszZzoA"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**A list contains comma separated values within square brackets.**"
      ],
      "metadata": {
        "id": "GZgYJw64i6nu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = [ ]\t\t\t\t                                         # An empty list."
      ],
      "metadata": {
        "id": "KpdrvMRTg1hp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "b = [1, 2, 3]\t\t\t                                     # A list with numeric values."
      ],
      "metadata": {
        "id": "khZc_As6g5G_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "c = ['Life', 'is', 'too', 'short']\t\t                 # A list with strings."
      ],
      "metadata": {
        "id": "LELZACN5g7VI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "d = [1, 2, 'Life', 'is']\t\t\t                         # A list with mixed data type values.\t"
      ],
      "metadata": {
        "id": "wFo_lRuzhGeO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "d = [1, 2, 'Life', 'is']\t\t\t                         # A list with mixed data type values."
      ],
      "metadata": {
        "id": "4MMrC9KTg_7K"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "e = [1, 2, ['Life', 'is']]\t\t                         # A nested list."
      ],
      "metadata": {
        "id": "yin6cccwhVoW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "e[1]\t\t\t\t                                           # Indexing of a list."
      ],
      "metadata": {
        "id": "_Xz7V3CehlkR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "e[2]"
      ],
      "metadata": {
        "id": "8WqhXPkyhp4y"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "e[2][1]"
      ],
      "metadata": {
        "id": "4XhFko4mhuc-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a = [1, 2, 3, 4, 5]"
      ],
      "metadata": {
        "id": "-rjNzbG2hyID"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Slicing a list:**"
      ],
      "metadata": {
        "id": "3JSUWaccjKVC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a[:2]                                      # From the index 0 to 1 (inclusive)."
      ],
      "metadata": {
        "id": "kv-4O03viKyp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a[2:]                       \t\t           # From the index 2 to the end."
      ],
      "metadata": {
        "id": "OmLPOF_XiOlz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a[:]\t\t\t          \t                     # The whole list!"
      ],
      "metadata": {
        "id": "LxvEbzwmiRaz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a = [1, 2, 3, ['a', 'b', 'c'], 4, 5]"
      ],
      "metadata": {
        "id": "DE9Tw2ZXihm9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a[2:5]"
      ],
      "metadata": {
        "id": "F93x4IFZij8U"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a[3][:2]"
      ],
      "metadata": {
        "id": "qhH2oMAOimTw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Concatenation (+) :**\n",
        "\n",
        "To join two list objects, use the + operator."
      ],
      "metadata": {
        "id": "yrKdhwOGjasF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = [1, 2, 3]\n",
        "b = [4, 5, 6]\n",
        "a + b"
      ],
      "metadata": {
        "id": "n8AsQKQGjt2U"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Repetition (*):**\n",
        "\n",
        "To repeat a list object by a given number of times, use the * operator. "
      ],
      "metadata": {
        "id": "5gskgQt9kCU2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = [1, 2, 3]\n",
        "a * 3"
      ],
      "metadata": {
        "id": "PKcs5r__kU_7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Modifying a list: change one or multiple entries :**\n",
        "\n"
      ],
      "metadata": {
        "id": "9dJ7aJobk81V"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = [1, 2, 3]\n",
        "a[1] = -1\n",
        "a"
      ],
      "metadata": {
        "id": "ZQfvX0Vnk81c"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a[1:3]"
      ],
      "metadata": {
        "id": "qRVp10SslLsr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a[1:3] = [3, 5, 7, 9, 11]\n",
        "a"
      ],
      "metadata": {
        "id": "hk334_WmlNUe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Modifying a list: careful with the following differences.**"
      ],
      "metadata": {
        "id": "QoMmDXchmYcw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = [1, 2, 3]\n",
        "a[1:2] = [-1, -2, -3]\t\t\t             # Partial change of the list values.\n",
        "a"
      ],
      "metadata": {
        "id": "yqDhocGJmfI_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a = [1, 2, 3]\n",
        "a[1] = [-1, -2, -3]\t\t\t                # An entry is replaced by another list.\n",
        "a"
      ],
      "metadata": {
        "id": "qAxJ9gQlmq4N"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Modifying a list: partial removal.**"
      ],
      "metadata": {
        "id": "E2gD0pgrnAfj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = [1, 2, 3, 4, 5]\n",
        "a[1:3] = []\t\t\t\t# Partial removal.\n",
        "a"
      ],
      "metadata": {
        "id": "PzztU1MFnEL7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a = [1, 2, 3, 4, 5]\n",
        "del a[2]\t\t\t\t# Removes a specific entry using del keyword\n",
        "a"
      ],
      "metadata": {
        "id": "_bQ4syfWnFeM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Python list methods:\n",
        "* **x.insert(pos, val) :** Insert a value at a specified position.\n",
        "* **x.remove(val) :** Remove a specific value from a list.\n",
        "* **x.pop() :** Remove and return the last value of a list.\n",
        "* **x.count(val) :** Count the appearances of a value in a list.\n",
        "* **x.extend(y) :** Extend the list x with another list y. Means  x = x + y.\n",
        "* **x.append(val) :** Appends a value as an entry.\n",
        "* **x.sort() :** Sorting of a list.\n",
        "* **x.reverse() :** Reversal of the entry ordering.\n",
        "* **x.index(val) :** Looks for the position of a specific value. Error if no match is found.\n",
        "* **len(x) :** Total number of entries in a list. A built-in Python function.\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "DycYd6zKpiQO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = [3, 1, 5, 2, 4]\n",
        "a.sort()\t      \t\t\t# Sorting of a list object (lasting effect).\n",
        "a"
      ],
      "metadata": {
        "id": "eUUo3D8pqGX1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a = [1, 2, 3]\n",
        "a.append(4)\t\t\t    \t# A value is added as an entry. \t\t\n",
        "a.append([5,6])\t\t \t\t# A list is added as an entry.\n",
        "a"
      ],
      "metadata": {
        "id": "P1eHAx6Zqbzl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a = [3, 1, 5, 2, 4]\n",
        "a.sort(reverse=True)\t\t\t# Sorting in reverse order.\t\t\n",
        "a"
      ],
      "metadata": {
        "id": "Y1b0fdcAqhbg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a = [1, 2, 3, 4, 5]\n",
        "a.reverse()\t\t\t\t       # Reverse the order. Different from sorting.\t\n",
        "a\n"
      ],
      "metadata": {
        "id": "Y2Rt4FRiqso8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a = [3, 1, 5, 2, 4]\n",
        "sorted(a)\t\t\t         \t# Displays a sorted view."
      ],
      "metadata": {
        "id": "cciucqjMqxAm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a                       # No permanent changes."
      ],
      "metadata": {
        "id": "NJC6klNlrIMQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a.index(5)"
      ],
      "metadata": {
        "id": "djdn8pw2rZ8s"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Composite Data Types : Tuple (1/5)"
      ],
      "metadata": {
        "id": "KMIUN69PMFu9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = ( )\n",
        "a\t\t\t\t                         # An empty tuple."
      ],
      "metadata": {
        "id": "ss1E1SL9MfE8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "b = (1, 2, 3)\n",
        "b[2]\t\t\t\t# A tuple with numeric values.\n",
        "b[2] = 4  #error"
      ],
      "metadata": {
        "id": "yOnHFNHWMqlV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "c = ('Life', 'is', 'too', 'short')\t\t                     #A tuple with strings.\n",
        "c"
      ],
      "metadata": {
        "id": "yIhd-aqGMsad"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "d = (1, 2, 'Life', 'is')\t\t\t                         # A tuple with mixed data type values.\t\n",
        "d"
      ],
      "metadata": {
        "id": "7RjPHIoeMueU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "e = (1, 2, ('Life', 'is'))\n",
        "e"
      ],
      "metadata": {
        "id": "4MeV-1n2Mw3K"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "e[1]"
      ],
      "metadata": {
        "id": "JcrvuOLkOKqg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a = (1, 2, 3, 4, 5)\n",
        "print(a[:2])                                                                                                      # From the index 0 to 1 (inclusive).      \n",
        "print(a[2:])                                         \t\t                         # From the index 2 to the end.\n",
        "print(a[:])\t\t\t\t                         # The whole tuple!\t\n",
        "\n"
      ],
      "metadata": {
        "id": "lt_sC4wOOYoZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a = (1, 2, 3)\n",
        "b = (4, 5, 6)\n",
        "a + b\n"
      ],
      "metadata": {
        "id": "Dg72oistPBNw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a = (1, 2, 3)\n",
        "a[2] = 5\n",
        "a = b * 3\n",
        "\n",
        "del a[1]\n",
        "\n"
      ],
      "metadata": {
        "id": "Rr02FMBuPZQh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a = { }\t\t\t\t\t# An empty dictionary.\n",
        "b = {'NAME': 'JAMES', \n",
        "     'GENDER': 'MALE', \n",
        "     'AGE': 35}\t# Numbers and strings as values. \t\n",
        "c = {1: 'Life', 2: 'is', 3: 'short' }\t\t\n",
        "d = {'x':[1,2,3], 'y':[4,5,6]}\t\t\t# Lists are used as values.\n",
        "e = {1:b, 2:c}\n",
        "b['NAME']\n",
        "print(e[1])\n",
        "print(d['x'])\n",
        "print(c[3])\n",
        "print(d['x'][1])"
      ],
      "metadata": {
        "id": "hVBOiuymQgQR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a = {}\t\t\t\t                         # An empty dictionary.\t\t\n",
        "a['NAME'] = 'JAMES'\t\t\t# Add a pair.\n",
        "a['GENDER'] = 'MALE'\t\t\t# Add a pair.\n",
        "a['AGE'] = 35\t\t\t\t# Add a pair.\n",
        "a\n"
      ],
      "metadata": {
        "id": "Fbj6KaP9SZtY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "del a['AGE'] \t\t\t\t# Delete a pair.\n",
        "a"
      ],
      "metadata": {
        "id": "EjCMyfQxTEAY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a['NAME'] = 'JOHN' \t\t\t# Change the value of a pair. \n",
        "a"
      ],
      "metadata": {
        "id": "TU7s9uZBTaTO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a.items()\t\t\t\t# Show the content of a dictionary. "
      ],
      "metadata": {
        "id": "qNZuBVM0T0bM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a.clear()\n",
        "a"
      ],
      "metadata": {
        "id": "9LipaFmDT3a4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "x = [1, 2, 3, 4]\n",
        "print(x[2])\n",
        "print(x[10])"
      ],
      "metadata": {
        "id": "vA3Vao5DUHmS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a = {'name': 'JONE', 'gender': 'MALE', 'age': 35} \n",
        "print(a['wage'])"
      ],
      "metadata": {
        "id": "RcA-1yx7UZ-Q"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a = {'name': 'JONE', 'gender': 'MALE', 'age': 35} \n",
        "print(a.get('name'))\n",
        "print(a['name'])\n",
        "print(a.get('wage', 5))\n",
        "print(a)"
      ],
      "metadata": {
        "id": "bfSctxhQUpJ-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a = {'name': 'JOHN', 'gender': 'MALE', 'age': 35} \n",
        "print('name' in a)\n",
        "print('wage' in a)"
      ],
      "metadata": {
        "id": "iE9lFCj3VVBI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a = set()\t\t\t\t# An empty set.\n",
        "b = set([1,2,3,3,3,3,4,5])\n",
        "c = tuple([1,2,3,3,3,3,4,5])\n",
        "print(a)\n",
        "print(b)\n",
        "print(c)\n",
        "print(type(a))\n",
        "print(type(b))\n",
        "print(type(c))\n",
        "print(type([1,2,3,3,3,3,4,5]))\n"
      ],
      "metadata": {
        "id": "-_RdD8CiV5b9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "s1 = set([1, 2, 3, 4, 5])\n",
        "s2 = set([4, 5, 6, 7, 8])\n",
        "print(s1 & s2)\t\t\t\t# Intersection of s1 and s2.\t\n",
        "print(s1.intersection(s2))\n",
        "print(s1 | s2)\n",
        "print(s1.union(s2))\n",
        "print(s1-s2)\n",
        "print(s1.difference(s2))\n",
        "s2.add(1)\n",
        "print(s2)\n",
        "s2.update([7,9,11])\n",
        "print(s2)\n",
        "s2.remove(6)\n",
        "print(s2)\n"
      ],
      "metadata": {
        "id": "ycNce0YtXA9C"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "m = input()\n",
        "print(m)\n",
        "if x in s2:\n",
        "  s2.remove(m)\n",
        "  print(s2)\n",
        "else:\n",
        "  print(m, \" is not in the set\")"
      ],
      "metadata": {
        "id": "mxIF99wHaE67"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Quiz 0101 "
      ],
      "metadata": {
        "id": "9n3ulWz_eBHl"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**1)**. In the class A, students' heights are:\n",
        "\n",
        "161.5\n",
        "165.9\n",
        "168.7\n",
        "163.1\n",
        "170.8\n",
        "167.2\n",
        "\n",
        "Calculate the mean height by using Python 'list' and 'for' loop:"
      ],
      "metadata": {
        "id": "QxDPFIGpeSvG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "A = [161.5,165.9,168.7,163.1,170.8,167.2]\n",
        "sum = 0\n",
        "i = 0\n",
        "for a in A:\n",
        "    print(a)\n",
        "    sum += a\n",
        "    i = i+1\n",
        "print(sum/len(A))"
      ],
      "metadata": {
        "id": "j23p2qauY5n2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**2)**. In the class B, students' heights are:\n",
        "\n",
        "172.5\n",
        "162.9\n",
        "161.7\n",
        "160.1\n",
        "161.8\n",
        "169.2\n",
        "\n",
        "Calculate the mean height by using Python 'list' and 'for' loop:"
      ],
      "metadata": {
        "id": "L_3vDLUZeaza"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "B = [172.5,162.9, 161.7, 160.1, 161.8, 169.2] \n",
        "sum = 0\n",
        "for b in B:\n",
        "    sum += b\n",
        "print(sum/len(B))"
      ],
      "metadata": {
        "id": "H_zpNZGLeNm8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "YXHFSkm4g2FA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**3).** The class A and the class B are joined together to form the class AB. Calculate the mean height by using Python 'list' and 'for' loop:"
      ],
      "metadata": {
        "id": "HR6_h3Y5eoPZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "AB = A + B\n",
        "sum = 0\n",
        "for ab in AB:\n",
        "    sum += ab\n",
        "print(sum/len(AB))"
      ],
      "metadata": {
        "id": "Xs-5O9Hberzy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "yOwyWEAag24T"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**4).** Sort the heights of the class AB."
      ],
      "metadata": {
        "id": "AfNUCSSte5Af"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "AB.sort()\n",
        "print(AB)"
      ],
      "metadata": {
        "id": "WSpOifbHe8B5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "fHPVY_Zwg3sv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**5)**. The class C is formed with students with the height less than 165. Make a list 'C' containing the heights of the class C."
      ],
      "metadata": {
        "id": "EwIQy1-0fByF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "C =[]\n",
        "for ab in AB:\n",
        "    if (ab < 165):\n",
        "        C.append(ab)\n",
        "print(C)"
      ],
      "metadata": {
        "id": "8o_R1BdJfDxx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**6).** The class D is formed with students with the height larger than 160 and less than 170. Make a list containing the heights of the class D."
      ],
      "metadata": {
        "id": "C-SWkYVRfKtK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "D =[]\n",
        "for ab in AB:\n",
        "    if (ab > 160 and ab < 170):\n",
        "        D.append(ab)\n",
        "print(D)"
      ],
      "metadata": {
        "id": "b7IoH4wmfMqs"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}