4)Functions in Python.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Functions in Python.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Coders-Asylum/Python-101/blob/master/Functions_in_Python.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Fu3iudDw5SpU",
        "colab_type": "text"
      },
      "source": [
        "# Defining Functions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mRXKwAIJ5Vnr",
        "colab_type": "text"
      },
      "source": [
        "A function in python is similar as a function in anny other programming language\n",
        "\n",
        "Defining function un python is done by using def keyword followed by the function name and parenthesis () . And should always end with : .\n",
        "\n",
        "The () hold the function parameters(arguments) that is passed on to the function. #not necessary that the arguments name should be exactly same as the name of the arguments that were used while defining the function.\n",
        "\n",
        "to return a value form the function, use the return keyword followed by the variable name and no parenthesis is ()required."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kOiBUnBa5iGd",
        "colab_type": "code",
        "outputId": "bf261309-fd59-48c4-90a5-72fa9ee97f98",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 90
        }
      },
      "source": [
        "# todo: Given below are various methods to declare functions\n",
        "def sum_function(c, d):\n",
        "    return c + d\n",
        "\n",
        "\n",
        "a = 3\n",
        "b = 6\n",
        "result = sum_function(a, b)\n",
        "print(result)\n",
        "\n",
        "\n",
        "# the above function can be written as\n",
        "\n",
        "def sum2(f, g):\n",
        "    result4 = f + g\n",
        "    return result4\n",
        "\n",
        "\n",
        "a = 5\n",
        "b = 6\n",
        "print(sum2(a, b))\n",
        "\n",
        "\n",
        "# Function can be designed to print the result and not return any value\n",
        "\n",
        "def sum3(f, g):\n",
        "    print(f + g)\n",
        "    return f + g\n",
        "\n",
        "\n",
        "a = 7\n",
        "b = 9\n",
        "sum3(a, b)\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "9\n",
            "11\n",
            "16\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "16"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pbF7M_t95rKe",
        "colab_type": "text"
      },
      "source": [
        "**More Information On Functions:**\n",
        "\n",
        "Coming from other languages, you might object that a function without a return is not a function but a procedure since it doesn’t return a value. In fact, even functions without a return statement do return a value, albeit a rather boring one.\n",
        "\n",
        "This value is called None (it’s a built-in name). Writing the value None is normally suppressed by the interpreter if it would be the only value written. You can see it if you really want to using print().\n",
        "\n",
        "The execution of a function introduces a new symbol table used for the local variables of the function. More precisely, all variable assignments in a function store the value in the local symbol table; whereas variable references first look in the local symbol table, then in the local symbol tables of enclosing functions, then in the global symbol table, and finally in the table of built-in names. Thus, global variables and variables of enclosing functions cannot be directly assigned a value within a function (unless, for global variables, named in a global statement, or, for variables of enclosing functions, named in a nonlocal statement), although they may be referenced.</p>\n",
        "<p>The actual parameters (arguments) to a function call are introduced in the local symbol table of the called function when it is called; thus, arguments are passed using call by value (where the value is always an object reference, not the value of the object). 1 When a function calls another function, a new local symbol table is created for that call.</p>\n",
        "<p>A function definition introduces the function name in the current symbol table. The value of the function name has a type that is recognized by the interpreter as a user-defined function. This value can be assigned to another name which can then also be used as a function</p>\n",
        "\n"
      ]
    }
  ]
}