3 - Programacion funcional.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Programacion funcional en Python\n",
    "Hay dos tipos principales de programacion, **funcional** y **orientada a objetos**. En este curso solo vamos a ver la programacion funcional, primero porque es mas sencilla de comprender e intuitiva y segundo porque con la programacion funcional podemos hacer las mismas cosas que con la programacion orientada a objetos (aunque si sobra tiempo el ultimo dia de curso os puedo enseñar lo poco que sé sobre programacion orientada a objetos)\n",
    "\n",
    "La **programacion funcional** se basa en el uso de **funciones**. En una funcion, los datos de entrada o inputs fluyen a través de un conjunto de expresiones / operaciones (cuerpo de la funcion) que dan un resultado final o datos de salida de la funcion (outputs).\n",
    "\n",
    "## 1. Tipos de funciones\n",
    "\n",
    "![](util/tipos_funciones.png)\n",
    "\n",
    "### 1.1 Funciones creadas por nosotros \n",
    "Siempre para definir una funcion debemos seguir esta plantilla.\n",
    "\n",
    "![](util/plantilla_funcion.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def suma(x,y):\n",
    "    \"\"\"Funcion simple que calcula la suma de dos valores x e y\"\"\"\n",
    "    resultado = x + y\n",
    "    return resultado"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "🚨 **Importante**: De nuevo al igual que vimos en las operaciones condicionales (`if`, `elif`, `else`) y con los bucles (`for`, `while`) la indentacion está presente en las funciones.\n",
    "\n",
    "<img src=\"util/indentacion.png\" width=\"300px\">\n",
    "\n",
    "⚡**Ejercicio**: Ahora intenta tu crear una funcion como la de arriba pero que se llame `multiplica` y que multiplique tres valores x, y, z."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Desde ahora, como pasa con la variables, las funciones `suma` y `multiplica` se guardan en la memoria y las podemos utilizar cuando queramos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 2\n",
    "y = 6\n",
    "suma(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "suma(5,10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tambien podemos especificar los valores que tomaran por defecto los inputs de una funcion sino son especificados. Vamos a modificar la funcion suma para que sume por defecto x=1 y y=1 si los valores de x e y no son especificados cuando llamamos a la funcion."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def suma(x=1,y=1):\n",
    "    \"\"\"Funcion simple que calcula la suma de dos valores x e y\"\"\"\n",
    "    resultado = x + y\n",
    "    return resultado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "suma()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "⚡ ¿Que creeis que da como resultado la celda de abajo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "suma(8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Documentacion o texto de ayuda de una funcion\n",
    "\n",
    "Algo muy importante que debe tener una funcion es documentacion y comentarios que expliquen la funcion en si y las expresiones que contiene. La documentacion de la funcion viene siempre al principio de la funcion entre \"\"\". Si queremos ver esta documentacion de cualquier funcion podemos hacer click en el nombre de la funcion y pulsar Shift + Tab. \n",
    "\n",
    "![](util/ayuda_funcion.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos a crear ahora una funcion un poco mas complicada, con un blucle `for` en el cuerpo de la funcion. La funcion que vamos a crear se va a llamar `suma_lista` (recuerda no puede haber espacios por ello usamos _ uniendo las dos palabras) y va a calcular la suma de los valores una lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def suma_lista(x):\n",
    "    \"\"\"Calcula la suma de los valores de una lista\"\"\"\n",
    "    \n",
    "    resultado = 0 # valor inicial de la variable resultado (inicializacion de la variable)\n",
    "    \n",
    "    for i in x:\n",
    "        resultado = resultado + i\n",
    "        \n",
    "    return resultado"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ya que tenemos definida la funcion podemos utilizarla cuando queramos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista = [1,2,3,10,17,11,15,16,3]\n",
    "\n",
    "suma_lista(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Algunos ejemplos\n",
    "Vamos a crear una funcion que tenga como input un nombre de persona y dé como resultado un saludo a esa persona."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def saludo(nombre):\n",
    "    \"\"\"\n",
    "    Esta función saluda a la persona con el nombre que introducimos como input\n",
    "    \"\"\"\n",
    "    print(\"Hola, \" + nombre + \". ¿Qué tal?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "saludo('Andres')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Si ejecuto la celda de abajo, ¿cual crees que será el valor de `mi_saludo`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mi_saludo = saludo('Andres')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mi_saludo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y ahora vamos a crear una funcion que tenga como input tu edad y dé como resultado tu año de nacimiento."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def año_nacimiento(edad):\n",
    "    \"\"\"\n",
    "    Esta funcion calcula tu año de nacimiento\n",
    "    \"\"\"\n",
    "    año = 2022 - edad\n",
    "    print(\"Tu año de nacimiento es\" + año)\n",
    "    \n",
    "    return año"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "año_nacimiento(1990)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "⚡ ¿por qué me da error? Pista: str = string y int = integer\n",
    "\n",
    "Vamos a crear otra funcion, que no va a tener **ningun input**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mi_funcion():\n",
    "    x = 10\n",
    "    print(\"El valor de x dentro de la funcion es:\",x)\n",
    "\n",
    "x = 20\n",
    "mi_funcion()\n",
    "print(\"El valor de x fuera de la funcion es:\",x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos a crear ahora otra version de la función pero ahora con x como input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mi_funcion_2(x):\n",
    "    print(\"El valor de x dentro de la funcion es:\",x)\n",
    "\n",
    "x = 20\n",
    "mi_funcion_2(x)\n",
    "print(\"El valor de x fuera de la funcion es:\",x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos a crear otra funcion que multiplique por 2 el valor de x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 20\n",
    "mi_funcion_3(x)\n",
    "print(\"El valor de x*2  fuera de la funcion es:\",x*2)\n",
    "\n",
    "def mi_funcion_3(x):\n",
    "    print(\"El valor de x*2 dentro de la funcion es:\",x*2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "⚡ ¿por qué me da error? Pista: el orden es importante"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora una funcion en el que el input tiene **un valor predeterminado** (o por defecto)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mi_funcion_4(x=1):\n",
    "    print(\"El valor de x + 1 es:\",x + 1)\n",
    "\n",
    "mi_funcion_4(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mi_funcion_4()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Otro ejemplo pero ahora con dos inputs con valores predeterminados"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mi_funcion_5(x=1,y=1):\n",
    "    print(\"El valor de x + y es:\",x + y)\n",
    "\n",
    "mi_funcion_5(3,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mi_funcion_5(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mi_funcion_5()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 Funciones propias de Python (built-in functions)\n",
    "Python cuenta con funciones internas que siempre estan disponibles.\n",
    "\n",
    "![](util/list_built_in_functions.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una de estas funciones que viene integrada en Python es equivalente a la funcion `suma_lista` que acabamos de crear, en el caso de la funcion de Python se llama `sum`. Con ella podemos tambien sumar los valores de una lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista = [1,2,3,10,17,11,15,16,3]\n",
    "\n",
    "sum(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista = [3,5,-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Otras funciones por ejemplo nos sirven para calucar el maximo y el minimo valor de una lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "min(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Crear una secuencia de numeros enteros con la funcion `range`. Para ello entre parentesis ponemos primero el valor inicial de la secuenca, segundo ponemos el valor final de la secuencia (en realidad es el valor final menos uno) y por ultimo ponemos el paso. Sino ponemos el paso, por defecto la funcion interpreta que es 1.\n",
    "\n",
    "```python\n",
    "range(inicio, fin, [paso])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "range(1, 10, 1) # primer elemento: start, segundo elemento: stop, tercer elemento: step"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sino ponemos el paso obtenemos el mismo resultado porque el paso es 1 por defecto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "range(1, 10) # primer elemento: start, segundo elemento: stop, tercer elemento: step"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos guardar dicha secuencia como una variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = range(1,10,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y podemos extraer valore concretos de dicha secuencia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x[9]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿por qué no podemos obtener el elemento 9 de la secuencia?\n",
    "\n",
    "Con otra funcion de Python llamada `len` podemos saber el numero de elementos o valores de la secuencia alamcenada en x."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La secuencia tiene 9 elementos pero como la posicion de los elementos se empieza a contar desde 0, pues el ultimo elemento se encuentra en la posicion 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x[8]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Y por que el ultimo valor es 9 y no 10? Como ya hemos dicho en la funcion range(inicio, fin, [paso]), el valor *fin* es el valore final de la secuencia menos 1. Si es verdad, no tiene mucho sentido 😤 pero es una de las cosas que no son muy logicas en Python y que no debeis olvidar porque esto ocurre muy a menudo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mejor que utilizar listas, a partir de ahora vamos a utilizar matrices, que en Python se conocen como *array*. Para poder crear matrices y operar con ellas necesitamos importar una biblioteca de funciones muy conocida en el mundo Python llamada **Numpy**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Otra funciones propias (built-in) interesantes y utiles son las funciones `str`, `int` y `float` con las que podemos cambiar el tipo de valor, entre cadenas de caracteres, numeros enteros y numeros decimales"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "str(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int(1.6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "float(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "⚡ Volvamos a nuestra funcion `año_nacimiento`, ¿la podemos arreglar ahora?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "def año_nacimiento(edad):\n",
    "    \"\"\"\n",
    "    Esta función calcula tu año de nacimiento\n",
    "    \"\"\"\n",
    "    año = 2022 - edad\n",
    "    print(\"Tu año de nacimiento es \" + año)\n",
    "    \n",
    "    return año"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "⚡¿Si ejecuto la celda de abajo, ¿cuál crees que será el valor de `mi_año`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mi_año = año_nacimiento(1990)\n",
    "mi_año"
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}