functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions\n",
    "A function is a block of code that performs a single action that can be reused indefinitely. They provide a great way of breaking code into smaller reusable pieces."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Built-in and user-defined functions\n",
    "We've seen serveral built-in functions now: `print()`, `len()`, `input()`, `int()`, `float()`, etc. Note that the syntax is similar - *function_name(arguments)*. When we call a function, it executes some code using as input arguments passed into the function, such as variables and values, and returns a result. More simply stated, a function takes arguments, executes code, and returns a result. This result is called a *return value*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example, the length function `len()` takes as an argument an object, such as a string, some code runs in the background that determines the number of items in the object, for a string this would the number of characters, and a value is returned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len('ATGCATGCTATC')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See https://docs.python.org/3.10/library/functions.html for a list and description of the ~70 built in functions. Go through the list and explore them on your own."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python makes it easy to create your own functions. These functions are completely portable and can be used in any Python script essentially just like the built-in functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can define a function by assigning a name to the function and a block of code to execute - this is referred to as *function definition*. The syntax is as follows:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "def function_name(arguments):\n",
    "    block of code\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`def` is a keyword that is used to indicate that this is a function definition. The first line is called the header and the block of code is called the body and must be indented."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's define a function called `echo()` that prints whatever arugment is passed to it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the code within a function will not be run unless the function is specifically called from outside the function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can call our new function just like we would a built-in function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "echo(\"Circus McGurcus\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 1.** Write a function, `char_count()` that prompts the user for word or phrase (using the `input()`) function and prints the number of characters it contains.  You can use the `len()` function to compute the number of characters. Remember to call your function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Return values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions always return a value. The `echo()` function we wrote above prints whatever argument we pass to it, and returns a value. However, the value it returns is `None` (a keyword meaning null in Python), which is not particularly useful. Let's look back at the `echo()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def echo(text):\n",
    "    print(text)\n",
    "\n",
    "return_value = echo(\"Hello?\")\n",
    "#print(return_value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A function that doesn't return a useful value is called a void function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's a function called `cat()` that concatenates two DNA or RNA sequences passed as arguments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cat(seq1, seq2):\n",
    "    return seq1 + seq2\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `return` statement is used to provide a value from a function. The `return` statement also exits the function so you can have one `return` statement executed each time the function is called and you can't include any code after the `return` statement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that the function we defined specifically requires two arguments, `seq1` and `seq2` (what you call these variables is arbitrary), which are then used in place of the actual seq1 and seq2 in the function definition. Naming of functions follows the same general rules as naming variables."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's write a function called `base_id(sequence)` that takes as an argument a nucleic acid sequence and returns `dna` if it contains Ts and `rna` if it contains Us:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that it's okay to have mutlipe `return` statements in a function but only 1 will be executed and then the program steps out of the function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we call a function we have to provide the required arguments, in this case a single sequence, which is then assigned to the parameter `seq` that we specified in the function. Just as with built-in function, the argument can be a variable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's assign a sequence to a variable and then call the `base_id()` function providing the variable as the argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "seq = 'ATG'\n",
    "base_id(seq)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we were to call the function in a script, just as with built-in functions such as `len()`, a result is returned but it is not printed or acted on. We can store the return value as a variable if that is useful or we could print the return value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nt = base_id(seq)\n",
    "print(nt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 2.** Write a function, `square(n)`, that returns the square of n. For example, `sqaure(2)` would return 4.  Call the function, passing it a number to test it and print the return value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Local vs global variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variables assigned within a function cannot be used outside of the function, these are called local variables because they can only be used locally. Variables assigned outide of a function are global, meaning they can be used anywhere:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num = 5 #global variable assignment\n",
    "def cube(n):\n",
    "    num_cube = n**3 #local variable assignment\n",
    "    print(num) #print global variable\n",
    "    print(num_cube) #print local variable inside function\n",
    "cube(num)\n",
    "#print(num_cube) #print local variable outside function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Typically when we write a Python program, we'll include a special function, called `main()`, that handles calling other functions. Let's open a text editor (or you can use the Spyder IDE) and write a function called `abs_val(num)` that computes and returns the absolute value of a number.  We'll also write a `main()` function that prompts the user for a number and calls `abs_val()` passing the number input by the user and then prints the result."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Assignment 12\n",
    "Use the code cell below or a text editor to write a function called `power(base, exponent)` that computes and returns a number (base) raised to another number (power).  For example, `power(2, 3)` would compute 2\\*\\*3 and return 8. Within the same code cell, write a `main()` function that calls the function, passing test numbers to it, and prints the return value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Copy your code to canvas, assignment 12, for grading."
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}