about_functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "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",
    "## About functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Last revision  Thu Oct  6 19:25:42 2022\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "print(' Last revision ', time.asctime())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# general imports\n",
    "%matplotlib inline\n",
    "\n",
    "# the general imports\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "# possible styles: ggplot (simplicity), bmh (scientify data), \n",
    "matplotlib.style.use('ggplot')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 1. About functions\n",
    "\n",
    "In this notebook we revisit some notions about *functions*.\n",
    "\n",
    "A function in Python is encapsulated pieze of code that can take several arguments, performs several computations and returns a result. \n",
    "\n",
    "The next cell shows the definition of a function, named *fib*, that returns a list with the first *n* Fibonacci numbers. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def fib(n):\n",
    "    \"\"\" returns a list with the first n numbers of the Fibonacci serie\n",
    "    \"\"\"\n",
    "    ns = [0, 1]\n",
    "    \n",
    "    for i in range(2, n):\n",
    "        ns.append(ns[i-2] + ns[i-1])\n",
    "    \n",
    "    return ns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]\n"
     ]
    }
   ],
   "source": [
    "n      = 10\n",
    "values = fib(n)\n",
    "print(values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "A function have a name (interface), *fib*, a type, *function*, it can take *n*. arguments and it returns something (or none), in this case, *fib* returns a list with the *n* fist Fibonacci numbers. \n",
    "\n",
    "The expresions of the function are its body, they follow the definition of the function and they are indented. \n",
    "\n",
    "The variables defined in the body are local and are deleted when the function ends. In this sense, a function defines its own scope. \n",
    "\n",
    "In general functions should not change the values of the arguments inside the body. \n",
    "\n",
    "Some functions do not take arguments, or do return nothing. But they are expected to do something, produce some side efects, as printing or writting in a output, plots, etc. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 1.1 Recursivity\n",
    "\n",
    "Python supports recursivity. A function can call itself. Here is the example of the function, *nfactorial*, that computes the factorial of *n*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "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)        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 4! =  24\n"
     ]
    }
   ],
   "source": [
    "m = 4\n",
    "print(' ' + str(m) + '! = ', nfactorial(m))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 1.2 functions inside functions\n",
    "\n",
    "A funcion can be defined inside another function. The function is then local, and can only be used in the scope of the large function.\n",
    "\n",
    "In the following example, the *distance()* function is only defined and valid inside *closest_distance_to*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "def element_at_closest_distance_to(x0, xs):\n",
    "    \"\"\" return the element of the *xs* list that is closer to *x0*\n",
    "    \"\"\"\n",
    "    def distance(x0, xi):\n",
    "        return abs(x0 - xi)\n",
    "    \n",
    "    d, x = 1e16, 0\n",
    "    for xi in xs:\n",
    "        di = distance(x0, xi)\n",
    "        if (di < d): \n",
    "            d, x = di, xi\n",
    "    \n",
    "    return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " closest point to x0  6j  is : 1j\n"
     ]
    }
   ],
   "source": [
    "x0, xs = 6j, [0., 0.5, 1j, 20.]\n",
    "\n",
    "xi = element_at_closest_distance_to(x0, xs)\n",
    "\n",
    "print(' closest point to x0 ', x0, ' is :', xi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 1.3 functions and variables\n",
    "\n",
    "A function can be associated to a variable and be passed to another piece of code.\n",
    "\n",
    "In the folowing example *nf* is a variable, which value is the function *nfactorial*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "factorials  [1, 1, 2, 6, 24, 120]\n"
     ]
    }
   ],
   "source": [
    "ns = [] \n",
    "for ni in range(6):\n",
    "    ns.append( nfactorial(ni) )\n",
    "print('factorials ', ns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1, 2, 6, 24]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "function"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nf = nfactorial\n",
    "ns = []\n",
    "for ni in range(5):\n",
    "    ns.append( nf(ni) )\n",
    "print(ns)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 1.4 A function can return a function\n",
    "\n",
    "A function can return another function. This is called a **functor**.\n",
    "\n",
    "In the following example, we pass to a function, *create_polynomial*, a list of coefficients, $[a_0, a_1, \\dots, a_n]$, ant it returns the actual polynomial function, $p(x)$. When called it with an scalar $x$, it computes $p(x) = a_0 + a_1 \\, x + a_2 \\, x^2 + ... + a_n x^n = \\sum_{i=0}^n a_i \\, x^i$ \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def create_polynomial(coeficients):\n",
    "    \"\"\" returns a function that is a polinomial with the coeficients\n",
    "    given in the list coeficients\n",
    "    \"\"\"\n",
    "    def pol(x):\n",
    "        y = 0.\n",
    "        for i  in range(len(coeficients)):\n",
    "            y = y + coeficients[i] * (x**i)\n",
    "        return y\n",
    "    \n",
    "    return pol"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " pol is a :  <class 'function'>\n",
      " is pol callable  True\n",
      " pol(x0) with x0  2.0  =  7.0\n"
     ]
    }
   ],
   "source": [
    "# p1 is un polinomio p(x) = 1 - x + 2 x**2\n",
    "coeficients = (1., -1., 2.)\n",
    "x0          = 2.\n",
    "pol         = create_polynomial(coeficients)\n",
    "\n",
    "print(' pol is a : ', type(pol))\n",
    "print(' is pol callable ', callable(pol))\n",
    "print(' pol(x0) with x0 ', x0, ' = '  , pol(x0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYEAAAEJCAYAAAByupuRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAApo0lEQVR4nO3deXSV1b3G8e/vTUKAhISQg2CCyCCIYAQhYRKIQJgH44SKqCjVOpWKLa3T1V6pigVuWiwOqAUK1wmUoAiKMRJQHMIk4IBFqUiRISEkhCkk775/nJZrK2ACOWefc97fZy3Xag7kvM8mXXnOO+y9xRhjUEop5UmO7QBKKaXs0RJQSikP0xJQSikP0xJQSikP0xJQSikP0xJQSikPi7Yd4FTs2LHDdoQa8/l8FBUV2Y4RNF4bL+iYvSJcx5ySknLc1/VMQCmlPExLQCmlPExLQCmlPExLQCmlPExLQCmlPExLQCmlPExLQCmlPMwzJWA+X4+7dIHtGEopFVI8VALrMLnzMPuKbUdRSqmQ4ZkSkD6DwXUx779jO4pSSoUM75TAGWdC+wsxK5Zhqqpsx1FKqZDgmRIAcC4eAiVFsHG17ShKKRUSPFUCXJABDZNxC5baTqKUUiHBUyUgUVFI74Hw2TrMnp224yillHWeKgHAXwIimBVv246ilFLWea8EkpLhgq6Y99/BHD1qO45SSlnluRIAcPoOgfIyzJoPbEdRSimrPFkCtOsIZ6Rgli+xnUQppazyZAmI4yB9h8DXX2K2fWM7jlJKWePJEgCQHv2hTh09G1BKeZp3SyAuHul2MebjAszBcttxlFLKCs+WAIBcPAQqjmBW5duOopRSVni7BJq3htbtMMuXYlzXdhyllAo6T5cAgFw8FHb9A7741HYUpZQKOi2BLhdBg0Tc/MW2oyilVNBpCcTEIJmDYeNqXU9IKeU5ni8B+OeGM46jj4sqpTwnOlgHuuOOO6hbty6O4xAVFcXkyZMpLy8nJyeHPXv20LhxYyZMmEB8fHywIh0jScnIhT386wmNHI3E1g16BqWUsiFoJQDw0EMPkZCQcOzr3Nxc0tLSyM7OJjc3l9zcXMaMGRPMSMdIv+GY1e9jPl7uPzNQSikPsHo5qLCwkMzMTAAyMzMpLCy0F+ac8+Cslpj8NzHG2MuhlFJBFNQzgUceeQSAAQMGkJWVRWlpKUlJSQAkJSVRVlZ23O/Ly8sjLy8PgMmTJ+Pz+QKS79DIayib8SiJu76jzvmda/W9o6OjA5Y7FHltvKBj9opIG3PQSmDSpEk0atSI0tJSfv/735OSklLt783KyiIrK+vY10VFRYGIiGl/IcQ3oOTVeUQ1bV6r7+3z+QKWOxR5bbygY/aKcB3ziX7nBu1yUKNGjQBITEwkIyODLVu2kJiYSElJCQAlJSX/dr/ABqkT678f8OnH+rioUsoTglIChw8f5tChQ8f+94YNG2jevDnp6ekUFBQAUFBQQEZGRjDinJRkDvFvP/nem7ajKKVUwAXlclBpaSlTp04FoKqqil69etGpUydat25NTk4O+fn5+Hw+7r777mDEOSlp5EO6XIR5P8//uGjderYjKaVUwASlBJo0acKUKVN+9HqDBg148MEHgxGhRqT/CEzhSsyH+UjfYbbjKKVUwOiM4eNpdS60aIPJX6yriyqlIpqWwHGICNJ/BOz8B3y2znYcpZQKGC2BE5D0iyCxEW7eIttRlFIqYLQETkCiY5B+w+Dz9Zjtf7cdRymlAkJL4CQkc7B/M/q8121HUUqpgNASOAmJa4D06OffjL6sxHYcpZSqdVoCP0GyRkLlUczypbajKKVUrdMS+AnStBmkpfs3oz9aYTuOUsqDzIH9VE1/GLPt61p/by2BanAGXAL7SzEfLbcdRSnlQabgLdi4GpyoWn9vLYHqaHeBf6+Bdxbp5DGlVFCZo0cx+Yuh/YVIsxa1/v5aAtUgIsjAS+H772DTGttxlFIeYj4pgNISnEHZAXl/LYFqkvRekOTDXZZrO4pSyiOMMZhludCsBZzXKSDH0BKoJomO9i8lsXkj5tvavzmjlFI/8tla2LENGZCNiATkEFoCNSC9B0Ldev5mVkqpAHOX5ULDRkjX3gE7hpZADUj9OKTPIMzqlZjiPbbjKKUimNn2DXzxKdJvBBIdE7DjaAnUkPQf4d95TJeSUEoFkHl7IcTWQ/oMCuhxtARqSBo1RjL6YFa+jTlQbjuOUioCmaJdmNUrkT4Dkbj4gB5LS+AUyKBL4chhzPIltqMopSKQyXsdRJCsSwJ+LC2BUyDNWsD5XTDvvoGpOGI7jlIqgpjyMszKZUjXTKSRL+DH0xI4Rc7gy/xLSXz4nu0oSqkIYpYvgYoj/isOQaAlcKranu/fh3jZQoxbZTuNUioCmIojmHcXQ1o6knp2UI6pJXCKRMR/NrD7e1j3ke04SqkIYD54F8rL/L9bgkRL4HRc2B3OSMFdsgBjjO00SqkwZqqqMG+/Bq3bQZsOQTuulsBpECcKGXwZbPsaPl9vO45SKoyZwhVQvBtnyBUBWyLieLQETpN07wsNG+EuXWA7ilIqTBnXxSx9FVKaQ1p6UI+tJXCaJCYGGZDtX1ju6y9tx1FKhaONq/0LxQ25HHGC+2s5qEdzXZff/OY3TJ48GYDy8nImTZrE+PHjmTRpEuXl4TkDV/oMgrgGejaglKoxY4z/d0fyGUhGn6AfP6glsGTJElJTU499nZubS1paGtOnTyctLY3c3Nxgxqk1Urce0m8YfPoJ5h/f2o6jlAonX30GX3+JDLoMiar97SN/StBKoLi4mLVr19K/f/9jrxUWFpKZmQlAZmYmhYWFwYpT66TfcIiti9GzAaVUDbhL5kODROSi/j/9lwMgaCUwe/ZsxowZ8293vUtLS0lKSgIgKSmJsrKyYMWpdRKfgGQOxnyyErP7e9txlFJhwGz9Cj5fhwzMRurEWskQHYyDrFmzhsTERFq1asVnn31W4+/Py8sjLy8PgMmTJ+PzBX49jVNRddVNFL23hNj3FpNwx73/9mfR0dEhmzsQvDZe0DF7RW2Oed/MP1AR3wDf5WNw6sXVynvWVFBKYPPmzaxevZp169ZRUVHBoUOHmD59OomJiZSUlJCUlERJSQkJCQnH/f6srCyysrKOfV1UVBSM2KdELsri0HtLOTIgG2nU+NjrPp8vpHPXNq+NF3TMXlFbYzbbt+IWvo+MuIa9Bw7BgUO1kO7EUlJSjvt6UC4HjR49mqeffpoZM2Zw1113cf755zN+/HjS09MpKCgAoKCggIyMjGDECSgZfBlg/BtCKKXUCZglC6BuPaT/cKs5rM4TyM7OZsOGDYwfP54NGzaQnZ1tM06tkOQzkO59MSuXYcpKbMdRSoUgs3M7ZvX7yMVDkbgGVrME5XLQD3Xo0IEOHfzrYjRo0IAHH3ww2BECToZcgVmVj1mWi1xxo+04SqkQY5YsgOgYZMBI21F0xnAgSJMUJKM35r0lmP2ltuMopUKI2f095uPlSOZgJCHJdhwtgUCR4aPgaAXmnVzbUZRSIcQsmQ9OFDIoeMtFn4yWQIDImWch6b0w+Usw5eE7/0EpVXvMnp2Yj95D+gxCGjayHQfQEggoGXYVVBzGvPO67ShKqRBgli7wbyA/+HLbUY7REgggSW2OdO6JyX8DV88GlPI0U7wbs+pdpNdAJCnZdpxjtAQCTIZfBYcPcfCNV2xHUUpZZJYsAAQZEjpnAaAlEHDSrAV07snBxS9jDuy3HUcpZYEp3o35IA/plfVvKwmEAi2BIHBGXI05eACzbJHtKEopC8ybr4CADB1lO8qPaAkEgTRrQexF/THvvqFPCinlMWbPTv+9gN6DkEaht9ielkCQxF91k/9JoWW6ppBSXuI/C3CQoVfYjnJcWgJBEn1WSySjDyb/TZ1FrJRHmN07MB/m+2cHNwydJ4J+SEsgiGTEVVBRgXnrNdtRlFJBYBa/DFHRITUv4D9pCQSRNG2GdMvELH8Ts2+v7ThKqQAy33+H+agA6Ts0ZGYHH4+WQJDJyGugqgqzROcNKBXJzKIXoE5sSJ8FgJZA0EnjpshFAzArlmGKdtmOo5QKALPta8yaD5CsEUiDRNtxTkpLwAIZNgpEMItfsh1FKRUA7qIXoH4cMjDbdpSfpCVggTTyIRcPxax6D7Nzu+04SqlaZL7+EjYUIoMuQ+rH247zk7QELJEhl0OdOpjXX7QdRSlVS4wxuLnzoEEi0n+E7TjVoiVgiSQ0RPqPxBSuxGz72nYcpVRt+GI9fLkBGXolElvXdppq0RKwSAZdCnENcBfOtR1FKXWajOvivjYXks9AMofYjlNtWgIWSf04/1TyTWsxmzfajqOUOh1rV8G3W5CRo5GYGNtpqk1LwDK5eCgk+XBfnYMxxnYcpdQpMJWVuAvnQUpzpHum7Tg1oiVgmdSJRUZcDVu/gvUf246jlDoFZtW7sHsHzqXXIU6U7Tg1oiUQAqRnf2jaDHfhXExVle04SqkaMEeOYN54EVq3g45dbcepMS2BECBRUTiXXgfff4f5IM92HKVUDZi8RbBvL87lYxER23FqTEsgVFzYHVq3w7z+IubIYdtplFLVYPaXYt56FTp1Q9q0tx3nlGgJhAgRwbniRijdi3lHt6FUKhyYN1+BiiM4l91gO8opiw7GQSoqKnjooYeorKykqqqK7t27M2rUKMrLy8nJyWHPnj00btyYCRMmEB8f+tOsA0XOOQ8u7I556zVMn0FIQkPbkZRSJ2B278AsX4L0GoCc2cx2nFMWlDOBmJgYHnroIaZMmcIf/vAH1q9fz1dffUVubi5paWlMnz6dtLQ0cnNzgxEnpDmXXQ9Hj+jickqFOLNwnn/DmBHX2I5yWoJSAiJC3br+KdRVVVVUVVUhIhQWFpKZ6X+mNjMzk8LCwmDECWnStBnSZxCm4C1dXE6pEGW+/hKz+n1kYHZIbxhTHUG5HATgui6//e1v2blzJ4MGDaJNmzaUlpaSlJQEQFJSEmVlZcf93ry8PPLy/E/NTJ48GZ/PF6zYtSY6Orraud0b7qDo4wJiXn+Bhvf9IcDJAqMm440UOmZviIqKIuq1OZCUTPLom3Hq1bcd6bQErQQcx2HKlCkcOHCAqVOnsm3btmp/b1ZWFllZWce+LioqCkTEgPL5fDXLPeQKjrz2V/a8n4+0uyBwwQKkxuONADpmb4jf/ClHv/oMuf5O9h44CAcO2o5ULSkpKcd9PehPB8XFxdG+fXvWr19PYmIiJSUlAJSUlJCQkBDsOCFLskZCo8a4rzyPcXUCmVKhwBytoHzuU9CsBXJRf9txakVQSqCsrIwDBw4A/ieFNm7cSGpqKunp6RQUFABQUFBARkZGMOKEBYmpg1x2PXy3FfPhcttxlFKAyV9M1a4dOFfeFHbLQ5xItS8HzZkzh8zMTFq0aFHjg5SUlDBjxgxc18UYQ48ePejSpQtt27YlJyeH/Px8fD4fd999d43fO5JJ1z6Yd9/A5M7FdOmJ1K1nO5JSnmX2l2LenE+dLj2oat/JdpxaI6aaS1f+5S9/4cMPPyQhIYHevXvTu3dvkpOTA53vuHbs2GHluKfjVK+dmi1f4D7+W2TYKJzsMQFIFhhevFasY45s7twnMe8vI/mP89hXL/zmM53onkC1zwRuuukmxo4dy7p161i5ciWvvfYabdq0oU+fPnTr1u3YI6Cqdsk55/nPCJblYnoPRJLPsB1JKc8x323FrFyG9BtG9FktIIKKr0b3BBzHoUuXLtx111088sgjlJWV8eSTT3LzzTfz9NNPs3fv3kDl9DS5/AYQMAtm246ilOcYY3Bffg7i4sJ+Ytjx1OgR0YMHD/LRRx+xcuVKvv32W7p168a4cePw+XwsXryYRx99lKlTpwYqq2dJo8bIoMsxb7yI6TsUaXu+7UhKece6D2HzRmT0rUhc+F0G+inVLoFp06bx6aefct555zFgwAAyMjKI+cEWatdffz1jx44NREYFyKDLMB+8g/vyczj3T4uYJxOUCmXmaAXu/FmQejbSZ5DtOAFR7RJo06YN48aNo2HDhsf9c8dxePbZZ2srl/oPEhuLXD4W8+xUzPvvIH0G246kVMQzby+Eol04d09CoiLzg1e17wmMHDnyhAXwL7GxsaebR52EZPSGth0wC+diDuy3HUepiGaK92CWzocuPZHzOtqOEzC6n0AYERGca26BAwcwuf9rO45SEc2d/zwAzpXjLCcJLC2BMCPNWiJ9h/pXGd32je04SkUk88WnsGYVMuRKJLmx7TgBpSUQhmTkaIiLx33xGao5108pVU2mshL3xZnQuCky6FLbcQJOSyAMSVy8f12hLV9gPnzPdhylIop59w34/jucq36GxNSxHSfgtATClFyUBa3OxSyYhTlQbjuOUhHB7N2DeeNF6NgV6djVdpyg0BIIU+I4ONfeBuX7MbnzbMdRKiK4Lz8PxsW5+mbbUYJGSyCMSfNWSL9hmIKlmL//zXYcpcKa2bQG1q5Cho5CfE1sxwkaLYEwJyNHQ0JD3HlP6eYzSp0ic7QC94VnoEkqMjDybwb/kJZAmJP6cciVN8G3WzDLl9qOo1RYMkvmw56dOKN/jvxgORwv0BKIANK1D7S/0D+TuKTYdhylworZsQ2z9FWk+8VIBG0WU11aAhFARHCuvRWqqnBfmmk7jlJhw7gu7twnoW49/xm1B2kJRAg540xkxNWw9kPM+o9tx1EqLJgP8mDL58gVY5GEhrbjWKElEEFkQDakno37wjOYwwdtx1EqpJmyff6Nmtp28M+78SgtgQgi0dE4190B+4oxC3XugFInY156FioO44y5HRGxHccaLYEII63bIX2HYd57E7PlC9txlApJZv3HmMKVyLCrkDPPsh3HKi2BCCSXXgdJPtw5T2COVtiOo1RIMQcP4P7vU/7dwgZfZjuOdVoCEUjq1sO57nbYuR3z5iu24ygVUsyrc6B0H84N45Fob80JOB4tgQgl53dBuvfFvPUqZvtW23GUCglm80bMireQASORlm1sxwkJWgIRTK4aB/XjcWf9CVNZaTuOUlaZI4dxZ0/37xMw8lrbcUKGlkAEk/gEnDG3wbZvMG8tsB1HKavMq3OgeDfO2F8iuh/6MVoCEU4690QyemMWv6KXhZRnmc2bMO+9ifQbjrTtYDtOSIkOxkGKioqYMWMG+/btQ0TIyspi6NChlJeXk5OTw549e2jcuDETJkwgPj4+GJE8Ra75OebLDbiz/oRz71QkOig/dqVCgjlyGHfOPy8DXXq97TghJyhnAlFRUVx33XXk5OTwyCOP8Pbbb7N9+3Zyc3NJS0tj+vTppKWlkZubG4w4niMNEnDG3O6/LLREnxZS3mIWzIaiXXoZ6ASCUgJJSUm0atUKgHr16pGamsrevXspLCwkMzMTgMzMTAoLC4MRx5Okcw+k+8WYN1/RDWiUZ5hNazHLlyADLtHLQCcQ9OsCu3fvZuvWrZxzzjmUlpaSlJQE+IuirKzsuN+Tl5dHXl4eAJMnT8bn8wUtb22Jjo62ntu9816Kf/k5Mns6ydNmB/RTUSiMN9h0zKHF3V9G8dw/E3VWS5LH/RKpUzv/fw/lMZ+KoJbA4cOHmTZtGmPHjqV+/frV/r6srCyysv5/gaeioqJAxAson88XGrmvv5OqnAfZ8+z/BHQf1ZAZbxDpmEOL++xUTGkJzu33U1y2H9hfK+8bymM+mZSUlOO+HrSngyorK5k2bRq9e/emW7duACQmJlJSUgJASUkJCQkJwYrjWdK+E9JvOObdNzBffGo7jlIB4RauxHyyAhl+NXJ2a9txQlpQSsAYw9NPP01qairDhw8/9np6ejoFBQUAFBQUkJGREYw4nieX3QBNU3H/8kdM+fEvwSkVrkzxHsy8J6FlW2TIFbbjhLyglMDmzZtZsWIFmzZtYuLEiUycOJG1a9eSnZ3Nhg0bGD9+PBs2bCA7OzsYcTxPYmNxfvZr2F+KO/dJjDG2IylVK4xbhfuXHKhycX72KyQqynakkBeUewLt2rXjlVeO/2jigw8+GIwI6j/I2a2RS8dgFszGfJCH9BpgO5JSp828vRC+2oTc+EvkjDNtxwkLOmPYw2RANrS7APPSs5hdO2zHUeq0mL//DbPof5H0XkiPfrbjhA0tAQ8Tx8G5aQJEx+DOnII5etR2JKVOiTl0EHfmFEhIQjy+U1hNaQl4nCQl44wdD9u+xrw2x3YcpWrMGOO/EVy8G+fmXyNxuvRMTWgJKKRTN6T/CEze65j1H9uOo1SNmA/y/I+DjhyNtGlvO07Y0RJQAMjlY6F5a9zZ0zF799iOo1S1mO+/w7z4DLS7ABlyue04YUlLQAEgMTE4t0yEykr//QHdhEaFOHPkMO7Tj0NsPZxxdyOOPg56KrQE1DHSJAW5/g74+kvMwr/ajqPUCfnvAzwF33/nnw/QsJHtSGFLS0D9G6drH6TvUMyyXMzaVbbjKHVcZuUyzEfvISOuQdp3sh0nrGkJqB+RK8dBizb++wO7df6ACi3m268xL86E9hciw0bZjhP2tATUj0hMDM6tvwVxcJ96HHPkiO1ISgFgDuzHfXoyxCfg/OxuxNFfYadL/wXVcUnyGTg3/wr+8XfMX/+s6wsp64xbhTtzKuwrxrntHqRBou1IEUFLQJ2QnN8FueRazCcFmHdftx1HeZxZ9AJ8vg655udIq3Ntx4kYWgLqpGTIFdCpO2b+LMzmTbbjKI8yaz/ELJmP9B6I02eQ7TgRRUtAnZR/faG74IwU3GcexxTvth1JeYzZ/nf/8tAt2yLX/Nx2nIijJaB+ktSrj3PH/f6JZH/+PebwIduRlEeY/WW4f/491K2Pc9u9SEyM7UgRR0tAVYs0TcX5+W/gH9tw/5KDcV3bkVSEM5VH/U8ClZbg3HEfkpRsO1JE0hJQ1SYdLkRG3QjrPsK8/oLtOCqCGWMwLz7r3yDmhl8gLdvajhSxgrKzmIoc0n8kbP8W8+YruE1Tcbr3tR1JRSDzziLMireQIZfjdL/YdpyIpiWgakREYMxtmKJdmNlPYBo1RtqebzuWiiBm3UeYBbOgS08k+zrbcSKeXg5SNSbRMTi33QuNm+LOeBSzc7vtSCpCmG+34D43DVq0wblpgs4IDgL9F1anROLiccY/CFFRuNMfxpTtsx1JhTlTtAv3iUnQIBHnzvuROrG2I3mCloA6ZdK4qf/R0dK9uE9M0kdH1Skz5WW4f/odHK3A+cWDSEKS7UieoSWgTou0bodz80T49mvcZ/6gm9GoGjNHjvjPAIp249z5X0hqc9uRPEVLQJ026dQNGXMbbFqDmTtDF5tT1WaqqnCfnQJbv8K5+Ve6R7AF+nSQqhVOn0G4+/Zi3ngR4htgbp1oO5IKccZ1MbOnw6efIKNvRTr3tB3Jk7QEVK2REVfDgf2YZbkc8J0BfYfbjqRClDEG8/Jz/t3BLhmN03eo7UiepSWgao2IwFU/g4MHOPDCTATB6TvMdiwVgswbL2LyFyNZlyDDrrIdx9OCUgJPPvkka9euJTExkWnTpgFQXl5OTk4Oe/bsoXHjxkyYMIH4+PhgxFEBJI4DY8dTx63kyAvP4NaJxbkoy3YsFULct17FvPESclF/ZNRN/g8Pypqg3Bi++OKLue+++/7ttdzcXNLS0pg+fTppaWnk5uYGI4oKAomKIvFXD0P7CzFznsD96D3bkVSIcPMWYV6dg2T0Rq6/UwsgBASlBNq3b/+jT/mFhYVkZmYCkJmZSWFhYTCiqCCROrE4d9wH56Zh/vIn3E9W2I6kLHPfexPz8vPQuQdy0wTEibIdSWHxnkBpaSlJSf4JIUlJSZSVlZ3w7+bl5ZGXlwfA5MmT8fl8QclYm6Kjo8My96mKjo6mcUoq5qEcSib9iqPP5xCfkEDdXpF7achrP2Oo/pgPLn2V/S88Q52MXjSc+EhY7wsQaT/nsLgxnJWVRVbW///yKCoqspjm1Ph8vrDMfap+OF5z2z0w/WFK/+d3lJWU4PSIzJVHvfYzhuqN2c1b5D8D6NiVyhsnUFxaGqR0gRGuP+eUlJTjvm5tslhiYiIlJSUAlJSUkJCQYCuKCjCpWx/nl7+Dc8/HzPoj7vvv2I6kgsR9+7Vjl4CcW38b1mcAkcpaCaSnp1NQUABAQUEBGRkZtqKoIJDYuji/+C9o38l/s/jdxbYjqQAyxuAuegGzYDaS0Rvn5olItBZAKArK5aA//vGPfP755+zfv59bb72VUaNGkZ2dTU5ODvn5+fh8Pu6+++5gRFEW+W8W3487cwrmpZm4B/YjI67WJ0QijHFd/0Sw/MX+x0CvuxOJ0pvAoUpMGC70smPHDtsRaixcryOeqpON11RVYf76Z8yqd5H+I5BR4yJi3Xiv/Yzhx2M2lZWYOdMxHy1HBmYjV9wYcSUfrj/nE90TCIsbwyqySFQU3PALiIvHvLMIyvbBjXfp9eIwZw4fxH36cfhsHZI9Bhl6ZcQVQCTSElBWiOPAlTdBQkPMq3MwpXtxbr8fidNZ4+HI7NuL+8TDsP3vyPV34vQeaDuSqqbwPwdXYUtEcAZfjvzsV/DNZtzHf4sp2mU7lqohs2Mb7uTfwK4dOHf+lxZAmNESUNY53TJx7nrYv0PZo7/GbPncdiRVTUfWfOgvgMqjOBMfRdK62I6kakhLQIUEOfd8nHunQL043KkP4H7wru1I6iSMMbjvLGLfoxPB1wTnvqnI2efYjqVOgZaAChnStBnOfVOgbQfM7D/hvvy8blcZgkzFEczs6ZhXnie2ax+c3z6ONGpsO5Y6RVoCKqRIXAOc8Q8h/YZj8hbh5vwXpqzEdiz1T2bPTv+9m1XvIsOvJnHi75HYurZjqdOgJaBCjkRH41xzCzJuAvz9b7iTJuh9ghBgNq7BfeRXsGeX/wbwJaMjYn6H1+lPUIUsp3tfnHumQEwd3Cn34S6Zj3Fd27E8x1RW4i6YhTv9v6FhI5wHpiEddZmXSKHzBFRIk7Na4jyQg5k7A7NwLubLDTjj7kYSk2xH8wRTtAv32anwzWYkc7B/dnedWNuxVC3SElAhT+rHwS0T/YvPvTQT93e/wLnudqRzT9vRIpYxBrMqH/PSTBDB+flvkPRetmOpANASUGFBRJDeAzGt2+E+n4P71GSkR1/k6lv8JaFqjSnbhzv3SVj/EbTtgHPjXYivie1YKkC0BFRYkZTmOPdOwbz5MmbJfMwXG3DG3IZ07Go7WtgzxmA+Xo55+Tk4fAi58kYk6xK9+RvhtARU2JHoaOSSazEXZODOeQL3z79H0nsh19yMJOi9glNhinfjznsKNq2Blm1xbhiPpDa3HUsFgZaAClvSsi3OA/+DeXshZvFLmM/WIZdci1w8RNevryZz9Chm2ULMkldAHOTqm5G+Q3UTeA/RElBhTaJjkGGjMF164r44E/PSTMzKt/3zDM5Nsx0vZBljYMNq3Feeg93f+7d/HDUOST7DdjQVZFoCKiJI02Y4d/03rPsI95XncafeDx274lx+A3LmWbbjhRTz7Rbc+bNg80Zokopz138jHS60HUtZoiWgIoaI+D/RduiMyX8Ds3QB7kO/QHplIcNGef5Trtm5HfPGS5hPVkB8gv/JqsxBuvevx2kJqIgjsbHIkCswvQb6nyIqWIpZlY/07Off7cpjjzuandsxi1/GfLISYmKQIVcggy/XR2sVoCWgIpg0SECuvhkz8FLMWwswK5dhPshD0nv79789u7XtiAFjjIGvv8B9Oxc+/Rhi6iADL0EGXookNLQdT4UQLQEV8aSRDxl9K2bwFZi8Rf4y+KQAzk3DuXgIdOoWMZdETMURzOoPMMuXwNavIK6B/1JY32H6y18dl5aA8gxp5ENGjcMMv9pfBPmLcZ/5AyQ0RC7qj/ToF5Y3kY0x8N03mA/fw6zKh4Pl0CQVGf1zpGd/XepZnZSWgPIcqR+HDLoUM2AkfLYOt+AtzFsLMUtfheatkW59kAt7II2b2o56Uub77Zi1qzAfF8D330FUNHJhdyRzMJyb5r9RrtRP0BJQniVOFKSlE5WWjiktwRSuwHxUgJk/CzN/FqSejXTqhrS/EFq1tX7JyBytgC1fYD5bh/n0Y9j5D/8fnNMeGXM70qUnEp9gNaMKP1oCSgGSmIRkXQJZl2B278Cs/wTz6ceYJQswb74CsXWhTXukdTuk5bnQog0SFx/QTGZ/GWzdjNn6FebrL2HLF3C0AqKi/J/0+w1HOnbVrR3VadESUOo/yBkpyMBsGJiNObAfNm/CfPkp5suNmE1rMf/6i8lnwJlnISnNoXFTjrRsjYmOhYSGUD/+J5euMJWV/uv3ZSVQvAdTvBv27MTs2AY7tsG+vf8M5PjPSjKHIOddAG07IHXrB/BfQHmJloBSJyFxDaBzD6RzDwDMwQPw7RbM1q/gH9swO7ZhvtwAlUfZ95/fXK++/wwiKhr+dSmp8ihUVsKRQ3D40I8PWKcOnNkcadcRmp2NtGgLZ7dG6tYL5DCVh1kvgfXr1zNr1ixc16V///5kZ2fbjqTUCUn9ODivI3Jex2OvGbcKSveRWFXBvm/+BvvL4MB+/38VR/y/9Ksq/X85+p+FUCcW4hpAfAOkQSI0auw/s2iQqEs3q6CyWgKu6/L888/zwAMPkJyczL333kt6ejrNmjWzGUupGhEnCpKSqePz4fjOtB1HqRqx+pFjy5YtNG3alCZNmhAdHU3Pnj0pLCy0GUkppTzF6pnA3r17SU5OPvZ1cnIyf/vb33709/Ly8sjLywNg8uTJ+Hy+oGWsLdHR0WGZ+1R5bbygY/aKSBuz1RIwxvzoteNNcMnKyiIrK+vY10VFRQHNFQg+ny8sc58qr40XdMxeEa5jTklJOe7rVi8HJScnU1xcfOzr4uJikpJ0e0CllAoWqyXQunVrvv/+e3bv3k1lZSWrVq0iPT3dZiSllPIUq5eDoqKiuOmmm3jkkUdwXZe+ffty1lnht4CXUkqFK+vzBDp37kznzp1tx1BKKU/SWSlKKeVhYo73iI5SSilP0DOBILnnnntsRwgqr40XdMxeEWlj1hJQSikP0xJQSikP0xIIkh/OePYCr40XdMxeEWlj1hvDSinlYXomoJRSHqYloJRSHmZ9xrDXvP7668ybN4/nnnuOhIQE23ECau7cuaxZs4bo6GiaNGnC7bffTlxcnO1YAeG1HfKKioqYMWMG+/btQ0TIyspi6NChtmMFnOu63HPPPTRq1ChiHhXVEgiioqIiNm7cGFFrkZ/MBRdcwOjRo4mKimLevHksXLiQMWPG2I5V67y4Q15UVBTXXXcdrVq14tChQ9xzzz1ccMEFET1mgCVLlpCamsqhQ8fZHzpM6eWgIJozZw7XXnvtcfdMiEQdO3YkKioKgLZt27J3717LiQLDizvkJSUl0apVKwDq1atHampqxP58/6W4uJi1a9fSv39/21FqlZZAkKxevZpGjRrRokUL21GsyM/Pp1OnTrZjBMTxdsiL9F+IP7R79262bt3KOeecYztKQM2ePZsxY8ZE3Ic4vRxUiyZNmsS+fft+9PrVV1/NwoULeeCBB4IfKsBONuaMjAwAXnvtNaKioujdu3eQ0wVHdXfIi0SHDx9m2rRpjB07lvr169uOEzBr1qwhMTGRVq1a8dlnn9mOU6t0nkAQbNu2jYcffpjY2Fjg/3dQe+yxx2jYsKHdcAG2fPly3nnnHR588MFj4480X331FfPnz+f+++8HYOHChQBceumlNmMFXGVlJY8//jgdO3Zk+PDhtuME1AsvvMCKFSuIioqioqKCQ4cO0bVrV8aPH2872ukzKuhuv/12U1paajtGwK1bt87cddddET/WyspKc8cdd5hdu3aZo0ePml//+tdm27ZttmMFlOu65oknnjCzZs2yHSXoNm3aZB577DHbMWqNXg5SAfP8889TWVnJpEmTAGjTpg233HKL5VS1z4s75G3evJkVK1bQvHlzJk6cCMA111yjG0SFIb0cpJRSHqZPBymllIdpCSillIdpCSillIdpCSillIdpCSillIdpCSillIdpCSillIdpCSillIdpCSh1Gnbu3MmNN97IN998A/hXFB03blzELTKmIpeWgFKnoWnTplx77bU88cQTHDlyhKeeeorMzEw6dOhgO5pS1aLLRihVCx5//HF2796NiPDYY48RExNjO5JS1aJnAkrVgv79+/Pdd98xePBgLQAVVrQElDpNhw8fZs6cOfTr14/58+dTXl5uO5JS1aYloNRpmjVrFi1btuTWW2+lc+fOzJw503YkpapNS0Cp01BYWMj69euP7ZNwww03sHXrVlauXGk5mVLVozeGlVLKw/RMQCmlPExLQCmlPExLQCmlPExLQCmlPExLQCmlPExLQCmlPExLQCmlPExLQCmlPOz/ANcvTPgiwZYQAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "xs = np.linspace(-5., 5, 100)\n",
    "plt.plot(xs, pol(xs));\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "----\n",
    "## 2. Lambda expresions\n",
    "\n",
    "**Lambda** is a command that allows you to define a function in one expression, on the flight, without given it a name!\n",
    "\n",
    "The function is expected to work on the local scope.\n",
    "\n",
    "In the following example *sq* is a function defined using *lambda* and computes the squared of its argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " fun(3) =  9.0\n",
      " xs     =  [0, 1, 2, 3]\n",
      " fun(xs) =  [0, 1, 4, 9]\n"
     ]
    }
   ],
   "source": [
    "sq = lambda x : x * x \n",
    "print(' fun(3) = ', sq(3.))\n",
    "\n",
    "xs  = list(range(4))\n",
    "xs2 = []\n",
    "for xi in xs:\n",
    "    xs2.append( sq(xi) )\n",
    "\n",
    "print(' xs     = ', xs)\n",
    "print(' fun(xs) = ', xs2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "The **lambda** function is a crucial ingredient in **functional programming**.\n",
    "\n",
    "It appears associated to expressions applied to lists, usually with *map()* and *filter()* builtin functions.\n",
    "\n",
    "In the following example, *map()* applies a function defined on the flight using lambda to compute the squared of to the elements on the list *xs* and produces another list with the squared values!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " xs  =   [0, 1, 2, 3]\n",
      " xs2 =  [0, 1, 4, 9]\n"
     ]
    }
   ],
   "source": [
    "xs  = list(range(4))\n",
    "#sq  = lambda x: x * x \n",
    "xs2 = list(map(lambda x : x * x, xs))\n",
    "print(' xs  =  ', xs)\n",
    "print(' xs2 = ' , xs2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Here is another example, the **lambda** defines a boolean function that returns true if the argument is even and false if it is odd. We apply it to a list of numbers *ns* using the *filter()* builtin function to select the even numbers in the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ns     [0, 1, 2, 3, 4, 5]\n",
      " even1  [True, False, True, False, True, False]\n",
      " even2  [True, False, True, False, True, False]\n"
     ]
    }
   ],
   "source": [
    "ns      = list(range(6))\n",
    "is_even = lambda n: n%2 == 0\n",
    "even1   = list(map(is_even              , ns))\n",
    "even2   = list(map(lambda ni: ni%2 == 0 , ns))  \n",
    "print(' ns    ', ns)\n",
    "print(' even1 ', even1)\n",
    "print(' even2 ', even2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ns    [0, 1, 2, 3, 4, 5]\n",
      " ns2   [0, 1, 4, 9, 16, 25]\n",
      " evs1  [0, 2, 4]\n"
     ]
    }
   ],
   "source": [
    "# is_even = lambda ni : ni % 2 == 0\n",
    "ns2   = list(map   (lambda ni: ni * ni, ns))\n",
    "evs1  = list(filter(lambda ni: ni%2 == 0, ns))\n",
    "\n",
    "print(' ns   ', ns)\n",
    "print(' ns2  ', ns2)\n",
    "print(' evs1 ', evs1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "-----\n",
    "## 3. About arguments\n",
    "\n",
    "### 3.1 Default arguments\n",
    "\n",
    "It is common that some functions take some default arguments. We asign the argument to a default value *argument = value* in the definition of the function. In the case the user does not pass that argument, the function will use the default value!\n",
    "\n",
    "In the following example, the *comment* is set by default to *'Please, enter yes or no'*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def ask_user(comment = 'Please enter yes or no (y, n): '):\n",
    "    \n",
    "    while True:\n",
    "        ok = input(comment)\n",
    "        if (ok in ['y', 'yes']): \n",
    "            return True\n",
    "        elif (ok in ['n', 'no']):\n",
    "            return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter yes or no (y, n): depende\n",
      "Please enter yes or no (y, n): y\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ask_user()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Note: If the function has several arguments, the default arguments must go at then end!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 3.2 Arguments from a list\n",
    "\n",
    "You can pass several arguments to a function using a tuple. In order to unpack the tuple, just use the * operator in front! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-3\n"
     ]
    }
   ],
   "source": [
    "def prod(a, b):\n",
    "    return a * b\n",
    "\n",
    "x = [3, -1]\n",
    "print(prod(*x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "An function can also returns a list of objects, that can be take either as a list or either individually."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n",
      "(5.0, 3.0)\n"
     ]
    }
   ],
   "source": [
    "def total_and_delta(a, b):\n",
    "    return a + b, a - b\n",
    "\n",
    "a, b = 4, 1.\n",
    "cc = total_and_delta(a, b)\n",
    "print(type(cc))\n",
    "print(cc)\n",
    "#print('total ', total, ', delta', delta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total  5.0 , delta 3.0\n"
     ]
    }
   ],
   "source": [
    "cc  = total_and_delta(a, b)\n",
    "print('total ', cc[0], ', delta', cc[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 3.3 Arguments from a dictionary\n",
    "\n",
    "You can also pass the arguments to a function using a dictionary, in that case the keys of the dictonary should be strings and be identical to the name of the arguments of the function. You need to use the double * operator in front of the dictionary!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def print_client_phone(client, phone):\n",
    "    print(' client ', client, ' phone ', phone)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " client  Angel  phone  66123153\n"
     ]
    }
   ],
   "source": [
    "print_client_phone('Angel', 66123153)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " client  Jose Angel  phone  22123123\n"
     ]
    }
   ],
   "source": [
    "data = {'client' : 'Jose Angel', 'phone' : 22123123}\n",
    "print_client_phone(**data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 3.4 Typed arguments\n",
    "\n",
    "Python only requires that the arguments of a function fulfill the requirements in the body of the function. That is functions in Python use 'generic' or 'template' arguments. \n",
    "\n",
    "Some programmers consider this a disadventage. You can name the arguments if you want, to make the code more readable. See the *typing* module within Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "#from typing import Tuple\n",
    "\n",
    "def create_polynomial(coeficients  : tuple) -> callable:\n",
    "    \"\"\" returns a function that is a polinomial with the coeficients given in the list coeficients\n",
    "    \"\"\"\n",
    "    def pol(x : float) -> float:\n",
    "        y = 0.\n",
    "        for i  in range(len(coeficients)):\n",
    "            y = y + coeficients[i] * (x**i)\n",
    "        return y\n",
    "    return pol"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.0\n"
     ]
    }
   ],
   "source": [
    "cas = (1., 1., 1.)\n",
    "pol = create_polynomial(cas)\n",
    "x = 1\n",
    "print(pol(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Exercises\n",
    "\n",
    "  1. Define a function to compute the mean and the variance of a list of numbers. Check with numpy\n",
    "  \n",
    "  \n",
    "  2. Given a list of $[(x, y)]$ numbers, make a function to compute its minimum distance to the origin. \n",
    "  \n",
    "  \n",
    "  4. Define a poisson probability function, $p(\\mu | n)$. \n",
    "  \n",
    "      * Define a functor, that passing as argument the mean value of a poisson, $\\mu$,  will return to you a function, $f(n)$, that $f(n) = p(n | \\mu)$. \n",
    "\n",
    "\n",
    "  5. Write a set of functions to fit a sample $\\{(x_i, y_i)\\}$ points, with uncertainties $\\sigma_i$ to a straight line via least squares method."
   ]
  }
 ],
 "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
}