PY.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyNn2fs+CM4EdWEPBmMyQJUU",
      "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/dishamodi0910/Python/blob/main/PY.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Keywords_Identifiers_Indentation_Comments_Input_Output"
      ],
      "metadata": {
        "id": "r6BGVs__trtt"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 192
        },
        "id": "cy8Q2jipkQgb",
        "outputId": "731c7c1d-f005-421c-f140-67e2035fd071"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "12\n",
            "Value of x is :  12\n",
            "Value of a is 10 and that of b is 20 \n",
            "Value of a is 20 and that of b is 10 \n",
            "Value of a is :  10 Value of b is :  20\n",
            "Hello World\n",
            "Hello World\n",
            "We have Django project under Software project subject.\n",
            "The value of x is 12\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'This is also \\n    a multi\\n    Line Comment'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 4
        }
      ],
      "source": [
        "import keyword\n",
        "#print(\"Helloworld\");\n",
        "#print(\"\\n\");\n",
        "#print(\"The keywords in python are : #\");\n",
        "#print(keyword.kwlist);\n",
        "\n",
        "x = 12;\n",
        "#@ = 13;\n",
        "print(x);\n",
        "#print(@x);\n",
        "#print(x@);\n",
        "print(\"Value of x is : \",x);\n",
        "#print \"The value of x is \" + str(x)\n",
        "a = 10;\n",
        "b = 20;\n",
        "print(\"Value of a is {} and that of b is {} \".format(a,b));\n",
        "print(\"Value of a is {1} and that of b is {0} \".format(a,b));\n",
        "print(\"Value of a is : \",a,\"Value of b is : \",b);\n",
        "\n",
        "a = \"Hello\"\n",
        "b = \"World\"\n",
        "print(a,b);\n",
        "print(\"{a} {b}\".format(a=\"Hello\",b=\"World\"));\n",
        "print(\"We have {abc} project under {subject} subject.\".format(abc = \"Django\",subject = \"Software project\"));\n",
        "print (\"The value of x is \"+str(x))\n",
        "\n",
        "#Single Line Comment\n",
        "\n",
        "#MuLtI\n",
        "#LiNe\n",
        "#CoMmEnT\n",
        "\n",
        "\"\"\"This is also \n",
        "    a multi\n",
        "    Line Comment\"\"\"\n",
        "\n",
        "    "
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Document Strings\n",
        "\n",
        "-->used to mention access the strings of document\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "GQNandfGuxIr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def my_fun():\n",
        "  '''HELLO WORLD'''\n",
        "    #comment\n",
        "\n",
        "print(my_fun.__doc__)   #accesses the '''''' content.\n",
        "\n",
        "def double_num(num):\n",
        "  return 2*num;\n",
        "\n",
        "print(double_num(6))\n",
        "print(double_num.__doc__);  #There is no string in the document..Hence has no use here."
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WQMHP3mouvU2",
        "outputId": "78e87ab0-4c92-47d3-8495-536e0332649d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "HELLO WORLD\n",
            "12\n",
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Variables and playing with them\n",
        "\n",
        "Variable types - \n",
        "Integers\n",
        "Float\n",
        "Strings (Single quotes,double quotes)\n",
        "Characters\n",
        "Complex Numbers\n",
        "Boolean \n",
        "\n",
        "\n",
        "id(ONE_ARGUMENT)\n",
        "type(ONE_ARGUMENT)\n",
        "isinstance(character,datatype)\n",
        "\n",
        "\n",
        "Strings are immutable"
      ],
      "metadata": {
        "id": "gGSU1UBBwKSs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = 12;  #assigning variables\n",
        "#isinstance --> Used to check the datatype instance\n",
        "print(a,isinstance(a,int));\n",
        "\n",
        "#complex numbers are also allowed\n",
        "print(5+6j,isinstance(5+6j,complex))\n",
        "\n",
        "a = \"Hello World\"\n",
        "print(a)\n",
        "\n",
        "a = 34.566\n",
        "print(a)\n",
        "\n",
        "\n",
        "#various ways for string declarations and definations\n",
        "a = '1'\n",
        "print(a,type(a))\n",
        "a = \"1\"\n",
        "print(a,type(a))\n",
        "a = '''1'''\n",
        "print(a,type(a))\n",
        "a = \"\"\"1\"\"\"\n",
        "print(a,type(a))\n",
        "\n",
        "\n",
        "a,b,c = \"Hello\",5,78.90   #Assigning Multiple variables at a time.\n",
        "#id ---> Tells us about the address of variable\n",
        "#type --->Tells us about the type of variable\n",
        "print(a,\"\\n\",b,\"\\t\",c)\n",
        "print(id(a),type(a))\n",
        "print(id(b),type(b))\n",
        "print(id(c),type(c))\n",
        "\n",
        "a=b=c=\"Great\"   #Assigning values to all the variables at a time\n",
        "print(a,\" \",b,\" \",c)\n",
        "print(id(a),type(a))\n",
        "print(id(b),type(b))\n",
        "print(id(c),type(c))\n",
        "\n",
        "\n",
        "a = False;\n",
        "print(id(a),type(a),a)\n",
        "\n",
        "\n",
        "str = \"hELLOWORLD\"\n",
        "#str[0] = \"H\"\n",
        "print(str)\n",
        "print(str[7])\n",
        "print(str[6:])\n",
        "print(str[1::3])\n",
        "#printing string in reverse\n",
        "print(str[-1::-1])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "t3pwzCkRwIpa",
        "outputId": "863f9a74-d2d6-481f-fc38-960bec4ff00f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "12 True\n",
            "(5+6j) True\n",
            "Hello World\n",
            "34.566\n",
            "1 <class 'str'>\n",
            "1 <class 'str'>\n",
            "1 <class 'str'>\n",
            "1 <class 'str'>\n",
            "Hello \n",
            " 5 \t 78.9\n",
            "140131439661808 <class 'str'>\n",
            "11531040 <class 'int'>\n",
            "140131438851248 <class 'float'>\n",
            "Great   Great   Great\n",
            "140131440604016 <class 'str'>\n",
            "140131440604016 <class 'str'>\n",
            "140131440604016 <class 'str'>\n",
            "11397120 <class 'bool'> False\n",
            "hELLOWORLD\n",
            "R\n",
            "ORLD\n",
            "EOR\n",
            "DLROWOLLEh\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "List,Tuple,Dictionary,Sets\n",
        "\n",
        "List is the only mutable.\n",
        "Set is not subsrciptable\n",
        "List - > []  =>Unordered and mutable,Duplicates allowed\n",
        "Sets -> {}   =>Ordered and immutable, No duplicates allowed\n",
        "Tuple -> ()   =>Unordered and immutable,Duplicates allowed\n",
        "Dictionary -> { key : value }, Duplicates allowed but the last modified value will be considered.\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "BL9WxzeWtp19"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "#Lists\n",
        "a = [1,\"Helloworld\",'A',True,1.11,'''HEY''','A']\n",
        "print(a)\n",
        "a[4] = 12355.878\n",
        "print(a)\n",
        "print(id(a),type(a))\n",
        "print(id(a[1]))\n",
        "#print(id(a[6]))\n",
        "\n",
        "\n",
        "\n",
        "#Tuples\n",
        "a = ('Hello',\"HEY\",12,1232.8367,'Hello')\n",
        "print(a,id(a),type(a))\n",
        "#a[2] = 63735\n",
        "print(a[3],id(a),type(a))\n",
        "\n",
        "\n",
        "\n",
        "#Sets\n",
        "a = {1,2,3,4,43/4364,\"Hello\",'Hello'}\n",
        "print(a,id(a),type(a))\n",
        "#print(a[3],id(a),type(a))\n",
        "\n",
        "\n",
        "\n",
        "#Dictionary\n",
        "a = {\n",
        "    \"marks\" : 12,\n",
        "    \"grade\" : 'A',\n",
        "    \"marks\" : 123\n",
        "}\n",
        "\n",
        "print(a)\n",
        "print(id(a),type(a),isinstance(a,dict))\n",
        "print(a[\"marks\"])\n",
        "\n",
        "\n",
        "\n",
        "#Type conversions\n",
        "a = int(1223);\n",
        "print(a,type(a),id(a))\n",
        "\n",
        "a = float(a)\n",
        "#a = str(27456)\n",
        "print(a,type(a),id(a))\n",
        "\n",
        "#tuple to set\n",
        "a = ('Hello',\"HEY\",12,1232.8367,'Hello')\n",
        "a = set(a)\n",
        "print(a,type(a),id(a))\n",
        "\n",
        "#set to list\n",
        "a = list(a)\n",
        "print(a,type(a),id(a))\n",
        "\n",
        "#list to tuple\n",
        "a = tuple(a)\n",
        "print(a,type(a),id(a))\n",
        "\n",
        "#string to int\n",
        "print(int(\"2136\"))\n",
        "#print(str(23))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LxoJ4kZt0deo",
        "outputId": "33f46e66-0752-4432-c93a-21f89b2edea2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 'Helloworld', 'A', True, 1.11, 'HEY', 'A']\n",
            "[1, 'Helloworld', 'A', True, 12355.878, 'HEY', 'A']\n",
            "140131440566400 <class 'list'>\n",
            "140131438094832\n",
            "('Hello', 'HEY', 12, 1232.8367, 'Hello') 140131438779264 <class 'tuple'>\n",
            "1232.8367 140131438779264 <class 'tuple'>\n",
            "{1, 2, 3, 4, 'Hello', 0.009853345554537122} 140131439367776 <class 'set'>\n",
            "{'marks': 123, 'grade': 'A'}\n",
            "140131438219200 <class 'dict'> True\n",
            "123\n",
            "1223 <class 'int'> 140131438853872\n",
            "1223.0 <class 'float'> 140131438252432\n",
            "{1232.8367, 'HEY', 12, 'Hello'} <class 'set'> 140131439367104\n",
            "[1232.8367, 'HEY', 12, 'Hello'] <class 'list'> 140131439864832\n",
            "(1232.8367, 'HEY', 12, 'Hello') <class 'tuple'> 140131439708256\n",
            "2136\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Operators and the evaluation\n",
        "\n",
        "->Addition(+), Subtraction(-), Multiplication(*), Division(/), Modulo Division(%), Floor Division(//), Exponent(**)"
      ],
      "metadata": {
        "id": "gDELIk9AZANH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = 10;\n",
        "b = 20;\n",
        "#arithmetic\n",
        "print(\"Arithmetic operations results are : \")\n",
        "print(b+a)\n",
        "print(a+b)\n",
        "print(b/a)\n",
        "print(a/b)\n",
        "print(b-a)\n",
        "print(a-b)\n",
        "print(b*a)\n",
        "print(a*b)\n",
        "print(b//a)\n",
        "print(a//b)\n",
        "print(b%a)\n",
        "print(a%b)\n",
        "\n",
        "\n",
        "#exponent\n",
        "a = 2;\n",
        "b = 3;\n",
        "print(\"Value of a is {} and b is {}\".format(a,b))\n",
        "print(\"Value of a**b is  : \"+str(a**b))\n",
        "print(\"Value of b**a is : \"+str(b**a))\n",
        "\n",
        "\n",
        "#bitwise operators\n",
        "print(\"Value of a&b is \"+str(a & b))\n",
        "print(\"Value of a|b is \"+str(a | b))\n",
        "print(\"Value of ~a is \"+str(~a))\n",
        "print(\"Value of ~b is \"+str(~b))\n",
        "print(\"Value of a>>b is \"+str(a>>b))\n",
        "print(\"Value of a<<b is \"+str(a<<b))\n",
        "print(\"Value of a^b is \"+str(a^b))\n",
        "\n",
        "\n",
        "#comparison operators\n",
        "print(\"Value of a>b is : \"+str(a>b))\n",
        "print(\"Value of a>=b is : \"+str(a>=b))\n",
        "print(\"Value of a<b is : \"+str(b>a))\n",
        "print(\"Value of a<=b is : \"+str(b>=a))\n",
        "print(\"Value of a==b is : \"+str(a==b))\n",
        "print(\"Value of b==a is : \"+str(b==a))\n",
        "\n",
        "\n",
        "#Logical Operators\n",
        "var = True;\n",
        "var2 = False;\n",
        "print(\"Value of var is {} and var2 is {}\".format(True,False))\n",
        "print(\"Value of var or var2 is : \"+str(var or var2))\n",
        "print(\"Value of var and var2 is : \"+str(var and var2))\n",
        "\n",
        "\n",
        "#Assignment Operators\n",
        "a = 10;\n",
        "a+=10;\n",
        "print(a)\n",
        "a=+10\n",
        "print(a)\n",
        "a-=10\n",
        "print(a)\n",
        "a=-10\n",
        "print(a)\n",
        "a**=a;\n",
        "print(a)\n",
        "\n",
        "\n",
        "\n",
        "#Identity Operators (is and is not)\n",
        "l1 = [1,2,3]\n",
        "l2 = [1,2,3]\n",
        "print(l1 is l2)\n",
        "l2 = [1,2,4]\n",
        "print(l1 is l2)\n",
        "print(l1 is not l2)\n",
        "\n",
        "\n",
        "\n",
        "#Membership Operators(in and not in)\n",
        "l1 = [1,2,4]\n",
        "print(2 in l1);\n",
        "print(7 not in l1)\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-X5C8QTXZGWC",
        "outputId": "30e38f35-4472-458b-c6cf-b25a11659920"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Arithmetic operations results are : \n",
            "30\n",
            "30\n",
            "2.0\n",
            "0.5\n",
            "10\n",
            "-10\n",
            "200\n",
            "200\n",
            "2\n",
            "0\n",
            "0\n",
            "10\n",
            "Value of a is 2 and b is 3\n",
            "Value of a**b is  : 8\n",
            "Value of b**a is : 9\n",
            "Value of a&b is 2\n",
            "Value of a|b is 3\n",
            "Value of ~a is -3\n",
            "Value of ~b is -4\n",
            "Value of a>>b is 0\n",
            "Value of a<<b is 16\n",
            "Value of a^b is 1\n",
            "Value of a>b is : False\n",
            "Value of a>=b is : False\n",
            "Value of a<b is : True\n",
            "Value of a<=b is : True\n",
            "Value of a==b is : False\n",
            "Value of b==a is : False\n",
            "Value of var is True and var2 is False\n",
            "Value of var or var2 is : True\n",
            "Value of var and var2 is : False\n",
            "20\n",
            "10\n",
            "0\n",
            "-10\n",
            "1e-10\n",
            "False\n",
            "False\n",
            "True\n",
            "True\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Conditional Statements(if,elif,else)"
      ],
      "metadata": {
        "id": "SENZvcX8s5Gk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#To check if number is positive or not\n",
        "num = int(input(\"Enter the number : \"));\n",
        "if(num>0):\n",
        "  print(\"Number is positive\");\n",
        "elif(num==0):\n",
        "  print(\"Number is 0\");\n",
        "else:\n",
        "  print(\"Number is negative\");\n",
        "\n",
        "\n",
        "#To find largest of all three numbers\n",
        "num1 = int(input(\"Enter the first number : \"));\n",
        "num2 = int(input(\"Enter the second number : \"));\n",
        "num3 = int(input(\"Enter the third number : \"));\n",
        "if(num1>=num2 and num1>=num3):\n",
        "  print(\"The largest of all three numbers is : \"+str(num1));\n",
        "elif(num2>=num3 and num2>=num1):\n",
        "  print(\"The largest of all three numbers is : \"+str(num2));\n",
        "else:\n",
        "  print(\"The largest of all three numbers is : \"+str(num3));\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gNkt9SA0tMUG",
        "outputId": "2f04d0d0-d1be-48f7-ea65-55906708ae02"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter the number : 12\n",
            "Number is positive\n",
            "Enter the first number : 12\n",
            "Enter the second number : 2321\n",
            "Enter the third number : 11\n",
            "The largest of all three numbers is : 2321\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Loops(For and While)\n"
      ],
      "metadata": {
        "id": "m-0reuA4wAG7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#for loops\n",
        "#printing elements of list1\n",
        "list1 = [1,3,5,6,8];\n",
        "for i in list1:\n",
        "  print(i);\n",
        "  print(type(i));\n",
        "\n",
        "print(\"\\n\\n\\n\\n\");\n",
        "\n",
        "#printing elements from 1 to 10\n",
        "print(\"The numbers from 1 to 10\");\n",
        "#start,stop,step\n",
        "for i in range(1,11,1):\n",
        "  print(i);\n",
        "\n",
        "print(\"\\n\\n\\n\\n\");\n",
        "\n",
        "#by default,starts from 0\n",
        "for i in range(10):\n",
        "  print(i);\n",
        "\n",
        "#Multiple of 2\n",
        "print(\"\\n\\n\\n\\n\");\n",
        "for i in range(2,21,2):\n",
        "  print (i);\n",
        "\n",
        "print(\"\\n\\n\\n\\n\");\n",
        "#printing table horizontally and vertically\n",
        "for i in range (1,11,1):\n",
        "  for j in range (1,11,1):\n",
        "    print(str(i*j)+\"   \",end=\"\")   #Add argument end = \"\" in order to keep the cursor on the same line.\n",
        "  print(\"\\n\");\n",
        "\n",
        "print(\"\\n\\n\\n\\n\");\n",
        "#Printing the even numbers from the list taken as input from the user.\n",
        "num = int(input(\"Enter the numbers you want to have : \"));\n",
        "list = [];\n",
        "for i in range (1,num+1,1):\n",
        "  x = int(input(\"Enter the number in list : \"));\n",
        "  list.append(x);\n",
        "for element in list:\n",
        "  if(element%2==0):\n",
        "    print(str(element)+\" \",end=\"\");\n",
        "\n",
        "print(\"\\n\\n\\n\\n\");\n",
        "#Print all odd numbers that are divisible by 3 using while loop.\n",
        "num = int(input(\"Enter the maximum value you can have : \"));\n",
        "i = 3;\n",
        "while i<=num:\n",
        "  if(i%3==0 and i%2!=0):\n",
        "    print(i)\n",
        "  i = i+1;\n",
        "  \n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xn6HMEtSwKyG",
        "outputId": "74d7b84f-e009-4bec-a4a8-921150b6d1bf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "<class 'int'>\n",
            "3\n",
            "<class 'int'>\n",
            "5\n",
            "<class 'int'>\n",
            "6\n",
            "<class 'int'>\n",
            "8\n",
            "<class 'int'>\n",
            "\n",
            "\n",
            "\n",
            "\n",
            "\n",
            "The numbers from 1 to 10\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n",
            "10\n",
            "\n",
            "\n",
            "\n",
            "\n",
            "\n",
            "0\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n",
            "\n",
            "\n",
            "\n",
            "\n",
            "\n",
            "2\n",
            "4\n",
            "6\n",
            "8\n",
            "10\n",
            "12\n",
            "14\n",
            "16\n",
            "18\n",
            "20\n",
            "\n",
            "\n",
            "\n",
            "\n",
            "\n",
            "1   2   3   4   5   6   7   8   9   10   \n",
            "\n",
            "2   4   6   8   10   12   14   16   18   20   \n",
            "\n",
            "3   6   9   12   15   18   21   24   27   30   \n",
            "\n",
            "4   8   12   16   20   24   28   32   36   40   \n",
            "\n",
            "5   10   15   20   25   30   35   40   45   50   \n",
            "\n",
            "6   12   18   24   30   36   42   48   54   60   \n",
            "\n",
            "7   14   21   28   35   42   49   56   63   70   \n",
            "\n",
            "8   16   24   32   40   48   56   64   72   80   \n",
            "\n",
            "9   18   27   36   45   54   63   72   81   90   \n",
            "\n",
            "10   20   30   40   50   60   70   80   90   100   \n",
            "\n",
            "\n",
            "\n",
            "\n",
            "\n",
            "\n",
            "Enter the numbers you want to have : 12\n",
            "Enter the number in list : 11\n",
            "Enter the number in list : 11\n",
            "Enter the number in list : 11\n",
            "Enter the number in list : 11\n",
            "Enter the number in list : 11\n",
            "Enter the number in list : 11\n",
            "Enter the number in list : 11\n",
            "Enter the number in list : 23\n",
            "Enter the number in list : 22\n",
            "Enter the number in list : 22\n",
            "Enter the number in list : 32\n",
            "Enter the number in list : 12\n",
            "22 22 32 12 \n",
            "\n",
            "\n",
            "\n",
            "\n",
            "Enter the maximum value you can have : 78\n",
            "3\n",
            "9\n",
            "15\n",
            "21\n",
            "27\n",
            "33\n",
            "39\n",
            "45\n",
            "51\n",
            "57\n",
            "63\n",
            "69\n",
            "75\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Break And Continue"
      ],
      "metadata": {
        "id": "OtVv80AA5cVE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Check if a given number is prime or not using the break,,\n",
        "num = int(input(\"Enter the number : \"));\n",
        "i = 2;\n",
        "isPrime = False;\n",
        "while(i<num):\n",
        "  if(num%i==0):\n",
        "    isPrime = True;\n",
        "    break;\n",
        "  i=i+1;\n",
        "if(isPrime == True):\n",
        "  print(\"{} is not Prime\".format(num));\n",
        "else:\n",
        "  print(\"{} is Prime\".format(num));\n",
        "\n",
        "\n",
        "#Print all odd numbers using continue statement\n",
        "num = int(input(\"Enter the upper bound of the list : \"));\n",
        "for i in range(1,num+1,1):\n",
        "  if(i%2==0):\n",
        "    continue;\n",
        "  else:\n",
        "    print(i);\n",
        "  i=i+1;\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vZbNrDhN5gFv",
        "outputId": "bd248500-297f-4b88-a324-17064ba85ad8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter the number : 12\n",
            "12 is not Prime\n",
            "Enter the upper bound of the list : 14\n",
            "1\n",
            "3\n",
            "5\n",
            "7\n",
            "9\n",
            "11\n",
            "13\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Lists\n",
        "->Collection of items.\n",
        "->Uses index values for the items."
      ],
      "metadata": {
        "id": "pjMLAgvsljWV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "list = [];\n",
        "print(list);\n",
        "\n",
        "list1 = [1,2,3,'Hello'];\n",
        "print(list1);\n",
        "list1[1] = 5;\n",
        "print(list1);\n",
        "\n",
        "list3 = [1,2,3,[5,6,7]];\n",
        "print(list3);\n",
        "\n",
        "\n",
        "print(\"Length of list is \" + str(len(list3)));\n",
        "\n",
        "\n",
        "list.append('Hello');\n",
        "print(list);\n",
        "list.append(\"Everyone\");\n",
        "print(list);\n",
        "\n",
        "\n",
        "#in extend..the values will be added at the end of list ..\n",
        "#in append all the items will be inserted at a index...\n",
        "list.extend(list1);\n",
        "print(list);\n",
        "\n",
        "\n",
        "#listname.insert(position,valuetobeinserted);\n",
        "list.insert(2,\"World\");\n",
        "print(list);\n",
        "\n",
        "#remove vs delete\n",
        "list.remove(\"World\");\n",
        "print(list);\n",
        "\n",
        "#delete will delete from the index\n",
        "del list[1];\n",
        "print(list);\n",
        "#delete from last\n",
        "list.pop();\n",
        "print(list);\n",
        "\n",
        "#reverse\n",
        "list.reverse();\n",
        "print(list);\n",
        "\n",
        "if 'Hello' in list:\n",
        "  print(\"hey\");\n",
        "if 'Hello' not in list:\n",
        "  print(\"Hello\");\n",
        "\n",
        "\n",
        "#sorting\n",
        "#print(list.sort());\n",
        "\n",
        "abc = [1,2,4];\n",
        "list = abc;\n",
        "print(id(abc),id(list));\n",
        "print(abc,list);\n",
        "abc[2] = 8;\n",
        "print(abc,list);\n",
        "print(id(abc),id(list));\n",
        "\n",
        "\n",
        "#string to list\n",
        "string  = \"hey,how are you,I am great.\";\n",
        "l = string.split(',');  #argument - delimiter(by default it is space)\n",
        "print(l);\n",
        "\n",
        "print(l[-1],l[0]);\n",
        "\n",
        "\n",
        "abc = [1,2,3,4,5,6,7,8,9,10];\n",
        "print(abc);\n",
        "print(abc[:]);\n",
        "print(abc[2:])\n",
        "print(abc[2::2]);\n",
        "#printing in reverse\n",
        "print(abc[-1: :-1]);\n",
        "\n",
        "#finding the frequency of the element in the list.\n",
        "print(abc.count(10));\n",
        "\n",
        "#extending the list using the + operator\n",
        "list1 = [1,2,3,4];\n",
        "list2 = [7,8,9,0];\n",
        "list3 = list1+list2;\n",
        "print(list3);\n",
        "\n",
        "#list comprehensions\n",
        "#create list of tuples such that it is stored as only even number,square of the number\n",
        "list = [(i,i**2) for i in range(11) if i%2==0];\n",
        "print(list);\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CTuJlQ1nl9Z-",
        "outputId": "3d7c7631-f39c-4936-f50f-ff8085274f50"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[]\n",
            "[1, 2, 3, 'Hello']\n",
            "[1, 5, 3, 'Hello']\n",
            "[1, 2, 3, [5, 6, 7]]\n",
            "Length of list is 4\n",
            "['Hello']\n",
            "['Hello', 'Everyone']\n",
            "['Hello', 'Everyone', 1, 5, 3, 'Hello']\n",
            "['Hello', 'Everyone', 'World', 1, 5, 3, 'Hello']\n",
            "['Hello', 'Everyone', 1, 5, 3, 'Hello']\n",
            "['Hello', 1, 5, 3, 'Hello']\n",
            "['Hello', 1, 5, 3]\n",
            "[3, 5, 1, 'Hello']\n",
            "hey\n",
            "139792743389504 139792743389504\n",
            "[1, 2, 4] [1, 2, 4]\n",
            "[1, 2, 8] [1, 2, 8]\n",
            "139792743389504 139792743389504\n",
            "['hey', 'how are you', 'I am great.']\n",
            "I am great. hey\n",
            "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
            "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
            "[3, 4, 5, 6, 7, 8, 9, 10]\n",
            "[3, 5, 7, 9]\n",
            "[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]\n",
            "1\n",
            "[1, 2, 3, 4, 7, 8, 9, 0]\n",
            "[(0, 0), (2, 4), (4, 16), (6, 36), (8, 64), (10, 100)]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Strings\n",
        "-->Immutable."
      ],
      "metadata": {
        "id": "wPFHf9H_un8h"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "string = \"Hello\";\n",
        "print(id(string));\n",
        "string = 'Hello';\n",
        "print(id(string));\n",
        "string = '''Hello''';\n",
        "print(id(string));\n",
        "\n",
        "print(string[3]);\n",
        "\n",
        "#deleting one character is not possible.\n",
        "#Entire string can be deleted using del\n",
        "del string;\n",
        "#print(string);\n",
        "\n",
        "string = \"abc \";\n",
        "print(string * 4);\n",
        "#string = reversed(string);\n",
        "print(string);\n",
        "print(string.upper());\n",
        "print(string.lower());\n",
        "print(string.find(\"c\"));\n",
        "string = string.replace(\"c\",\"a\");\n",
        "print(string);\n",
        "string = \"Hello,I,am,a,good,person\";\n",
        "string = string.split(',');\n",
        "print(string);\n",
        "string = ''.join(string);\n",
        "print(string);"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dOqwX0tPurNR",
        "outputId": "057418ba-4078-4faa-a8da-1a168ad5e2a6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "139792972211888\n",
            "139792972211888\n",
            "139792972211888\n",
            "l\n",
            "abc abc abc abc \n",
            "abc \n",
            "ABC \n",
            "abc \n",
            "2\n",
            "aba \n",
            "['Hello', 'I', 'am', 'a', 'good', 'person']\n",
            "HelloIamagoodperson\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Tuples"
      ],
      "metadata": {
        "id": "Dt_Nzo7Exslh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "t = ('ABC', ('pqr', 'mno', 'jkl'));\n",
        "print(t,type(t),id(t));\n",
        "print(type(t[1]));\n",
        "t = ('ABC', ['pqr', 'mno', 'jkl']);\n",
        "print(t,type(t),id(t));\n",
        "print(type(t[1]));\n",
        "t[1][1]= \"Hello\";\n",
        "print(t,type(t),id(t));\n",
        "print(type(t[1]));\n",
        "t= (1,2,3,45,6);\n",
        "print(len(t));\n",
        "print(max(t));\n",
        "print(min(t));\n",
        "t =(('Hello',)* 4);\n",
        "print(t);\n",
        "print(t.count('Hello'));\n",
        "print(t.index('Hello'));\n",
        "if 'Hello' in t:\n",
        "  print(\"hell\");"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_Qn_x_nCxudR",
        "outputId": "244caf3c-a2c6-428b-cf34-070355ff5033"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "('ABC', ('pqr', 'mno', 'jkl')) <class 'tuple'> 139792743594496\n",
            "<class 'tuple'>\n",
            "('ABC', ['pqr', 'mno', 'jkl']) <class 'tuple'> 139792743568000\n",
            "<class 'list'>\n",
            "('ABC', ['pqr', 'Hello', 'jkl']) <class 'tuple'> 139792743568000\n",
            "<class 'list'>\n",
            "5\n",
            "45\n",
            "1\n",
            "('Hello', 'Hello', 'Hello', 'Hello')\n",
            "4\n",
            "0\n",
            "hell\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Sets"
      ],
      "metadata": {
        "id": "ErrMlG2b1Gu3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "s = {1,2,3,5,6};\n",
        "#s[0] = 9886;\n",
        "print(s);\n",
        "print(id(s));\n",
        "print(type(s));\n",
        "s.update({1,6,7,9},[12,2,34]);\n",
        "print(s);\n",
        "print(id(s));\n",
        "s.add(2635);\n",
        "print(s);\n",
        "s.pop();\n",
        "print(s);\n",
        "s.remove(2);\n",
        "print(s);\n",
        "s.discard(187);\n",
        "print(s);"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cxDsmY761Ief",
        "outputId": "21c3fcd0-1821-446c-98c9-ecad6c5a1189"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1, 2, 3, 5, 6}\n",
            "139792901741696\n",
            "<class 'set'>\n",
            "{1, 2, 3, 34, 5, 6, 7, 9, 12}\n",
            "139792901741696\n",
            "{1, 2, 3, 34, 5, 6, 7, 9, 2635, 12}\n",
            "{2, 3, 34, 5, 6, 7, 9, 2635, 12}\n",
            "{3, 34, 5, 6, 7, 9, 2635, 12}\n",
            "{3, 34, 5, 6, 7, 9, 2635, 12}\n"
          ]
        }
      ]
    }
  ]
}