wk4/MY470_wk4_class.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### MY470 Computer Programming\n",
    "# Writing and Calling Functions in Python\n",
    "### Week 4 Lab"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Defining and Calling Functions\n",
    "\n",
    "### Defining a function\n",
    "\n",
    "```\n",
    "def *function_name*(*list of parameters*):\n",
    "    *body of function*\n",
    "```\n",
    "\n",
    "### Calling a function\n",
    "\n",
    "```\n",
    "*function_name*(*arguments*)\n",
    "```\n",
    "\n",
    "### Functions can take 0 or more arguments and return 1 or more values!\n",
    "\n",
    "### If a function does not have `return` statement, it returns `None`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Functions Take Arguments by Reference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 0]\n"
     ]
    }
   ],
   "source": [
    "def change_list(alist):\n",
    "    alist.append(0)\n",
    "\n",
    "mylist = [1, 2, 3]\n",
    "change_list(mylist)\n",
    "print(mylist)\n",
    "\n",
    "# take note that if you pass a mutable type, it will affect locally and in the main frame.\n",
    "# by default, if the function does not have return, it will exit and return None."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "def zero_list(alist):\n",
    "    \"\"\"Takes a list and returns another list of the same length \n",
    "    that looks like [0, 0, 0, ...].\n",
    "    \"\"\"\n",
    "    alist = [0]*len(alist)  # Creates a new local reference for alist\n",
    "\n",
    "mylist = [1, 2, 3]\n",
    "zero_list(mylist)\n",
    "print(mylist)\n",
    "\n",
    "# the moment you have assignment, you are creating a new local variable\n",
    "# a local variable does not exist outside in the main frame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 0, 0]\n"
     ]
    }
   ],
   "source": [
    "# Exercise 1: Rewrite the function definition and call above \n",
    "# to accomplish what the function intends to do.\n",
    "\n",
    "def zero_list(alist):\n",
    "    \"\"\"Takes a list and returns another list of the same length \n",
    "    that looks like [0, 0, 0, ...].\n",
    "    \"\"\"\n",
    "    newlist = [0]*len(alist)  \n",
    "    return newlist\n",
    "\n",
    "mylist = [1, 2, 3]\n",
    "newlist = zero_list(mylist)\n",
    "print(newlist)\n",
    "\n",
    "# if you want to create new items, you have to return them."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Using Docstrings (String Literals) to Specify Functions\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function f in module __main__:\n",
      "\n",
      "f(x, y)\n",
      "    Demonstrates the importance of providing specification for functions.\n",
      "    Assumes x and y any type.\n",
      "    Returns nothing.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def f(x, y):\n",
    "    \"\"\" Demonstrates the importance of providing specification for functions.\n",
    "    Assumes x and y any type.\n",
    "    Returns nothing.\n",
    "    \"\"\"\n",
    "    pass\n",
    "\n",
    "help(f)\n",
    "\n",
    "# the point of the docstring is to explain the function and restrictions (eg. only takes numerical values)\n",
    "# no info of implementation unless completely necessary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "![Commenting](figs/commenting.jpg \"Commenting\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Using Functions Instead of Copy-Pasting Code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alan Turing was a mathematician.\n",
      "Richard Feynman was a physicist.\n",
      "Marie Curie was a chemist.\n",
      "Charles Darwin was a biologist.\n",
      "Ada Lovelace was a mathematician.\n",
      "Werner Heisenberg was a physicist.\n"
     ]
    }
   ],
   "source": [
    "# Consider the following code:\n",
    "\n",
    "# Print the name and profession of famous dead scientists:\n",
    "print('Alan Turing was a mathematician.')\n",
    "print('Richard Feynman was a physicist.')\n",
    "print('Marie Curie was a chemist.')\n",
    "print('Charles Darwin was a biologist.')\n",
    "print('Ada Lovelace was a mathematician.')\n",
    "print('Werner Heisenberg was a physicist.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alan Turing was a Mathematician .\n",
      "Richard Feynman was a Physicist .\n",
      "Marie Curie was a Chemist .\n",
      "Charles Darwin was a Biologist .\n",
      "Ada Lovelace was a Mathematician .\n",
      "Werner Heisenberg was a Physicist .\n"
     ]
    }
   ],
   "source": [
    "# Exercise 2: Rewrite the code using a function and a suitable data structure.\n",
    "\n",
    "scientists = {'Alan Turing': 'Mathematician', 'Richard Feynman': 'Physicist',\n",
    "              'Marie Curie': 'Chemist', 'Charles Darwin': 'Biologist',\n",
    "              'Ada Lovelace': 'Mathematician', 'Werner Heisenberg': 'Physicist'}\n",
    "\n",
    "def sentence(dic):\n",
    "    \"\"\" \n",
    "    Takes dictionary with names as keys and professions as values\n",
    "    Prints Name was a Profession.\n",
    "    Returns None.\n",
    "    \"\"\"\n",
    "    for n, scientists in dic.items():\n",
    "        print(n, 'was a', scientists, '.')\n",
    "\n",
    "sentence(scientists)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Using Functions to Improve Legibility and Modularity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25\n",
      "78.5\n",
      "8.860022573334675\n"
     ]
    }
   ],
   "source": [
    "# Consider the following code:\n",
    "\n",
    "# You are given two points in 2-D space\n",
    "x = (1, 1)\n",
    "y = (5, 4)\n",
    "\n",
    "# Calculate the area of the circle if one of the points is the circle center \n",
    "# and the other is on the perimeter and then calculate the side of the square \n",
    "# with the same area\n",
    "r_sq = (x[0] - y[0])**2 + (x[1] - y[1])**2\n",
    "print(r_sq)\n",
    "area = 3.14*r_sq\n",
    "print(area)\n",
    "sq_side = area**0.5\n",
    "print(sq_side)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "78.5\n",
      "8.860022573334675\n",
      "5.0 78.53981633974483 8.86226925452758\n"
     ]
    }
   ],
   "source": [
    "# Exercise 3: Rewrite the code above using functions \n",
    "# to make it easier to read.\n",
    "\n",
    "def area(x, y):\n",
    "    return (3.14*((x[0] - y[0])**2 + (x[1] - y[1])**2))\n",
    "\n",
    "def square(x,y):\n",
    "    return (3.14*((x[0] - y[0])**2 + (x[1] - y[1])**2))**0.5\n",
    "    \n",
    "print(area(x, y))\n",
    "print(square(x,y))\n",
    "\n",
    "\n",
    "from numpy import pi \n",
    "\n",
    "def get_dist(x,y):\n",
    "    \"\"\"\n",
    "    Assumes x and y are coordinates of 2 points in 2D\n",
    "    Returns distance between x and y.\n",
    "    \"\"\"\n",
    "    d_sq = (x[0] - y[0])**2 + (x[1] - y[1])**2\n",
    "    return d_sq**0.5\n",
    "    \n",
    "def get_circle_area(r):\n",
    "    return pi*r*r\n",
    "# this assumes you have already get_dist'ed, and have r\n",
    "\n",
    "def get_square_side(area):\n",
    "    return area**0.5\n",
    "\n",
    "r= get_dist(x,y)\n",
    "area = get_circle_area(r)\n",
    "sq_side = get_square_side(area)\n",
    "\n",
    "print(r, area, sq_side)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Using Functions Inside List Comprehensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[25, 16, 9, 4, 1, 0.0, 1.0, 1.4142135623730951, 1.7320508075688772, 2.0, 2.23606797749979]\n"
     ]
    }
   ],
   "source": [
    "def sq_or_sqrt(x):\n",
    "    \"\"\"Assumes x is numeric. Returns the square of x if x is negative\n",
    "    and the square root of x if x is nonnegative.\n",
    "    \"\"\"\n",
    "    if x < 0:\n",
    "        return x**2\n",
    "    else:\n",
    "        return x**0.5\n",
    "\n",
    "lst = [sq_or_sqrt(i) for i in range(-5, 6)]\n",
    "print(lst)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[None, None, 2, 178, None, 12, None, None, 12]\n",
      "[None, None, 2, 178, None, 12, None, None, 12]\n"
     ]
    }
   ],
   "source": [
    "# Exercise 4: Using a function and a list comprehension, \n",
    "# create a new list that has the numbers from testlist \n",
    "# if they are positive and None otherwise\n",
    "\n",
    "testlist = [-1, 0, 2, 178, -17.2, 12, -2, -3, 12]\n",
    "\n",
    "def pos_only(alist):\n",
    "    new_list = []\n",
    "    for i in alist:\n",
    "        if i > 0:\n",
    "            new_list.append(i)\n",
    "        else:\n",
    "            new_list.append(None)\n",
    "    return new_list\n",
    "positive = pos_only(testlist)\n",
    "print(positive)\n",
    "\n",
    "# alternatively, where the function does the base task of evaluating if x>0 only without making a new list\n",
    "\n",
    "def positive_or_none(alist):\n",
    "    \"\"\" Assumes x is a numeric type. Returns x if x>0 \n",
    "    otherwise returns None \"\"\"\n",
    "    if x > 0:\n",
    "        return x\n",
    "# you dont even have to code else, because if theres nothing, it returns None by default.\n",
    "\n",
    "newlist = [i if i > 0 else None for i in testlist]\n",
    "print(newlist)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# Exercise 5: Using a function and a list comprehension, create \n",
    "# a new list that includes the result from dividing each number \n",
    "# from testlist1 by the corresponding number in testlist2; \n",
    "# For the cases when the divisor is 0, the new list should include None\n",
    "\n",
    "testlist1 = [-1, 0, 2, 178, -17.2, 12, -2, -3, 12]\n",
    "testlist2 = [0, 5, 0, 2, 12, 0.5, 0, 0.25, 0]\n",
    "\n",
    "[]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Using Functions For General Cases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# Exercise 6: Write a Python function that checks if a string \n",
    "# is a palindrome. A palindrome is a word or a phrase that reads \n",
    "# the same backward as forward. For example, redder, nurses run, dad...\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}