Chapter-06:Functions.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Chapter6_Functions.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyMs5PehoBKyzOLtn4nHzesS",
      "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/kbehrman/foundational-python-for-data-science/blob/main/Chapter6_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": "cxIh2XdSnYm4"
      },
      "source": [
        "## Notes\n",
        "[Functions](https://docs.python.org/3/reference/compound_stmts.html#function-definitions)\n",
        "\n",
        "[Calls](https://docs.python.org/3/reference/expressions.html#calls)\n",
        "\n",
        "[DocStrings](https://www.python.org/dev/peps/pep-0257/#:~:text=A%20docstring%20is%20a%20string,special%20attribute%20of%20that%20object.&text=String%20literals%20occurring%20elsewhere%20in%20Python%20code%20may%20also%20act%20as%20documentation.)\n",
        "\n",
        "[Positional Parameters](https://www.python.org/dev/peps/pep-0457/)\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2IsWbHNdkm2R"
      },
      "source": [
        "## Function Definition\n",
        "Function definitions define a function object. This object wraps the executable block. The definition does not run the block, just defines the function. The definition describes how the function can be called, what it is named, what parameters can be passed to it, and what will be executed when it is invoked. The building blocks of a function are the controlling statement, an optional docstring, the controlled code block and a return statement."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fokV3pexnQe3"
      },
      "source": [
        "### Control Statement\n",
        "The first line of a function definition is the control statement. This control statement takes the form:\n",
        "\n",
        "`def <Function Name> (<Parameters>):`\n",
        "\n",
        "`def` is the keyword indicating a function definition, `<Function Name>` is where the name that will be used to call the function is defined and `<Parameters>` is where any arguments that can be passed to the function are defined. For example, the function:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VoHNX1qXjDLn"
      },
      "source": [
        "def do_nothing(not_used):\n",
        "    pass"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BJ0hfEZKyeqn"
      },
      "source": [
        "Is defined with the name `do_nothing` and a single parameter named `not_used`.\n",
        "\n",
        "\n",
        "### DocString\n",
        "\n",
        "The next part of a function definition is the DocString. This DocString contains documentation for the function. It can be omitted, the python compiler will not object. It is highly recommended to supply a docstring for all but the most obvious methods. The Docstring consists of a single or multiline triple quoted string. It must immediatly follow the control statement. \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h5icngjNj6P6"
      },
      "source": [
        "def do_nothing(not_used):\n",
        "    \"\"\"This function does nothing.\"\"\"\n",
        "    pass"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aMrIw3pAqcmE"
      },
      "source": [
        "If it is a single line, the quotes should be on the same line as the text, for multi-line DocStrings, the quotes are generally above and below the text."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E9OGW3Ahqdak"
      },
      "source": [
        "def do_nothing(not_used):\n",
        "    \"\"\"\n",
        "    This function does nothing.\n",
        "\n",
        "    This function uses a pass statement to \n",
        "    avoid doing anything.\n",
        "\n",
        "    Parameters:\n",
        "       not_used - a parameter of any type,\n",
        "                  which is not used.\n",
        "    \"\"\"\n",
        "    pass\n"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZZvZzmTGq7PB"
      },
      "source": [
        "The first line of the docstring should be a statement summerizing what the function does. If a more detailed explanation is desired, a blank line should be left after the first statement. There are many different possible conventions for what is contained in a DocString after the first line, but generally you want to offer an explantion of what the function does, what parameters it takes and what it is expected to return. \n",
        "The DocString is useful both for someone reading your code and for various utilities which read and display either the first line, or the whole DocString. For example if we call the help function on our function, the DocString is displayed."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "il8Bk5r1rx28",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7be1cfc0-5059-4f65-a1e5-78da0aecb947"
      },
      "source": [
        "help(do_nothing)"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Help on function do_nothing in module __main__:\n",
            "\n",
            "do_nothing(not_used)\n",
            "    This function does nothing.\n",
            "    \n",
            "    This function uses a pass statement to \n",
            "    avoid doing anything.\n",
            "    \n",
            "    Parameters:\n",
            "       not_used - a parameter of any type,\n",
            "                  which is not used.\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z0jowVGzt7Nj"
      },
      "source": [
        "### Parameters\n",
        "keyword vs position\n",
        "default value \n",
        "call using position or keyword"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4AjdXfZArzw7"
      },
      "source": [
        "def does_order(first, second, third):\n",
        "    '''Prints parameters.'''\n",
        "    print(f'First: {first}')\n",
        "    print(f'Second: {second}')\n",
        "    print(f'Third: {third}')"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GU-u-UZFytWL",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "193f84f2-f4d9-4ae6-8490-aae512ea9465"
      },
      "source": [
        "does_order(1, 2, 3)\n"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "First: 1\n",
            "Second: 2\n",
            "Third: 3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rRWLAxF-yzae",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f2ae857d-c6a3-4582-c364-f24867545db0"
      },
      "source": [
        "does_order(first=1, second=2, third=3)"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "First: 1\n",
            "Second: 2\n",
            "Third: 3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eDZ14ioE3vTc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a67e71a2-669a-479c-dde2-6f511c8f9163"
      },
      "source": [
        "does_order(1, third=3, second=2)"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "First: 1\n",
            "Second: 2\n",
            "Third: 3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FXjOCf733zp9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 130
        },
        "outputId": "70b74d90-c24e-474b-8612-2015426e951c"
      },
      "source": [
        "does_order(second=2, 1, 3)"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "error",
          "ename": "SyntaxError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-9-eed80203e699>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    does_order(second=2, 1, 3)\u001b[0m\n\u001b[0m                        ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m positional argument follows keyword argument\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aakCFwWCBezH"
      },
      "source": [
        "def does_keyword(first, second, *, third):\n",
        "    '''Prints parameters.'''\n",
        "    print(f'First: {first}')\n",
        "    print(f'Second: {second}')\n",
        "    print(f'Third: {third}')"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MaZYqX9FBnHv",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "852bfd58-0889-4149-d78c-abaa5fcfa2df"
      },
      "source": [
        "does_keyword(1, 2, third=3)"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "First: 1\n",
            "Second: 2\n",
            "Third: 3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4NmVE5RBBsRx",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 164
        },
        "outputId": "9212e7e3-4b42-4640-fb25-641ef5bd9036"
      },
      "source": [
        "does_keyword(1, 2, 3)"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-15-88b97f8a6c32>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mdoes_keyword\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: does_keyword() takes 2 positional arguments but 3 were given"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "74NvU1Tr3_Vk"
      },
      "source": [
        "def does_defaults(first, second, third=3):\n",
        "    '''Prints parameters.'''\n",
        "    print(f'First: {first}')\n",
        "    print(f'Second: {second}')\n",
        "    print(f'Third: {third}')"
      ],
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wu9E0PTPBAq5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "429b9b07-f0ef-4278-a2a1-64fffcb4b0d4"
      },
      "source": [
        "does_defaults(1, 2, 3)"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "First: 1\n",
            "Second: 2\n",
            "Third: 3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XteWCqjNBEFX",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2a16c775-3fca-4a30-f925-f7e06be982da"
      },
      "source": [
        "does_defaults(1, 2)"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "First: 1\n",
            "Second: 2\n",
            "Third: 3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wYPqtPItBGn_",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 130
        },
        "outputId": "f696a6cb-2016-4e91-bde4-2033562215ad"
      },
      "source": [
        "def does_defaults(first=1, second, third=3):\n",
        "    '''Prints parameters.'''\n",
        "    print(f'First: {first}')\n",
        "    print(f'Second: {second}')\n",
        "    print(f'Third: {third}')"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "error",
          "ename": "SyntaxError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-19-a015eaeb01be>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    def does_defaults(first=1, second, third=3):\u001b[0m\n\u001b[0m                     ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m non-default argument follows default argument\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZzNKWCc6BUH7"
      },
      "source": [
        "def does_list_default(my_list=[]):\n",
        "    '''Uses list as default.'''\n",
        "    my_list.append(1)\n",
        "    print(my_list)"
      ],
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n_HN8ubJCnDo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2b33286d-ba00-4a29-faaf-9072db58a76a"
      },
      "source": [
        "does_list_default()\n",
        "does_list_default()\n",
        "does_list_default()"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1]\n",
            "[1, 1]\n",
            "[1, 1, 1]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WwkKuQjxHe40"
      },
      "source": [
        "def does_list_param(my_list=None):\n",
        "    '''Assigns default in code to avoid confusion.'''\n",
        "    my_list = my_list or []\n",
        "    my_list.append(1)\n",
        "    print(my_list)"
      ],
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yB2zZpCKHyAy",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "96cde62d-07dc-4eba-a46a-32bee07c39e8"
      },
      "source": [
        "does_list_param()\n",
        "does_list_param()\n",
        "does_list_param()"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1]\n",
            "[1]\n",
            "[1]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "anjofATZCtlw",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 130
        },
        "outputId": "b42282a5-1c97-4446-9955-ef60223a0d61"
      },
      "source": [
        "# Requires Python 3.8\n",
        "# see: https://research.google.com/colaboratory/local-runtimes.html\n",
        "def does_positional(first, /, second, third):\n",
        "    '''Demonstrates a positional parameter.'''\n",
        "    print(f'First: {first}')\n",
        "    print(f'Second: {second}')\n",
        "    print(f'Third: {third}')"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "error",
          "ename": "SyntaxError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-24-9c7d1da34fbe>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    def does_positional(first, /, second, third):\u001b[0m\n\u001b[0m                               ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N73Er1X-DZeH",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 164
        },
        "outputId": "1eeb17cc-b2bd-420d-c3e1-5166b50bbca9"
      },
      "source": [
        "does_positional(1, 2, 3)"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-25-b02cc2a86113>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mdoes_positional\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m: name 'does_positional' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O5PFF-unDc-m",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 164
        },
        "outputId": "acc81c1b-3e7b-4f3e-bafa-2f639e712462"
      },
      "source": [
        "does_positional(first=1, second=2, third=3)"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-26-7b1f45f64358>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mdoes_positional\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfirst\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msecond\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mthird\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m: name 'does_positional' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ekrgIc0ADh-O"
      },
      "source": [
        "def does_positional(first, /, second, *, third):\n",
        "    '''Demonstrates a positional and keyword parameters.'''\n",
        "    print(f'First: {first}')\n",
        "    print(f'Second: {second}')\n",
        "    print(f'Third: {third}')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zoVFiAibDsEW"
      },
      "source": [
        "does_positional(1, 2, third=3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KPvNYfNDDxtV"
      },
      "source": [
        "def does_wildcard_positions(*args):\n",
        "    '''Demonstrates wildcard for positional parameters.'''\n",
        "    for item in args:\n",
        "        print(item)"
      ],
      "execution_count": 27,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VPSl-SZPETet",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9fb332b7-e606-430c-f430-8a23da46bd96"
      },
      "source": [
        "does_wildcard_positions('Donkey', 3, ['a'])"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Donkey\n",
            "3\n",
            "['a']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RxSa9_JTEgYC"
      },
      "source": [
        "def does_wildcard_keywords(**kwargs):\n",
        "    '''Demonstrates wildcard for keyword parameters.'''\n",
        "    for key, value in kwargs.items():\n",
        "        print(f'{key} : {value}')"
      ],
      "execution_count": 29,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VP-AdfjGE2HK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "19dd02b8-b10c-4505-d22b-71442d4ac9d8"
      },
      "source": [
        "does_wildcard_keywords(one=1, name='Martha')"
      ],
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "one : 1\n",
            "name : Martha\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sRQDSxnGFCaA"
      },
      "source": [
        "def does_wildcards(*args, **kwargs):\n",
        "    '''Demonstrates wildcard parameters.'''\n",
        "    print(f'Positional: {args}')\n",
        "    print(f'Keyword: {kwargs}')"
      ],
      "execution_count": 31,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XOlMfJl7FpTi",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "44770aa5-0c3c-4ab7-ea0f-30c30688777f"
      },
      "source": [
        "does_wildcards(1, 2, a='a', b=3)"
      ],
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Positional: (1, 2)\n",
            "Keyword: {'a': 'a', 'b': 3}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2KmfDf6pI5qg"
      },
      "source": [
        "def adds_one(some_number):\n",
        "    '''Demonstrates return statement.'''\n",
        "    return some_number + 1"
      ],
      "execution_count": 33,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C6UxpyeEJEW_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b1649ae3-e148-44e2-efd1-2101731dfca8"
      },
      "source": [
        "adds_one(1)"
      ],
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4YERaOgSFuME"
      },
      "source": [
        "def returns_none():\n",
        "    '''Demonstrates default return value.'''\n",
        "    pass"
      ],
      "execution_count": 35,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kDCUoepPIn78",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3a3a6868-f3fd-4dfb-fe92-1e4c7ac6a214"
      },
      "source": [
        "returns_none() == None"
      ],
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RtanaGVnIpgo"
      },
      "source": [
        "outer = 'Global scope'\n",
        "\n",
        "def shows_scope():\n",
        "    '''Demonstrates local variable.'''\n",
        "    inner = 'Local scope'\n",
        "    print(outer)\n",
        "    print(inner)"
      ],
      "execution_count": 37,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oVJm5ChOJv7T",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "89febf14-fd19-45ac-a691-5d49e4bdbd38"
      },
      "source": [
        "shows_scope()"
      ],
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Global scope\n",
            "Local scope\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GI8JXN3lJxGK",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 164
        },
        "outputId": "5bd38e23-1af1-430a-9c0f-006f08bc83d7"
      },
      "source": [
        "print(inner)"
      ],
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-39-9504624e1153>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minner\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m: name 'inner' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2F-_HN-gJyOl",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "76cbce75-1673-40cf-bd53-90aa08a3ddd9"
      },
      "source": [
        "def add_one(n):\n",
        "    '''Adds one to a number.'''\n",
        "    return n + 1\n",
        "\n",
        "my_func = add_one\n",
        "print(my_func)"
      ],
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<function add_one at 0x7facc7a03050>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LgZ51GZXKNan",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c8dace28-319c-4a9b-aa6e-3825c0b6cb68"
      },
      "source": [
        "my_func(2)"
      ],
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 41
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8X8VLlfCKPcN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1df0ab5f-41ae-4d9b-c94f-abb2ebaf6e45"
      },
      "source": [
        "def add_one(n):\n",
        "    '''Adds one to a number.'''\n",
        "    return n + 1\n",
        "\n",
        "def add_two(n):\n",
        "    '''Adds two to a number.'''\n",
        "    return n + 2\n",
        "\n",
        "my_functions = [add_one, add_two]\n",
        "\n",
        "for my_func in my_functions:\n",
        "    print(my_func(1))"
      ],
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2\n",
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TSr0v0WXKoRj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9f231668-ae4f-47a2-caa5-d781c68ffce9"
      },
      "source": [
        "def call_nested():\n",
        "    '''Calls a nested function.'''\n",
        "    print('outer')\n",
        "\n",
        "    def nested():\n",
        "        '''Prints a message.'''\n",
        "        print('nested')\n",
        "        \n",
        "    return nested\n",
        "\n",
        "my_func = call_nested()"
      ],
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "outer\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vFeSgL3Wh0jQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8aa6be7d-05c2-4514-e0c8-dd71cbade271"
      },
      "source": [
        "my_func()"
      ],
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "nested\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T1aEd2k9jkHM",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "49ab0bc0-9544-4df5-b3ca-3eba02e541dc"
      },
      "source": [
        "def add_one(number):\n",
        "    '''Adds to a number.'''\n",
        "    print('Adding 1')\n",
        "    return number + 1\n",
        "\n",
        "def wrapper(number):\n",
        "    '''Wraps another function.'''\n",
        "    print('Before calling function')\n",
        "    retval = add_one(number)\n",
        "    print('After calling function')\n",
        "    return retval\n",
        "\n",
        "wrapper(1)"
      ],
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Before calling function\n",
            "Adding 1\n",
            "After calling function\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 45
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4hYw1L9Hh2e4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "30b2f823-9315-4d3f-c0fd-261401f9906f"
      },
      "source": [
        "def add_one(number):\n",
        "    '''Adds to a number.'''\n",
        "    print('Adding 1')\n",
        "    return number + 1\n",
        "\n",
        "def do_wrapping(some_func):\n",
        "    '''Returns a wrapped function.'''\n",
        "    print('wrapping function')\n",
        "\n",
        "    def wrapper(number):\n",
        "        '''Wraps another function.'''\n",
        "        print('Before calling function')\n",
        "        retval = some_func(number)\n",
        "        print('After calling function')\n",
        "        return retval\n",
        "\n",
        "    return wrapper\n",
        "\n",
        "\n",
        "my_func = do_wrapping(add_one)"
      ],
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "wrapping function\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vhelHppLkL5E",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f9b6281b-dc7c-44b9-e7f4-f5b46efc5524"
      },
      "source": [
        "my_func(1)"
      ],
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Before calling function\n",
            "Adding 1\n",
            "After calling function\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 47
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lvD5UaYF13xG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "97c855d4-b76f-44b1-ceb2-e7ca10fc35ad"
      },
      "source": [
        "def add_two(number):\n",
        "    '''Adds two to a number.'''\n",
        "    print('Adding 2')\n",
        "    return number + 2\n",
        "\n",
        "my_func = do_wrapping(add_two)\n",
        "my_func(1)"
      ],
      "execution_count": 48,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "wrapping function\n",
            "Before calling function\n",
            "Adding 2\n",
            "After calling function\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 48
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MZK-1DJwkSGL",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9f990bc1-f5db-4c68-bb7b-cbc70694c5b0"
      },
      "source": [
        "def do_wrapping(some_func):\n",
        "    '''Returns a wrapped function.'''\n",
        "    print('wrapping function')\n",
        "\n",
        "    def wrapper(number):\n",
        "        '''Wraps another function.'''\n",
        "        print('Before calling function')\n",
        "        some_func(number)\n",
        "        print('After calling function')\n",
        "\n",
        "    return wrapper\n",
        "\n",
        "@do_wrapping\n",
        "def add_one(number):\n",
        "    '''Adds to a number.'''\n",
        "    print('Adding 1')\n",
        "    return number + 1\n",
        "\n"
      ],
      "execution_count": 49,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "wrapping function\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Vq7Fxwf5kmuP",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2ffda20a-8a26-4686-8ccb-ac16d3bb477c"
      },
      "source": [
        "add_one(1)"
      ],
      "execution_count": 50,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Before calling function\n",
            "Adding 1\n",
            "After calling function\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V1FT4e4ekrMB",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4f91af1e-542c-45f0-a2be-bbbd2ce87d14"
      },
      "source": [
        "my_func = lambda x: x + 1\n",
        "my_func(1)"
      ],
      "execution_count": 51,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 51
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SHqJMybGlGtZ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f12bc5f0-b9ac-416b-ea89-2a03222dde55"
      },
      "source": [
        "def apply_to_list(data, my_func):\n",
        "    '''Applies a function to items in a list.'''\n",
        "    for item in data:\n",
        "        print(f'{my_func(item)}')\n",
        "\n",
        "apply_to_list([1, 2, 3], lambda x: x + 1)"
      ],
      "execution_count": 52,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2\n",
            "3\n",
            "4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ad0kdo88lITv"
      },
      "source": [
        "def add_prefix(word, prefix='before-'):\n",
        "    '''Prepend a word.'''\n",
        "    return f'{prefix}{word}'"
      ],
      "execution_count": 53,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_Tvzu0FIXVEL"
      },
      "source": [
        "def return_one():\n",
        "    return 1\n",
        "\n",
        "def wrapper():\n",
        "    print('a')\n",
        "    retval = return_one()\n",
        "    print('b')\n",
        "    print(retval)\n",
        "    "
      ],
      "execution_count": 54,
      "outputs": []
    }
  ]
}