03_Functions.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.9.2"
    },
    "colab": {
      "provenance": [],
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Aditi31kapil/python-/blob/main/03_Functions.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AVmSvfoZPFq3"
      },
      "source": [
        "# Python Quickstart\n",
        "## Functions\n",
        "Functions are very easy to write in python and all non-trivial programs will have functions. Function names have the same rules as variable names."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ng1QMogVPFq8"
      },
      "source": [
        "#### def keyword"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "udbV5nIOPFq8"
      },
      "source": [
        "# A simple function, almost trivial\n",
        "def square(n):\n",
        "    return n * n"
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UkwpYPJgPFq-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9c4ec914-557d-48dc-81f2-9aab68f7e354"
      },
      "source": [
        "print(square(7))"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "49\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "svvDiWIxPFq-",
        "outputId": "af8ee386-f503-4f75-9b5b-cd05c771662b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "print(square(7.1))\n"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "50.41\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nyUhS6A4PFq_",
        "outputId": "898d2924-58b1-40ca-b9ab-017eaaab5c92",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "print(square(7j))"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(-49+0j)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZZjimds4PFrA"
      },
      "source": [
        "Note the absence of type declarations and that the return type is determined by the input type."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eawNO_zaPFrA",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 263
        },
        "outputId": "c099e15e-1d28-416b-9a1d-663a91ae639d"
      },
      "source": [
        "print(square(\"Hello\"))"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "can't multiply sequence by non-int of type 'str'",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-5-6957b28a17ef>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msquare\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Hello\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m<ipython-input-1-4e66674b473c>\u001b[0m in \u001b[0;36msquare\u001b[0;34m(n)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# A simple function, almost trivial\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0msquare\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn\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----> 3\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mn\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mn\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: can't multiply sequence by non-int of type 'str'"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oocUWP6nPFrB"
      },
      "source": [
        "# some more functions\n",
        "def isPrime(n):\n",
        "    if n in [2, 3]:\n",
        "        return True\n",
        "    if n % 2 == 0:\n",
        "        return False\n",
        "    r = 3\n",
        "    while r * r <= n:\n",
        "        if n % r == 0:\n",
        "            return False\n",
        "        r += 2\n",
        "    return True"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zABFCwpxPFrB",
        "outputId": "395c4b35-6f5d-4e45-cc19-f800c3ef47f9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "print(isPrime(78), isPrime(79))"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O02_1vWBPFrC"
      },
      "source": [
        "def vowelCount(s):\n",
        "    \"\"\"Counts the number of vowels in s and returns the same\n",
        "    Ignores case of letters\"\"\"\n",
        "    VOWELS = \"aeiouAEIOU\"\n",
        "    vc = 0\n",
        "    for ch in s:\n",
        "        if ch in VOWELS:\n",
        "            vc += 1\n",
        "    return vc"
      ],
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LIDyd6Q-PFrC",
        "outputId": "5b7d7678-413b-433e-bb87-cc6d00a18fb7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "print(vowelCount(\"The quick brown fox jumps over the lazy dog\"))"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "11\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_nksZMjKPFrD"
      },
      "source": [
        "#### Recursion\n",
        "Recursion is also pretty simple."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JZsJtWNDPFrD"
      },
      "source": [
        "def isPowerOf2(n):\n",
        "    \"\"\"Checks if a number is a power of 2.\n",
        "    That is, verifies if an integer p exists such that n == 2 ** p\n",
        "    Remember 1 is 2 ** 0    \"\"\"\n",
        "    if n == 1:\n",
        "        return True\n",
        "    if n % 2 == 1:\n",
        "        return False\n",
        "    return isPowerOf2(n // 2)"
      ],
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(isPowerOf2(32),isPowerOf2(20))"
      ],
      "metadata": {
        "id": "U66iKNEy3hc7",
        "outputId": "48104048-11ed-4d15-ac64-906bb15637f8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F9bW7rdGPFrE"
      },
      "source": [
        "def isPalindrome(s):\n",
        "    \"\"\"Checks if a given string is a palindrome\"\"\"\n",
        "\n",
        "    # Empty strings and 1 character strings are palindromes\n",
        "    if len(s) <= 1:\n",
        "        return True\n",
        "    # if first character is different from last it is not\n",
        "    if s[0] != s[-1]:\n",
        "        return False\n",
        "    #Now first == last, so we can throw those out!\n",
        "    return isPalindrome(s[1:-1])"
      ],
      "execution_count": 28,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "m=\"monom\"\n",
        "print(isPalindrome(m))"
      ],
      "metadata": {
        "id": "oBX8h41a4Itn",
        "outputId": "fb50a730-da35-47e1-af6c-2bc123fbe755",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AuQ71fubPFrE"
      },
      "source": [
        "Python functions can return multiple values. The simplest example is the built-in function divmod"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VGkYMpBCPFrF",
        "outputId": "c640b5fa-4510-4025-97ea-80a9052e2483",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "divmod(17, 5)"
      ],
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(3, 2)"
            ]
          },
          "metadata": {},
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GHlRuFVRPFrG",
        "outputId": "a3ead731-c63d-4ca1-e1ae-f5c55d05ce1d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "quotient, remainder = divmod(17, 5)\n",
        "print(quotient, remainder)"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3 2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zCW20OT6PFrG"
      },
      "source": [
        "# Our own implementation of divmod\n",
        "def quotrem(n, d):\n",
        "    return n // d, n % d"
      ],
      "execution_count": 32,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qu3Je6DVPFrG",
        "outputId": "8003b579-b426-4fe1-af0b-459223fde708",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "quotrem(17, 5)"
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(3, 2)"
            ]
          },
          "metadata": {},
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wkaaxssPPFrG"
      },
      "source": [
        "#### New style functions\n",
        "After version 3.5, the idea of type hints was added. This is **NOT** enforced by the language/interpreter/runtime.\n",
        "\n",
        "This helps to\n",
        " * document the function\n",
        " * eneble external tools (such as IDEs) to offer warnings\n",
        "\n",
        " All the functions used above are shown below in the new style"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NE__H_F9PFrH"
      },
      "source": [
        "def square(n: int) -> int:\n",
        "    return n * n\n",
        "    # Note that this in way stops us from calling square(4.7)\n",
        "    # From version 3.10 we can do better\n",
        "\n",
        "#def square310(n: int| float|complex) -> int|float|complex:\n",
        "#    return n * n\n",
        "\n",
        "def isPrime(n: int) -> bool:\n",
        "    if n in [2, 3]:\n",
        "        return True\n",
        "    if n % 2 == 0:\n",
        "        return False\n",
        "    r = 3\n",
        "    while r * r <= n:\n",
        "        if n % r == 0:\n",
        "            return False\n",
        "        r += 2\n",
        "    return True\n",
        "\n",
        "def vowelCount(s: str) -> int:\n",
        "    \"\"\"Counts the number of vowels in s and returns the same\n",
        "    Ignores case of letters\"\"\"\n",
        "    VOWELS = \"aeiouAEIOU\"\n",
        "    vc = 0\n",
        "    for ch in s:\n",
        "        if ch in VOWELS:\n",
        "            vc += 1\n",
        "    return vc\n",
        "\n",
        "def isPowerOf2(n: int) -> bool:\n",
        "    \"\"\"Checks if a number is a power of 2.\n",
        "    That is, verifies if an integer p exists such that n == 2 ** p\n",
        "    Remember 1 is 2 ** 0    \"\"\"\n",
        "    if n == 1:\n",
        "        return True\n",
        "    if n % 2 == 1:\n",
        "        return False\n",
        "    return isPowerOf2(n // 2)\n",
        "\n",
        "def isPalindrome(s: str) -> bool:\n",
        "    \"\"\"Checks if a given string is a palindrome\"\"\"\n",
        "\n",
        "    # Empty strings and 1 character strings are palindromes\n",
        "    if len(s) <= 1:\n",
        "        return True\n",
        "    # if first character is different from last it is not\n",
        "    if s[0] != s[-1]:\n",
        "        return False\n",
        "    #Now first == last, so we can throw those out!\n",
        "    return isPalindrome(s[1:-1])\n",
        "\n",
        "def quotrem(n: int, d: int) -> (int, int):\n",
        "    return n // d, n % d"
      ],
      "execution_count": 34,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "temCv4T9PFrH"
      },
      "source": [
        "#### Higher Order Functions\n",
        "Python functions are first class objects. They can be assigned to variables, passed to functions as parameters and returned from functions!\n",
        "\n",
        "We will discuss more when covering functional programming"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P1jzF27pPsVn"
      },
      "source": [],
      "execution_count": null,
      "outputs": []
    }
  ]
}