about_list_expressions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Computational Physics \n",
    "\n",
    "\n",
    "## More about Python : Functions and Classes\n",
    "\n",
    "\n",
    "#### *J.A. Hernando Morata*, in collaboration wtih *G. Martínez-Lema*, *M. Kekic*.\n",
    "####  USC, October 2020 \n",
    "\n",
    "\n",
    "\n",
    "## List Expressions and Generators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Last revision  Fri Oct  7 19:19:53 2022\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "print(' Last revision ', time.asctime())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 1. Introduction\n",
    "\n",
    "**Functional Programming**, FP, is a computing paradigm that defines a program as a flow of functions evaluated in (in general) a serie. See [FP in Python](https://docs.python.org/2/howto/functional.html)\n",
    "\n",
    "Each function takes an input and produces an output, it has no side effect, it always produces the same output for the same input. \n",
    "\n",
    "Data has no evolving states. It does not change along the program. Data just flows between functions.\n",
    "\n",
    "The FP code is modular, reusable, and safe. \n",
    "\n",
    "Functions are small pieces of code, they can be re-arranged to create a new program and they are easy to check.\n",
    "\n",
    "Functions must be tested. Create tests for each function. In fact, the tests *define* the function.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Python nicely supports functional programming, via mostly the **list expressions**, **iterators**, **generators** and a large functionality for **functions**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 2. Some useful utilities\n",
    "\n",
    "###  2.1 *zip* \n",
    "\n",
    "The *zip()* builtin function generates an iterable from several iterables of the same length. \n",
    "\n",
    "This is an expample of how to use *zip()*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2]\n",
      "[3, 4, 5]\n",
      "[(0, 3), (1, 4), (2, 5)]\n",
      " xi, yi  0 3\n",
      " xi, yi  1 4\n",
      " xi, yi  2 5\n"
     ]
    }
   ],
   "source": [
    "xs  = list(range(0, 3))\n",
    "ys  = list(range(3, 6))\n",
    "xys = list(zip(xs, ys))\n",
    "print(xs)\n",
    "print(ys)\n",
    "print(xys)\n",
    "\n",
    "for xi, yi in zip(xs, ys):\n",
    "    print(' xi, yi ', xi, yi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "### 2.2 *enumerate*\n",
    "\n",
    "Another important iterator is generated by the *enumerate()* builtin function. *enumerate()* takes an iterable and returns and iterator with two elements: the index position of the item and the item itself in the iterable.\n",
    "\n",
    "This is particulary useful when inside a loop one needs access to both, the index position of the item in the list and the item.\n",
    "\n",
    "Let's see the example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "item [ 0 ] =  a\n",
      "item [ 1 ] =  b\n",
      "item [ 2 ] =  c\n",
      "item [ 3 ] =  d\n"
     ]
    }
   ],
   "source": [
    "xs = ['a', 'b', 'c', 'd']\n",
    "\n",
    "for i, xi in enumerate(xs):\n",
    "    print('item [', i, '] = ', xi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "------------\n",
    "\n",
    "### Exercises\n",
    "\n",
    "\n",
    "  1. Implement a function that takes two tuples with names and phone numbers, and return a unique tuple with (name, phone number), use the *zip* function. Return now a dictionary\n",
    "  \n",
    "  \n",
    "  2. Implement a function that takes a tuple with items and using *enumerate*, return the largest item in a list and its position inside the list.\n",
    "  \n",
    "  3. Define the tests for a function that add two numbers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "## 3. List expressions\n",
    "\n",
    "List expressions are expressions (predicates) applied to the items of an iterable (a list). They can operate on the items of the list, reduce or filter them.\n",
    "\n",
    "List expressions are the key ingredients in Functional Programming.\n",
    "\n",
    "The syntax:\n",
    "\n",
    "  * *[predicate(item) for item in iteratable]* \n",
    " \n",
    "  * *[item for item in iterable if condition(item)]* \n",
    "\n",
    "List expressions are a elegant version of *map* and *filter* built-in functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "list  [0, 1, 2, 3, 4, 5]\n",
      "x2  [0, 1, 4, 9, 16, 25]\n",
      "x2  [0, 1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "xs = list(range(6))\n",
    "print('list ', xs)\n",
    "\n",
    "# compute the square of the items on the list\n",
    "x2as = list(map(lambda xi: xi * xi, xs))\n",
    "print('x2 ', x2as)\n",
    "\n",
    "# the same!\n",
    "x2bs = [xi * xi for xi in xs]\n",
    "print('x2 ', x2bs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "initial list  [0, 1, 2, 3, 4, 5]\n",
      "evens  [0, 2, 4]\n",
      "evens  [0, 2, 4]\n"
     ]
    }
   ],
   "source": [
    "print('initial list ', xs)\n",
    "\n",
    "# filter the even numbers on the list\n",
    "xevens = list(filter(lambda xi: xi % 2 == 0, xs))\n",
    "print('evens ', xevens)\n",
    "\n",
    "# the same!\n",
    "xevens = [xi for xi in xs if xi % 2 == 0]\n",
    "print('evens ', xevens)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "list expressions can support several iterables. The general systax is:\n",
    "\n",
    "*[predicate(item1, item2, ...) for item1 in iterable1 for item2 in iterable2 ... ]*\n",
    "\n",
    "They can be combined:\n",
    "\n",
    "*[predicate(item1, item2, ... for item1 in iterable1 if condition(item1) for item2 in iterable2 if condition(item2) ...]*\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "xs  [0, 1, 2]\n",
      "ys  [3, 4, 5]\n",
      "xy!  [(0, 3), (0, 4), (0, 5), (1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5)]\n",
      "xys  [(0, 3), (0, 4), (0, 5), (1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5)]\n",
      "xy-even  [(0, 3), (0, 5), (2, 3), (2, 5)]\n",
      "the same : [(0, 3), (0, 5), (2, 3), (2, 5)]\n"
     ]
    }
   ],
   "source": [
    "xs = list(range(3))\n",
    "ys = list(range(3,6))\n",
    "print('xs ', xs)\n",
    "print('ys ', ys)\n",
    "\n",
    "xys = [(xi, yi) for xi in xs for yi in ys]\n",
    "print('xys ', xys)\n",
    "\n",
    "xyevens = [(xi, yi) for xi in xs if xi%2 == 0 for yi in ys if yi % 2 != 0]\n",
    "print('xy-even ', xyevens)\n",
    "\n",
    "xyevents = []\n",
    "for xi in xs:\n",
    "    if (xi % 2 == 0): \n",
    "        for yi in ys:\n",
    "            if (yi % 2 != 0):\n",
    "                xyevents.append( (xi, yi))\n",
    "print('the same :', xyevents)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "They can also support several iterables at the same time, providing that they have the same length. We can use the *zip()* builtin function to create an iterable.\n",
    "\n",
    "The general expression is:\n",
    "\n",
    "*[predicate(item1, item2) for item1, item2 in zip(iterable1, iterable2) if condition(item1, item2)]*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "xs  [0, 1, 2]\n",
      "ys  [3, 4, 5]\n",
      "xys  [3, 3]\n"
     ]
    }
   ],
   "source": [
    "xs = list(range(3))\n",
    "ys = list(range(3, 6))\n",
    "print('xs ', xs)\n",
    "print('ys ', ys)\n",
    "\n",
    "#xys = [(yi-xi) for xi, yi in zip(xs, ys)]\n",
    "#print('xys ', xys)\n",
    "xys = [yi - xi for xi, yi in zip(xs, ys) if xi%2 == 0]\n",
    "print('xys ', xys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Another possibility is combine *map()* that accepts several iterables, and get use of the *lambda* command."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "xs = [0, 1, 2]\n",
      "ys = [3, 4, 5]\n",
      "xys = [3, 5, 7]\n"
     ]
    }
   ],
   "source": [
    "xs = list(range(3))\n",
    "ys = list(range(3, 6))\n",
    "print('xs =', xs)\n",
    "print('ys =', ys)\n",
    "\n",
    "xys = list(map(lambda xi, yi: yi + xi, xs, ys))\n",
    "print('xys =', xys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "### 3.2 Ordering a list\n",
    "\n",
    "The *sorted()* builtin function allow us to sort a list. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original  [8, 10, 9, 5, 3, 1]\n",
      "ordered  [1, 3, 5, 8, 9, 10]\n",
      "primera lista  [8, 10, 9, 5, 3, 1]\n"
     ]
    }
   ],
   "source": [
    "xs = [8, 10, 9, 5, 3, 1]\n",
    "print('original ', xs)\n",
    "\n",
    "oxs = sorted(xs, reverse = False)\n",
    "print ('ordered ', oxs)\n",
    "print ('primera lista ', xs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "*sorted()* accepts several arguments. We can reverse the ordering by setting the argument *reverse=True*.\n",
    "\n",
    "There is a third argument *key* that applies a function to the item to get a value that it will be used to order the items.\n",
    "\n",
    "You can use comparison functions to order the list.\n",
    "\n",
    "Let's see some examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original list [0, 1, 2, 3, 4]\n",
      "inverse ordering  [4, 3, 2, 1, 0]\n"
     ]
    }
   ],
   "source": [
    "xs = list(range(5))\n",
    "print('original list', xs)\n",
    "\n",
    "# reverse ordering\n",
    "ixs = sorted(xs, reverse = True)\n",
    "print('inverse ordering ', ixs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "initial list  [0, 1, 2, 3, 4]\n",
      "ordered respect 2 [1, 0, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "# using a function to get the value in which the ordering will be performed\n",
    "def dis2(x, x0 = 1.):\n",
    "    \"\"\" return the absolute distance of x with respect x0\n",
    "    \"\"\"\n",
    "    return abs(x-x0)\n",
    "\n",
    "x2s = sorted(xs, key = dis2)\n",
    "print ('initial list ', xs)\n",
    "print ('ordered respect 2', x2s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "from functools import cmp_to_key\n",
    "\n",
    "# using a function to compare two items\n",
    "def comp3(x, y, x0 = 0):\n",
    "    \"\"\" orden the items as they are close to x0\n",
    "    \"\"\"\n",
    "    if abs(x - x0) <  abs(y - x0):\n",
    "        return -1\n",
    "    if abs(x - x0) == abs(y - x0):\n",
    "        return 0\n",
    "    return 1\n",
    "\n",
    "x3s = sorted(ixs, key = cmp_to_key(comp3))\n",
    "print('original ', ixs)\n",
    "print('ordered  ', x3s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 3.3 List compressions\n",
    "\n",
    "There are some builtin functions that reduce a list to the sum of all items, *sum()*, the maximum, *max()* or the minimum, *min()*.\n",
    "\n",
    "In addition, if the list is of boolean, you can apply *any()* that returns *True* is one item in the list is *True* and *all()* that returns *True* if all items are *True*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "xsi =  [9, 8, 7, 6, 5, 4, 3, 2, 1]\n",
      "sum(xs) =  45\n",
      "max(xs) =  9\n",
      "min(xs) =  1\n"
     ]
    }
   ],
   "source": [
    "xs  = list(range(1, 10))\n",
    "xsi = sorted(xs, reverse = True) \n",
    "print('xsi = ', xsi)\n",
    "\n",
    "print('sum(xs) = ', sum(xsi))\n",
    "print('max(xs) = ', max(xsi))\n",
    "print('min(xs) = ', min(xsi))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bs =  [1, 1, 0]\n",
      "any(bs) =  True\n",
      "all(bs) =  False\n"
     ]
    }
   ],
   "source": [
    "bs = [1, 1, 0]\n",
    "print ('bs = ', bs)\n",
    "print ('any(bs) = ', any(bs))\n",
    "print ('all(bs) = ', all(bs))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "xs =  [1, 2, 3, 4]\n",
      "list  =  [1, 2, 3, 4]\n",
      "product of all items in list = 24\n"
     ]
    }
   ],
   "source": [
    "from operator  import mul\n",
    "from functools import reduce\n",
    "\n",
    "xs = list(range(1, 5))\n",
    "print('xs = ', xs)\n",
    "\n",
    "p = reduce(mul, xs)\n",
    "print('list  = '                      , xs)\n",
    "print('product of all items in list =', p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Remember the function *create_polynomial*, we can re-write it now with list expressions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def create_polynomial(cas : tuple) -> callable :\n",
    "    \n",
    "    def pol(x : float) -> float:\n",
    "        ys = [ai * (x ** i) for i, ai in enumerate(cas)]\n",
    "        return sum(ys)\n",
    "\n",
    "    return pol"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7.0\n"
     ]
    }
   ],
   "source": [
    "cas = (1., +1., 1.)\n",
    "pol = create_polynomial(cas)\n",
    "x = 2\n",
    "print(pol(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "We can use list expression to write more elegant code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880]\n"
     ]
    }
   ],
   "source": [
    "def nfactorial(n):\n",
    "    \"\"\" returns n! = n*(n-1)*...*1\n",
    "    \"\"\"\n",
    "    if (n <= 1 ): \n",
    "        return 1\n",
    "    return n * nfactorial(n-1)   \n",
    " \n",
    "ns = [nfactorial(ni) for ni in range(10)]\n",
    "print(ns)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Exercises\n",
    "\n",
    "*Exercises*:\n",
    "  \n",
    "  1. Generate uniform random distributed numbers in the $[-L/2, L/2]$ interval, compute its mean and standard deviation.\n",
    " \n",
    "  2. Generate $n$ 2D points $(x, y)$ randomly with respect a 2D normal distribution (a gaussian with zero mean and sigma one).\n",
    "  \n",
    "    a) compute the distance of the points respect the origin.\n",
    "    \n",
    "    b) order the points by distance to the origin.\n",
    "    \n",
    "    c) select those points at a distance greater than 1 respect the origin and that they are in the first quadrant.\n",
    "    \n",
    " \n",
    "  3. Generate random $n$ 2D $(x, y)$ points in a $[-L, L]$ square. Order them respect the $y$ coordinate. \n",
    "  \n",
    "     a) Reorder them with the distance to $(L, L)$ vertex. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Bibliography\n",
    "\n",
    "  1. \"Structure and Iterpretation of Computer Programs\", H. Abelson, G. J. Sussman and J. Sussman. Mc Graw-Hill (1996)\n",
    "  2. Phython org (https://docs.python.org/2/howto/functional.html)"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "celltoolbar": "Slideshow",
  "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}