Content for Decem's Python course.
1{
2 "cells": [
3 {
4 "cell_type": "markdown",
5 "metadata": {
6 "slideshow": {
7 "slide_type": "slide"
8 }
9 },
10 "source": [
11 "## 6. Funciones"
12 ]
13 },
14 {
15 "attachments": {
16 "image.png": {
17 "image/png": "iVBORw0KGgoAAAANSUhEUgAAATgAAABqCAYAAAAoTk0iAAAfZElEQVR4Ae1dCXRURda+vSSddCIJBAgBQhYgENxwCRJgZAnLgDIEWXQcwI2wBJifsIyoh1VxhgEEBAQCIzAuKCqLihiioDIBwaCgiDhAMAyLKEsIJOmkl/efr/Jep9PpdJbupjvk3nM67716Vbeqvnrvq3tvVXeIWBgBRoARYAQYAUaAEWAEGAFGgBFgBBgBRoARYAQYAUaAEWAEPIHAEiKaSkQqB8o7E9E2IgoiIpzPd5BHSWou5x2hJHjgOIaIkm30+hPRHCKaaJPGp4wAI8AIWBH4iogsRDTcmlJ60oqIfpbvgbxaElEnuzy2l4uJ6FciGmSb6Obze4go2kbnX4gon4h62KTxKSPACDACVgTek0kMRHGvnArL6H05HeQXbs3t+MSPiHKJaIjj2x5LvYuI3iKih4kowGO1sGJGgBGoswhsIKJVRPQmER2SyewZmdzmysemRNSViJZX0svVcr7LRNRLdnehL9Em//8R0UgiakBEHxLRULnOo0SUYpMPp22J6DUi+o6IUokoUL4/nogUF7gxER2zIeGPiKiJnE8hvkeJ6HMigpX6B7s6+LIeIaCuR33lrpZHoISIbhDRNCKCJfY6ESEuB2L5Us6K+FwcET1Rvqj1aqd8tpKIfiKiYCJ6nIjCrDmIbiciEA+ICRbXZiK6RkTriQjuLYgRAlc4g4jayfdmEdEU+V4ClerB5SQiui67rF2IqD0RvSjng3v9ZyJaKxPcNzKZtpDv86GeIaCtZ/3l7pYhABcUBIb4GSyp/USUSUQbiegBORvu41NYVqzcGSw/CIjpgo0lBQJSxEhEeM4kOQFWIsgNggWMbkS0WybGi0QE6+sSEe0iImUCRnm0F0ScRkTjiOiM/IF1h7wvyTpxAGlmE1GonB8Ee87mPp/WEwSY4OrJQDvoJshDIZ0DRNSTiH4hoiKbdNxHvsoIDlYgBLE7CMgQYvtcgZigA0cI3EtFThERrC7IKCKCywtyg2Cho5F8rpTXyVaiQU5X8uEIK80sp5+Qj3nyUXFh5Us+1BcE8OCw1E8EQEIKIQABuKVYMLAXjROCg3UGUQgO5ASr7n45HWXhQppsCA5piiDGBkKF5BBRpHyOA6zI/8qxO1hu0AGXGtaf7ZYRxO0guKcQtlKHQrRKO+WsfKgvCCgPQH3pL/ezDAGMPUjDkSgEAQJUrDJH+UAqkBD5CCsNcbV0WTfiaUky6SnkY6sPixggMQgWFz6R3VDEzrB95VOZADERK+WXEdFh2T2FZTlBXiw5LsfxZHXioJcvbF1m2/t8fosjoDzIt3g3uXsOEAC5nCQiEIO9gBiayVsxsHAAQXzOXkBoyId412n5JhYb4BpiMeBrIjpIRD8Q0bdE1IGIthDRVTkvrDuQFdxRtAWrnn2IaKBcHxYPCmQ3Fu4s3FvE6UCA2AuHvXEriOgVIiqWyRH9etfGOo2Xt75gpZeFEWAEGAFGgBFgBBgBRoARYAQYAUaAEWAEGAFGgBFgBBgBRoARYAQYAUaAEWAEGAFGgBFgBBgBRoARYARuPQRsN13eer2rIz0aNGjQge3btzv7zbVa9aRt27bKV5WqXV6lUlk3f+t0OmUPXLXL1yZj5874SmqZFBQUnFeuTCaT8k0HCg4OLrcxuaioCD/I6RbR6/XKV8moc+fO5TYGa7Va67XRaFT2+1FUVFS5r7Dp9fqDKpVqU7du3az53dI4VsII1GEEYu68807s0ufPLYJBmzZtsBk5pg4/k7dM062z9S3TozrWkZiYmNtq2uTmzfFDu6XSpInr3yPv37+/oo78/ZWvlRJdvIj3tEzCw8t+/9L+Xlmu8mfHj5d9UeLGDeWbXUSHDik/RFI+f02u2rfHFyFKxVb32bNnlWRq2LCh9RwnffrgixKlcu0afrWpVDIy8IMo7pGTJ082xbiePm019tyjmLUwAnUNgXnz5j2ZkJCAX+WQpk2bJrHUXQRSUlKsVjjGta49i7die/nXRLw8qidPngyOjY3F9y1Z6jgCU6fif/iUCsZVOeej9xBggvMe9taaTSZTme9mTeUTRoARcBUBJjhXEeTyjAAj4LMIMMH57NBwwxgBRsBVBJjgXEWQyzMCjIDPIsAE5+WhycvL04SFhV3xcjO4ejcjgHF1s0pWVwsEmOBqARoXYQQYgbqBABNc3RgnbiUjwAjUAgEmuFqAxkUYAUagbiDABOflcbpy5Yo2Jiam3Je2vdwkrt4NCGBc3aCGVbiIABOciwBycUaAEfBdBJjgfHdsuGWMACPgIgJMcC4CyMUZAUbAdxFggvPy2Pz666+I1fA/JfbyOLi7enlc3a2W9dUQASa4GgLG2RkBRqDuIMAEV3fGilvKCDACNUSACa6GgHF2RoARqDsIMMF5eazOnz/v//vvv5f9BrmX28PVuwcBjKt7NLEWVxBggnMFPS7LCDACPo0AE5xPDw83jhFgBFxBgAnOFfS4LCPACPg0AkxwXh6ewsJCHgMvj4E7q1f+pSOPqztRrb0ufrlqjx2XZAQYAR9HgAnOxweIm8cIMAK1R4AJrvbYcUlGgBHwcQSY4Hx8gLh5dQuBJk2a1K0G3+KtZYK7xQeYu8cI1GcE+FdH6/Poc9/rHALZ2dkhRqNxMhouSVIPfLzZCZVK9QU+aIOfn9/S+++//5o322Nft5XgfA04+4ZWdu3rAFfWbk5nBGqKQFZW1qDi4uJtDRs2NAYFBVkaNGhgDg0NvV5TPe7Mn5eX1yk/Pz+xoKBAffXq1TlZWVnJXbt23e7OOlzRJQjOF4Grbqd8HeDq9oPzMQLOENi3b193jVqzPq5dXGFoaKjZWd6beQ9tUdqTl5dn/O/P/12/b9++wV26dPnyZrajsrq0vgpcZQ22T/d1gO3by9eMQG0QkCRpQ1y7OJ1CJrXR4ekyaBvaeOzYsQ1EFOPm+mbL+g4TUR4RVYtA1XUBuOoCpQCMPlW3TCX5ACY+g4ioeyV5OJkRuJkIRNuT244dOzSDBw8OaNWqVXCfPn0CVyxf4Xf16tVqtenw4cPq5OTkgOLiYvr88881EydO1DkqeOHCBRXy5efnO7pdIU1uY3SFG64l3E1Ec+TPNiJCzA8dXS+/oyGVqccqajngDh44qO7YsaM+Li4uKDo6OjgiIiI4LCzstjZt2gT99NNPqsoUeSp92bJlfm+++aY1VlhVPW4AuNZgVtU2vs8IuAuBzz77TDNw4EB9RESE9MILLxg6dOhgWfzKYv8BAwbof//99yqrOXXqlOrDDz/0y8vLU8XExFiGDRlmclRIyXcm94w3d1yEOmgb0p4kIhAeLLolRFSB6CoQx67MXdrCwkLVmDFjSqBUrVaTSqWioKAgqXnz5pKDisolgfFfeOEF/0ULFxU3CmtU7l5tLvbu3atp2rSpNGLECIcDUBudVZRxBiYAhSyVZxOXV4y6dOlCN27c0Mh6+XCLIIBx3bdvn8d688UXX2gSExPNK1euLMb7SUSm1NTUkvj4+ODMXZnax//yuNP3Be81RJIkio2NlWJjY8vF9ZBuNBpJoyl9NM2Wcrc91i8XFGNlGSvKyUSUq+ipwMolJSUUFhYmTZs2zYjPlClTjGlpacYxY8aYQkIqEKSix3o8ceKEasOGDf4Xf7vokrUHcC0WC2m1WjKbfQ5cgAkzOcracQ+dwIXo378/xcXFUcuWLemBBx6gl19+mX788UdR4/Xr1+nhhx+mnJwcD7XAdbUrV6ykd955x3VFDjQcPHCQevbsSb/88ouDu2VJv/76Kz3yyCMEvM6dPUt/+tOfqLpuV5kW3zlLSEgw79+/X/Piiy/6nzt7VrxrcXFx0qJFiwz33HuP9YUxGAwEL6h79+6BAwYMCMzMzBSMpRCcxWyhXbt2aUaNGhWg9A7WYbdu3fQBAQG3TZgwQaTjXYSA+LZu3Spc48TERH16errWbLJWp6hw9xHxNhgXsNScSUciQowOoSUhFQgOjG0yVU7+X3/9tXrgwIGB69at06KDCQkJ+p07dwrQYBqnpaUJQJKTk/W5ubkq5Hvqqad0w4cPF7ECAFwZ6GjRlctX6LnnnvNv2bJlcPv27YMOHDigsSU4Z2XlPrl6qDWYrlbsqDweqE8//ZQ6duxIM56dQQMGDKB///vf1LVrV0Fyly5doh07dvg0wX351Zf0n//8x1H3XEoDWQ0dNpQaNmxITRo3dqoLE8DWrVvpf//7HzUICaEnn3ySgoODnZbx1ZsGg0HXOynJf8mSJZZly5b5R7ZqFTxq1KigTz75RD969GhtVKuogMKCwsDr168Hjh8/Pmj27NkBvXr1ogYNGqiGDRuG91InSZIf+mcoNvgfPXrUH+5qcXGx/759+3R9+/bVt23blhYsWGAKDg4W5FlcXCzur1q1KmDIkCH6Zs2aqbt06SKNGzcuMGNXBmJ5/spHxk2JY7vriLgeyKsqgQcGtxXxOargooKpT5w4oUHsraioSKXT6SQ/Pz967LHHpHlz51lgoSG4uXfvXm1KSorlypUrlJKSgpnB0ioyUkpKSlJ999139PTTT1tCQ0P9jhw5ot24caPm4YcfNk+ePNncunVr7fjx43WYBdLS0kyI6wH0I0eOlISHh0uT0yZrs7Oz1ciLl3fJkiVao9GoAXhoW2pqqtZR2WbNmtm7zwDWFQGYVW2iVMDEosZTrlRWWVmdTkdNmzalB//wIE2cNFFkmzZ1KvXu04c2bdpEo0ePFmkgQkWAE9wW2XVRkm/6UXFxPGWF6wP1lJycTPAsfsnNpdtvv71CHxVXy9Ziue2224Q1Z58ZuGEyRXsxyeO5VwRWikbr/UiC0WjU4l1Au0DSmPAyPs2gbdu3qWHJDxw4kP75z39SREQE7fh4B23YsIHeffdd6tevn/bYsWPi/MSJE/7oJ7AxGAz+6CueMxDnv/71L7r//vvplcWvaNBfeAzdu3cn1PnTTz/R888/TzNmzKDp06drJItEb775Jh0/ftwPE66dYFHAmyLCSRUIDi1q2LChZdKkSSVqtVpdUlIiiOWO2+9QGU1GtQIMXI7ExET15cuX6fXXX6fs7GwNfgsL4AC4QYMGQbcW50hbs2aNRq/XOwX93Llz9MYbb9Dbb71NAx4aINoG1wIEZzAYNM4GLDS0QujsZgKsxOZqTHJVWREgKTx8FqnURcD4aLRaERvBWCgvLs4he3bvoSlTp9CZM2fEwz937lzEWMQ9EM6rr75Kmzdvps6dO4v7a9euFUS5ZMkS8WJPmTJF5IXV+PbbbwtrEQm//fYbbX53Mx3/+biwJuHigXgdCVbyFi1aROvWrRPkgxeod+/eIitI5Ksvv6Kdn+4UbccL2q1bt0rJGF7B4sWL6cMPPyRYIc/NmEEtWrYUupa9uoyWL18uzl966SVCXxTCRyKwmDlrJmVlZdG9994r8iGWBCvumWeeobfeeovw3VFYgii7YsUKunbtGt11110iJLBmzRpxb+bMmXDz6M4776RJkyaJOiqbPNA/SFXjKjLV4o8kScKigkX8ww8/0Pjx42nkqJE0YuQIvIOE8UM/5s+fT5ve2YT3EOQmalJCTBgfJbaGG2gznjHIoUOHBEkqZA6yF3nMFuFJIN/YsWNLnzs1UVRUFFVnUUMoufl/oiu4qCAkWEOIvaWmplrQGYD4hwf/IJqnANOuXTtxHRYWJo5KJ1EeojwAyA8XAuQGcQZ67i+lscF77yt9GJE/ICDA6jI7KyuUe/ePu5fGrb0BMe3evZtWLF8hCCotLU28tD169CCNTbAYbhhctjvuuINmz54tXuQJEyZQUVGR0IWZHfE7EMXRo0fpj3/8I33wwQdUUFBA+/fvF/mVShHTwmSDhx96QUKvLHmF8vLyaM6cOeIlOH36tJLdekR+vGRwB6dPn06DBw8m5FMmRhBRz149xcv5zTff0IMPPggrXUyKViXyCcIRTzzxBG3cuJFGjRpFBw8epKHDhong988//0zz5s2jpUuX0vnz5wn9TElJIeiE4GXvldSL2rdvL/TDaoOgHSC4zMxM8WKivX/7299o6tSpIsaJUMAXX3xBe/fuFfmBFyxlkCzIeMyYMfTRRx+Je9744+/vb8TnwoUL9I9//ENMPGgH3jeMe7NmzayxRZC17SQEjwhiMprEuOIcEyQwUQguOjqaYKkp77Hy7GBiKCwsFBOCkhdEiZg9Pj4oiJEnV7Dg0DHFKgCQZrNZU1JSUmaryz1BcBKidM7fr/SfCIGQIIpFAeCVc6QDdDx0itiCHta4lCxhfWCg0BbMrngIqyqr6PPSUYDpqbrRfxDQ9u3lvwEDAsILCAFW77//PrVp04ZWr1pFQcHB1sWJbVu3UZeuXWjhwoVidh8xYoTAFLP8rFmzRFk8rIqVA33KRIaxW7BgAfn7+9Oe3bupeYsWdPHiRRo+fDhipRUWD0CccItAcHAfIbD+QNLff/+9IF6QBUgaApcIxIRVR1iVtrJr1y7auXOnIHPch0t2+PBh4ToqBATCCQwMFCQG/Vu2bKGEhARhPXbq1InWrF4jXEsQ6X333Sf6rby8eM5PnDhBq1evpnHjxtFrr70mqn/22WcFVvAeQCLwKP78+J/FPYzFtGnTBLa2Lqxtuz19HhgYaOjXr1/JzJkz9ZMnT7YMGjTI9Ntvv6kyMjI0x44dU2dmZhqCg4Kl1NRUzeOPP64LCQkp0ev16vT0dI1KpVJp/bRGvJcqlcpPr9cLT02lUmkCAgJKUlJSEGP3a9KkiRm7JjZt2iTK+Pn5lQwfNhwTrH9aWpq5Y8eO0gcffKD+/vvv1X379jUFBATYrjTAHPSEB4VFhNKHyjnIqHsuslQgOAzgxYsXVYsXL/aDeapRa8wqlcoCk3XY0GHmwMBAtUqlCtAH6QuDg4LpSskVAKUPCwsrDg4KNsfHx6tCQkICV65caR47dqzZz89PbbFY1AEBAUZUOG7sOPWIkSP8GjRoYAoKCiJb0Lt17Wbp37+/H2b+ESNGWL777jvV+++/jxUbc0BAgMlZ2YCAgDIfjsgdANcYTOeY1/4uZkxYGBMnTCSTuXQBCC94nz59aMiQIUIxXtpTp04JNwrkBkGgGBZJ7plcCgkNEZNLr569xD283ErMCrEUjDtISBHFAscMjhgOJqaWkZHKbesxPT0dwWvrtWLVIXajCNqPiUqxrtAXfGwl+5vsCgQHNywpKUmQH/Ji0kN/0FdYndCrTKwgG5Ag3DbIgQMHBDb2rhbKoq8Q9FFZfcVKtdJnWEIQWHqQ9vFlEzJiTZgoMCHYWkci4038ExkZadmyZUshFhlmz57tHxERYendu7dp7dq1xvbt2ws3Cu9rYWGhJT093R9ji20k2HYV1SqqRK1R4/lRhYeHF3fo0EHTs2dPrU6nK4GV+t577xlnzZoVcOnSJfVjjz1mbN26tTo6OrokKipK2r51u2nBwgX+r7/+ujopKcmESTEuLs6s0+lsVybx/gmCcSMk2J8qfmSgCp0IF21U8lQguE6dOplXr16tmz59unXZGJlbtmwpderUqbB169bmfv36mRo2bGjGw4NYAxg8vkO8SaPVWLCdYcOGDYULFy7U7dmzx3LXXXeZtVqtGuBBz6OPPoqVG5Mj0PVBesu6teuMc+bO8X/ppZf87777btPEiRNLWrRoYdHpdEZnZXU6nT3BuQJwrcBUQK3JEfgVFRWVBkAqKYiJBpYU8FZeWGWl209balzD4kLYANYWLA+QAQgFFg/SGjUq3ZN47vw5at6iOSForuzTUqlVIpgM1wwvAsgCbikEJII4FeJSsJZwX7HIEXO1JTfkbyyvZoI4EOgGoYDcUEaJS7344osUGRkpQg+4D2LBi2UvaHNubi4C3KIdCIOAlGHJwjqDZbj/6/3CfQZpoT8gdUjr1q2FG67oNxQZRDraoRAcSB7tgMD9RZAeaQrpod+IW2VkZNA999wj+g73FC5+Zb/7Bu8DovRVXHjoT2JioiUxMdGg9NG+GjwrTz/9tAkf+3u4zsjIELGLQYMGmfFBGsZiyJAh5sGDBxcAK3srtXvP7ubuPbuXxjwcKfVcGhb8KgTabarDFhKQW3k3JysrS5IkKd/+Y7FY8m0/9verukbZqvI4u28wGET9zvJUdg99sul4bU7/D16fkw++JmLda1ObCpQyjzzyyOyRI0ceR13Tpk3DWJQTi8UiRUdHS8nJydKK5Suwz0kaPXq01KhRI2x+lk6dOiXauWvXLnGO+GnXrl3hnog8w4YNk4qKiiSz2Sw9+uijUrt27aT58+cLHUr/rl69Kh06dEjoGT9+vDR16lRxHhISItryxhtviOsZM2ZI27dvF5/Zs2dLOTk55dqKi5KSEumhhx6S4MIsXbpUGjlypCiLduTl5Ym29ejRQ0pPT5cyMzOlVatWSWvXrq2gBwknT5wUfejfv7/In5KSIrVt21bKzc2VgAt0JyQkSIsXL5b69u0r8srPs5SRkSHqnThxovT3v/9dio+PF9e4v2f3HnEO/dAzduxYcY12JSUliXNgU1hYKD3//PMScEDdyr3dn+922N7jx4+LvCiLcVXG2B3Hyt7Tyt4Bb6a74f1zBBm+MmkdG7tzbAlxuEm3wiKDohlMbvtR0qt7RFlXBJaDqzpcqN/ZfhtsCcGCQvmZwoXKnBXF7JyYmCisEWwTQcwKFg1WKeEeYgEHFgWCw1gthYUBKwpB9L/+9a+0etVqsVADywSxJsS7tm3bJiwjxOIgflqtiL8hbgYrCFYIFgOw5QCCfLDu4KbCtUxNTRVxOOi0F8z4WJGEi6osdEyePFnExWANffzxx8JSQqxs6NChIoanrNTZ62rdpjV99dVXoj+w+vA8wF1u1aqVOIdlCksOLmNMTIyw7OCmQuC+o449e/aI+BwWVLCiiM3SsNpwHzFf6Hx5/svCyoWFiAULuMGwFBFPfv6550Sc8rPPPhNxyN2f7xaLJPZtvRnXN2FDrcvd8GAbHb2T2N0Nyw67Fxx/qwhsazKaXLK2vDlb2NeNvrhhBsFsYD9bYMnQ7V+8r8qCszUVYG24U9avXy/6CAvPkTiqD2mO0h2VNxgMTvNWV48j3bZpzvTAcoVVWZmgLCzOcePGSe+9956wBmF9Ln91eWVFKk33sAW3Pjc3F+6oT7+raGNWVpbYZOsyW1ZUAM9JeS+rVQem4A3nzp8rXQKtqLDOpch9cfXXRDAb2H4tBPrw8y/V+omWmoCG7TMGg0GY17BanYm7Ldrw8HBhTWGF1JE4qg9pjtIdla/KCq+uHke6bdOc6YGVaR9Hsi8LqxhWJLaawFKbPm06pU5Itc1W7XNYuRBlW1S1C1aRUafTTT579uyFoz8cDcSPS1aR/abfRpvQNrQRbfVQA6AXK6SK1VZlNVg5AXA98q/lt4yJjSnGL4VWWcoHMwDg0zmndfnX88+6CWCACVcUW0DcTmy+ACFWDvGp7wKix4ZhbIJ2RpbexAk/BZ6dnd3xRsGNyUeOHJnT4LYGpuKSYnVxcbFXyQ6Le1qtViooKNCo1eo5Op3Okz9bbl0dre5YaH0VuOp2wIMA1xjM6raZ8/kmAr5Kbgpa8v87mJudnb30+o3rHSVJ+qVr167WX85Q8t3MY1ZWVlRJSUm0Tqc77Gv/jwE4iG0ivghcdQfJ1wGuqh9wZY4fPy42kilbFqoqw/d9HwF3u6i2PZbfV5/wKmSC9SrJ2mJjf15uH5wvAWff0MqufR3gytrN6YwAI+B5BLzqv3u+e1wDI8AI1GcEmODq8+hz3xmBWxwBJjgvDzB+oaGoqMjxPg0vt42rrz0CGFcW7yPABOf9MeAWMAKMgIcQYILzELCslhFgBLyPABOc98eAW8AIMAIeQoAJzkPAVlctYjVnz54V23UcfXm9uno4n28hwDE43xgPJjjfGAduBSPACHgAASY4D4DKKhkBRsA3EGCC841x4FYwAoyABxBggvMAqDVReePGDfFDkiiDH2NkuTUQwLiyeB8BJjjvjwG3gBFgBDyEABOch4BltYwAI+B9BJjgvD8G3AJGgBHwEAJMcB4CtrpqOVZTXaTqRr6778Z/nCTicfWN8WKC841x4FYwAoyABxBggvMAqKySEWAEfAMBJjjfGAduBSPACHgAASY4D4BaE5X5+fk1yc55fRwB5fvEPK6+MVBMcL4xDtwKRoAR8AACTHAeAJVVMgKMgG8gwATnG+PArWAEGAEPIMAE5wFQWWX9RSA+Pr7+dt4He84E54ODwk1iBBgB9yDABOceHFkLI8AI+CACTHA+OCjcJEaAEXAPAkxw7sGx1lrOnDlD8fHxBigwGMSh1rq4oPcRMJlMohEYVxbvIyD+2Yn3m1F/W4ANoY0aNdIAgZUrV9K+ffscghEaGmpNb9eunfW8uietIluVyxoTG1Pu+mZfnDp1qlpVenLD7PXr16vVhupmKigooM2bN4vsnmx3ddvD+YhUDIJ3EYiNjU3NyclZ6d1WlNUeEhJivUhMTLSe4yQ8PLzctXLRuHFj5bTC8dKlSxXSkPDtt99a00EMtpKTk2N76dJ5WFiYS+VrU/jy5csUGxs7IScn57XalOcy7kOACc59WNZKU0RExCORkZGbL126pHHni12rxnAhlxBo2rQpSZIkdGi12iEXLlzY4pJCLuwyAkxwLkPosoI2RHSyEi1lfilRx0ry9KgkHcndndyz1Wdbj5MiXr+VZ9eCw3bXyuUJ5YSIfrQ5r+1pC5uCtliVNz2JcA+4RhNRgpNxtVHHp55E4P8BXsLHX/AktvkAAAAASUVORK5CYII="
18 }
19 },
20 "cell_type": "markdown",
21 "metadata": {
22 "slideshow": {
23 "slide_type": "slide"
24 }
25 },
26 "source": [
27 "Podemos entender una **función** como un bloque de código reutilizable que lleva a cabo una acción determinada.\n",
28 "\n",
29 "Podemos entenderla como un *proceso* que puede tener (o no) una entrada y genera (o no) una salida.\n",
30 "\n",
31 ""
32 ]
33 },
34 {
35 "cell_type": "markdown",
36 "metadata": {
37 "slideshow": {
38 "slide_type": "slide"
39 }
40 },
41 "source": [
42 "\n",
43 "Como hemos comentado en la introducción, **todo en Python es un objeto**, y también lo son las funciones.\n",
44 "\n",
45 "Una función se define con la palabra reservada `def` seguida del nombre de la función que queremos crear, y poniendo a continuación, entre paréntesis, los argumentos de la función."
46 ]
47 },
48 {
49 "cell_type": "code",
50 "execution_count": 1,
51 "metadata": {
52 "slideshow": {
53 "slide_type": "slide"
54 }
55 },
56 "outputs": [
57 {
58 "name": "stdout",
59 "output_type": "stream",
60 "text": [
61 "0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 \n"
62 ]
63 }
64 ],
65 "source": [
66 "def fib(n): \n",
67 " \"\"\"Muestra la secuencia de Fibonacci hasta n.\"\"\"\n",
68 " a, b = 0, 1\n",
69 " while a < n:\n",
70 " print(a, end=' ')\n",
71 " a, b = b, a+b\n",
72 " print()\n",
73 "\n",
74 "fib(2000)"
75 ]
76 },
77 {
78 "cell_type": "markdown",
79 "metadata": {
80 "slideshow": {
81 "slide_type": "slide"
82 }
83 },
84 "source": [
85 "Las funciones son ciudadanos de primera clase, esto es que pueden ser tratadas como si fueran objetos, y ser pasadas por ejemplo, como argumentos de otras funciones. Se puede hacer referencia a la función con el nombre de esta, sin usar paréntesis."
86 ]
87 },
88 {
89 "cell_type": "code",
90 "execution_count": 2,
91 "metadata": {
92 "slideshow": {
93 "slide_type": "slide"
94 }
95 },
96 "outputs": [
97 {
98 "data": {
99 "text/plain": [
100 "<function __main__.fib(n)>"
101 ]
102 },
103 "execution_count": 2,
104 "metadata": {},
105 "output_type": "execute_result"
106 }
107 ],
108 "source": [
109 "fib"
110 ]
111 },
112 {
113 "cell_type": "code",
114 "execution_count": 3,
115 "metadata": {
116 "slideshow": {
117 "slide_type": "fragment"
118 }
119 },
120 "outputs": [
121 {
122 "name": "stdout",
123 "output_type": "stream",
124 "text": [
125 "4585580472 4585580472\n"
126 ]
127 }
128 ],
129 "source": [
130 "f = fib\n",
131 "print(id(f), id(fib))"
132 ]
133 },
134 {
135 "cell_type": "markdown",
136 "metadata": {
137 "slideshow": {
138 "slide_type": "slide"
139 }
140 },
141 "source": [
142 "### Valor de retorno\n",
143 "\n",
144 "Se usa la palabra reservada `return` para definir el valor que una función devuelve. Aunque una función no incluya una instrucción `return`, esta siempre devuelve `None`."
145 ]
146 },
147 {
148 "cell_type": "markdown",
149 "metadata": {
150 "slideshow": {
151 "slide_type": "slide"
152 }
153 },
154 "source": [
155 "### Argumentos\n",
156 "\n",
157 "Una función puede recibir cualquier número de argumentos, pudiendo definir valores por defecto.\n",
158 "\n",
159 "Se pueden pasar argumentos a las funciones de dos formas:\n",
160 "\n",
161 "- Posicionalmente, donde cada valor pasado como argumento se asociará al argumento que esté en la misma posición en la declaración.\n",
162 "- Por nombre, donde indicamos a que argumento se asocia cada valor, usando el operador de asignación `=`."
163 ]
164 },
165 {
166 "cell_type": "markdown",
167 "metadata": {
168 "slideshow": {
169 "slide_type": "slide"
170 }
171 },
172 "source": [
173 "### Argumentos genéricos\n",
174 "\n",
175 "Podemos declarar una función que reciba un número de argumentos arbitrario. Para ello solo tenemos que poner como argumentos `*args` y `**kwargs`. En este caso, `args` contendrá en una tupla los argumentos pasados posicionalmente, mientras que `kwargs` contendrá en un diccionario todos los argumentos que se le han pasado por nombre.\n",
176 "\n",
177 "Se pueden crear funciones que tengan un número de argumentos dinámicos. Para ello simplemente declaramos los argumentos de la sigueinte forma:\n"
178 ]
179 },
180 {
181 "cell_type": "code",
182 "execution_count": 4,
183 "metadata": {
184 "slideshow": {
185 "slide_type": "subslide"
186 }
187 },
188 "outputs": [
189 {
190 "name": "stdout",
191 "output_type": "stream",
192 "text": [
193 "Argumentos posicionales: (10, 2)\n",
194 "Argumentos por nombre: {'test': 'foo', 'c': 23}\n"
195 ]
196 }
197 ],
198 "source": [
199 "def generic_arguments(*args, **kwargs):\n",
200 " print(\"Argumentos posicionales:\", args)\n",
201 " print(\"Argumentos por nombre:\", kwargs)\n",
202 "\n",
203 "generic_arguments(10, 2, test=\"foo\", c=23)"
204 ]
205 },
206 {
207 "cell_type": "markdown",
208 "metadata": {
209 "slideshow": {
210 "slide_type": "slide"
211 }
212 },
213 "source": [
214 "### Funciones lambda\n",
215 "\n",
216 "Además de las funciones normales, Python nos permite declarar funciones anónimas, o funciones lambda, Para hacerlo, basta con untilizar la palabra reservada `lambda`."
217 ]
218 },
219 {
220 "cell_type": "code",
221 "execution_count": 12,
222 "metadata": {
223 "slideshow": {
224 "slide_type": "slide"
225 }
226 },
227 "outputs": [
228 {
229 "name": "stdout",
230 "output_type": "stream",
231 "text": [
232 "[('water', 1), ('food', 2), ('air', 3)]\n",
233 "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]\n"
234 ]
235 }
236 ],
237 "source": [
238 "l = [(\"food\", 2), (\"water\", 1), (\"air\", 3)]\n",
239 "\n",
240 "l.sort(key=lambda x: x[1])\n",
241 "print(l)\n",
242 "\n",
243 "l = range(10)\n",
244 "print(list(map(lambda x: x * 2, l)))\n"
245 ]
246 },
247 {
248 "cell_type": "code",
249 "execution_count": 5,
250 "metadata": {
251 "slideshow": {
252 "slide_type": "slide"
253 }
254 },
255 "outputs": [
256 {
257 "name": "stdout",
258 "output_type": "stream",
259 "text": [
260 "<function <lambda> at 0x111526e18>\n",
261 "6\n"
262 ]
263 }
264 ],
265 "source": [
266 "print(lambda x: x[1])\n",
267 "\n",
268 "foo = lambda x: x[1]\n",
269 "print(foo(range(5, 10)))"
270 ]
271 },
272 {
273 "cell_type": "markdown",
274 "metadata": {
275 "slideshow": {
276 "slide_type": "slide"
277 }
278 },
279 "source": [
280 "### Generadores\n",
281 "\n",
282 "Los generadores son herramientas simples y sencillas para crear iteradores.\n",
283 "\n",
284 "Un generador se escribe igual que cualquier función, sólo que se usa la instrucción `yield` para devolver los datos, de forma que un **generador produce una secuencia de datos en vez de un valor único**."
285 ]
286 },
287 {
288 "cell_type": "code",
289 "execution_count": 13,
290 "metadata": {
291 "slideshow": {
292 "slide_type": "slide"
293 }
294 },
295 "outputs": [
296 {
297 "name": "stdout",
298 "output_type": "stream",
299 "text": [
300 "<generator object countdown at 0x1115085e8>\n",
301 "[2, 1]\n"
302 ]
303 }
304 ],
305 "source": [
306 "def countdown(n):\n",
307 " while n > 0:\n",
308 " yield n\n",
309 " n -= 1\n",
310 "\n",
311 "gen = countdown(2)\n",
312 "print(gen)\n",
313 "print(list(gen))"
314 ]
315 },
316 {
317 "cell_type": "markdown",
318 "metadata": {
319 "slideshow": {
320 "slide_type": "slide"
321 }
322 },
323 "source": [
324 "Cuando se llama a una función generador, en realidad no se está ejecutando el código, si no que está creando un objeto generador. No se ejecuta hasta que se llama a la función `next()` con el objeto generador."
325 ]
326 },
327 {
328 "cell_type": "code",
329 "execution_count": 19,
330 "metadata": {
331 "slideshow": {
332 "slide_type": "slide"
333 }
334 },
335 "outputs": [
336 {
337 "name": "stdout",
338 "output_type": "stream",
339 "text": [
340 "Cuenta atrás desde: 10\n",
341 "10\n",
342 "8\n",
343 "6\n",
344 "4\n",
345 "2\n"
346 ]
347 }
348 ],
349 "source": [
350 "def countdown(n):\n",
351 " print(\"Cuenta atrás desde:\", n)\n",
352 " while n > 0:\n",
353 " yield n\n",
354 " n -= 1\n",
355 "\n",
356 "gen = countdown(10)\n",
357 "for x in gen:\n",
358 " print(x)\n",
359 " next(gen)"
360 ]
361 }
362 ],
363 "metadata": {
364 "celltoolbar": "Slideshow",
365 "kernelspec": {
366 "display_name": "Python 3",
367 "language": "python",
368 "name": "python3"
369 },
370 "language_info": {
371 "codemirror_mode": {
372 "name": "ipython",
373 "version": 3
374 },
375 "file_extension": ".py",
376 "mimetype": "text/x-python",
377 "name": "python",
378 "nbconvert_exporter": "python",
379 "pygments_lexer": "ipython3",
380 "version": "3.7.1"
381 }
382 },
383 "nbformat": 4,
384 "nbformat_minor": 2
385}