Update 017_Functions.ipynb

Author: profLewis

notebooks/017_Functions.ipynb

@@ -1618,14 +1618,16 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## `lambda` functions\n",
+    "## `map()` functions\n",
+    "\n",
+    "In Python, the `map()` function is a special function that allows you to apply some function to all the items in a list or similar *iterable* without using an explicit loop. \n",
     "\n",
-    "Sometimes the function we want to write is very simple, and might consist of only a few statements on a single line. As an example, consider the function `y(x)` here:"
+    "As an example, consider the function `y(x)` here:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 30,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1634,24 +1636,107 @@
     "    a function y(x) with\n",
     "    zeros at x=4,x=3\n",
     "    '''\n",
-    "    return 2.0*(x-3)*(x-4)"
+    "    return 2*(x-3)*(x-4)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Whilst it is fine to write a function in this way, and it has the advantage of being quite explicit about what it is doing, it is not very efficient: there is a computational cost to calling a function, especially in a high-level language like Python. \n",
+    "Now, suppose we want to apply that function to each item in a list. We could do this quite neatly with a list comprehension:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[12, -0.0, 24]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# some values in an array -- some are float \n",
+    "# some are int\n",
+    "xvals = [1, 3.0, 7]\n",
     "\n",
-    "If we were only ever going to use this function in places in the code where performance is unimportant, then we can go ahead with the above.\n",
+    "result = [y(x) for x in xvals]\n",
+    "print(result)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Or, as we shall see later in the course, we could do this also more directly in numpy arrays if the data type is the same for every item in the list/array. \n",
     "\n",
-    "If we are worried that it might be used in a case when we would not want to slow it down unnecessarily with as function call, we can use a special type of function, called a [`lambda` function](https://www.w3schools.com/python/python_lambda.asp). The syntax is:\n",
+    "Another approach to this is to use a [`map()`](https://realpython.com/python-map-function/) function, which has syntax `map(function,iterable1[,iterable12,...])`, whereby `function(iterable1)` is applied to each iten in turn in `iterable1` (then `iterable12` ...). This can be very efficient as it does not have all of the memory overheads associated with an explicit loop. It is also a very compact way of coding.\n",
+    "\n",
+    "For example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[12, -0.0, 24]"
+      ]
+     },
+     "execution_count": 32,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "xvals = [1, 3.0, 7]\n",
+    "\n",
+    "result = map(y,xvals)\n",
+    "list(result)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## `lambda` functions\n",
+    "\n",
+    "A lambda function is a special function definition that has a lower overhead than a *full* function definition.\n",
+    "\n",
+    "The syntax is:\n",
+    "\n",
+    "        function_name = lambda args : function_code\n",
+    "\n",
+    "where `function_name` is the name of the function, `args` is a list of arguments, and `function_code` here represents the (short!) code inside the function."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "A function that is often used alongside the `map()` operation, is `reduce()`. This is another operation on an iterable, but this time it has just a single output that is the reduction of the iterable. It has syntax `reduce(function,iterable,initializer=None)`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "\n",
+    "In such a case, we might consider using a [`lambda` function](https://www.w3schools.com/python/python_lambda.asp). The syntax is:\n",
     "\n",
     "        function_name = lambda args : function_code\n",
     "\n",
     "where `function_name` is the name of the function, `args` is a list of arguments, and `function_code` here represents the (short!) code inside the function.\n",
     "\n",
-    "Our example above translates to:"
+    "Our example for `y(x)` above translates to:"
    ]
   },
   {
@@ -1667,14 +1752,109 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "which is a much *neater* and more efficient code than a full function. Use these when appropriate.\n",
+    "although [PEP008](https://www.python.org/dev/peps/pep-0008/) suggests that you don't use it in that way. \n",
     "\n",
-    "Generally, you are not expected to use a docstring with a `lambda` function, as it should be a simple statement that is self-evident from the code. If you do feel the need, you can add one with:\n",
+    "Suppose though that we wanted to apply this function to each item in a list, e.g. in a `map()` function. The function is so small and simple that we don't really need to define a full *named* function for this in our code.\n",
     "\n",
-    "        y.__doc__ = '''\n",
-    "        a function y(x) with\n",
-    "        zeros at x=4,x=3\n",
-    "        '''\n"
+    "We could instead use:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[12.0, -0.0, 24.0]"
+      ]
+     },
+     "execution_count": 34,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "xvals = [1, 3.0, 7]\n",
+    "\n",
+    "result = map(lambda x : 2.0*(x-3)*(x-4),xvals)\n",
+    "list(result)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "which is simpler, more efficient, and clearer code to achieve this task."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## `reduce()` functions\n",
+    "\n",
+    "A `reduce` function is a special type of function that is often used alongside the `map()` function, particularly within the context of processing environments such as [Google Earth Engine](https://developers.google.com/earth-engine/guides/reducers_intro). Like `map()`, it is an efficient coding method that is applied to each item in an iterable. But unlike `map()`, information is passed in pairs. The first time a function is called within `reduce`, the function receives the first item from the iterator and an `initializer` value if given. If not given, it receives teh first two values. It then calculates the result of this function (with these two inputs). The function is then called with the next item from the iterator and that first result, and so on. At the end of the iterators, the final function output is returned.\n",
+    "\n",
+    "To illustrate this:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "I am adding 1 and 3.0\n",
+      "I am adding 4.0 and 7\n",
+      "final value: 11.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "from functools import reduce\n",
+    "# import the reduce function\n",
+    "\n",
+    "# define a function of 2 variables, a & b\n",
+    "def my_add(a,b):\n",
+    "    print(f'I am adding {a} and {b}')\n",
+    "    return a + b\n",
+    "\n",
+    "xvals = [1, 3.0, 7]\n",
+    "\n",
+    "print(f'final value: {reduce(my_add, xvals)}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Dropping the `print` this is neater using a `lambda` function:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "final value: 11.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "from functools import reduce\n",
+    "\n",
+    "xvals = [1, 3.0, 7]\n",
+    "\n",
+    "print(f'final value: {reduce(lambda a,b:a+b, xvals)}')"
    ]
   },
   {
@@ -1713,7 +1893,37 @@
     "\n",
     "\n",
     "* Test this function, inputting a list of integers from 0 to 4 inclusive\n",
-    "* Write a more Pythonic version of this, making use of list comprehensions and `lambda` functions"
+    "* Write a more Pythonic version of this, making use of list comprehensions, `map`, `reduce` or `lambda` functions as appropriate."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {
+    "solution2": "hidden"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2**[1, 2, 3, 4] = [2, 4, 8, 16]\n",
+      "2**[1, 2, 3, 4] = [2, 4, 8, 16]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# ANSWER\n",
+    "\n",
+    "# probably a map function is most appropriate here\n",
+    "# with a lambda function to define the 2**x\n",
+    "\n",
+    "ilist = [1,2,3,4]\n",
+    "\n",
+    "print(f'2**{ilist} = {list(map(lambda x: 2**x,ilist))}')\n",
+    "\n",
+    "## but a list comprehension would do very well too\n",
+    "print(f'2**{ilist} = {[2**x for x in ilist]}')"
    ]
   },
   {
@@ -1929,7 +2139,9 @@
     "\n",
     "We have also seen `lambda` functions, used for short functions:\n",
     "\n",
-    "        function_name = lambda args : function_code\n"
+    "        function_name = lambda args : function_code\n",
+    "\n",
+    "We also learned about `map()`, `reduce()` and `lambda` functions."
    ]
   },
   {