Lab2_Function.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/nevermind78/Python4LM/blob/master/Lab2_Function.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oNFKS8kl6U4s"
      },
      "source": [
        "# Lab 2: Functions\n",
        "\n",
        "## Overview\n",
        "Build familiarity with reading and writing Python functions with different types of formal parameters, explore some nuances of function execution semantics, and dive into the internals of functions.\n",
        "\n",
        "*Disclaimer: we know that this lab is particularly focused on Python semantics, which may not seem exciting at first. However, mastering the mechanics of Python functions gives you access to a whole lot of powerful tools that either don't exist or are uncommon or hard-to-use in other languages! The skills you learn through this lab will allow you to write (and debug) powerful Pythonic code quickly and easily!*\n",
        "\n",
        "**As with Lab 1, we don't expect you to finish all of the material here in one class period. If you do - great! But if not, you are encouraged to work through the extra material at your own pace - it explores interesting and intriguing aspects of Python functions.**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LMVT1lCp6U4z"
      },
      "source": [
        "## Exploring Arguments and Parameters\n",
        "\n",
        "With a partner, work through the following problems.\n",
        "\n",
        "### Familiar Functions\n",
        "Consider the following function definition:\n",
        "\n",
        "```\n",
        "def print_two(a, b):\n",
        "    print(\"Arguments: {0} and {1}\".format(a, b))\n",
        "```\n",
        "\n",
        "For each of the following function calls, predict whether the call is valid or not. If it is valid, what will the output be? If it is invalid, what is the cause of the error?\n",
        "\n",
        "*Note: make your predictions **before** running the code in the interactive interpreter. Then check yourself!*\n",
        "\n",
        "```\n",
        "# Valid or invalid?\n",
        "print_two()\n",
        "print_two(4, 1)\n",
        "print_two(41)\n",
        "print_two(a=4, 1)\n",
        "print_two(4, a=1)\n",
        "print_two(4, 1, 1)\n",
        "print_two(b=4, 1)\n",
        "print_two(a=4, b=1)\n",
        "print_two(b=1, a=4)\n",
        "print_two(1, a=1)\n",
        "print_two(4, 1, b=1)\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6Wyp80LS6U41"
      },
      "outputs": [],
      "source": [
        "def print_two(a, b):\n",
        "    print(\"Arguments: {0} and {1}\".format(a, b))"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print_two(4, 1, c=1)"
      ],
      "metadata": {
        "id": "dKJovHZXGCs8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AyMloGhR6U42"
      },
      "source": [
        "Write at least two more instances of function calls, not listed above, and predict their output. Are they valid or invalid? Check your hypothesis.\n",
        "\n",
        "*These \"write-some-more\" problems are your chance to clarify your own understanding of function call semantics. You can skip them if you'd like, but using the interactive interpreter to test your own hypotheses is a crucial Python skill that lets you answer questions of the form \"But what happens if I...\"*"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fBIT4kfx6U43"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dwPhHfHu6U43"
      },
      "source": [
        "### Default Arguments\n",
        "\n",
        "Consider the following function definition:\n",
        "\n",
        "```\n",
        "def keyword_args(a, b=1, c='X', d=None):\n",
        "    print(\"a:\", a)\n",
        "    print(\"b:\", b)\n",
        "    print(\"c:\", c)\n",
        "    print(\"d:\", d)\n",
        "```\n",
        "\n",
        "For each of the following function calls, predict whether the call is valid or not. If it is valid, what will the output be? If it is invalid, what is the cause of the error?\n",
        "\n",
        "```\n",
        "keyword_args(5)\n",
        "keyword_args(a=5)\n",
        "keyword_args(5, 8)\n",
        "keyword_args(5, 2, c=4)\n",
        "keyword_args(5, 0, 1)\n",
        "keyword_args(5, 2, d=8, c=4)\n",
        "keyword_args(5, 2, 0, 1, \"\")\n",
        "keyword_args(c=7, 1)\n",
        "keyword_args(c=7, a=1)\n",
        "keyword_args(5, 2, [], 5)\n",
        "keyword_args(1, 7, e=6)\n",
        "keyword_args(1, c=7)\n",
        "keyword_args(5, 2, b=4)\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7rwPe6Mn6U44"
      },
      "outputs": [],
      "source": [
        "def keyword_args(a=1, b=1, c='X', d=None):\n",
        "    b=4\n",
        "    print(\"a:\", a)\n",
        "    print(\"b:\", b)\n",
        "    print(\"c:\", c)\n",
        "    print(\"d:\", d)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "keyword_args(5, 2, d=8, c=4)"
      ],
      "metadata": {
        "id": "0s-O0xURIr-P"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jtmk2xeR6U45"
      },
      "source": [
        "Write at least two more instances of function calls, not listed above, and predict their output. Are they valid or invalid? Check your hypothesis.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YQQIey2U6U46"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eiLNWt0q6U46"
      },
      "source": [
        "### Exploring Variadic Argument lists\n",
        "As before, consider the following function definition: \n",
        "\n",
        "```\n",
        "def variadic(*args, **kwargs):\n",
        "    print(\"Positional:\", args)\n",
        "    print(\"Keyword:\", kwargs)\n",
        "```\n",
        "\n",
        "For each of the following function calls, predict whether the call is valid or not. If it is valid, what will the output be? If it is invalid, what is the cause of the error?\n",
        "\n",
        "```\n",
        "variadic(2, 3, 5, 7)\n",
        "variadic(1, 1, n=1)\n",
        "variadic(n=1, 2, 3)\n",
        "variadic()\n",
        "variadic(cs=\"Computer Science\", pd=\"Product Design\")\n",
        "variadic(cs=\"Computer Science\", cs=\"CompSci\", cs=\"CS\")\n",
        "variadic(5, 8, k=1, swap=2)\n",
        "variadic(8, *[3, 4, 5], k=1, **{'a':5, 'b':'x'})\n",
        "variadic(*[8, 3], *[4, 5], k=1, **{'a':5, 'b':'x'})\n",
        "variadic(*[3, 4, 5], 8, *(4, 1), k=1, **{'a':5, 'b':'x'})\n",
        "variadic({'a':5, 'b':'x'}, *{'a':5, 'b':'x'}, **{'a':5, 'b':'x'})\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "if9lpi8Q6U47"
      },
      "outputs": [],
      "source": [
        "# *args ===> une séquence d'argument ( * unpacking )\n",
        "#**kwargs ==key words argument :=> a=2((** unpacking dictionnaire))\n",
        "\n",
        "def variadic(*args, **kwargs):\n",
        "    print(\"Positional:\", args)\n",
        "    print(\"Keyword:\", kwargs)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "variadic({'a':5, 'b':'x'}, *{'a':5, 'b':'x'}, **{'a':5, 'b':'x'})\n"
      ],
      "metadata": {
        "id": "TUat91UJEV_G"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "variadic({'a':5, 'b':'x'}, *{'a':5, 'b':'x'}, **{'a':5, 'b':'x'})"
      ],
      "metadata": {
        "id": "RuEIbApvC9NV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ll_5n1Ud6U47"
      },
      "source": [
        "Write at least two more instances of function calls, not listed above, and predict their output. Are they valid or invalid? Check your hypothesis."
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Gizojiy7G7V8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kKhjNNIL6U48"
      },
      "source": [
        "### *Optional: Putting it all together*\n",
        "*If you feel confident that you understand how function calling works, you can skip this section. We suggest that you work through it anyway, but the final decision is up to you.*\n",
        "\n",
        "Often, however, we don't just see keyword arguments of variadic parameter lists in isolated situations. The following function definition, which incorporates positional parameters, keyword parameters, variadic positional parameters, keyword-only default parameters and variadic keyword parameters, is valid Python. \n",
        "\n",
        "```\n",
        "def all_together(x, y, z=1, *nums, indent=True, spaces=4, **options):\n",
        "    print(\"x:\", x)\n",
        "    print(\"y:\", y)\n",
        "    print(\"z:\", z)\n",
        "    print(\"nums:\", nums)\n",
        "    print(\"indent:\", indent)\n",
        "    print(\"spaces:\", spaces)\n",
        "    print(\"options:\", options)\n",
        "```\n",
        "\n",
        "For each of the following function calls, predict whether the call is valid or not. If it is valid, what will the output be? If it is invalid, what is the cause of the error?\n",
        "```\n",
        "all_together(2)\n",
        "all_together(2, 5, 7, 8, indent=False)\n",
        "all_together(2, 5, 7, 6, indent=None)\n",
        "all_together()\n",
        "all_together(indent=True, 3, 4, 5)\n",
        "all_together(**{'indent': False}, scope='maximum')\n",
        "all_together(dict(x=0, y=1), *range(10))\n",
        "all_together(**dict(x=0, y=1), *range(10))\n",
        "all_together(*range(10), **dict(x=0, y=1))\n",
        "all_together([1, 2], {3:4})\n",
        "all_together(8, 9, 10, *[2, 4, 6], x=7, spaces=0, **{'a':5, 'b':'x'})\n",
        "all_together(8, 9, 10, *[2, 4, 6], spaces=0, **{'a':[4,5], 'b':'x'})\n",
        "all_together(8, 9, *[2, 4, 6], *dict(z=1), spaces=0, **{'a':[4,5], 'b':'x'})\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jWZaaUKi6U49"
      },
      "outputs": [],
      "source": [
        "def all_together(x, y, z=1, *nums, indent=True, spaces=4, **options):\n",
        "    print(\"x:\", x)\n",
        "    print(\"y:\", y)\n",
        "    print(\"z:\", z)\n",
        "    print(\"nums:\", nums)\n",
        "    print(\"indent:\", indent)\n",
        "    print(\"spaces:\", spaces)\n",
        "    print(\"options:\", options)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "all_together(8, 9, *[2, 4, 6], *dict(z=1), spaces=0, **{'a':[4,5], 'b':'x'})\n"
      ],
      "metadata": {
        "id": "rzmSYPjaYNRl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RCgGWZPc6U49"
      },
      "source": [
        "Write at least two more instances of function calls, not listed above, and predict their output. Are they valid or invalid? Check your hypothesis.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "19Dtz7dg6U49"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Cm22gJtc6U49"
      },
      "source": [
        "## Writing Functions\n",
        "### `speak_excitedly`\n",
        "Write a function `speak_excitedly` that accepts one required positional argument (a message) and two optional keyword arguments, the first of which is a positive integer referring to the number of exclamation marks to put at the end of the message (defaults to 1), and the second of which is a boolean flag indicating whether or not to capitalize the message (defaults to False).\n",
        "\n",
        "What would the function signature and implementation look like for this function?\n",
        "\n",
        "```\n",
        "def speak_excitedly(???):\n",
        "    pass\n",
        "```\n",
        "\n",
        "How would you call this function to produce the following outputs?\n",
        "\n",
        "```\n",
        "\"I love Python!\"\n",
        "\"Keyword arguments are great!!!!\"\n",
        "\"I guess Java is okay...\"\n",
        "\"LET'S GO STANFORD!!\"\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0Pj9XrgT6U4-"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "source": [
        "speak_excitedly(\"I love Python\")"
      ],
      "metadata": {
        "id": "vcLLrLmXdY7Q"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "speak_excitedly(\"Keyword arguments are great\",n=4)"
      ],
      "metadata": {
        "id": "jGR3o-AYdY-G"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "speak_excitedly(\"I guess Java is okay...\",n=0)"
      ],
      "metadata": {
        "id": "Ore1ss_xdp7r"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "speak_excitedly(\"let's go stanford\",b=True,n=2)"
      ],
      "metadata": {
        "id": "qrEVF58OdwEk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r7DD_Ap46U4-"
      },
      "source": [
        "### `average`\n",
        "Write a function `average` that accepts a variable number of integer positional arguments and computes the average. If no arguments are supplied, the function should return `None`.\n",
        "\n",
        "What would the function signature and implementation look like for this function?\n",
        "\n",
        "```\n",
        "def average(???):\n",
        "    pass\n",
        "```\n",
        "\n",
        "It should be possible to call the function as follows:\n",
        "\n",
        "```\n",
        "average()  # => None\n",
        "average(5) # => 5.0\n",
        "average(6, 8, 9, 11)  # => 8.5\n",
        "```\n",
        "\n",
        "Suppose that we have a list `l = [???]` supplied by the user of unknown length. How can we use the `average` function we just wrote function to compute the average of this list? For this second half of the problem, do not use the builtin `sum` or `len` functions – try passing the contents of `l` to `average`.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PRm-pyyE6U4_"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(average(6,8,9,11))"
      ],
      "metadata": {
        "id": "aSxruWWOfBYE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "mot='abc'\n",
        "print('{:*^11}'.format(mot))"
      ],
      "metadata": {
        "id": "clOpl_MAgEdU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lLFuFp8_6U4_"
      },
      "source": [
        "### Challenge: `make_table`\n",
        "\n",
        "Write a function to make a table out of an arbitrary number of keyword arguments. There should be two parameters, `key_justify` and `value_justify`, whose default values are `'left'` and `'right'` respectively, and which control the justification for keys and values in the table. Valid options for these parameters are `['left', 'right', 'center']`. There should be an extra space of padding on either side of the keys and values.\n",
        "\n",
        "What would the function signature and implementation look like for this function?\n",
        "\n",
        "```\n",
        "def make_table(???):\n",
        "    pass\n",
        "```\n",
        "\n",
        "As an example:\n",
        "\n",
        "```\n",
        "make_table(\n",
        "    first_name=\"Sam\",\n",
        "    last_name=\"Redmond\",\n",
        "    shirt_color=\"pink\"\n",
        ")\n",
        "```\n",
        "\n",
        "should produce\n",
        "\n",
        "```\n",
        "=========================\n",
        "| first_name  |     Sam |\n",
        "| last_name   | Redmond |\n",
        "| shirt_color |    pink |\n",
        "=========================\n",
        "```\n",
        "\n",
        "and\n",
        "\n",
        "```\n",
        "make_table(\n",
        "    key_justify=\"right\",\n",
        "    value_justify=\"center\",\n",
        "    song=\"Style\",\n",
        "    artist_fullname=\"Taylor $wift\",\n",
        "    album=\"1989\"\n",
        ")\n",
        "```\n",
        "\n",
        "should produce\n",
        "\n",
        "```\n",
        "==================================\n",
        "|            song |     Style    |\n",
        "| artist_fullname | Taylor $wift |\n",
        "|           album |     1989     |\n",
        "==================================\n",
        "```\n",
        "\n",
        "Hint: you may find Python's string `.format()` [alignment specifiers](https://pyformat.info/#string_pad_align) useful."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "mMK_EExY6U4_"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "source": [
        "make_table(\\\n",
        "    key_justify=\"right\",\\\n",
        "    value_justify=\"center\",\\\n",
        "    song=\"Style\",\\\n",
        "    artist_fullname=\"Taylor $wift\",\\\n",
        "    album=\"1989\"\\\n",
        ")"
      ],
      "metadata": {
        "id": "0_kP5uOtiwSv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_B-7jPa36U5A"
      },
      "source": [
        "## Function Nuances\n",
        "### Return\n",
        "\n",
        "Predict the output of the following code snippet. Then, run the code to check your hypothesis.\n",
        "\n",
        "```\n",
        "def say_hello():\n",
        "    print(\"Hello!\")\n",
        "\n",
        "print(say_hello())  # => ?\n",
        "\n",
        "def echo(arg=None):\n",
        "    print(\"arg:\", arg)\n",
        "    return arg\n",
        "\n",
        "print(echo())  # => ?\n",
        "print(echo(5)) # => ?\n",
        "print(echo(\"Hello\")) # => ?\n",
        "\n",
        "def drive(has_car):\n",
        "    if not has_car:\n",
        "        # Please never actually signal an error like this\n",
        "        return \"Oh no!\"\n",
        "    return 100  # miles\n",
        "\n",
        "print(drive(False))  # => ?\n",
        "print(drive(True))   # => ?\n",
        "```\n",
        "\n",
        "If you made any incorrect predictions, talk to a partner about why!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "mSi4cAhr6U5A"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AHJ3VYeG6U5A"
      },
      "source": [
        "### Parameters and Object Reference\n",
        "\n",
        "*Optional Reading: [Jeff Knupp's Blog](https://jeffknupp.com/blog/2012/11/13/is-python-callbyvalue-or-callbyreference-neither/)*\n",
        "\n",
        "Suppose we have the following two functions:\n",
        "\n",
        "```\n",
        "def reassign(arr):\n",
        "    arr = [4, 1]\n",
        "    print(\"Inside reassign: arr = {}\".format(arr))\n",
        "\n",
        "def append_one(arr):\n",
        "    arr.append(1) \n",
        "    print(\"Inside append_one: arr = {}\".format(arr))\n",
        "```\n",
        "\n",
        "Predict what the following code snippet will output. What's the difference between the sections? What is the cause of this difference?\n",
        "\n",
        "```\n",
        "l = [4]\n",
        "print(\"Before reassign: arr={}\".format(l))  # => ?\n",
        "reassign(l)\n",
        "print(\"After reassign: arr={}\".format(l))  # => ?\n",
        "\n",
        "l = [4]\n",
        "print(\"Before append_one: arr={}\".format(l))  # => ?\n",
        "append_one(l)\n",
        "print(\"After append_one: arr={}\".format(l))  # => ?\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "sq3CblqX6U5A"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L8gNJz1O6U5B"
      },
      "source": [
        "### Scope\n",
        "*Optional Reading: [Python's Execution Model](https://docs.python.org/3.4/reference/executionmodel.html), especially Section 4.2.2.*\n",
        "\n",
        "Predict the output of the next two Python programs, then run them to confirm or refute your hypothesis.\n",
        "\n",
        "```\n",
        "# Case 1\n",
        "x = 10\n",
        "\n",
        "def foo():\n",
        "    print(\"(inside foo) x:\", x)\n",
        "    y = 5\n",
        "    print('value:', x * y)\n",
        "\n",
        "print(\"(outside foo) x:\", x)\n",
        "foo()\n",
        "print(\"(after foo) x:\", x)\n",
        "```\n",
        "\n",
        "and\n",
        "\n",
        "```\n",
        "# Case 2\n",
        "x = 10\n",
        "\n",
        "def foo():\n",
        "    x = 8  # Only added this line - everything else is the same\n",
        "    print(\"(inside foo) x:\", x)\n",
        "    y = 5\n",
        "    print('value:', x * y)\n",
        "\n",
        "print(\"(outside foo) x:\", x)\n",
        "foo()\n",
        "print(\"(after foo) x:\", x)\n",
        "```\n",
        "\n",
        "Draw a picture of the variable bindings at each scope (global scope and `foo` function-level scope) in each case. \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MSFth6LB6U5B"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mJQdbCoI6U5C"
      },
      "source": [
        "#### UnboundLocalError\n",
        "\n",
        "If we swap just two lines of code, something unusual happens. What is the error? Why might it be happening?\n",
        "\n",
        "```\n",
        "x = 10\n",
        "\n",
        "def foo():\n",
        "    print(\"(inside foo) x:\", x)  # We swapped this line\n",
        "    x = 8                        # with this one\n",
        "    y = 5\n",
        "    print('value:', x * y)\n",
        "\n",
        "print(\"(outside foo) x:\", x)\n",
        "foo()\n",
        "print(\"(after foo) x:\", x)\n",
        "```\n",
        "\n",
        "In a similar vein, `foo` as defined in\n",
        "\n",
        "```\n",
        "lst = [1,2,3]\n",
        "def foo():\n",
        "    lst.append(4)\n",
        "foo()\n",
        "```\n",
        "\n",
        "will compile (that is, the function object will be byte-compiled without problem), but\n",
        "\n",
        "```\n",
        "lst = [1,2,3]\n",
        "def foo():\n",
        "    lst = lst + [4]\n",
        "foo()\n",
        "```\n",
        "\n",
        "will raise an UnboundLocalError. Why? It doesn't, surprisingly, have to do with the fact that `.append` is in place and `+` is not.\n",
        "\n",
        "This is such a common problem that the Python FAQ has [a section](https://docs.python.org/3.4/faq/programming.html#why-am-i-getting-an-unboundlocalerror-when-the-variable-has-a-value) dedicated to this type of `UnboundLocalError`.\n",
        "\n",
        "*Note, the `global` and `nonlocal` keywords can be used to assign to a variable outside of the currently active (innermost function) scope. If you're interested, you can read more about scoping rules in the optional reading, or in the [appropriate FAQ section](https://docs.python.org/3.4/faq/programming.html#what-are-the-rules-for-local-and-global-variables-in-python).*"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PSlfW7116U5C"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T5gUmX496U5C"
      },
      "source": [
        "### Default Mutable Arguments - A Dangerous Game\n",
        "\n",
        "A function's default values are evaluated at the point of function definition in the defining scope. For example\n",
        "\n",
        "```\n",
        "x = 5\n",
        "\n",
        "def square(num=x):\n",
        "    return num * num\n",
        "\n",
        "x = 6\n",
        "square()   # => 25, not 36\n",
        "square(x)  # => 36\n",
        "```\n",
        "\n",
        "**Warning: A function's default values are evaluated *only once*, when the function definition is encountered. This is important when the default value is a mutable object such as a list or dictionary**\n",
        "\n",
        "Predict what the following code will do, then run it to test your hypothesis:\n",
        "\n",
        "```\n",
        "def append_twice(a, lst=[]):\n",
        "    lst.append(a)\n",
        "    lst.append(a)\n",
        "    return lst\n",
        "   \n",
        "# Works well when the keyword is provided\n",
        "print(append_twice(1, lst=[4]))  # => [4, 1, 1]\n",
        "print(append_twice(11, lst=[2, 3, 5, 7]))  # => [2, 3, 5, 7, 11, 11]\n",
        "\n",
        "# But what happens here?\n",
        "print(append_twice(1))\n",
        "print(append_twice(2))\n",
        "print(append_twice(3))\n",
        "```\n",
        "\n",
        "After you run the code, you should see the following printed to the screen:\n",
        "\n",
        "```\n",
        "[1, 1]\n",
        "[1, 1, 2, 2]\n",
        "[1, 1, 2, 2, 3, 3]\n",
        "```\n",
        "Discuss with a partner why this is happening.\n",
        "\n",
        "If you don’t want the default value to be shared between subsequent calls, you can use a sentinel value as the default value (to signal that no keyword argument was explicitly provided by the caller). If so, your function may look something like:\n",
        "\n",
        "```\n",
        "def append_twice(a, lst=None):\n",
        "    if lst is None:\n",
        "        lst = []\n",
        "    lst.append(a)\n",
        "    lst.append(a)\n",
        "    return lst\n",
        "```\n",
        "\n",
        "Sometimes, however, this odd keyword value initialization behavior can be desirable. For example, it can be used as a cache that is modifiable and accessible by all invocations of a function:\n",
        "\n",
        "```\n",
        "def fib(n, cache={0: 1, 1: 1}):\n",
        "   if n in cache:  # Note: default value captures our base cases\n",
        "       return cache[n]\n",
        "   out = fib(n-1) + fib(n-2)\n",
        "   cache[n] = out\n",
        "   return out\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gCl7lcy16U5E"
      },
      "source": [
        "# Advanced Topics\n",
        "## Investigating Function Objects\n",
        "\n",
        "At the end of Tuesday's class, we mentioned some of the attributes of function objects. We'll explore several of these attributes more in depth here.\n",
        "\n",
        "Usually, this information isn't particularly useful for practitioners (you'll rarely want to hack around with the internals of functions), but even seeing that you *can* in Python is very cool.\n",
        "\n",
        "#### Default Values (`__defaults__` and `__kwdefaults__`)\n",
        "\n",
        "As stated earlier, any default values (either normal default arguments or the keyword-only default arguments that follow a variadic positional argument parameter) are bound to the function object at the time of function definition. Consider our `all_together` function from earlier:\n",
        "\n",
        "```\n",
        "def all_together(x, y, z=1, *nums, indent=True, spaces=4, **options): pass\n",
        "\n",
        "all_together.__defaults__  # => (1, )\n",
        "all_together.__kwdefaults__  # => {'indent':True, 'spaces':4}\n",
        "```\n",
        "\n",
        "Why might the `__defaults__` attribute be a tuple, but the `__kwdefaults__` attribute be a dictionary?\n",
        "\n",
        "#### Documentation (`__doc__`)\n",
        "\n",
        "The first string literal in any function, if it comes before any expression, is bound to the function's `__doc__` attribute. \n",
        "\n",
        "```\n",
        "def my_function():\n",
        "    \"\"\"Summary line: do nothing, but document it.\n",
        "        \n",
        "    Description: No, really, it doesn't do anything.\n",
        "    \"\"\"\n",
        "    pass\n",
        "\n",
        "print(my_function.__doc__)\n",
        "# Summary line: Do nothing, but document it.\n",
        "#\n",
        "#     Description: No, really, it doesn't do anything.\n",
        "```\n",
        "\n",
        "As stated in lecture, lots of tools use these documentation strings to great advantage. For example, the builtin `help` function displays information from docstrings, and many API-documentation-generation tools like [Sphynx](http://www.sphinx-doc.org/en/stable/) or [Epydoc](http://epydoc.sourceforge.net/) use information contained in the docstring to form smart references and hyperlinks on documentation websites.\n",
        "\n",
        "Furthermore, the [doctest](https://docs.python.org/3.4/library/doctest.html) standard library module, in it's own words, \"searches [the documentation string] for pieces of text that look like interactive Python sessions, and then executes those sessions to verify that they work exactly as shown.\" Cool!\n",
        "\n",
        "#### Code Object (`__code__`)\n",
        "\n",
        "In CPython, the reference implementation of Python used by many people (including us), functions are compiled into a sort of bytecode when defined. This code object is bound to the `__code__` attribute, and has a ton of interesting properties, best illustrated by example.\n",
        "\n",
        "```\n",
        "def all_together(x, y, z=1, *nums, indent=True, spaces=4, **options):\n",
        "    \"\"\"A useless comment\"\"\"\n",
        "    print(x + y * z)\n",
        "    print(sum(nums))\n",
        "    for k, v in options.items():\n",
        "        if indent:\n",
        "            print(\"{}\\t{}\".format(k, v))\n",
        "        else:\n",
        "            print(\"{}{}{}\".format(k, \" \" * spaces, v))\n",
        "            \n",
        "code = all_together.__code__\n",
        "```\n",
        "\n",
        "| Attribute  | Sample Value | Explanation |\n",
        "| --- | --- | --- |\n",
        "| `.co_argcount` | `3` | number of positional arguments (including arguments with default values) |\n",
        "| `.co_cellvars` | `()` | tuple containing the names of local variables that are referenced by nested functions |\n",
        "| `.co_code` | `b't\\x00\\x00...\\x00\\x00S'` | string representing the sequence of bytecode instructions |\n",
        "| `.co_consts` | `('A useless comment', '{}\\t{}', '{}{}{}', ' ', None)` | tuple containing the literals used by the bytecode - our `None` is from the implicit `return None` at the end |\n",
        "| `.co_filename` | `<stdin>` | file in which the function was defined |\n",
        "| `.co_firstlineno` | `1` | line of the file the first line of the function appears |\n",
        "| `.co_flags` | `79` | AND of compiler-specific binary flags whose internal meaning is (largely) unspecified |\n",
        "| `.co_freevars` | `()` | tuple containing the names of free variables |\n",
        "| `.co_kwonlyargcount` | `2` | number of keyword-only arguments |\n",
        "| `.co_lnotab` | `b'\\x00\\x02\\x12\\x01\\x10\\x01\\x19\\x01\\x06\\x01\\x19\\x02'` | string encoding the mapping from bytecode offsets to line numbers |\n",
        "| `.co_name` | `\"all_together\"` | the function name  |\n",
        "| `.co_names` | `('print', 'sum', 'items', 'format')` | tuple containing the names used by the bytecode |\n",
        "| `co_nlocals` | `9` | number of local variables used by the function (including arguments) |\n",
        "| `co_stacksize` | `6` | required stack size (including local variables) |\n",
        "| `co_varnames` | `('x', 'y', 'z', 'indent', 'spaces', 'nums', 'options', 'k', 'v')` | tuple containing the names of the local variables (starting with the argument names) |\n",
        "\n",
        "More info on this, and on all types in Python, can be found at the [data model reference](https://docs.python.org/3.4/reference/datamodel.html#the-standard-type-hierarchy). For code objects, you have to scroll down to \"Internal Types.\"\n",
        "\n",
        "##### Security\n",
        "\n",
        "As we briefly mentioned in class, this can lead to a pretty glaring security vulnerability. Namely, the code object on a given function can be hot-swapped for the code object of another (perhaps malicious function) at runtime!\n",
        "\n",
        "```\n",
        "def nice(): print(\"You're awesome!\")\n",
        "def mean(): print(\"You're... not awesome. OOOOH\")\n",
        "\n",
        "# Overwrite the code object for nice\n",
        "nice.__code__ = mean.__code__\n",
        "nice()  # prints \"You're... not awesome. OOOOH\"\n",
        "```\n",
        " \n",
        "##### `dis` module\n",
        "\n",
        "The `dis` module, for \"disassemble,\" exports a `dis` function that allows us to disassemble Python byte code (at least, for Python distributions implemented in CPython for existing versions). The disassembled code isn't exactly normal assembly code, but rather is a specialized Python syntax\n",
        "\n",
        "```\n",
        "def gcd(a, b):\n",
        "    while b:\n",
        "        a, b = b, a % b\n",
        "    return a\n",
        "    \n",
        "import dis\n",
        "dis.dis(gcd)\n",
        "\"\"\"\n",
        "  2           0 SETUP_LOOP              27 (to 30)\n",
        "        >>    3 LOAD_FAST                1 (b)\n",
        "              6 POP_JUMP_IF_FALSE       29\n",
        "\n",
        "  3           9 LOAD_FAST                1 (b)\n",
        "             12 LOAD_FAST                0 (a)\n",
        "             15 LOAD_FAST                1 (b)\n",
        "             18 BINARY_MODULO\n",
        "             19 ROT_TWO\n",
        "             20 STORE_FAST               0 (a)\n",
        "             23 STORE_FAST               1 (b)\n",
        "             26 JUMP_ABSOLUTE            3\n",
        "        >>   29 POP_BLOCK\n",
        "\n",
        "  4     >>   30 LOAD_FAST                0 (a)\n",
        "             33 RETURN_VALUE\n",
        "\"\"\"\n",
        "```\n",
        "\n",
        "Details on the instructions themselves can be found [here](https://docs.python.org/3.4/library/dis.html#python-bytecode-instructions).\n",
        "You can read more about the `dis` module [here](https://docs.python.org/3.4/library/dis.html).\n",
        "\n",
        "#### Parameter Annotations (`__annotations__`)\n",
        "\n",
        "As mentioned in class, Python allows us to offer type annotations on functions\n",
        "\n",
        "```\n",
        "def annotated(a: int, b: str) -> list:\n",
        "    return [a, b]\n",
        "\n",
        "print(annotated.__annotations__)\n",
        "# {'b': <class 'str'>, 'a': <class 'int'>, 'return': <class 'list'>}\n",
        "```\n",
        "\n",
        "This information can be used to build some really neat dynamic type-checkers for Python!\n",
        "\n",
        "For more info, check out [PEP 3107](https://www.python.org/dev/peps/pep-3107/) on function annotations or [Pep 484](https://www.python.org/dev/peps/pep-0484/) on type hinting (which was introduced in Python 3.5)\n",
        "\n",
        "#### Call (`__call__`)\n",
        "\n",
        "All Python functions have a `__call__` attribute, which is the actual object called when you use parentheses to \"call\" a function. That is,\n",
        "\n",
        "```\n",
        "def greet(): print(\"Hello world!\")\n",
        "\n",
        "greet() # \"Hello world!\"\n",
        "# is just syntactic sugar for\n",
        "greet.__call__()  # \"Hello world!\"\n",
        "```\n",
        "\n",
        "This means that any object (including instances of custom classes) with a `__call__` method can use the parenthesized function call syntax! We'll see a lot more about using these so-called \"magic methods\" to exploit Python's apparent operators (like function calling, `+` (`__add__`) or `*` (`__mul__`), etc) in Week 5.\n",
        "\n",
        "#### Name Information (`__module__`, `__name__`, and `__qualname__`)\n",
        "\n",
        "Python functions also store some name information about a function, generally for the purposes of friendly printing.\n",
        "\n",
        "`__module__` refers to the module that was active at the time the function was defined. Any functions defined in the interactive interpreter will have `__module__ == '__main__'`, but, for example, `encrypt_caesar.__module__ == 'crypto'`.\n",
        "\n",
        "`__name__` is the function's name. Nothing special here.\n",
        "\n",
        "`__qualname__`, which stands for \"qualified name,\" only differs from `__name__` when you're dealing with nested functions, which we'll talk about more Week 4.\n",
        "\n",
        "#### Closure (`__closure__`)\n",
        "\n",
        "If you're familiar with closures in other languages, Python closures work almost the exact same way. Closures really only arise when dealing with nested functions, so we'll see more Week 4. This bit of text is just to give you a teaser for what's coming soon - yes, Python has closures! \n",
        "\n",
        "#### `inspect` module\n",
        "\n",
        "As a brief note, all of this mucking around with the internals of Python functions can't be good for our health. Luckily, there's a standard library module for this! The `inspect` module gives us a lot of nice tools for interacting not only with the internals of functions, but also the internals of a lot of other types as well. Check out [the documentation](https://docs.python.org/3.4/library/inspect.html) for some nice examples.\n",
        "\n",
        "## Finished Early?\n",
        "Scan through [PEP 257](https://www.python.org/dev/peps/pep-0257/), Python's suggestions for docstring conventions, as well as [PEP 8](https://www.python.org/dev/peps/pep-0008/), Python's style guide, if you didn't get a chance to read it last week.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tbemnAuq6U5G"
      },
      "source": []
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "base",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "version": "3.9.13"
    },
    "orig_nbformat": 4,
    "vscode": {
      "interpreter": {
        "hash": "dd2f083c7091592f6e910b42e81e3d9326587f6134c1427a9ed8e8691fd16a23"
      }
    },
    "colab": {
      "provenance": [],
      "include_colab_link": true
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}