01_brief_intro_python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "25babeac",
   "metadata": {
    "id": "25babeac",
    "tags": []
   },
   "source": [
    "<img src='images/Practicum_AI_Logo.white_outline.svg' width=250 alt='Practicum AI logo'> <img src='https://github.com/PracticumAI/practicumai.github.io/blob/main/images/icons/practicumai_python.png?raw=true' align='right' width=50>\n",
    "\n",
    "***\n",
    "\n",
    "# Python for AI\n",
    "\n",
    "In this module, you will learn the basics of the Python programming language. While Python is a complete language with lots of functionality, the reality is that you need relatively little code to **do** AI. You should be set to get started with the basics covered in these modules. We will add additional Python sections to introduce more information later, but this should get you well on your way!\n",
    "\n",
    "### After this module, students will be able to:\n",
    "* Define what a variable is, and use the basic Python operators.\n",
    "* Recognize the importance of a consistent coding style, and describe best practices for variable naming.\n",
    "* Analyze Python error messages related to creating variables, and identify corrective action to fix them.\n",
    "* Describe the various Python data types, and convert a variable to another data type.\n",
    "* Use import statements to access library functions.\n",
    "* Write single-purpose functions."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5418d338",
   "metadata": {},
   "source": [
    "### Before we start, here are a few important tips:\n",
    "1. This file is a **Jupyter Notebook**. It combines `text cells` and `code cells` and is helpful as a hybrid didactic/experiential learning environment. In practice, Jupyter notebooks are often used for rapid code prototyping or communicating code and results understandably.\n",
    "\n",
    "2. Jupyter notebooks are *interactive*, and any code inside a code block is **executable**! Users will see the results of running code blocks directly inside the notebook.\n",
    "\n",
    "3. There are two ways to execute a code cell:\n",
    "    1. Select (click) the cell, and click the ▶️ button at the top of the notebook to execute the code.\n",
    "    2. Select the cell, and press `Control + Enter` (on Mac, `Command + Enter`)\n",
    "    \n",
    "4. To add a new cell, either click the `+` in the top toolbar or click the insert before or after buttons in the cell's toolbar.\n",
    "\n",
    "5.  Use the dropdown to select if the cell is a Code, Markdown, or Raw cell.\n",
    "\n",
    "6. To delete an entire cell, select the cell and either click the scissors icon in the top toolbar or click the 🗑️ button in the cell's toolbar. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1134ab8f",
   "metadata": {
    "id": "1134ab8f"
   },
   "source": [
    "## <img src='images/get_started_icon.svg' alt=\"Let's get started header\" width=40 align=center> Let's Get Started!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36ab2293",
   "metadata": {
    "id": "36ab2293"
   },
   "source": [
    "## Variables "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41045501",
   "metadata": {
    "id": "41045501"
   },
   "source": [
    "* Variables are names for values.  Or, more precisely, they are named memory locations.\n",
    "* In Python, the `=` symbol assigns the value on the right to the name on the left.\n",
    "* The variable is created when a value is assigned to it.\n",
    "In the cell below, Python assigns an integer (whole number) to the variable `age` and a string (text) to the variable `day_of_week`.\n",
    "\n",
    "Let's run the below code to create two new variables and assign them the given values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1baffa9d",
   "metadata": {
    "id": "1baffa9d"
   },
   "outputs": [],
   "source": [
    "age = 42\n",
    "day_of_week = 'Wednesday'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dab0eaf0",
   "metadata": {
    "id": "dab0eaf0"
   },
   "source": [
    "We will return to naming variables later in this notebook, but for now, remember that variable names:\n",
    "\n",
    "* Can contain **only** letters, digits and underscores (\"`_`\").\n",
    "* Cannot start with a digit.\n",
    "* Should be meaningful, describing the data that they hold.\n",
    "* Cannot be a Python reserved word."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f52fa13",
   "metadata": {},
   "source": [
    "### <img src='images/exercise_icon.svg' alt=\"Exercise icon\" width=40 align=center> Exercise 1\n",
    "> Create a new variable called `first_name` and assign it the value of your first name. ***Hint:*** Since   this variable will contain letters, it is a string variable. String values must be enclosed by quotation marks (either single or double quotes work). Example: `\"This is some text\"`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c6d4f31b-dd54-43b9-8fba-e5e1f4f8f0a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf40adb4",
   "metadata": {
    "id": "cf40adb4"
   },
   "source": [
    "## Use `print` to display text and variable values\n",
    "* Python has a built-in **function** called `print` that prints (i.e., displays) information to the screen. (Don't worry, we'll discuss functions a bit later.)\n",
    "* Call the function (i.e., tell Python to run it) by using its name, followed by ***input arguments*** (values) to the function (i.e., the things to print) in **parentheses**.\n",
    "* `print` can be used to see what value is contained in a particular variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "15d7d43e",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "15d7d43e",
    "outputId": "98eaba5a-4121-4d78-dea7-825f713e0905"
   },
   "outputs": [],
   "source": [
    "print('Hello world!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0020d760",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(age)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2bef58a-14b7-447d-9a72-43d0d0117baf",
   "metadata": {},
   "source": [
    "In the cells above, we printed only text or a variable. Frequently, we want to combine the two. Python has many ways of doing this. We typically use \"formatted string literals,\" or \"F-strings\" for short, a relatively new feature in Python. From the Python documentation:\n",
    "\n",
    "> Formatted string literals (also called f-strings for short) let you include the value of Python expressions inside a string by prefixing the string with f or F and writing expressions as {expression}.\n",
    "\n",
    "Here's an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d7e17d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"My first name is {first_name}. Nice to meet you!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d3ccfb3",
   "metadata": {
    "id": "1d3ccfb3"
   },
   "source": [
    "### Variables must be created before they are used.\n",
    "\n",
    "If a variable doesn't exist yet or the variable name has been misspelled, Python reports an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a944d837",
   "metadata": {
    "id": "a944d837"
   },
   "outputs": [],
   "source": [
    "print(last_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4f3cd36",
   "metadata": {
    "id": "c4f3cd36"
   },
   "source": [
    "### <img src='images/note_icon.svg' alt=\"Note icon\" width=40 align=center> Note\n",
    "> We expect an error above!\n",
    "> You will undoubtedly make mistakes! You will see lots of error messages! Don't worry! We all get them. The trick is to try and figure out how to fix them when we get an error. We will look at error messages in more detail later."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81456549-4852-49c9-80fa-81b112a521e1",
   "metadata": {},
   "source": [
    "In this case, the last line of the error message is:\n",
    "```python\n",
    "NameError: name 'last_name' is not defined\n",
    "```\n",
    "So, we see we have a `NameError`, and the explanation is that `last_name` is not defined. Hopefully, that reminds us that we haven't created a `last_name` variable."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8bdaf35",
   "metadata": {
    "id": "c8bdaf35"
   },
   "source": [
    "### Python keeps track of your variables and their current values (and order matters!).\n",
    "\n",
    "###  <img src='images/alert_icon.svg' alt=\"Alert icon\" width=40 align=center> Alert!\n",
    "> It is the **order of execution** of cells that is important, **not the order in which they appear in the notebook**. Nothing stops you from running any code cell in this notebook in any order you like (aside from potential errors!). If different code cells modify the same variable, it can sometimes lead to unexpected behavior.\n",
    "\n",
    "Let's look at the following two code cells to demonstrate this point.\n",
    "\n",
    "*Code cell 1:*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bf8c7a64",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 186
    },
    "id": "bf8c7a64",
    "outputId": "57daa3a9-4930-4554-bb21-a272fe0bca5f"
   },
   "outputs": [],
   "source": [
    "print(myval)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "defff42a",
   "metadata": {},
   "source": [
    "*Code cell 2:*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d9c1b187",
   "metadata": {
    "id": "d9c1b187"
   },
   "outputs": [],
   "source": [
    "myval = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17402c0f-324a-4e1f-98eb-a1a31a6fd09d",
   "metadata": {},
   "source": [
    "If you try to execute the cells in the order they appear (first cell 1, then cell 2), the first cell will give an error. However, if you run cell 2 and **then** run cell 1, it will correctly print the value of `myval` (since the `myval` variable was created by running cell 2.)\n",
    "\n",
    "### <img src='images/tip_icon.svg' alt=\"Tip icon\" width=40 align=center> Tip\n",
    "> To prevent confusion (or to start fresh), resetting things can sometimes be helpful.\n",
    ">* Kernel menu > Restart Kernel\n",
    ">\n",
    ">\n",
    ">This clears all variables stored in memory. After selecting this option, you start your notebook with a clean slate!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ef66dcd",
   "metadata": {},
   "source": [
    "### Variables can be used in calculations.\n",
    "We can use variables in calculations just as if they were values!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a7e7c92d",
   "metadata": {},
   "outputs": [],
   "source": [
    "age = 40\n",
    "age_plus = age + 3\n",
    "print(f'Age in three years: {age_plus}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cba832ba",
   "metadata": {
    "id": "cba832ba"
   },
   "source": [
    "### Assigning variables\n",
    "If you want to keep a value for future reference, you must assign it to a variable. Otherwise, the value disappears into the void! For example, after running the cell below, the value of `z` remains `3`, and the value of `9` is lost because it was not assigned to a variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "26a00b2a",
   "metadata": {
    "id": "26a00b2a"
   },
   "outputs": [],
   "source": [
    "z = 3\n",
    "print(z + 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d46c9233",
   "metadata": {
    "id": "d46c9233"
   },
   "outputs": [],
   "source": [
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "546c16fc",
   "metadata": {
    "id": "546c16fc"
   },
   "source": [
    "## Order of Operations\n",
    "Remember the acronym **PEMDAS** from math class? Python follows the same order, evaluating items in the order: Parentheses (`(`,`)`), Exponentiation (`**`), Multiplication (`*`), Division (`/`), Addition (`+`), and Subtraction (`-`).\n",
    "\n",
    "<img src=\"images/pemdas.gif\" />\n",
    "\n",
    "**Parentheses** are helpful in complex expressions and can be used for clarity, but they are not technically required. This aligns with the overall philosophy of Python, that code should be written for clarity of reading.\n",
    "\n",
    "There's a common saying: \n",
    "> Code is written once but read many times.\n",
    "\n",
    "**Do your best to make your code simple to read!**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "nNVTOE9yOQWw",
   "metadata": {
    "id": "nNVTOE9yOQWw"
   },
   "source": [
    "### <img src='images/exercise_icon.svg' alt=\"Exercise icon\" width=40 align=center> Exercise 2\n",
    "> Compute this expression: $\\frac{100 - 5^3}{5}$.\n",
    "> * *Hint 1:* $5^3$ can be written in code as `5**3` (5^3 does not return what you might expect. The `^` operator in Python is a bitwise XOR operator. Don't worry about what this means, but understand that it is not the way to raise a number to the power of another number.).\n",
    "> * *Hint 2:* The answer should be -5.0.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b0750797",
   "metadata": {
    "id": "b0750797"
   },
   "outputs": [],
   "source": [
    "# Add your code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b864290b",
   "metadata": {
    "id": "b864290b"
   },
   "source": [
    "###  <img src='images/exercise_icon.svg' alt=\"Exercise icon\" width=40 align=center> Exercise 3\n",
    "\n",
    "> Divide 15 by 4 and add 6 (the answer should be: 9.75)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "39a13254",
   "metadata": {
    "id": "39a13254"
   },
   "outputs": [],
   "source": [
    "# Add your code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35a757b5",
   "metadata": {
    "id": "35a757b5"
   },
   "source": [
    "## Integer and Float Types\n",
    "\n",
    "Python has many data **types**, or ways of storing the variable's data in memory. Since each type has different properties, keeping track of the type used for each variable is important. Many coding errors are due to variables being stored as the wrong type. Python has a built-in function to determine the type of a variable, the `type()` function.\n",
    "\n",
    "###  <img src='images/definition_icon.svg' alt=\"Definition icon\" width=40 align=center> Definition\n",
    "> An **integer** is a whole number without a decimal point, while a **float** is a number that includes a decimal point.\n",
    "\n",
    "Let's compare the **type** of `6` and `6.0`. Try the code `type(6)` and `type(6.0)` in the cells below. You should get `int` and `float` for integer and floating point numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "253572ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(type(6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fa6d9f42",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(type(6.0))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25548dd7",
   "metadata": {
    "id": "25548dd7"
   },
   "source": [
    "### <img src='images/exercise_icon.svg' alt=\"Exercise icon\" width=40 align=center> Exercise 4\n",
    "> Let's try looking at the **type** of a variable. Enter the following code in the empty code cell below, and see what you get!\n",
    ">\n",
    ">```python\n",
    ">x = 3.14\n",
    ">print(type(x))\n",
    ">```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "916cb7f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add your code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce2a989b-4756-45f3-a839-5ddea5b5635c",
   "metadata": {},
   "source": [
    "   > Check the type of some of the other variables you have created. e.g. `firt_name`, `age`, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "72949368-a78b-44a4-be02-bc0e349d93a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add your code here to check the type of some of your variables\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aff198cd",
   "metadata": {
    "id": "aff198cd"
   },
   "source": [
    "### <img src='images/exercise_icon.svg' alt=\"Exercise icon\" width=40 align=center> Exercise 5\n",
    "\n",
    "> Python will gladly convert a variable from one type to another if it makes sense. This is called **type casting**. Let's change `x` (which currently has the **float** value `3.14`) to an **integer**, and assign the result to a new variable `y`.\n",
    ">\n",
    ">Here's a hint to get you started with type casting `x` to an `int`: `y = int(x)`\n",
    ">\n",
    ">Add your own code to:\n",
    ">* Print the type of `y`\n",
    ">* Print the value of `y`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c7808e73",
   "metadata": {
    "id": "c7808e73"
   },
   "outputs": [],
   "source": [
    "# Add your code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29422def-9b14-48e2-a411-c676a21fd531",
   "metadata": {},
   "source": [
    "> **Question:** Do you think Python used rounding or another method when converting the floating point value 3.14 to the integer 3?\n",
    ">\n",
    "> Make a variable with a decimal value greater than .5 to test your answer. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bac1f719-b8eb-4343-a5db-3fddd4346d99",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add your code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a5a7cf0",
   "metadata": {
    "id": "3a5a7cf0"
   },
   "source": [
    "### <img src='images/exercise_icon.svg' alt=\"Exercise icon\" width=40 align=center> Exercise 6\n",
    "> Finally, let's go the other way: convert an `int` (after running the previous cell, `y=3`) to a `float`.\n",
    "> * Use type casting to convert `y` to a `float`, assigning the result to a new variable\n",
    "> * Print the type of your new variable\n",
    "> * Print the value of your new variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b980b98",
   "metadata": {
    "id": "4b980b98"
   },
   "outputs": [],
   "source": [
    "# Add your code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76f1f584-84c5-4eca-8082-200fce909358",
   "metadata": {},
   "source": [
    ">Note the `.0` added to the end to make the integer `3` into the float `3.0`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0aa3fe1-3cbd-4c44-a50c-1114243e5c70",
   "metadata": {},
   "source": [
    "## The List Type\n",
    "\n",
    "A list is a sequence of values--in some ways, a test string is a special kind of list consisting of a sequence of letters. \n",
    "\n",
    "The values in a list are called **list elements** or **list items**. \n",
    "\n",
    "In Python, lists are most easily defined using square brackets:\n",
    "\n",
    "```python\n",
    "my_list = [1, 35, 5.6, \"Fun\"]\n",
    "```\n",
    "\n",
    "The list `my_list` has four elements, two of which are integers; one is a floating point number, and the last is a string. This demonstrates an important feature of Python lists: lists can contain elements with different types!\n",
    "\n",
    "This can be handy--it may make your life easier in accomplishing your task. But comes at a cost in terms of speed and memory, which is one reason lists are used less in AI, at least for storing data. \n",
    "\n",
    "List elements are accessed using their index (or position in the list).\n",
    "\n",
    "> A critical point to remember is that Python is \"zero-indexed.\" That means the first item in a list has an index of 0!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ca34bd6a-79a4-443c-9417-be4da1b5f25a",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [1, 35, 5.6, \"Fun\"]\n",
    "print(f\"The fourth element in my list is: {my_list[3]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "edebe76c-91d9-4f79-989d-f4c3674f25e5",
   "metadata": {},
   "source": [
    "Experiment with lists in the cell below. They are a common data type, and understanding how lists work will help you with similar data types we will encounter later. It will also help reinforce the concept of zero-indexing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a591c8f-2fc1-4d25-8170-577ed8cf83f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Experiment with lists here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ef85bb4-fc41-4cab-853a-58df58de1de7",
   "metadata": {},
   "source": [
    "## Variable Naming\n",
    "\n",
    "### Python is case-sensitive\n",
    "\n",
    "* Python treats upper- and lower-case letters as different, so `Name` and `name` are different variables.\n",
    "* We will follow the convention of using lower-case letters for variable names.\n",
    "\n",
    "### Use meaningful variable names\n",
    "\n",
    "* Python doesn't care what you call variables as long as they obey the rules (alphanumeric characters and the underscore)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f81cf851-7096-4235-84a8-9cc742b85624",
   "metadata": {},
   "outputs": [],
   "source": [
    "flabadab = 42\n",
    "ewr_422_yY = 'Ahmed'\n",
    "print(f'{ewr_422_yY} is {flabadab} years old')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00658c61-23f5-4a10-8686-b1f5e3d74c92",
   "metadata": {},
   "source": [
    "\n",
    "* Use meaningful variable names to help other people understand what the program does.\n",
    "* **The most important \"other person\" is your future self.**\n",
    "\n",
    "\n",
    "When naming variables, there are a few important rules:\n",
    "\n",
    "  * Some words are reserved for Python and cannot be used for variable names. These words have special meanings.\n",
    "  * Python variable names cannot start with a digit.\n",
    "  * Python variable names cannot include special characters other than underscore(\"_\").\n",
    "\n",
    "### <img src='images/tip_icon.svg' alt=\"Tip icon\" width=40 align=center> Tip\n",
    "   > See the PEP8 Style Guide for coding recommendations: [https://www.python.org/dev/peps/pep-0008/](https://www.python.org/dev/peps/pep-0008/)\n",
    "\n",
    "While not written rules, it is best practice to:\n",
    "* Have variable names reflect what they store: `time` is far better than `t` or `x`.\n",
    "* Use plural names for variables that hold multiple items and single names for single items: `records` for a list of all records and `record` for a single record from the list.\n",
    "* Be consistent in using `camelCase` or `underscores_between_words`. PEP8 prefers underscores.\n",
    "*  Variable names that start with underscores, like `__alistairs_real_age`, have a special meaning, so we won't do that until we understand the convention."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46fa6b77-57e5-4be2-85a5-9481b0163e97",
   "metadata": {
    "tags": []
   },
   "source": [
    "To see what happens, let's create a variable named `1st_name` and assign it your name: e.g.\n",
    "\n",
    "  ```python\n",
    "  1st_name = 'Matt'\n",
    "  ```\n",
    "###  <img src='images/note_icon.svg' alt=\"Note icon\" width=40 align=center> Note\n",
    "   > You will get an error. Read the message and try to interpret it. Notice that the \"^\" (caret) points to where Python thinks the error is. That is close, but not exactly where the issue is. Sometimes, the error can be a line or two above the caret--don't assume it is pointing to the code that caused the error. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "602a749a-fd1f-40e5-a783-1dfc1955aff6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add your code here from above\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "553e3538-c152-4ffb-8bc3-d4bd7492f043",
   "metadata": {},
   "source": [
    "Can you fix the variable name to one that works?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7a2476f2-90fd-4888-89a6-aaf959f13526",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d69619b2-506b-44bd-bdba-a7213d213442",
   "metadata": {},
   "source": [
    "As another example of variables that are not allowed, run the following cell, then rename the variable in a way that removes the error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a80d6bed-82e5-4a79-945c-a2cf0b2cb198",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Run this cell, observe the error, and fix it by changing the variable name\n",
    "my_$ = 100"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8cf74874",
   "metadata": {
    "id": "8cf74874"
   },
   "source": [
    "## Use `# comments` to add documentation to programs.\n",
    "\n",
    "### Comments in code\n",
    "* Any text on a line **after the `#` symbol** is considered a **comment** and is ***ignored*** by the Python interpreter (the part of Python that converts, or interprets, your code into instructions for the computer to execute.).\n",
    "* Comments are handy for explaining lines or sections of code (for your team and even your future self!).\n",
    "* In addition to comments, *strive to make your code self-documenting and easy to read*. Clear variable names, consistent structure and spacing, and logical flow contribute to readability.\n",
    "* Too many comments can be distracting; avoid making comments that state the obvious.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d68f7746",
   "metadata": {
    "id": "d68f7746"
   },
   "outputs": [],
   "source": [
    "# This sentence isn't executed by Python.\n",
    "adjustment = 0.5   # Neither is this - anything after '#' is ignored."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd2873a3",
   "metadata": {
    "id": "cd2873a3"
   },
   "source": [
    "# Libraries\n",
    "### The power of a programming language is in its libraries.\n",
    "\n",
    "* A *library* is a collection of Python files (called *modules*) that contain pre-written code for use by other programs.\n",
    "* The Python *standard library* is built into Python itself (for example, the `math` library we used is part of the Python standard library).\n",
    "* Many additional libraries are available from various online sources, including conda channels (e.g. [Conda Forge](https://conda-forge.org/)), the Python Package Index ([PyPI](https://pypi.python.org/pypi/)), and [GitHub](https://github.com).\n",
    "* ***Coding for AI and machine learning relies heavily on libraries!***\n",
    "\n",
    "###  <img src='images/definition_icon.svg' alt=\"Definition icon\" width=40 align=center> Definition\n",
    "> A **library** is a collection of module files. A **module** is a file with one or more **functions** defined in it (see below for more on functions). *Library and module are often used interchangeably* as many libraries consist of a single module.\n",
    "\n",
    "#### A Python file must `import` a library module before using it.\n",
    "\n",
    "* Use `import` to load a library module into a running program.\n",
    "* Then refer to things from the module as `module_name.thing_name`.\n",
    "    * Python uses `.` to mean \"part of\".\n",
    "* Here is an example of using the `math` library, one of the libraries in the standard library:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fdced80b",
   "metadata": {
    "id": "fdced80b"
   },
   "outputs": [],
   "source": [
    "import math\n",
    "print(f'pi is {math.pi}')\n",
    "print(f'cos(pi) is {math.cos(math.pi)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c63a25a4",
   "metadata": {
    "id": "c63a25a4"
   },
   "source": [
    "### <img src='images/tip_icon.svg' alt=\"Tip icon\" width=40 align=center> Tip\n",
    "> Use `help` and `dir` to learn about the contents of a library module.  The `dir()` function is versatile because it returns a list of attributes and methods for any object (function, module, list, dictionary, etc.)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5818b9ab",
   "metadata": {
    "id": "5818b9ab"
   },
   "outputs": [],
   "source": [
    "help(math)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bab96f73-3c08-4378-afac-3f91c21c4dd0",
   "metadata": {},
   "outputs": [],
   "source": [
    "dir(math)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd50771d-e745-4e30-a2d2-f5e1bd5f7b17",
   "metadata": {},
   "source": [
    "#### Use `from <lib> import <obj>` to import specific object(s) from a library.\n",
    "\n",
    "Rather than import an entire library, you may want to import a single function. This lets you use that function directly rather than the `library.function()` syntax. For example, we can import just the `cos()` function with this line of code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d53eb4d1-130c-4160-a714-befeaa16f47f",
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import cos\n",
    "\n",
    "print(cos(0))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7f2073e-4ee2-47aa-b0a6-d4e659c6478e",
   "metadata": {},
   "source": [
    "#### To reduce typing, rename imported libraries using aliases.\n",
    "\n",
    "You can specify an alternative name, or alias, for a library.  For example, we can import the math library, abbreviate its name, and reference it later as **m** in the code. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bca772ce-0f34-4cdd-86d0-13b8b2978d6b",
   "metadata": {},
   "outputs": [],
   "source": [
    "import math as m\n",
    "\n",
    "# Print the pi variable\n",
    "print(m.pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5071cf2d",
   "metadata": {
    "id": "Ic5O-JZ73I7f"
   },
   "source": [
    "# Functions\n",
    "\n",
    ">You can think of a function as a small program inside a program. A function's basic idea is to write a sequence of statements and give that sequence a name. The instructions can then be executed at any point in the program by referring to the function name… when a function is subsequently used in a program, we say that the definition is called or invoked.\n",
    ">\n",
    ">John Zelle ([Python Programming: An Introduction to Computer Science, 3rd Edition](https://fbeedle.com/our-books/23-python-programming-an-introduction-to-computer-science-3rd-ed-9781590282755.html), p. 177)\n",
    "\n",
    "Functions make coding more straightforward to write, read, and maintain. They reduce repetition and provide discrete mini-programs that can be used repeatedly once written and tested.\n",
    "\n",
    "We've been using Python functions since the start... `print()` is a function! But the really cool thing is that you can (and should) write functions too! Functions are not complicated or limited to people with special skills. Plus, they can make your coding much more accessible!\n",
    "\n",
    "Two good indicators of when to write a function are when you are tempted to copy and paste code from one section into another to reuse it or when a section of code needs to be run multiple times in different locations within your code.\n",
    "\n",
    "The repeated code can likely be made into a function and called when needed. And the \"thing\" that needs to be done can also probably be written as a function.\n",
    "\n",
    "### <img src='images/tip_icon.svg' alt=\"Tip icon\" width=40 align=center> Tip\n",
    "> It might be time to write a function when you're about to copy and paste code from one section into another to reuse it."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c73c7464",
   "metadata": {},
   "source": [
    "## Defining a Python function\n",
    "\n",
    "Below are the steps to creating your first Python function. A function must be defined like a variable before it can be used. We will demonstrate using this simple function that takes as input two numbers and outputs the sum:\n",
    "\n",
    "```python\n",
    "def add(x,y):\n",
    "    '''Takes two values and returns their sum.'''\n",
    "    sum = x+ y\n",
    "    return sum\n",
    "```\n",
    "\n",
    "1. The definition line: `def add(x,y):`.\n",
    "    * Begin the definition of a new function with `def`, followed by an appropriate name for the function\n",
    "    * Then, add parentheses `()` after the function name.\n",
    "    *  Inside the parentheses, list any number of **input arguments**, separated by commas, that your function will use (many functions take **no arguments**).\n",
    "    * Add a colon `:` after the closing parentheses.\n",
    "1. The **docstring**: `'''Takes two values and returns their sum.'''`.\n",
    "    * Functions should have a **docstring** documenting what the function will do.\n",
    "       * It should be the first line(s) after the `def` line and is enclosed in triple quotes (even if it's a single line).\n",
    "       * >The docstring is a phrase ending in a period. It prescribes the function or method’s effect as a command (“Do this”, “Return that”), not as a description; e.g. don’t write “Returns the pathname …”.\" ([PEP-0257](https://peps.python.org/pep-0257/))\n",
    "1. The code to do what your function needs to do: `sum = x+ y`.\n",
    "   * **Important:** All code inside a function must be **indented**.\n",
    "1. A `return` statement: `return sum`.\n",
    "    * If you want the function to output something, add a `return` statement, followed by the variable or expression you wish to return.\n",
    "    * A `return` statement is not necessary, but if not used, the function will return a special value: `None`.\n",
    "\n",
    "### <img src='images/exercise_icon.svg' alt=\"Exercise icon\" width=40 align=center> Exercise 7\n",
    "> Define the `add` function in code below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7398c39b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# *Define* the add function displayed above\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4d5b12c",
   "metadata": {},
   "source": [
    "###  <img src='images/note_icon.svg' alt=\"Note icon\" width=40 align=center> Note\n",
    "> **Defining** a function does not run the code inside the function; it simply creates the function for later use.\n",
    "\n",
    "To **call** a function, write its name followed by zero or more comma-separated input arguments. Here's an example of defining and then calling a simple function: \n",
    "\n",
    "```python\n",
    "# Define the function\n",
    "def print_number(number):\n",
    "    '''Takes value and prints it.'''\n",
    "    print(number)\n",
    "    \n",
    "# Call the function\n",
    "a = 7\n",
    "print_number(a) # One way\n",
    "print_number(7) # Another way\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eebb7097",
   "metadata": {},
   "source": [
    "### <img src='images/exercise_icon.svg' alt=\"Exercise icon\" width=40 align=center> Exercise 8\n",
    "> Call the `add` function we already defined, to add two numbers of your choosing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "000b30bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# *Call* the add function using any two numbers\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc0e03c7",
   "metadata": {},
   "source": [
    "### <img src='images/exercise_icon.svg' alt=\"Exercise icon\" width=40 align=center> Exercise 9\n",
    "> Create a function that takes **any** number as input, and outputs the **square** of that number. Example: An input of 6 will output 36. **Hint:** In Python code, `x ** 2` will compute $x^2$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2c837d51",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a function to compute the square of any input number.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53c7df54-0243-447e-8e1a-7b6a85a0bc57",
   "metadata": {},
   "source": [
    "### Function return values\n",
    "\n",
    "Python functions always return *something*. If you want to capture the returned value(s), assign them to one or more variables.\n",
    "\n",
    "Let's make a function to play with here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "83faec58-7f2f-47ce-893c-765a29c36a6c",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def powers(number):\n",
    "    '''Takes a number and returns the number's square, cube and 4th power.'''\n",
    "    return number**2, number**3, number**4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "42303a78-9955-408b-b610-adafb87793db",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Now call the function\n",
    "powers(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5bf87db-bb0b-4762-a49c-ad607ea1f3da",
   "metadata": {},
   "source": [
    "Our `powers` function works! But the returned values are lost...we didn't save them.\n",
    "\n",
    "To save them, we can assign the returned values to one or more variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b5ed3963-8550-4cd4-92f8-c2395ddd519d",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Let's also make x to use in printing...\n",
    "x = 2 \n",
    "values = powers(x)\n",
    "\n",
    "output = f'{x} squared is {values[0]}, {x} cubed is {values[1]},\\\n",
    " and {x} to the 4th is {values[2]}.'\n",
    "\n",
    "print(output)\n",
    "print(f'The values returned look like: {values}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa2a25e8-b43f-4761-8718-ff97d638a022",
   "metadata": {},
   "source": [
    "Because we only provided one variable name, Python assigned all the returned values into a **tuple** (a new variable type, similar to lists).\n",
    "\n",
    "We can also provide three values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bdf9ab81-8f46-401e-a480-ec0974eb9202",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "x = 2 \n",
    "power2, power3, power4 = powers(x)\n",
    "\n",
    "output = f'{x} squared is {power2}, {x} cubed is {power3},\\\n",
    " and {x} to the 4th is {power4}.'\n",
    "\n",
    "print(output)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a07945e-2ccd-4ba7-b896-49f44af16e9a",
   "metadata": {},
   "source": [
    "What happens if you provide 2 or 4 variables to take our returned values from the `powers` function?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a01f283e-770a-458a-af3f-1597a9654d39",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Experiment with calling the powers function \n",
    "# providing 2 or 4 return variables\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23c48c96-bddc-4acd-9f75-4b0a0e2a4fe5",
   "metadata": {},
   "source": [
    "#### `None` returned if no `return` specified\n",
    "\n",
    "Lastly, if we don't *explicitly* return something, we *implicitly* return `None`, a special Python reserved word.\n",
    "\n",
    "Remember our `print_number` function? Let's see what's returned:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "11107bae-5dae-4e18-8808-892d5216a66c",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def print_number(a):\n",
    "    print(a)\n",
    "    \n",
    "value = print_number(5)\n",
    "print(f'The return of print_number is: {value}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec54678e",
   "metadata": {},
   "source": [
    "### BONUS: Positional arguments\n",
    "\n",
    "In the `add` function above, `x` and `y` are **positional arguments** - the order arguments are passed to the function matters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd33fc6d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def order(x,y):\n",
    "    print(x)\n",
    "    print(y)\n",
    "    \n",
    "print(order(3,4))\n",
    "print() # print() with no arguments will add a blank line to the output.\n",
    "print(order(4,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74092fa8",
   "metadata": {},
   "source": [
    "### BONUS: Default values\n",
    "\n",
    "* Functions may have default values for some input arguments.\n",
    "* If an argument has a default value, the function will use that value unless the user specifies something different for that particular variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "68b38517",
   "metadata": {},
   "outputs": [],
   "source": [
    "def add(x,y=1):\n",
    "    result = x + y\n",
    "    return result\n",
    "\n",
    "print(add(2))\n",
    "\n",
    "print(add(2,6))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f2593a9",
   "metadata": {},
   "source": [
    "### BONUS: Function variable scope\n",
    "\n",
    "* Variables created inside functions are **locally scoped**, which means they are only accessible inside of the function that created them.\n",
    "    * Once the function has been executed, any variables created inside the function are removed from memory! (Use `return` to send the outputs back to the main program)\n",
    "* Variables created outside of functions are **globally scoped**, and can be accessed anywhere once the variable is created."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "16ae018e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def waste_of_code(): # This function doesn't do anything!\n",
    "    x = 3\n",
    "\n",
    "# Let's optimistically call the waste_of_code() function.\n",
    "# Perhaps we would expect to now have a variable x with value equal to 3.\n",
    "print(waste_of_code())\n",
    "    \n",
    "# This will result in an error! (x has not been defined outside of the function)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a466a4d3-6f11-486f-9ecf-e58fc9c698f0",
   "metadata": {},
   "source": [
    "Can you fix the `waste_of_code` function to return the value of x? You will also need to assign the returned value to a variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ca8da266-19ea-42c9-b9de-c2efaf9f8f95",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "ada71e00-9833-484b-baaf-ef6cd5550c32",
   "metadata": {},
   "source": [
    "***\n",
    "#### Attribution \n",
    "Some content in this learning experience was adapted from Ben Shickel's [AI for Medicine bootcamp](https://github.com/gatorai/scripps) content. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "079cdd13-eec5-41e1-b343-e655113bcb8d",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.2"
  },
  "vscode": {
   "interpreter": {
    "hash": "442d0c0e479a9a390f050bd5e20dc551a2c9cfe478296c9d47f476f59d719e25"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}