python-primer/episodes/Writing Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Writing Functions\n",
    "**Teaching**: 15min<br>\n",
    "**Exercises**: 5min"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Break down programs into functions\n",
    "* Readability: human beings can only keep a few items in working memory at a time. Encapsulate complexity so that we can treat it as a single “thing”.\n",
    "* Reuse: write one time, use many times.\n",
    "* Testing: components with well-defined boundaries are easier to test."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define a function using `def` with a name, parameters, and a block of code\n",
    "\n",
    "* Function name must obey the same rules as variable names\n",
    "* Put *parameters* in parentheses\n",
    "* Then a colon, then an indented code block"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Empty parentheses if the function doesn't take any inputs:\n",
    "def print_greeting():\n",
    "    print('Hello!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Arguments in call are matched to parameters in definition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1871/3/19\n"
     ]
    }
   ],
   "source": [
    "def print_date(year, month, day):\n",
    "    joined = str(year) + '/' + str(month) + '/' + str(day)\n",
    "    print(joined)\n",
    "\n",
    "print_date(1871, 3, 19)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Functions may return a result to their caller using `return`\n",
    "\n",
    "* May occur anywhere in the function\n",
    "* But functions are easier to understand if `return` occurs\n",
    "   * At the start, to handle special cases\n",
    "   * At the very end, with a final result\n",
    "\n",
    "\n",
    "* Functions without explicit `return` produce `None`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def average(values):\n",
    "    if len(values) == 0:\n",
    "        return None\n",
    "    return sum(values) / len(values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "average of actual values: 2.6666666666666665\n"
     ]
    }
   ],
   "source": [
    "a = average([1, 3, 4])\n",
    "print('average of actual values:', a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "average of empty list: None\n"
     ]
    }
   ],
   "source": [
    "print('average of empty list:', average([]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1871/3/19\n",
      "result of call is: None\n"
     ]
    }
   ],
   "source": [
    "result = print_date(1871, 3, 19)\n",
    "print('result of call is:', result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Can specify default values for parameters\n",
    "* All paramters with defaults must come *after* all parameters without.\n",
    "* Otherwise, argument-to-parameter matching would be ambigious.\n",
    "* Makes common cases simpler, and signals intent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my_sum with default: 6.0\n",
      "sum with factor: 3.0\n"
     ]
    }
   ],
   "source": [
    "def my_sum(values, scale=1.0):\n",
    "    result = 0.0\n",
    "    for v in values:\n",
    "        result += v * scale\n",
    "    return result\n",
    "\n",
    "print('my_sum with default:', my_sum([1, 2, 3]))\n",
    "print('sum with factor:', my_sum([1, 2, 3], 0.5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Succinctly...\n",
    "def my_sum(values, scale=1.0):\n",
    "    return sum(v * scale for v in values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Can pass parameters by name\n",
    "* Helpful when functions have lots of options\n",
    "> If you have a procedure with ten parameters, you probably missed some. <br>-- from \"Epigrams in Programming\", by Alan J. Perlis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "out of order: 1.5\n"
     ]
    }
   ],
   "source": [
    "print('out of order:', my_sum(scale=0.25, values=[1, 2, 3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions can take a variable number of arguments\n",
    "* Prefix at most one parameter's name with `*`.\n",
    "* By convention, everyone calls the parameters `*args`.\n",
    "* All \"extra\" paramters are put in a list-like structure assigned to that parameter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with one value: 0.5\n",
      "with two values: 2.0\n"
     ]
    }
   ],
   "source": [
    "def total(scale, *args):\n",
    "    return sum(a * scale for a in args)\n",
    "\n",
    "print('with one value:', total(0.5, 1))\n",
    "print('with two values:', total(0.5, 1, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions can return multiple values\n",
    "* This is just a special case of many-to-many assignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "order(10, 5): 5 10\n"
     ]
    }
   ],
   "source": [
    "red, green, blue = 10, 50, 180\n",
    "\n",
    "def order(a, b):\n",
    "    if a < b:\n",
    "        return a, b\n",
    "    else:\n",
    "        return b, a\n",
    "\n",
    "low, high = order(10, 5)\n",
    "print('order(10, 5):', low, high)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: Find the first\n",
    "Fill in the blanks to create a function that takes a list of numbers as an argument and returns the first negative value in the list. What does your function do if the list is empty?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def first_negative(values):\n",
    "    for v in ____:\n",
    "        if ____:\n",
    "            return ____"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise : Running sum\n",
    "Write a function that calculates the running sum of any number of input arguments, returning the result as a list. For example:\n",
    "\n",
    "* running(1, 2) => [1, 3]\n",
    "* running(-5, 2, 7) => [-5, -3, 4]\n",
    "\n",
    "What should running() return, and why?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: How's your phase-change memory?\n",
    "A chalcogenide is a chemical compound consisting of at least one chalcogen anion (commonly restricted to ‘S’, ‘Se’, or ‘Te’) and at least one more electropositive element. Generalize the `halide` function below as `compound_class`, a function that takes a crystal and function as parameters and returns whether or not the compound is of that class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "from operator import attrgetter\n",
    "import random\n",
    "\n",
    "from pymatgen import Element\n",
    "\n",
    "with open('../data/crystals.json') as f:\n",
    "    crystals = json.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "`compound_class` fails",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-14-05e676728315>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     17\u001b[0m     [c for c in crystals if halide(c)], 1)[0]\n\u001b[1;32m     18\u001b[0m assert (compound_class(my_crystal, halogen)\n\u001b[0;32m---> 19\u001b[0;31m         == halide(my_crystal)), \"`compound_class` fails\"\n\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m: `compound_class` fails"
     ]
    }
   ],
   "source": [
    "def halogen(element):\n",
    "    return element.is_halogen\n",
    "\n",
    "def halide(crystal):\n",
    "    elts = [Element(s) for s in crystal['elements']]\n",
    "    anion = sorted(elts)[-1] # sorts by electronegativity\n",
    "    return halogen(anion)\n",
    "\n",
    "def chalcogen(crystal):\n",
    "    return element.is_chalogen\n",
    "\n",
    "def compound_class(crystal, predicate):\n",
    "    # Fill this in.\n",
    "    pass\n",
    "\n",
    "my_crystal = random.sample(\n",
    "    [c for c in crystals if halide(c)], 1)[0]\n",
    "assert (compound_class(my_crystal, halogen)\n",
    "        == halide(my_crystal)), \"`compound_class` fails\""
   ]
  }
 ],
 "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.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}