Python/2019_03_12_Python-Class-2/Python_Class_II.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Python Class-II.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "metadata": {
        "id": "UlrnYE1XEuFl",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# String\n",
        "\n",
        "Strings are ordered text based data which are represented by enclosing the same in single/double/triple quotes.\n",
        "\n",
        "String in single quotes cannot hold any other single quoted character in it otherwise an error arises because the compiler won’t recognize where to start and end the string. To overcome this error, use of double quotes is preferred, because it helps in creation of Strings with single quotes in them. For strings which contain Double quoted words in them, use of triple quotes is suggested. Along with this, triple quotes also allow the creation of multiline strings.\n"
      ]
    },
    {
      "metadata": {
        "id": "FWOjU4NaDy3r",
        "colab_type": "code",
        "outputId": "b5fe84ee-fa7e-4f8d-bbef-38e307ab0b35",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 221
        }
      },
      "cell_type": "code",
      "source": [
        "string0 ='Welcome to first class of python'\n",
        "string1 =\"Welcome to first class of python\"\n",
        "string2 = \"\"\"Welcome to first\n",
        "class\n",
        "of\n",
        "python\"\"\"\n",
        "string3=\"This is first\\nclass\\nof\\npython\"\n",
        "string4='He said,\"How are you?\"'   #Try single quotes inside single quotes\n",
        "string5=\"He said,'How are you?'\"   #Try double quotes inside double quotes\n",
        "print(string0)\n",
        "print(string1)\n",
        "print(string2)\n",
        "print(string3)\n",
        "print(string4)\n",
        "print(string5)"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Welcome to first class of python\n",
            "Welcome to first class of python\n",
            "Welcome to first\n",
            "class\n",
            "of\n",
            "python\n",
            "This is first\n",
            "class\n",
            "of\n",
            "python\n",
            "He said,\"How are you?\"\n",
            "He said,'How are you?'\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "3otv_PD8HOoB",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## Input and output\n",
        "\n",
        "Taking input, storing it in a variable of type string and giving string output"
      ]
    },
    {
      "metadata": {
        "id": "pf5zxiecHU3a",
        "colab_type": "code",
        "outputId": "24e0d0b1-a86e-43ed-c9b5-f3f4717c5efc",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        }
      },
      "cell_type": "code",
      "source": [
        "name = input(\"What is your name?\")\n",
        "print(\"Hello, \" + name)\n",
        "print(\"How are you,\",name+\"?\")"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "What is your name?Python\n",
            "Hello, Python\n",
            "How are you, Python?\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "DsL9qii6Hfnc",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## String formatting"
      ]
    },
    {
      "metadata": {
        "id": "jHdSGVCsHjch",
        "colab_type": "code",
        "outputId": "11b52971-830a-46fc-b8be-3249b01440cb",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "cell_type": "code",
      "source": [
        "greeting=\"Hello\"\n",
        "name=\"Adam\"\n",
        "\n",
        "message=\"{}, {}\".format(greeting,name)\n",
        "\n",
        "print(message)"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello, Adam\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "GD00U4MdHrCV",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## Indexing and slicing\n",
        "\n",
        "In python, indexing starts from 0\n",
        "\n",
        "Indexing and slicing are same as discussed in lists"
      ]
    },
    {
      "metadata": {
        "id": "qlIukmL4HulL",
        "colab_type": "code",
        "outputId": "5aeeb38e-780a-4aee-ef7a-a8be02b5dfd1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 119
        }
      },
      "cell_type": "code",
      "source": [
        "name =\"asdfghj\"\n",
        "print(name[0])        #Char at index 0\n",
        "print(name[0:4])      #Substring from index 0 to 3\n",
        "print(name[2:])       #Substring from index 2 to end of string\n",
        "print(name[:3])       #Substring from start to index 2 \n",
        "print(name[:])        #Substring from start to end\n",
        "print(name[2:5:2])    #Characters from index 2 to 4 in steps of 2"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "a\n",
            "asdf\n",
            "dfghj\n",
            "asd\n",
            "asdfghj\n",
            "dg\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "A_bQGSvPJIK-",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## Built-in functions\n",
        "\n",
        "**len()** function is an inbuilt function in Python programming language that returns the length of the string. \n",
        "\n",
        "**find( )** function returns the index value of the given data that is to found in the string. If it is not found it returns -1. One can also input find( ) function between which index values it has to search.\n",
        "\n",
        "**index( )** works the same way as find( ) function the only difference is find returns '-1' when the input element is not found in the string but index( ) function throws a ValueError"
      ]
    },
    {
      "metadata": {
        "id": "Yr78uV4HJahk",
        "colab_type": "code",
        "outputId": "435ce62e-9184-4abf-945d-5a37a705ec8a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 299
        }
      },
      "cell_type": "code",
      "source": [
        "print(len(name))\n",
        "\n",
        "print(name.find(\"df\"))      #First index where \"dy\" is found\n",
        "print(name.find(\"ty\"))      #Returns -1 if not found\n",
        "print(name.find(\"df\",2,5))  #finds string from index 2 to 4\n",
        "print(name.find(\"df\",4,6))\n",
        "\n",
        "print(name.index('df'))\n",
        "print(name.index('ty'))     #error"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "7\n",
            "2\n",
            "-1\n",
            "2\n",
            "-1\n",
            "2\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-5-e6c75499e80c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'df'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'ty'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m     \u001b[0;31m#error\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m: substring not found"
          ]
        }
      ]
    },
    {
      "metadata": {
        "id": "G48wenJ2LQcy",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**capitalize( )** is used to capitalize the first element in the string.\n",
        "\n",
        "**lower( )** converts any capital letter to small letter.\n",
        "\n",
        "**upper( )** converts any small letter to capital letter.\n",
        "\n",
        "**endswith( )** function is used to check if the given string ends with the particular character(s) which is given as input.\n",
        "\n",
        "**count( )** function counts the number of char in the given string. The start and the stop index can also be specified or left blank. (These are Implicit arguments which will be dealt in functions)"
      ]
    },
    {
      "metadata": {
        "id": "tIigUeZ8Lf3a",
        "colab_type": "code",
        "outputId": "e2e3be63-10a7-40c3-ce00-43138e457865",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 170
        }
      },
      "cell_type": "code",
      "source": [
        "print(name.capitalize())\n",
        "print(name.lower())\n",
        "print(name.upper())\n",
        "print(name)\n",
        "\n",
        "print(name.endswith('j'))\n",
        "print(name.endswith('a'))\n",
        "\n",
        "print(name.count('a',0,7))\n",
        "print(name.count('a'))\n",
        "print(name.count('b'))"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Asdfghj\n",
            "asdfghj\n",
            "ASDFGHJ\n",
            "asdfghj\n",
            "True\n",
            "False\n",
            "1\n",
            "1\n",
            "0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "GwVdpBFTLw4c",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**join( )** function is used to add a char in between the elements of the input string.\n",
        "\n",
        "**replace( )** function replaces the element with another element.\n"
      ]
    },
    {
      "metadata": {
        "id": "qMUDgfkuLtt9",
        "colab_type": "code",
        "outputId": "3f01a570-d15e-4680-b280-374c5b47fc4e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "cell_type": "code",
      "source": [
        "print('AB'.join('python'))\n",
        "\n",
        "a=\"Python is not so cool\"\n",
        "print(a.replace('Python','C'))"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "pAByABtABhABoABn\n",
            "C is not so cool\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "D32LL8V0PATB",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## Print Statement"
      ]
    },
    {
      "metadata": {
        "id": "eVZf6QKtPClv",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "e8b2d007-7efe-4f64-96da-3fe0875952c6"
      },
      "cell_type": "code",
      "source": [
        "name = \"abc\"\n",
        "lan = \"python\"\n",
        "\n",
        "print(name,lan,'def',sep='/')"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "abc/python/def\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "Cbl6nkFbFgGj",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "\n",
        "# Functions"
      ]
    },
    {
      "metadata": {
        "id": "0tlY_pElNBqB",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**Basic Syntax**\n",
        "\n",
        "def function_name(parameters):<br>\n",
        " >     \"\"\"docstring\"\"\"        (optional) \n",
        "      statement(s)\n",
        "      return statement (optional)\n",
        "\n",
        " **Syntax of return statement**\n",
        "\n",
        "    return [expression_list]"
      ]
    },
    {
      "metadata": {
        "id": "EQLoPp3UM9ao",
        "colab_type": "code",
        "outputId": "3613a265-4a26-4ea2-8d2e-7e704e38edb4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "cell_type": "code",
      "source": [
        "# without parameters\n",
        "def func():\n",
        "    print('Hello')\n",
        "func()\n"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "2VcxLAM9F4Ss",
        "colab_type": "code",
        "outputId": "a69f6b3a-a404-476f-b78c-288260af1fd5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "cell_type": "code",
      "source": [
        "# with parameters\n",
        "def purchase(egg_count):\n",
        "  print(egg_count)\n",
        "purchase(10)"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "10\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "Nxij3venNZfH",
        "colab_type": "code",
        "outputId": "71b20aea-238d-48b9-d174-ad6b53fcd3f4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "cell_type": "code",
      "source": [
        "# with default parameters\n",
        "def purchase(egg_count=10):\n",
        "  print(egg_count)\n",
        "purchase()\n",
        "purchase(20)\n",
        "\n",
        "#SyntaxError: non-default argument follows default argument(Uncomment and run following)\n",
        "#def greet(msg = \"Good morning!\", name):\n",
        "#  print(name,msg)"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "10\n",
            "20\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "a5TGHsPzNezW",
        "colab_type": "code",
        "outputId": "4aecb49d-546d-4d79-84db-cd53f0b091b4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "cell_type": "code",
      "source": [
        "# with return statement\n",
        "def purchase(egg_count=10):\n",
        "  return 10 * egg_count\n",
        "answer = purchase()\n",
        "print(answer)\n",
        "answer = purchase(15)\n",
        "print(answer)"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "100\n",
            "150\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "RQbDe_CgNhbq",
        "colab_type": "code",
        "outputId": "9bd3ee6e-f574-4283-81b4-f1378359c6ae",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 119
        }
      },
      "cell_type": "code",
      "source": [
        "#keyword argument\n",
        "def fib(n, m):\n",
        "    print(\"n = \" + str(n))\n",
        "    print(\"m = \" + str(m))\n",
        "\n",
        "fib(5, 10)\n",
        "print('\\n')\n",
        "fib(m=5, n=10)"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "n = 5\n",
            "m = 10\n",
            "\n",
            "\n",
            "n = 10\n",
            "m = 5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "YaA_zDgcPi_A",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## Recursion (factorial)"
      ]
    },
    {
      "metadata": {
        "id": "ShFTyHYwOOcQ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "500fa98e-5a91-4877-be0e-353a9a5e443a"
      },
      "cell_type": "code",
      "source": [
        "def factorial(num):\n",
        "    if num == 1:      #base case\n",
        "        return 1\n",
        "    return num * factorial(num - 1)\n",
        "\n",
        "print(factorial(5))"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "120\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "Tqdu7guFP3Of",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## args, kwargs"
      ]
    },
    {
      "metadata": {
        "id": "eQ3OcUqoQBRB",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 238
        },
        "outputId": "15dd2625-500e-4a57-c890-892cc0e90476"
      },
      "cell_type": "code",
      "source": [
        "# variable no. of arguments (*args)\n",
        "def func(*args):\n",
        "    #args is tuple with the argument\n",
        "    for i in args:\n",
        "        print(i)\n",
        "func('hello', 'to', 'python', 'class', 'for', 'first', 'years')\n",
        "\n",
        "print()\n",
        "\n",
        "def my_print(*args):\n",
        "    for i in args:\n",
        "        print(i)\n",
        "        \n",
        "my_print('hello', 'my', 'name', 'is', 'bin'+'bash')"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "hello\n",
            "to\n",
            "python\n",
            "class\n",
            "for\n",
            "first\n",
            "years\n",
            "\n",
            "hello\n",
            "my\n",
            "name\n",
            "is\n",
            "binbash\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "df3cVkMKQEXf",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 136
        },
        "outputId": "f0700279-b93c-4b92-95ae-d5f307431000"
      },
      "cell_type": "code",
      "source": [
        "# variable no. of arguments (**kwargs)\n",
        "def func(**kwargs):\n",
        "    for key, values in kwargs.items():\n",
        "        print(key, values)\n",
        "func(hello='to', python='class', year='first')\n",
        "\n",
        "print()\n",
        "\n",
        "def kw_args_func(**kwargs):\n",
        "    for key, value in kwargs.items():\n",
        "        print('key:', key, ' ', 'value:', value)\n",
        "        \n",
        "kw_args_func(sep='/', end='*', name='bin')"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "hello to\n",
            "python class\n",
            "year first\n",
            "\n",
            "key: sep   value: /\n",
            "key: end   value: *\n",
            "key: name   value: bin\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "agPcS99EQfeq",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#Lambda Function\n",
        "\n",
        "Syntax of Lambda Function in python\n",
        "\n",
        "> ```lambda arguments: expression```\n",
        "\n",
        "Lambda functions can have any number of arguments but only one expression. The expression is evaluated and returned. Lambda functions can be used wherever function objects are required.\n",
        "\n",
        "We use lambda functions when we require a nameless function for a short period of time.\n",
        "\n",
        "In Python, we generally use it as an argument to a higher-order function (a function that takes in other functions as arguments). Lambda functions are used along with built-in functions like filter(), map() etc.\n"
      ]
    },
    {
      "metadata": {
        "id": "t8aDInHyQHlf",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "4c2ec878-66b8-47b2-b299-c8d8766ca9be"
      },
      "cell_type": "code",
      "source": [
        "# Program to show the use of lambda functions\n",
        "\n",
        "double = lambda x: x * 2\n",
        "\n",
        "# Output: 10\n",
        "print(double(5))"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "10\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "WlHtDZGoQvQ8",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "534c9f08-70c8-48a2-9eb6-a6c0631fb9d3"
      },
      "cell_type": "code",
      "source": [
        "# Program to filter out only the even items from a list\n",
        "\n",
        "my_list = [1, 5, 4, 6, 8, 11, 3, 12]\n",
        "\n",
        "new_list = list(filter(lambda x: (x%2 == 0) , my_list))\n",
        "\n",
        "# Output: [4, 6, 8, 12]\n",
        "print(new_list)"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[4, 6, 8, 12]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "HVgqKuJVQxkT",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "e110b025-5334-4cbb-e98f-56f4234107fa"
      },
      "cell_type": "code",
      "source": [
        "# Program to double each item in a list using map()\n",
        "\n",
        "my_list = [1, 5, 4, 6, 8, 11, 3, 12]\n",
        "\n",
        "new_list = list(map(lambda x: x * 2 , my_list))\n",
        "\n",
        "# Output: [2, 10, 8, 12, 16, 22, 6, 24]\n",
        "print(new_list)"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[2, 10, 8, 12, 16, 22, 6, 24]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "PEXFM0vkRmdI",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}