07-Functions.ipynb

{
 "metadata": {
  "name": "",
  "signature": "sha256:e800937abe0d4537092fd068f0dad8749c34d5e0304e96f27f1d285940a1a094"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# Functions in Python\n",
      "\n",
      "Functions without arguments are straighforward. You can use the `def` keyword to define a\n",
      "function:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def myfunction():\n",
      "    print 'Called myfunction'\n",
      "myfunction()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Called myfunction\n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "We can also define functions with arguments:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def myfunction2(a, b):\n",
      "    print 'Called myfunction2(%r,%r)' % (a,b)\n",
      "myfunction2('avalue', 'bvalue')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Called myfunction2('avalue','bvalue')\n"
       ]
      }
     ],
     "prompt_number": 2
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "When calling a function with arguments, you may also pass the arguments *by name* rather than \n",
      "*positionally.* This is often useful when there are a large number of arguments and you \n",
      "don't want to remember the order in which they appear."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "myfunction2(b='bvalue first', a='avalue second')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Called myfunction2('avalue second','bvalue first')\n"
       ]
      }
     ],
     "prompt_number": 3
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## `lambda` functions\n",
      "\n",
      "Python provides a special form of defining functions that consist of nothing more than a single\n",
      "expression using the `lambda` keyword:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "lambda_adder = lambda a,b: a+b\n",
      "lambda_adder(1, 2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 4,
       "text": [
        "3"
       ]
      }
     ],
     "prompt_number": 4
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Note the fact that `lambda` returns the function object itself. This form is often used\n",
      "when a function needs to be passed as an argument to another function, as in a callback. Also\n",
      "note the fact that the `return` statement is implicit.\n",
      "\n",
      "The equivalent function defined with `def` would be the following"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def lambda_adder_equiv(a,b):\n",
      "    return a+b\n",
      "lambda_adder_equiv(1,2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 5,
       "text": [
        "3"
       ]
      }
     ],
     "prompt_number": 5
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Default arguments\n",
      "\n",
      "You can define a function with default argument values. If a value is not passed for an argument\n",
      "with a default value, the default will be used instead:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def myfunction3(a, b='default value'):\n",
      "    print 'Called myfunction3(%r,%r)' % (a,b)\n",
      "myfunction3('avalue')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Called myfunction3('avalue','default value')\n"
       ]
      }
     ],
     "prompt_number": 11
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "You can, of course, override the default:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "myfunction3('avalue', 'bvalue')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Called myfunction3('avalue','bvalue')\n"
       ]
      }
     ],
     "prompt_number": 12
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# DON'T DO THIS\n",
      "def append_to_list(x, lst=[]):\n",
      "    lst.append(x)\n",
      "    return lst\n",
      "\n",
      "lst1 = append_to_list(5)\n",
      "append_to_list(6, lst1)\n",
      "print lst1\n",
      "del lst1\n",
      "\n",
      "lst2 = append_to_list(3)\n",
      "print lst2"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[5, 6]\n",
        "[5, 6, 3]\n"
       ]
      }
     ],
     "prompt_number": 19
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Variable arguments\n",
      "\n",
      "We can define a function that takes any number of arguments using the `*args` syntax. The\n",
      "value of the `args` parameter below is any *positional* arguments that remain after \n",
      "accounting for other arguments:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def va_adder(prompt, *args):\n",
      "    print 'Called va_adder(%r, *%r)' % (prompt, args)\n",
      "    return sum(args)\n",
      "va_adder('ThePrompt>', 1,2,3)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Called va_adder('ThePrompt>', *(1, 2, 3))\n"
       ]
      },
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 20,
       "text": [
        "6"
       ]
      }
     ],
     "prompt_number": 20
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Likewise, we can call a function with a `tuple` of arguments using a similar syntax:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def normal_function(a,b):\n",
      "    print 'Called normal_function(%r, %r)' % (a,b)\n",
      "argument_tuple = ('avalue', 'bvalue')\n",
      "normal_function(*argument_tuple)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Called normal_function('avalue', 'bvalue')\n"
       ]
      }
     ],
     "prompt_number": 21
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "If you want to define a function with variable *keyword* arguments, you can do that as well\n",
      "with the `**kwargs` syntax. In this case, the keyword arguments are passed as a `dict`:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def kw_function(**kwargs):\n",
      "    print kwargs\n",
      "kw_function(a='avalue', b='bvalue')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "{'a': 'avalue', 'b': 'bvalue'}\n"
       ]
      }
     ],
     "prompt_number": 22
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Of course, we can also pass a dictionary as the keyword arguments of a function:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "arguments = { 'a': 'avalue', 'b': 'bvalue' }\n",
      "normal_function(**arguments)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Called normal_function('avalue', 'bvalue')\n"
       ]
      }
     ],
     "prompt_number": 23
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Exercise\n",
      "\n",
      "Write a function with the signature `def log(format, *args, **kwargs):` which prints a \n",
      "line, formatted according to the format string. Some sample results are below:\n",
      "\n",
      "    >>> log('The pair is (%r,%r)', 1, 2)\n",
      "    The pair is (1,2)\n",
      "    >>> log('The value of a is %(a)r', a='foo')\n",
      "    The value of a is 'foo'"
     ]
    }
   ],
   "metadata": {}
  }
 ]
}