intro-to-python/04_functions.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "04_functions.ipynb",
      "provenance": [],
      "private_outputs": true,
      "collapsed_sections": [],
      "toc_visible": true,
      "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/Ada-Developers-Academy/ada-build/blob/master/intro-to-python/04_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": "b84ZdHh4KUeQ",
        "colab_type": "text"
      },
      "source": [
        "**Functions**\n",
        "\n",
        "_Ada Build - Intro to Python - Lesson 4_"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DBFWUizNKYPG",
        "colab_type": "text"
      },
      "source": [
        "# Learning Goals\n",
        "\n",
        "By the end of this lesson we will be able to:\n",
        "\n",
        "- Use common built-in functions in Python.\n",
        "- Understand and use functions contained in modules.\n",
        "- Understand the utility of writing functions.\n",
        "- Write and use custom functions.\n",
        "- Understand and define the following terms:\n",
        "    - docstring\n",
        "    - signature\n",
        "    - arguments\n",
        "    - parameters\n",
        "    - return\n",
        "- Understand the results of an `AssertionError`.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "miEgNt6QKhho",
        "colab_type": "text"
      },
      "source": [
        "# Notes"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5QLiznSITE8y",
        "colab_type": "text"
      },
      "source": [
        "## Copy to Drive\n",
        "\n",
        "Before you get started, remember to copy this Colab notebook to your Google Drive so that you can save your work."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NrvKp-tkLvqO",
        "colab_type": "text"
      },
      "source": [
        "## [Built-in Functions](https://docs.python.org/3/library/functions.html)\n",
        "\n",
        "We have already learned about some of the functions built into Python. Functions are input/output machines. Fundamentally, they take an argument as input, and return a value as ouput. \n",
        "\n",
        "We will see that there are some exceptions to this simple input/output relationship soon, but for now, let's review some of the functions we have already seen and learn about a few new ones."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a0qBMtz9MUtK",
        "colab_type": "text"
      },
      "source": [
        "### Exercise: Review\n",
        "\n",
        "Below are the two Python functions that we have already seen. Uncomment and recomment each expression in the code block below to observe their output.\n",
        "\n",
        "- `type` takes an argument which is an *object* of any data type as input, and returns the data type as output.\n",
        "\n",
        "- `bool` takes data as _input_, and returns the boolean `True` or `False` as _output_.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZOoRpzayOBzP",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# bool(1)\n",
        "# bool(None)\n",
        "\n",
        "# type(1)\n",
        "# type(None)\n",
        "# type(True)\n",
        "# type(\"hello world\")\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XqXFY0tEN7_V",
        "colab_type": "text"
      },
      "source": [
        "### New Functions\n",
        "\n",
        "Let's take a look at some commonly used Python functions. \n",
        "\n",
        "* `str` converts data to the string class.\n",
        "* `int` converts data to the int class.\n",
        "* `float` converts data to the float class\n",
        "* `abs` returns the absolute value of the value\n",
        "* `round` returns the value rounded to the nearest integer\n",
        "* `input` accepts user input\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OnDhWW8-p-z9",
        "colab_type": "text"
      },
      "source": [
        "### Exercise\n",
        "\n",
        "- Review the code below. Make a prediction about the ouput for each line.\n",
        "\n",
        "- Uncomment and recomment each expression in the code cells below to observe their output.\n",
        "\n",
        "- Make a note of any questions you have by using the comment feature."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F7Di6L9hNgy8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# str(None)\n",
        "# str(1)\n",
        "# str(10.5)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gsTyrynLpbWY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# int(\"5\")\n",
        "# int(\"6.5\")\n",
        "# int(\"hello world!\")\n",
        "# int(True)\n",
        "# int(False)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MoNkWBpCpoII",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# float(\"6.5\")\n",
        "# float(\"1\")\n",
        "# float(\"hello world!\")\n",
        "# float(True)\n",
        "# float(False)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yG-85DZVrUfg",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#abs(6)\n",
        "#abs(-6)\n",
        "#abs(\"6\")\n",
        "#abs(True)\n",
        "#abs(False)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LKZo1fAQrgZZ",
        "colab_type": "text"
      },
      "source": [
        "You may have noticed that `True` evaluates to `1` and `False` evaluates to `0`. This can be handy!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B0iLsXhZrynv",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# round(2)\n",
        "# round(2.4)\n",
        "# round(2.6)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "35YypDu7r7Lg",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(\"What do you choose? A, B, C, or D \\n\")\n",
        "user_input = input()\n",
        "print(f'\\nYou chose {user_input}. Great choice!')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ACTMexT1V8Q8",
        "colab_type": "text"
      },
      "source": [
        "## [Modules](https://docs.python.org/3/tutorial/modules.html)\n",
        "\n",
        "Python provides some built-in modules that contain additional functions. \n",
        "\n",
        "Common Python modules include the [`math` module](https://docs.python.org/3/library/math.html?highlight=math#module-math) and the [`random` module](https://docs.python.org/3/library/random.html). _Modules_ are commonly called _libraries_.\n",
        "\n",
        "To access the functions in a modules, you must first import the module. The syntax is as follows:\n",
        "\n",
        "```python\n",
        "# import module\n",
        "import module_name\n",
        "\n",
        "# use functions provided by module\n",
        "module_name.function_name\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "01wnkZRWY789",
        "colab_type": "text"
      },
      "source": [
        "### Exercise\n",
        "\n",
        "Read and run the code cells below to understand the syntax for importing and using modules.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "okV12NfJZg3A",
        "colab_type": "text"
      },
      "source": [
        "#### `math.sqrt`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9J8lUM3tYxqa",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# import the math module\n",
        "import math\n",
        "\n",
        "# use the sqrt function that is part of the math module\n",
        "# sqrt is a function that returns the positive square root of the given value\n",
        "math.sqrt(16)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "80VRazfpZjO8",
        "colab_type": "text"
      },
      "source": [
        "#### `random`\n",
        "\n",
        "Run the following code cells multiple times to observe the random behavior.\n",
        "\n",
        "_Note that the first code cell results in a `NameError` because we did not first import the `random` module._\n",
        "\n",
        "Uncomment the second line `import random` and run the code again."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5uOQfb88Zo5I",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# import the random module\n",
        "# import random\n",
        "\n",
        "# use the randint function that is part of the random module\n",
        "# randint is a function that returns a random value between the first and second arguments \n",
        "# random.randint(a,b) - Returns a random integer N such that a <= N <= b\n",
        "random.randint(1,10)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gY_Xt7dwc3oX",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# returns a random floating point number in the range [0.0, 1.0).\n",
        "random.random()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MzqXCpBGVfCZ",
        "colab_type": "text"
      },
      "source": [
        "#### Range Notation\n",
        "\n",
        "The comment above refers to the range [0.0, 1.0). This is mathematical notation (not Python) for a range starting at 0.0 continuing up to, but excluding 1.0. It is inclusive on the lower bound, but exclusive on the upper. That is, 0.0 is included in the range, but 1.0 is not. We can get arbitrarily close to 1.0, even .999999, but 1.0 itself is excluded. We may encounter this notation in other places, so let's just review:\n",
        "- Brackets [a, b] &mdash; indicate inclusion of a bound in a range\n",
        "- Parentheses (a, b) &mdash; indicate exclusion of a bound from a range\n",
        "\n",
        "So [a, b) includes a, but excludes b; (a, b] excludes a, but includes b; [a, b] includes both a and b; while (a, b) excludes both a and b. Again, this is mathematical notation, not valid Python, so while it will not appear in code, we may encounter it in comments or documentation."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3oRUHTw_WBCd",
        "colab_type": "text"
      },
      "source": [
        "## [Defining Functions](https://docs.python.org/3/tutorial/controlflow.html#defining-functions)\n",
        "\n",
        "### Why?\n",
        "\n",
        "Functions allow us to assign a _name_ and _structure_ to sections of code. We create functions when we identify sections of code that we may want to reuse, test, and execute independently from other sections of code.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c2I8Pyf7x6PG",
        "colab_type": "text"
      },
      "source": [
        "### Defining Functions: Signatures and Blocks\n",
        "To create a function, you must first understand its function signature. A function signature comprises 2 parts: the _name_ of the function, and the _parameters_ it is expecting. Once you have defined those two things, you can create a `def` (function definition) block.\n",
        "\n",
        "Read and run the code cell below.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b4EKDaMRyYKd",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Example 1\n",
        "def say_hello(): # <= that's the function signature, note the colon :\n",
        "    print(\"hello world!\") # that's the block\n",
        "\n",
        "say_hello() # that's the call to the method"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8bKY7p_VzQLw",
        "colab_type": "text"
      },
      "source": [
        "In Example 1, `say_hello` is the function **name**. This function has no **parameters** (more on that shortly), so the function signature is just `say_hello`. The purpose of this function is to print out a string to the user. To call (or invoke) the function, we use the syntax `say_hello()`. The parentheses `()` are required in Python to call a function.\n",
        "\n",
        "Run the code cell below to see the output when you leave off the `()`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jJBL3upYzxv8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "say_hello"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FWBfjU29WUJX",
        "colab_type": "text"
      },
      "source": [
        "Notice that Python can determine that `say_hello` **refers** to a function, but it does not assume that we want to invoke it. Function **references** can be useful in many situations, though we won't use them just yet. It is currently enough to know that a function name without the () **refers** to the function, and that we must apply () to the **reference** to actually invoke it."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8HUwpAXqz5bD",
        "colab_type": "text"
      },
      "source": [
        "### Function Arguments (and parameters)\n",
        "\n",
        "Okay, let's get this out of the way. Most folx use argument and parameter interchangeably. That's fine and it almost never matters. But for completeness, here's the difference:\n",
        "\n",
        "In most programming languages, including Python, parameters are variables used to refer to pieces of data provided as input to a function, while arguments are those pieces of data passed to the function when it gets called. The parameters are defined in the function signature, and the arguments are the specific values given to the function when it's invoked.\n",
        "\n",
        "Once we have created a function, we may want to add a parameter to provide additional data or context to our function. Think back to our `Math.sqrt(16)` example. The `16` in the `()` is an argument — it's the input to the function.\n",
        "\n",
        "To add a parameter to the `say_hello` function, we need to change the function signature:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q5svLbNE0vZZ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Example 2\n",
        "def say_hello(name): # function signature with a name and one parameter\n",
        "    print(f\"welcome {name}! hello world!\") # <= the block\n",
        "\n",
        "say_hello(\"Ada\") # invoking the function with one argument\n",
        "# => welcome Ada! hello world!"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pgu7f4Tp0767",
        "colab_type": "text"
      },
      "source": [
        "In this updated function, `name` is a parameter. It's a variable that gets the value of the passed in argument. When we called the function, the `name` variable got the string value `\"Ada\"` since that was the argument we passed in."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3maexWkp1Jee",
        "colab_type": "text"
      },
      "source": [
        "### `return`\n",
        "\n",
        "So far we have seen functions with and without parameters. The functions in Example 1 and 2 both print something to the screen as their output.\n",
        "\n",
        "Now we will look at functions that `return` a value."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ur5d7JA81jrk",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Example 3\n",
        "\n",
        "def add(num_one, num_two): # function signature\n",
        "    \"\"\"\n",
        "    input: two numbers\n",
        "    output: the sum of the arguments\n",
        "    \"\"\"\n",
        "    return num_one + num_two # function block with return value\n",
        "\n",
        "the_sum = add(1, 2) # function called with arguments and return value assigned to the_sum\n",
        "\n",
        "print(f\"1 + 2 = {the_sum}\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Sbjr4h-Fj1B5",
        "colab_type": "text"
      },
      "source": [
        "In Example 3, the parameters (or inputs) for the function `add` are `num_one` and `num_two`. The return value (or output) is the sum of `num_one` and `num_two`.\n",
        "\n",
        "When the function is called (or invoked), the return value is assigned to the variable `the_sum`.\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wj3NR5Mv3JVH",
        "colab_type": "text"
      },
      "source": [
        "#### Scope\n",
        "\n",
        "Note: The code cell below will produce an error because `num_one` and `num_two` are not variables that are assigned values. They are _parameters_. They only have meaning inside the function block. They are scoped to the function. We will talk much more about scope in the Ada Core Curriculum.\n",
        "\n",
        "This code _would_ work if we put it inside of `add` though."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iV1koy2Z3Dkq",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(f\"The sum of {num_one} and {num_two} is {the_sum}\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uiuuyGKf88bO",
        "colab_type": "text"
      },
      "source": [
        "### docstrings\n",
        "\n",
        "Let's review the `add` function we made in Example 3. We introduced some new syntax in the function, but we didn't discuss it then. Did you notice it? Let's take a look now:\n",
        "\n",
        "```python\n",
        "\"\"\"\n",
        "input: two numbers\n",
        "output: the sum of the arguments\n",
        "\"\"\"\n",
        "```\n",
        "\n",
        "These lines of code right below the function definition are the docstring. The docstring provides information about what a function does &mdash; in particular its inputs and output. You access the docstring by using the `__doc__` method. This is often useful when we are trying to figure out how to use an unfamiliar function.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kAuimaZuforX",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Example 3 - Accessing docstring\n",
        "\n",
        "def add(num_one, num_two): # <= function signature\n",
        "    \"\"\"\n",
        "    input: two numbers\n",
        "    output: the sum of the arguments\n",
        "    \"\"\"\n",
        "    return num_one + num_two # <= function block with return value\n",
        "\n",
        "\n",
        "print(add.__doc__)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "loLWvxOq46K4",
        "colab_type": "text"
      },
      "source": [
        "### None\n",
        "\n",
        "Note that a function does not need to `return` a value. If a function does not return a value as in the case of `say_hello` from Example 1 and 2, the return value will be set to `None`.\n",
        "\n",
        "Run the code cell below to see that `say_hello` outputs the string defined by the `print` expression in the function, and returns `None`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aTCU0G-e5Jni",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def say_hello(name):\n",
        "    print(f\"welcome {name}! hello world!\")\n",
        "\n",
        "no_return_value = say_hello(\"becca\")\n",
        "print(no_return_value)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-B9rkj7n3Xq8",
        "colab_type": "text"
      },
      "source": [
        "## Function Vocabulary\n",
        "\n",
        "Take a look at the following code. We will refer back to various parts of it in the vocabulary list below.\n",
        "```python\n",
        "def sum(a, b, c):\n",
        "\"\"\"\n",
        "input: 3 integers or floats: a, b, c\n",
        "output: the sum of the arguments\n",
        "\"\"\"\n",
        "result = a + b + c\n",
        "return result\n",
        "\n",
        "number = sum(5, 17, 106)\n",
        "print(number)\n",
        "```\n",
        "\n",
        "Term|Description|Example\n",
        "---|---|---\n",
        "Function| A section of code with a name. Organizes code so it's easier to read,<br>and lets us do the same thing many times. | `def` through `end`\n",
        "Function Signature | The name and parameters of a function.<br>Answers the question \"how do I invoke this?\" | `sum(a, b, c)`\n",
        "Parameter | A variable used to receive input for a function.<br>Specified in the function signature. | `a`, `b`, `c`\n",
        "Return | Immediately exit a function. Can optionally send a result back to where ever it was called.<br>Uses Python's `return` keyword. If no result is supplied, the returned value will be `None`. | `return` or `return result`\n",
        "Invoke | Run a function. Also known as calling a function. The value returned by the function<br>can be used immediately, stored in a variable, or ignored. | `number = sum(5, 17, 106)`\n",
        "Argument | The value to be used for a particular parameter. Specified when the function is invoked.<br>May be a literal value or a variable. | `5`, `17`, `106`\n",
        "docstring | A string literal that appears right after the definition of a function.<br>Describes the input and the output. | `\"\"\"`<br>`input: 3 integers or floats: a, b, c`<br>`output: the sum of the arguments`<br>`\"\"\"`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "luJxL36qWCik",
        "colab_type": "text"
      },
      "source": [
        "# Practice Problems\n",
        "\n",
        "For each of the following problems that requires you to write a function, be sure to include a docstring that describes what your function does and what its inputs are. Refer to the `triple` example for a reasonable starting point and guide.\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i70ov9dAjUUy",
        "colab_type": "text"
      },
      "source": [
        "## Example Problem: `triple`\n",
        "Write the function ```triple(x)```, which takes in a numeric input and outputs three times that input.\n",
        "\n",
        "A complete _incorrect_ solution for this practice problem is provided below. \n",
        "\n",
        "Try to spot the logical error and fix it so that the tests pass.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pBDi7oqgfTdo",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# triple - complete solution.\n",
        "def triple(n): # Fix this function.\n",
        "    \"\"\"\n",
        "    input: integer or float n\n",
        "    output: three times the input\n",
        "    \"\"\"\n",
        "    return 5 * n\n",
        "\n",
        "# Tests below, do not change\n",
        "assert triple(3) == 9, f\"Reported {triple(3)} for triple(3) instead of 9\"\n",
        "assert triple(-3) == -9, f\"Reported {triple(-3)} for triple(-3) instead of -9\"\n",
        "assert triple(1.5) == 4.5, f\"Reported {triple(1.5)} for triple(1.5) instead of 4.5\"\n",
        "\n",
        "# If the program gets here, the code works!\n",
        "print(\"Your solution works!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FGvSqRgtlha7",
        "colab_type": "text"
      },
      "source": [
        "When you are ready you can view our solution on [repl.it](https://repl.it/@CheezItMan/triple)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S_tTn3fjjItk",
        "colab_type": "text"
      },
      "source": [
        "## `square`\n",
        "\n",
        "Write `square(x)`, which takes in a number named `x` as input. Then, `square` should output the square of its input."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4u6qrmsRfSCi",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# square\n",
        "def square(n):\n",
        "    \"\"\"\n",
        "    input: an integer or float value n\n",
        "    output: the square of n (n*n)\n",
        "    \"\"\"\n",
        "    \n",
        "    return # your code goes here\n",
        "\n",
        "# Tests below, do not change\n",
        "assert square(3) == 9, f\"Reported {square(3)} for square(3) instead of 9\"\n",
        "assert square(-3) == 9, f\"Reported {square(-3)} for square(-3) instead of 9\"\n",
        "\n",
        "# If the program gets here, the code works!\n",
        "print(\"Your solution works!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UV_ZHvLulyXJ",
        "colab_type": "text"
      },
      "source": [
        "When you are ready you can view our solution on [repl.it](https://repl.it/@CheezItMan/square#main.py)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Oq1YrFFbg_n-",
        "colab_type": "text"
      },
      "source": [
        "## `checkends`\n",
        "\n",
        "\n",
        "Write a function `checkends(s)`, which takes in a string `s` and returns `True` if the first character in `s` is the same as the last character in `s`. It returns `False` otherwise. The `checkends` function does not have to work on the empty string.\n",
        "\n",
        "There's a hint below, but read through the examples first.\n",
        "\n",
        "These examples help explain `checkends` — read them over now and be sure to try them once you have a first draft of your function. Notice that the final, fourth example below is the string of one space character, which is different from the empty string, which contains no characters `\"\"`.\n",
        "\n",
        "```python\n",
        "checkends('no match') # => False\n",
        "checkends('hah! a match') # => True\n",
        "checkends('q') # => True\n",
        "checkends(' ') # => True\n",
        "```\n",
        "\n",
        "Make sure to check that this last example (the string of a single space) works for your `checkends` function. Again, the empty string does not need to work.\n",
        "\n",
        "\n",
        "*Hint:* For this function you could use an `if...else` conditional.\n",
        "\n",
        "Here is a start:\n",
        "\n",
        "```python\n",
        "if s[0] == ______ :\n",
        "    return True\n",
        "else:\n",
        "    return False\n",
        "```\n",
        "\n",
        "You might find a solution that doesn't use `if...else` at all — that's fine, too. Notice that there's a missing expression above — you'll need to fill that in!\n",
        "\n",
        "Warning! Your function should not return strings! Rather, it should return a boolean value, either `True` or `False`, without any quotes around them. Recall from our discussions of branching that `True` and `False` are keywords recognized by Python as representing one bit of information, that is, a boolean value.\n",
        "\n",
        "You'll see these keywords turn a different color (pink in Colab), indicating that Python recognizes them as `bool` values. If you'd accidentally made them strings, they'd be quoted, and they'd be red. In short, booleans and strings are different, and for `True` and `False` you will almost always want the unquoted boolean keyword values."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AfP3d2EYfUro",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# checkends\n",
        "def checkends(s):\n",
        "    \"\"\"\n",
        "    input: a string s\n",
        "    output: False if the first and last character of the string are different,\n",
        "        True otherwise.\n",
        "    \"\"\"\n",
        "    # your code goes here\n",
        "\n",
        "# Tests below, do not change\n",
        "assert checkends('no match') == False, f\"Reported {checkends('no match')} for checkends('no match') instead of False\"\n",
        "assert checkends('hah! a match') == True, f\"Reported {checkends('hah! a match')} for checkends('hah! a match') instead of True\"\n",
        "assert checkends('q') == True, f\"Reported {checkends('q')} for checkends('q') instead of True\"\n",
        "assert checkends(' ') == True, f\"Reported {checkends(' ')} for checkends(' ') instead of True\"\n",
        "assert checkends('!ada!') == True, f\"Reported {checkends('!ada!')} for checkends('!ada!') instead of True\"\n",
        "\n",
        "# If the program gets here, the code works!\n",
        "print(\"Your solution works!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7QhKI2UFmdc-",
        "colab_type": "text"
      },
      "source": [
        "When you are ready you can see our solution on [repl.it](https://repl.it/@CheezItMan/checkends#main.py)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Kup4xyy9iuLN",
        "colab_type": "text"
      },
      "source": [
        " ## `flipside`\n",
        "\n",
        "Write a function `flipside(s)`, which takes in a string `s` and returns a string whose first half is `s`'s second half and whose second half is `s`'s first half. If `len(s)` (the length of `s`) is odd, the first half of the input string should have one fewer character than the second half. Accordingly, the second half of the output string will be one shorter than the first half in these cases. There's a hint after the examples below.\n",
        "\n",
        "You may want to use the built-in function `len(s)`, which returns the length of the input string, `s`.\n",
        "\n",
        "Examples:\n",
        "```python\n",
        "flipside('homework') # => workhome\n",
        "flipside('carpets') # => petscar\n",
        "```\n",
        "*Hint:* This function is simpler if you create a variable equal to `len(s) / 2` on the first line, e.g.,\n",
        "\n",
        "```python\n",
        "def flipside( s ):\n",
        "    \"\"\" put your docstring here\n",
        "    \"\"\"\n",
        "    x = len(s)/2\n",
        "    return   _____________\n",
        "```\n",
        "where the `return` statement has been left up to you... it will use the variable `x` (or whatever you choose to call it) twice, which is why it's nice to give it a name, rather than type and retype it! Plus, it reduces the number of chances we have to type it incorrectly!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kYSVqerhfVmt",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# flipside\n",
        "def flipside(s):\n",
        "\n",
        "    # your code goes here\n",
        "\n",
        "\n",
        "# Tests below, do not change\n",
        "assert flipside('carpets') == 'petscar', f\"Reported {flipside('carpets')} for flipside('carpets') instead of petscar\"\n",
        "assert flipside('homework') == 'workhome', f\"Reported {flipside('homework')} for flipside('homework') instead of workhome\"\n",
        "assert flipside('ada') == 'daa', f\"Reported {flipside('daa')} for flipside('ada') instead of daa\"\n",
        "\n",
        "# If the program gets here, the code works!\n",
        "print(\"Your solution works!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VllbeZmXrV_M",
        "colab_type": "text"
      },
      "source": [
        "When you are ready you can review our solution on [Repl.it](https://repl.it/@CheezItMan/flipside#main.py)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IDXVZ0WvWGQO",
        "colab_type": "text"
      },
      "source": [
        "# Project: Rock, Paper, Scissors - v2\n",
        "\n",
        "Copy and paste your code for Rock, Paper, Scissors from the previous lesson on [branching](https://colab.research.google.com/drive/1huE7PyavZSJIou4mh5G2e7yfG08Vb7da?usp=sharing). If you didn't quite get the solution, that's ok! You can use our [working example](https://repl.it/join/bzzpenqo-beccaelenzil).\n",
        "\n",
        "The solution to Version 1 of Rock, Paper, Scissors used hard coded data for `player1` and `player2`.\n",
        "\n",
        "For version 2, you will move your game logic into a function.\n",
        "\n",
        "- The function's signature for rps should be `rps(player1, player2)`. \n",
        "- The function does not need to return anything. It should simply print the winner as your code from version 1 does.\n",
        "- Here are some example function calls and output.\n",
        "\n",
        "```python\n",
        "rps('rock','scissors') # => \"Player 1 won!\"\n",
        "rps('paper','paper') # => \"It's a tie!\"\n",
        "```\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5xDOxNDmlNZV",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# complete Rock, Paper, Scissors, v2 in this code cell."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f9T-RrXeWJsG",
        "colab_type": "text"
      },
      "source": [
        "[A solution is linked here](https://repl.it/join/fhypixpk-beccaelenzil)."
      ]
    }
  ]
}