Day_01_Python_Basics_Part1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Day 1 : Python Basics with Code Implementation-Part1.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyM79Gcp9AHqMx7YHzhOYi+D"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "## Intro to Python\n",
        "\n",
        "Python is a high-level, most widely used multi-purpose, easy to read programming language.\n",
        "\n",
        "\n",
        "*   Interpreted - Python is processed at runtime by the interpreter. i.e. you do not need to compile your program before executing it.\n",
        "*   Interactive - You can interact with interpreter directly to write your programs\n",
        "*   Portable - It can run on wide range of hardware Platforms\n",
        "*   Object-Oriented - Python suppports Object-Oriented style and Procedural Paradigms\n",
        "*   Used as a scripting language or can be compiled to byte-code for building large applications\n",
        "*   It has simple structure, and a clearly defined syntax\n",
        "*   Known as Beginner's Language - It's great language for beginner-level programmers\n",
        "*   Source code is comparatively easy-to-maintain\n",
        "*   Provides very high-level dynamic data types and supports dynamic type checking.\n",
        "*   Has a huge collection of standard library\n",
        "\n",
        "Popular applications for Python\n",
        "\n",
        "\n",
        "*   Web Development\n",
        "*   Data Science - including machine learning, data analysis, and data visualization\n",
        "*   Scripting\n",
        "*   Game Development\n",
        "*   CAD Applications\n",
        "*   Embedded Applications\n",
        "\n"
      ],
      "metadata": {
        "id": "aGlocV5vD5Vh"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Python Data Types\n",
        "Data Types represent the kind of value variable can hold and what all operations can be performed on a particular data.\n",
        "\n"
      ],
      "metadata": {
        "id": "iQMxuxxcD5S7"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "<div style=\"text-align:center\"><img alt=\"Python Data Type\" src=\"https://github.com/thunderstroke325/60-Days-of-Data-Science-and-ML/blob/main/assets/data_types.png?raw=true\" /></div>.\n"
      ],
      "metadata": {
        "id": "Q9o7NslgD5Qg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Int data type\n",
        "var = 5\n",
        "print(var)\n",
        "print(type(var))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "o8MGcG31D4n-",
        "outputId": "0a40c650-63c0-487d-e291-63030dd1b3e9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n",
            "<class 'int'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Float data type\n",
        "var2 = 0.1234\n",
        "print(var2)\n",
        "print(type(var2))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DnKL7vbHO8Hj",
        "outputId": "1986a73e-4e5a-4cc3-fa85-f130874fd7de"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.1234\n",
            "<class 'float'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Complex numbers data type\n",
        "x = 2j\n",
        "print(x)\n",
        "print(type(x))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oUPnwgmXO8EP",
        "outputId": "99c948f0-ecf9-480b-d6f8-c6e0289e86c6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2j\n",
            "<class 'complex'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# String Data type\n",
        "str_one = \"Hello World\"\n",
        "print(str_one)\n",
        "print(type(str_one))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-sCRtktIO8B3",
        "outputId": "0aff5352-5438-4f96-b62e-335a51ce2170"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello World\n",
            "<class 'str'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# list data type\n",
        "list1 = [\"cat\", \"bike\"]\n",
        "print(list1)\n",
        "print(type(list1))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Wt2T1NgkQY0S",
        "outputId": "40e765fc-149b-469a-e2b0-d8af12bcb816"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['cat', 'bike']\n",
            "<class 'list'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# tuple data type\n",
        "tup = (\"cat\", \"bike\", \"bus\")\n",
        "print(tup)\n",
        "print(type(tup))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "D0BWy1LyQYx3",
        "outputId": "a9911556-f392-434c-a195-293cf2334ba9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "('cat', 'bike', 'bus')\n",
            "<class 'tuple'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# dictionary data type\n",
        "dict_one = {\"Name\": \"Steve\", \"Location\": \"NewYork\"}\n",
        "print(dict_one)\n",
        "print(type(dict_one))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jyKhnTHwQYvX",
        "outputId": "c4ed6976-d3df-46bf-e85f-9212a772750f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'Name': 'Steve', 'Location': 'NewYork'}\n",
            "<class 'dict'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Set data type\n",
        "set_one = set({\"Hello\", \"world\", \"Hello\"})\n",
        "print(set_one)\n",
        "print(type(set_one))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "w1ouiQNVS3Ye",
        "outputId": "a69fdc5d-617b-40ef-ddfd-f41715eaf859"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'world', 'Hello'}\n",
            "<class 'set'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Frozen set\n",
        "f_one = frozenset({\"Hello\", \"World\", \"Hello\"})\n",
        "print(f_one)\n",
        "print(type(f_one))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "z5uDiIQ4T49k",
        "outputId": "60a3c704-4194-4820-fa55-3404fd931e0d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "frozenset({'World', 'Hello'})\n",
            "<class 'frozenset'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Boolean data type\n",
        "b = True\n",
        "print(b)\n",
        "print(type(b))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8GApbL0VT47N",
        "outputId": "5bf0c259-1136-4ad6-e11a-e221864fac3e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "<class 'bool'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Byte data type\n",
        "byte_one = b\"World\"\n",
        "print(byte_one)\n",
        "print(type(byte_one))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NexryZhMT44_",
        "outputId": "4498762b-0eb0-406e-f512-875dd4da88a0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "b'World'\n",
            "<class 'bytes'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Python Strings\n",
        "Strings are arrays of bytes representing unicode characters.\n",
        "\n",
        "\n",
        "*   Strings in python are surrounded by either single quotation marks, or double quotation marks\n",
        "*   You can assign a multiline string to a variable by using three quotes.\n",
        "\n"
      ],
      "metadata": {
        "id": "Ckj1T9GsD5OG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# String\n",
        "str1 = \"Welcome to complete Python Course\"\n",
        "str2 = \"Welcome to the complete Python Course\"\n",
        "str3 = \"\"\"This is a\n",
        "        multiline\n",
        "        String\"\"\"\n",
        "\n",
        "print(str1)\n",
        "print(str2)\n",
        "print(str3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cwfeGoFHX7T4",
        "outputId": "b4fed76c-94f5-4a6b-b987-ef93b087196b"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Welcome to complete Python Course\n",
            "Welcome to the complete Python Course\n",
            "This is a\n",
            "        multiline\n",
            "        String\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Indexing and Slicing with Strings\n",
        "\n",
        "\n",
        "*   In python, Indexing is used to access individual characters of a string\n",
        "*   Square brackets are used to acces the character of the string using Index\n",
        "*   Index starts with 0\n",
        "*   -1 refers to the last character, -2 refers to the second last character and so on\n",
        "*   In python, Slicing is used to access a range of characters in the string\n",
        "*   Slicing operator colon (:) is used"
      ],
      "metadata": {
        "id": "ygjqR-ykD5Lp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Indexing : String starts with 0th index\n",
        "s = \"Captain America\"\n",
        "print(s[4])\n",
        "\n",
        "# Slicing : slice(start, stop, step), it returns a sliced object containing elements in the given range\n",
        "print(s[1:5:2])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "F79mnI7MY-D4",
        "outputId": "37bdeb51-e3be-4c35-e4b3-e32515ad46c4"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "a\n",
            "at\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Reverse\n",
        "print(s[::-1])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3ezbjDTUZYc1",
        "outputId": "7359b2a5-3328-4b6a-ca33-e2f6948262c9"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "aciremA niatpaC\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### String Methods\n",
        "\n",
        "*   istitle() : Checks for Titlecased String\n",
        "*   isupper() : returns if all characters are uppercase characters\n",
        "*   join() : Returns a Concatenated String\n",
        "*   ljust() : returns left-justified string of given width\n",
        "*   lower() : returns lowercased string\n",
        "*   lstrip() : Removes Leading Characters\n",
        "*   maketrans() : returns a translation table\n",
        "*   replace() : Replaces Substring Inside\n",
        "*   rfind() : Returns the Highest Index of Substring\n",
        "*   rjust() : returns right-justified string of given width\n",
        "*   rstrip() : Removes Trailing Characters\n",
        "*   split() : Splits String from Left\n",
        "*   splitlines() : Splits String at Line Boundaries\n",
        "*   startswith() : Checks if String Starts with the Specified String\n",
        "*   strip() : Removes Both Leading and Trailing Characters\n",
        "*   swapcase() : swap uppercase characters to lowercase; vice versa\n",
        "*   title() : Returns a Title Cased String\n",
        "*   translate() : returns mapped charactered string\n",
        "*   upper() : returns uppercased string\n",
        "*   zfill() : Returns a Copy of The String Padded With Zeros\n",
        "*   capitalize() : Converts first character to Capital Letter\n",
        "*   casefold() : converts to case folded strings\n",
        "*   center(): Pads string with specified character\n",
        "*   count() : returns occurrences of substring in string\n",
        "*   encode() : returns encoded string of given string\n",
        "*   endswith(): Checks if String Ends with the Specified Suffix\n",
        "*   expandtabs() : Replaces Tab character With Spaces\n",
        "*   find(): Returns the index of first occurrence of substring\n",
        "*   format(): formats string into nicer output\n",
        "*   format_map() : Formats the String Using Dictionary\n",
        "*   index(): Returns Index of Substring\n",
        "*   isalnum(): Checks Alphanumeric Character\n",
        "*   isalpha() : Checks if All Characters are Alphabets\n",
        "*   isdecimal() : Checks Decimal Characters\n",
        "*   isdigit() : Checks Digit Characters\n",
        "*   isidentifier() : Checks for Valid Identifier\n",
        "*   islower() : Checks if all Alphabets in a String are Lowercase\n",
        "*   isnumeric() : Checks Numeric Characters\n",
        "*   isprintable() : Checks Printable Character\n",
        "*   isspace() : Checks Whitespace Characters"
      ],
      "metadata": {
        "id": "VC1OYmR2D5JB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# capitalize() : Returns a copy of the string with its first character capitalized and the rest lowercased\n",
        "a = \"complete python course\"\n",
        "print(a.capitalize())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3_dr6W3YZ-2C",
        "outputId": "c346c18f-9fdc-4828-a8dc-eeb397891f1d"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Complete python course\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# center(width[, fillchar]) : Returns the string centered in a string of length width\n",
        "a = \"Python\"\n",
        "b = a.center(10, \"*\")\n",
        "print(b)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NxnhuiTAZ-z1",
        "outputId": "090cb37a-72a3-4993-f834-8605702a94ca"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "**Python**\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# casefold() : Returns a casefolded copy of the string. Casefolded strings may be used for caseless matching\n",
        "a = \"PYTHON\"\n",
        "print(a.casefold())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "48HMIHuyZ-xh",
        "outputId": "60fae73e-0c60-46c1-dfee-4dbe9b4a05ea"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "python\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# count(sub[, start[,end]]) : Returns the number of non-overlapping occurrences of substring (sub) in the range [start, end]\n",
        "a = \"Welcome to complete Python Course\"\n",
        "print(a.count(\"c\"))\n",
        "print(a.count(\"o\"))\n",
        "print(a.count(\"Python\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "glz8RnLeZ-vI",
        "outputId": "a4bc00c4-02c2-412e-804c-ffdd427d836a"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n",
            "5\n",
            "1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# endswith(suffix[, start[, end]]) : Returns True if the string ends with the specified suffix, otherwise it returns False\n",
        "a = \"Watermelon\"\n",
        "print(a.endswith(\"s\"))\n",
        "print(a.endswith(\"melon\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KJLTe6P6Z-s-",
        "outputId": "8a142607-cc78-48ed-c6fb-d9fa704ded7a"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# find(sub[, start[, end]]) : Returns the lowest index in the string where substring is found within the slice [start, end]\n",
        "a = \"Exercise\"\n",
        "print(a.find(\"r\"))\n",
        "print(a.find(\"e\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SYJ7vshYZ-qn",
        "outputId": "29ae3476-c311-4753-a6a5-cbfc680f58a4"
      },
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n",
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# index(sub[, start[, end]]) : Similar to find function, except that it raises a ValueError when the substring is not found\n",
        "a = \"Continent\"\n",
        "print(a.index(\"i\"))\n",
        "print(a.index(\"C\"))\n",
        "print(a.index(\"nent\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hNIZwuE8Z-oO",
        "outputId": "b9ea87fc-d6cf-40f8-b802-016832ab7711"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4\n",
            "0\n",
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# isalnum() : Returns True if all characters in the string are alphanumeric, elase returns False\n",
        "c = \"456\"\n",
        "d = \"$*%!!**\"\n",
        "print(c.isalnum())\n",
        "print(d.isalnum())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GEiN_GCWZ-lo",
        "outputId": "9dfec36b-cef0-453b-b361-33380f202a85"
      },
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# isalpha() : Returns True if all characters in the string are alphabetic, else returns False\n",
        "c = \"456\"\n",
        "d = \"Python\"\n",
        "print(c.isalpha())\n",
        "print(d.isalpha())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e-qjycN7Z-h5",
        "outputId": "017ef6aa-d078-4249-c889-b18be2389c8a"
      },
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# isdecimal() : Returns True if all the characters in the string are decimal characters, else returns False\n",
        "c = u\"\\u00B10\"\n",
        "x = \"10\"\n",
        "print(c.isdecimal())\n",
        "print(x.isdecimal())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-9y5eSNjgNF7",
        "outputId": "e0e685b2-2142-4f12-cf06-4b8c073fd68c"
      },
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# isdigit() : Returns True if all characters in the string are digits, else returns False\n",
        "c = \"4567\"\n",
        "d = \"1.65\"\n",
        "print(c.isdigit())\n",
        "print(d.isdigit())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "N8RN0bglgNDi",
        "outputId": "88c8b9e7-4e8a-4db4-e7c0-e27ffbf11b6f"
      },
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# join(iterable) : Returns a string which is the concatenation of the strings in iterable.\n",
        "# A TypeError will be raised if there are any non-string values in iterable\n",
        "a = \",\"\n",
        "print(a.join(\"CD\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mjVAEE0MgNBA",
        "outputId": "fe7735fb-b12b-4d20-f04a-6547c66cb5e8"
      },
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "C,D\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# partition(sep) : Splits the string at the first occurrence of sep, and returns a 3-tuple containing the part before the separator, \n",
        "# the separator itself, and the part after the separator\n",
        "a = \"Complete.Python-course\"\n",
        "print(a.partition(\"-\"))\n",
        "print(a.partition(\".\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1gqHFqTeZ-cY",
        "outputId": "23e54e92-8f54-466e-8867-f81ee44cfc48"
      },
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "('Complete.Python', '-', 'course')\n",
            "('Complete', '.', 'Python-course')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# split(sep=None, maxsplit=-1) : Returns a list of the words in the string, using sep as the delimiter strip. If maxsplit is given, at most maxsplit splits are done.\n",
        "# If maxsplit is not specified or -1, then there is no limit on the number of splits.\n",
        "a = \"Welcome,,Friends,\"\n",
        "print(a.split(\",\"))"
      ],
      "metadata": {
        "id": "ULC7wBiwD4lT",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "784e9fca-e2af-4e16-e01a-c44c710d0e7f"
      },
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['Welcome', '', 'Friends', '']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# strip([chars]) : Returns a copy of the string with leading and trailing characters removed. The chars argument is a string specifying the set of characters to be removed.\n",
        "a = \"***Python***\"\n",
        "print(a.strip(\"*\"))"
      ],
      "metadata": {
        "id": "RqUJFcOPD4im",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ea5125c6-4c6a-4353-9820-16e07da4f9cb"
      },
      "execution_count": 48,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Python\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# swapcase() : Returns a copy of the string with uppercase characters converted to lowercase and vice versa\n",
        "a = \"Hi Homies\"\n",
        "print(a.swapcase())"
      ],
      "metadata": {
        "id": "tjbAgk6lD4gH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6e9076c2-3b91-4c74-c244-50fd779a0ed2"
      },
      "execution_count": 49,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "hI hOMIES\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# zfill(width) : Returns a copy of the string left filled with ASCII 0 digits to make a string of length width\n",
        "a = \"-124\"\n",
        "print(a.zfill(6))"
      ],
      "metadata": {
        "id": "A2J82YT4D4dn",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "73c5f9d0-51dd-4d98-fc0f-e4d85a786d88"
      },
      "execution_count": 50,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "-00124\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# lstrip([chars]) : Returns a copy of the string with leading characters removed. The chars argument is a string specifying the set of characters to be removed.\n",
        "a = \"*****Python-----\"\n",
        "print(a.lstrip(\"*\"))"
      ],
      "metadata": {
        "id": "hwsMPZ_gD4bH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "15de6104-db5d-4d84-9016-efeab32c7285"
      },
      "execution_count": 53,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Python-----\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# rindex(sub[, start[, end]]) : Just like rfind() but raises ValueError when the substring sub is not found\n",
        "a = \"Hi World\"\n",
        "print(a.rindex(\"d\"))\n",
        "print(a.rindex(\"W\"))"
      ],
      "metadata": {
        "id": "7WtMg3neD4Ye",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7a8b7092-1dc1-4c8c-86a6-3bdf17522fb3"
      },
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "7\n",
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Python F Strings\n",
        "\n",
        "\n",
        "*   Python F-String are used to embed python expressions inside string literals for formatting, using minimal syntax.\n",
        "*   It’s an expression that’s evaluated at the run time.\n",
        "*   They have the f prefix and use {} brackets to evaluate values.\n",
        "*   f-strings are faster than %-formatting and str.format()\n",
        "*   In order to format and output an expression in the formatted way, you should use curly braces {}\n",
        "\n"
      ],
      "metadata": {
        "id": "3j7ZlEIfjKFp"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 55,
      "metadata": {
        "id": "4oy4ohqRDqan",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cebd9b3d-808b-4070-c71f-13dbb38af254"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Max of 12 and 25 is 25\n"
          ]
        }
      ],
      "source": [
        "def max_no(x, y):\n",
        "  return x if x > y else y\n",
        "\n",
        "f_no = 12\n",
        "s_no = 25\n",
        "print(f'Max of {f_no} and {s_no} is {max(f_no, s_no)}')"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from decimal import Decimal\n",
        "width = 4\n",
        "round_point = 2\n",
        "value = Decimal('12.39065')\n",
        "print(f'result:{value:{width}.{round_point}}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2CT-Rw7uj8cH",
        "outputId": "d0bf5dcf-f13c-457a-9bcf-99532ffb018d"
      },
      "execution_count": 56,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "result:  12\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Operators in Python\n",
        "\n",
        "*   In python, operators are used to perform operations on variables and values\n",
        "\n",
        "    Arithmetic operators : +, — , *, /, //, %, **\n",
        "    \n",
        "    Logical operators : and, or, not\n",
        "    \n",
        "    Identity operators : is, is not\n",
        "\n",
        "    Membership operators : in , not in\n",
        "\n",
        "    Bitwise operators : &, |, ^,~, << , >>\n",
        "\n",
        "    Assignment operators : =, +=, -=, *=,/= , %=, //=, **=, &=, |=, ^=, >>=, <<=\n",
        "\n",
        "    Comparison operators : ==, !=, > , <, >=, <=\n",
        "*   Ternary operators are operators that evaluate things based on a condition being true or false\n",
        "\n",
        "    Syntax : [true] if [expression] else [false]\n",
        "\n",
        "*   Operator overloading can be implemented in Python\n",
        "\n",
        "    a & b\n",
        "\n",
        "    a >> 2\n",
        "\n",
        "    a is not b\n",
        "\n",
        "    ‘b’ in list1"
      ],
      "metadata": {
        "id": "uryM4iBAkOh7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Arithmatic Operators\n",
        "x=10\n",
        "y=4\n",
        "\n",
        "#Addition\n",
        "print(\"Addition:\", x + y)\n",
        "\n",
        "#Subtraction\n",
        "print(\"Subtraction:\", x - y)\n",
        "\n",
        "#Multiply\n",
        "print(\"Multiply: \", x * y)\n",
        "\n",
        "#Division\n",
        "print(\"Division:\", x / y)\n",
        "\n",
        "#Modulus\n",
        "print(\"Modulus:\", x % y)\n",
        "\n",
        "#Floor Division\n",
        "print(\"Floor Division:\", x // y)\n",
        "\n",
        "#Exponent\n",
        "print(\"Exponent:\", x ** y)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-q_aHWxDj8aK",
        "outputId": "6ac43fc5-97a3-4700-8d96-a304669f4590"
      },
      "execution_count": 59,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Addition: 14\n",
            "Subtraction: 6\n",
            "Multiply:  40\n",
            "Division: 2.5\n",
            "Modulus: 2\n",
            "Floor Division: 2\n",
            "Exponent: 10000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Comparison Operator  : Result is either True or False\n",
        "x=5\n",
        "y=3\n",
        "\n",
        "#Greater than\n",
        "print(\"Greater than:\", x > y)\n",
        "\n",
        "#Less than\n",
        "print(\"Greater than:\", x < y)\n",
        "\n",
        "#Greater than equal to \n",
        "print(\"Greater than equal to:\", x >= y)\n",
        "\n",
        "#less than equal to\n",
        "print(\"Less than:\", x <= y)\n",
        "\n",
        "#Not equal to \n",
        "print(\"Not equal to:\", x != y)\n",
        "\n",
        "#Equal to\n",
        "print(\"Equal to:\", x == y)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cF5sUTE_j8Xt",
        "outputId": "5c931fa3-db37-4dc0-e60e-20b2d9c48405"
      },
      "execution_count": 60,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Greater than: True\n",
            "Greater than: False\n",
            "Greater than equal to: True\n",
            "Less than: False\n",
            "Not equal to: True\n",
            "Equal to: False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Logical Operators : and, or, not [Result is either True or False]\n",
        "x= True\n",
        "y= False\n",
        "\n",
        "#And\n",
        "print(\"And result:\", (x and y))\n",
        "\n",
        "#Or\n",
        "print(\"Or result:\", (x or y))\n",
        "\n",
        "#Not\n",
        "print(\"Not result:\", (not y))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uJ-7ag2Rj8VY",
        "outputId": "2ce59f01-738b-4831-82c9-f2bbf42359b5"
      },
      "execution_count": 61,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "And result: False\n",
            "Or result: True\n",
            "Not result: True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Bitwise operators\n",
        "x = 1001\n",
        "y = 1010\n",
        "\n",
        "#And\n",
        "print(\"And result:\", (x & y))\n",
        "\n",
        "#Or\n",
        "print(\"Or result:\", (x | y))\n",
        "\n",
        "#Not\n",
        "print(\"Not result:\", (~y))\n",
        "\n",
        "#Xor\n",
        "print(\"XOR result:\", (x ^ y))\n",
        "\n",
        "#Bitwise right shift\n",
        "print(\"Bitwise right shift result:\", (x >> 2))\n",
        "\n",
        "#Bitwise left shift\n",
        "print(\"Bitwise left shift result:\", (x << 2))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cyOECnUXlosx",
        "outputId": "465dea7e-57b5-4fca-d0bd-d29c5554457e"
      },
      "execution_count": 62,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "And result: 992\n",
            "Or result: 1019\n",
            "Not result: -1011\n",
            "XOR result: 27\n",
            "Bitwise right shift result: 250\n",
            "Bitwise left shift result: 4004\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Assignment operators : used in Python to assign values to variables\n",
        "x = 5\n",
        "print(x)\n",
        "\n",
        "x += 5\n",
        "print(x)\n",
        "\n",
        "x -= 2\n",
        "print(x)\n",
        "\n",
        "x *= 2\n",
        "print(x)\n",
        "\n",
        "x **= 2\n",
        "print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EN5kfpsklopj",
        "outputId": "735b30d4-a33f-435a-c2b2-8ff6b523f092"
      },
      "execution_count": 64,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n",
            "10\n",
            "8\n",
            "16\n",
            "256\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Identity Operator : is and is not are the identity operators in Python\n",
        "x = 5\n",
        "y = 5\n",
        "z = 'a'\n",
        "print(\"Is operator result:\", (x is y))\n",
        "print(\"Not is operator result:\", (y is not z))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "blHxdedglonC",
        "outputId": "0f08add8-e90e-4b48-c273-665df65cdc0b"
      },
      "execution_count": 65,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Is operator result: True\n",
            "Not is operator result: True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Membership operator : in operator\n",
        "x = 'Python Course'\n",
        "print('y' in x)\n",
        "print('a' in x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JPfosABRloky",
        "outputId": "68e303d3-577a-466d-bffd-f815444e88d1"
      },
      "execution_count": 66,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Chaining Comparison Operators with Logical Operators\n",
        "\n",
        "\n",
        "*   In python, in order to check more than two conditions, we implement chaining where two or more operators are chained together as shown in the example belowT\n",
        "\n",
        "    if x < y < z :\n",
        "\n",
        "*   In accordance with associativity and precedence in Python, all comparison operations have the same priority. Resultant values of Comparisons yield boolean values such as either True or False\n",
        "*   When chaining the comparison operators, the sequence can be arbitrary.\n",
        "\n",
        "    x > y <= c is equivalent to x > y and y <= c\n"
      ],
      "metadata": {
        "id": "ZdP_5unamOV9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Chaining Comparison operators with Logical operators\n",
        "a, b, c, d, e, f, g = 10, 15, 2, 1, 45, 25, 19\n",
        "e1 = a <= b < c > d < e is not f is g\n",
        "e2 = a is d < f is c\n",
        "print(e1)\n",
        "print(e2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GmBsopoKloia",
        "outputId": "2a09203b-d4b2-4cf0-9ef5-7bdc3ff07024"
      },
      "execution_count": 67,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False\n",
            "False\n"
          ]
        }
      ]
    }
  ]
}