Chapter 2 - Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 2 - Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions are the cornerstone of coding and are one of the best tools to **encapsulate** code. Functions in many programming languages are not like the ones found in math classes, where one set of inputs maps onto another set of outputs (see below)\n",
    "<img src=\"images/maps.png\" alt=\"map\" style=\"zoom:30%;\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, there are languages where that this is the case. These programming languages are called **functional programming** languages and I will go into more detail in later chapters. \n",
    "\n",
    "Most programming languages like C++, Java, JavaScript, and Python **may** have functions that return nothing or requires no input(s). Despite this freedom, it is often the case that a functions requires some number of input with some number of output because it is easier to read for the coder. For example, the following returns the double of the inputted number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# function\n",
    "def double(number):\n",
    "    # doubles the number\n",
    "    return number * 2\n",
    "# end of function\n",
    "\n",
    "# gets input\n",
    "number = int(input())\n",
    "\n",
    "# calls function\n",
    "doubled_number = double(number)\n",
    "\n",
    "# prints output\n",
    "print(number, \"* 2 =\", doubled_number)\n",
    "\n",
    "# the following also print also works, but requires f strings\n",
    "# which was explained in the extra section in chapter 1 \n",
    "# print(f'{number} * 2 = {doubled_number}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When running, input the number in the box and hit enter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that the return value is indeed double the inputed value, unless you inputed a word or character, in which case an error occurred. \n",
    "\n",
    "First we will go through the code to see how this is implemented line by line. \n",
    "\n",
    "1. the function (wrapped in the function comments) starts off with the **def** keyword. This keyword identifies the following as a function. \n",
    "2. the next part is the name of the function (in this case **double**) and the variables it is taking in (in this case **number**) enclosed in brackets. \\* Note the variable taken in does not have to match the variable name when it is later called because the variable in the function is a copy of the variable in the function call, unless it is a list, set, dictionary, or class object. \n",
    "3. after, we see \" **:** \" (colon) to indicate that the function has started\n",
    "\n",
    "\n",
    "4. on to the next line, we see it is indented in 4 spaces. This is very important and Python will look for this indent because no indent indicates that the code block (in this case a function), has ended. \n",
    "5. something that is optional is a return statement. Return is a keyword that specifies the following will be given to whatever called the function\n",
    "\n",
    "\n",
    "6. the next line, number = int(input()) assigns the variable number to the inputted number. The int() function turns the input to a integer because input() function returns a string.  \n",
    "\n",
    "\n",
    "7. It is important that the functional call is ahead of the function itself because Python reads code top to down, right to left. This function calls the number function with the number variable as it's argument (\\* note the argument being fed in does not need to be a variable and can be anything, ie. number, string, etc)\n",
    "\n",
    "\n",
    "8. the last line is a prints out the equation and the answer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some other things of note include having a default value for a variable, so if nothing is supplied as a argument"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def circle_area(radius, pi = 3.14):\n",
    "    # calculates the circle's area\n",
    "    # given the radius and the value of pi; defaults to 3.14\n",
    "    area = radius ** 2 * pi\n",
    "    return area, pi\n",
    "\n",
    "user_input = float(input('Radius: '))\n",
    "\n",
    "area, pi = circle_area(user_input)\n",
    "\n",
    "print(f'Calculated with a pi of {pi}, the area is {area}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now note that functions may return multiple things and you will need to **unpack** them by setting two or however any variables you return on the left hand side. \n",
    "\n",
    "Another good habit is to write the description of the function underneath it with descriptions of the arguments being taking in as a comment. Sometimes this is written in a docs string, which is another form of a comment but can be multi line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "calculates the circle's area\n",
    "given the radius and the value of pi; defaults to 3.14\n",
    "'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Extra"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the circle area, you may encounter an error of something that is off by a very, very small decimal (like .00000000001) because of something called **floating point error**. This is something that you must be careful about because this is a fundamental issue with how computers calculate floats. \n",
    "\n",
    "Learn more about it [here](https://en.wikipedia.org/wiki/Floating-point_error_mitigation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using what you have learned in this chapter, construct a function that calculates the volume of a sphere given an inputted value. The formula for a sphere is $\\frac{4}{3}\\pi r^3$.\n",
    "Again, the answer will be in the end of the next chapter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write your code below\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapter 1 Answer:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Chapter 1's exercise asks for you to print a float zero using what you learnt in chapter 1. One of the easiest (but certainly not the only way) way we can do this if we have two of the same floats and subtracting them "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# number variable\n",
    "number = 42.1 - 42.1\n",
    "\n",
    "# prints number\n",
    "print(number)"
   ]
  }
 ],
 "metadata": {
  "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.8.2"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": true,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}