4_Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "function"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def foo():\n",
    "    \"\"\"Print 'bar'\"\"\"  # in this line is documentation string that will be seen in help\n",
    "    print('bar')\n",
    "\n",
    "type(foo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bar\n"
     ]
    }
   ],
   "source": [
    "foo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function foo in module __main__:\n",
      "\n",
      "foo()\n",
      "    Print 'bar'\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(foo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Different ways to call the same function, with the same arguments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2, 2, 2, 2)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def fun(argument, argument_with_default=1):\n",
    "    \"\"\"Add two arguments\"\"\"\n",
    "    return argument + argument_with_default\n",
    "\n",
    "fun(1), fun(argument=1), fun(1, 1), fun(argument=1, argument_with_default=1), fun(argument_with_default=1, argument=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Unknown number of parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "a :  1\n",
      "b :  b\n",
      "c :  None\n"
     ]
    }
   ],
   "source": [
    "def foo(*args, **kwargs):\n",
    "    for argument in args:\n",
    "        print(argument)\n",
    "    \n",
    "    for name in kwargs:\n",
    "        print(name, ': ', kwargs[name])\n",
    "        \n",
    "foo(1, 2, 3, 4, a=1, b='b', c=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Builtins\n",
    "\n",
    "There are some built-in functions, that may support your development process. These are:\n",
    "\n",
    "* `range` - which you already know\n",
    "* `sum`\n",
    "* `min`\n",
    "* `max`\n",
    "* `map` - transforms all elements in collection, but evaluates during access\n",
    "* `filter` - preserves only element which match some condition. Evaluated during access.\n",
    "* and many others"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(range(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min(range(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(range(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mapping 0\n",
      "0\n",
      "mapping 1\n",
      "1\n",
      "mapping 2\n",
      "2\n",
      "mapping 3\n",
      "0\n",
      "mapping 4\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "def some_mapping(value):\n",
    "    print('mapping', value)\n",
    "    return value % 3\n",
    "\n",
    "mapped = map(some_mapping, range(5))\n",
    "\n",
    "for element in mapped:\n",
    "    print(element)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "checking filter for 0\n",
      "checking filter for 1\n",
      "1\n",
      "checking filter for 2\n",
      "2\n",
      "checking filter for 3\n",
      "checking filter for 4\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "def some_condition(value):\n",
    "    print('checking filter for', value)\n",
    "    return value % 3 != 0\n",
    "\n",
    "filtered = filter(some_condition, range(5))\n",
    "\n",
    "for element in filtered:\n",
    "    print(element)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Partial application"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At times it is useful to fix a number of function arguments, looking from the left. Consider the following `add` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add(x, y):\n",
    "    print(\"Got x =\", x, \" and y =\", y)\n",
    "    return x + y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With partial application, one can create an `add_five` callable that takes one argument less. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Got x = 5  and y = 3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from functools import partial\n",
    "\n",
    "add_five = partial(add, 5)\n",
    "add_five(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is also possible to provide default values using keyword arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Got x = 3  and y = 5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add_five = partial(add, y=5)\n",
    "add_five(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Partial application turns out to be really useful e.g. when sorting or filtering, as those operations work on a single argument. Notice that the argument order of `map` and `filter` functions is deliberately chosen to support natural partial function application."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "def is_positive(x):\n",
    "    return x > 0\n",
    "\n",
    "positive_only = partial(filter, is_positive)\n",
    "\n",
    "for x in positive_only(range(-3, 4)):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise - FizzBuzz\n",
    "\n",
    "Extract processing of single element into a function and use `map`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}