Python I.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <img src=\"uni-logo.png\" alt=\"Logo UNI\" width=100 hight=200 align=\"right\">\n",
    "\n",
    "\n",
    "<br><br><br>\n",
    "<h1><font color=\"#1D65DD\" size=5>Python desde cero</font></h1>\n",
    "\n",
    "\n",
    "\n",
    "<h1><font color=\"#1D65DD\" size=6>Python I</font></h1>\n",
    "\n",
    "<br>\n",
    "<div style=\"text-align: right\">\n",
    "<font color=\"#1D65DD\" size=3>Yuri Coicca, M.Sc.</font><br>\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <h2><font color=\"#1D65DD\" size=5>Índice de la Sesión</font></h2>\n",
    "\n",
    "---\n",
    "\n",
    "El objetivo de este módulo es conocer los elementos básicos del lenguaje python 3.7\n",
    "\n",
    "<a id=\"indice\"></a>\n",
    "\n",
    "Acorde al **índice**, en esta sesión veremos:\n",
    "\n",
    "\n",
    "* [1. Declaración de variables: tipado dinámico](#section1)\n",
    "*  [2. Expresiones](#section2)\n",
    "  *  [2.1 Operadores aritméticos](#section2A)\n",
    "  *  [2.2 Funciones y operaciones sobre Strings](#section2B)\n",
    "  *  [2.3 Operaciones con valores booleanos](#section2C)\n",
    "*  [3. Estructuras de control](#section3)\n",
    "*  [4. Funciones built-in](#section4)\n",
    "*  [5. Funciones](#section5)\n",
    " *  [5.1 Funciones - Avanzado](#section5A)\n",
    "  *  [5.2 Funciones lambda](#section5B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "<a id=\"section1\"></a>\n",
    "# <font color=\"#1D65DD\" size=5> 1. Declaración de variables: tipado dinámico</font>\n",
    "\n",
    "<br>\n",
    "\n",
    "En Python los **tipos se infieren dinámicamente**, es decir, no es necesario declarar de qué tipo es una variable pues ésta tiene un tipo asociado (el intérprete determina el tipo). Para declarar una variable basta con escribir un **identificador o nombre y asignarle un valor usando el símbolo `=`**. \n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "<i class=\"fa fa-info-circle\" aria-hidden=\"true\"></i>\n",
    "<strong>Nota</strong>: Para mostrar el valor de las variables harémos uso de la función built-in **print**, que será explicada en el punto 4. Para ver el tipo inferido para la variable haremos uso de la función built-in **type**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Declara una variable entera\n",
    "num_int=7\n",
    "print(num_int)           # Mostramos su valor\n",
    "print(type(num_int))     # Mostramos su tipo inferido\n",
    "\n",
    "# Declara una variable flotante\n",
    "num_float = 2.7371\n",
    "print(num_float)         # Mostramos su valor\n",
    "print(type(num_float))   # Mostramos su tipo inferido\n",
    "\n",
    "# Declara una variable compleja\n",
    "_comp = (3+2j) * (4+9j)  # Mostramos su valor\n",
    "print(_comp)\n",
    "print(_comp.real)\n",
    "print(_comp.imag)\n",
    "print(type(_comp))   # Mostramos su tipo inferido"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Existen los tipos de datos básicos habituales: int, float, str y bool\n",
    "print(type(1))                # Tipo int (entero)\n",
    "print(type(1.0))              # Tipo float (número flotante)\n",
    "print(type((3+2j) ** (2+3j))) # Tipo complex (número complejo)\n",
    "print(type(\"Hello\"))          # Tipo str (secuencia de caracteres)\n",
    "print(type(True))             # Tipo bool (Booleano, True o False)\n",
    "\n",
    "# Existe un tipo especial, llamado NoneType, que sirve para indicar que es una variable vacía. \n",
    "None\n",
    "# Es muy útil para representar ausencia de información, un resultado especial para una función, etc.\n",
    "print(type(None))   # None es una palabra reservada, al igual que True y False. Se usa igual... 'variable = None'\n",
    "# Por ejemplo si el campo de un atbla no tiene valor, podemos asignarle None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Tipos de Datos Fundamentales__\n",
    "<br>\n",
    "Todas las funciones de Python están asociadas a un objeto. Es uno de los elementos primitivos de Python. Además, todo tipo de objetos se clasifican en tipos. Uno de los tipos más fáciles de trabajar son los números, y los tipos de datos nativos admitidos por Python son cadenas, enteros, números de coma flotante y números complejos. La TABLA muestra los tipos de datos incorporados de Python.\n",
    "\n",
    "<img src=\"fundamental-data-types.jpg\" alt=\"fundamental-data-types\" width=702 hight=293 align=\"center\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "<i class=\"fa fa-exclamation-circle\" aria-hidden=\"true\"></i>\n",
    "Esta flexibilidad, la no necesidad de declarar tipos, es muy potente, pero hay que manejarla con cautela. No existe una declaración de variables al uso, es decir:\n",
    "<ul>\n",
    "    <li> La asignación se encarga de crear la variable si no existe</li>\n",
    "    <li> La asignación modifica el valor de la variable si existe ¡y puede asignar un valor de un tipo diferente! (dinámicamente se cambia el tipo)</li>\n",
    "</ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size=4> <i class=\"fa fa-book\" aria-hidden=\"true\" style=\"color:#004D7F\"></i> </font> __Importante!__ \n",
    "\n",
    "Es necesario cuidar el nombrado de variables y ser consistente, ya que es posible incluso reasignar (\"chancar\") **funciones especiales**, **palabras reservadas**, **paquetes importados**, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "variable = \"Creada por primera vez\"\n",
    "print(variable)  # Imprime el string \"Creada por primera vez\"\n",
    "variable = \"Este valor ha sido asignado\"\n",
    "print(variable)  # Imprime el string \"Este valor ha sido asignado\"\n",
    "\n",
    "# Asignamos ahora un número.\n",
    "variable = 1.0\n",
    "print(variable)  # ¡El tipo de la variable a cambiado dinámicamente a float!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejemplos de malas prácticas..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# preservando...\n",
    "_print = print"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "_print(\"Hola\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Incorrecta asignación\n",
    "print = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Se origina un error al usar una palabra resrvada\n",
    "print(\"Hola\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Corrigiendo el error\n",
    "print = _print"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hola\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color=\"#1D65DD\" size=5> Nombres de variables permitidos </font>\n",
    "\n",
    "Además, un identificador **válido** debe cumplir una serie de **condiciones**:\n",
    "\n",
    "* Tiene que **empezar por una letra o el símbolo _**\n",
    "* No puede contener espacios\n",
    "* Aunque puede contener caractéres especiales, como la ñ, se recomienda no hacerlo (estándar en programación)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mivariable = 1       # Tiene que empezar por una letra\n",
    "_mivariable = 0.123  # O empezar por el símbolo _\n",
    "\n",
    "# Tras el primer caracter, se permiten letras, números y _ (pero no espacios)\n",
    "_123 = \"Hola\"  \n",
    "var2_3_4_final = \"Mundo\"\n",
    "var2_3_4_final\n",
    "fecha=\"2020-10-06\"\n",
    "print(fecha)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size=4> <i class=\"fa fa-book\" aria-hidden=\"true\" style=\"color:#004D7F\"></i> </font> __Importante!__ \n",
    "\n",
    "Si ha trabajado con diferentes lenguajes de programación, se habrá dado cuenta que cada uno de ellos tiene su propia convención sobre cómo debemos de nombrar nuestras variables, métodos, clases, etc. Estas convenciones o estándares de nomenclatura son un conjunto de normas para un lenguaje de programación específico y se recomiendan como buenas prácticas para facilitar la lectura del código y sea más fácilmente entendible y mantenible. Veamos las más usadas:\n",
    "\n",
    "**`Camel Case`**: El nombre viene porque se asemeja a las dos jorobas de un camello, y se puede dividir en dos tipos:\n",
    "<br>\n",
    "– Upper Camel Case, cuando la primera letra de cada una de las palabras es mayúscula. También denominado Pascal Case. \n",
    "<br>\n",
    "  Ejemplo: **EjemploDeNomenclatura**.\n",
    "<br>\n",
    "– Lower Camel Case, igual que la anterior con la excepción de que la primera letra es minúscula.\n",
    "<br>\n",
    "  Ejemplo: **ejemploDeNomenclatura**.\n",
    "Es muy usada en los #hashTags de Twitter o en lenguajes como Java, PHP, C#…\n",
    "\n",
    "**`Snake Case`**: Cuando cada una de las palabras, se separa por un guión bajo (_). Es común en los nombres de variables y funciones de lenguajes como C, aunque también Ruby y **Python** lo han adoptado. Como el Camel Case existen variedades, como todas las letras en mayúsuculas, denominado SCREAMING_SNAKE_CASE, que se utiliza para definir constantes. Ejemplo: **ejemplo_de_nomenclatura**\n",
    "\n",
    "**`Kebab Case`**: Es igual que el Snake Case, esta vez, son guiones medios (-) los que separan las palabras. Su uso más común es de las urls. Ejemplo: **ejemplo-de-nomenclatura**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Palabras Reservadas__\n",
    "<br>\n",
    "    Estas son palabras clave reservadas por el lenguaje de programación Python y evitan que el usuario o el programador las utilicen como identificador en un programa. Hay 33 palabras clave reservadas como se muestra en la TABLA 1.\n",
    "\n",
    "<img src=\"reserved_keywords.jpg\" alt=\"reserved_keywords\" width=700 hight=225 align=\"center\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: right\"> <font size=5>\n",
    "    <a href=\"#indice\"><i class=\"fa fa-arrow-circle-up\" aria-hidden=\"true\" style=\"color:#7F000E\"></i></a>\n",
    "</font></div>\n",
    "\n",
    "---\n",
    "\n",
    "<a id=\"section2\"></a> </font></h1>\n",
    "<h1><font color=\"#1D65DD\" size=5>2. Expresiones</font>\n",
    "<a id=\"section2A\"></a> \n",
    "    \n",
    "## <font color=\"#1D65DD\" size=4> 2.1 Operadores aritméticos </font>\n",
    "\n",
    "Las operaciones aritméticas básicas son accesibles por defecto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(2 + 3)     # Suma: 5\n",
    "print(2 - 3)     # Resta: -1\n",
    "print(-6)        # Un número negativo: -6\n",
    "\n",
    "print(\"====\")\n",
    "\n",
    "print(2 * 3)     # Multiplicación: 6\n",
    "print(5 / 2)     # División flotante: 2.5\n",
    "print(4 / 2)     # Aunque los números sean enteros y la división sea exacta\n",
    "                 # el resultado es un número flotante\n",
    "print(5 // 2)    # División entera: 2 (se trunca; equivalente a int(5/2))\n",
    "print(4 // 2)    # El resultado es un entero: 2\n",
    "\n",
    "print(\"====\")\n",
    "\n",
    "print(5 % 2)     # El módulo es 1 (resto de 5 / 2)\n",
    "print(2**3)      # 2 elevado a 3: 8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color=\"#1D65DD\" size=4> El paquete `math` </font>\n",
    "\n",
    "Éste incluye funcionalidad de **operadores matemáticos**. En la siguiente sesión veremos más detalles sobre paquetes y el uso de `import`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# math\n",
    "?math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "?math.cos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sin embargo, si se quieren usar operaciones más complejas, es necesatio importar una librería llamada `math` (hablaremos en mayor detalle en el Tutorial Python II). Esto se realiza con el código `import math`, y se acceden a las funciones con un punto, por ejemplo `math.sqrt` para la raíz cuadrada.\n",
    "\n",
    "Nos centraremos en las operaciones matemáticas:\n",
    "\n",
    "* **Raíz cuadrada de n:** math.sqrt(n)\n",
    "* **Redondear n por lo alto:** math.ceil(n)\n",
    "* **Redondear n por lo bajo:** math.floor(n)\n",
    "* **Truncar:** math.trunc(n)\n",
    "* **Factorial de n:** math.factorial(n)\n",
    "* **Máximo común divisor (MCD):** math.gcd(a,b)\n",
    "* **Mínimo común múltiplo (MCM):** mat.lcm(a,b)\n",
    "* **Exponencial de n:** math.exp(n)\n",
    "* **Logaritmo natural de n:** math.log(n)\n",
    "* **Logaritmo base b de n:** math.log(n, b)\n",
    "\n",
    "Así como estas constantes: \n",
    "\n",
    "* **Número pi:** math.pi\n",
    "* **Número e:** math.e\n",
    "\n",
    "Y operaciones trigonométricas:\n",
    "\n",
    "* **Seno:** math.sin\n",
    "* **Coseno:** math.cos\n",
    "* **Tangente:** math.tam\n",
    "* **Arco seno:** math.asin\n",
    "* **Arco coseno** math.acos\n",
    "* **Arco tangente** math.atan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# importamos la librería (módulo) math\n",
    "import math\n",
    "\n",
    "print( math.sqrt(9) )           # Raíz cuadrada de 9: 3\n",
    "print( math.ceil(3.1) )         # El número redondeado a la alta: 4\n",
    "print( math.floor(3.9) )        # El número redondeado a la baja: 3\n",
    "print( math.factorial(3) )      # Factorial de 3: 6\n",
    "print( math.gcd(10,125) )       # Returna 5\n",
    "print( math.trunc(1.001) )      # Returna 1\n",
    "print( math.trunc(1.999) )      # Returna 1\n",
    "print( math.exp(3) )            # Exponencial de 3: 20.085536923187668\n",
    "print( math.log(2) )            # Logaritmo base e de 2: 0.6931471805599453\n",
    "print( math.log(100, 10) )      # Logaritmo base 10 de 100: 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Operaciones con ángulos\n",
    "print(math.pi)            # Número pi\n",
    "print(math.e)             # Número e\n",
    "print(math.sin(math.pi))  # Seno de pi (en radianes): 0\n",
    "print(math.cos(math.pi))  # Coseno de pi (en radianes): -1.0\n",
    "print(math.tan(math.pi))  # Tangente de pi (en radianes): 0\n",
    "print(\"===\")\n",
    "\n",
    "# También se dispone de las inversas\n",
    "print(math.asin(0))       # Arco seno de 0: 0 (en radianes)\n",
    "print(math.acos(-1))      # Arco coseno de -1: pi (en radianes)\n",
    "print(math.atan(0))       # Arco tangente de 0: 0 (en radianes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<i class=\"fa fa-info-circle\" aria-hidden=\"true\"></i>\n",
    "Los números flotantes tienen dos valores especiales:\n",
    "<br>    \n",
    "- **infinito** (`math.inf`, o `float('inf')`)\n",
    "<br>\n",
    "- **not a number** o **nan** (`math.nan` o `float('nan')`)\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "math.inf == float('inf')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color=\"#1D65DD\" size=4> El paquete `cmath` </font>\n",
    "\n",
    "Los números complejos son almacenados inicialmente usando coordenadas rectangulares o cartesianas. Un número complejo z será representado en coordenadas cartesianas como z = x + iy, en donde x representa la parte real y y representa la parte imaginaria. Otra manera de representarlos es usando coordenadas polares.\n",
    "\n",
    "En este caso, el número complejo sería definido por una combinación de los módulos r y ángulo de fase phi. El módulo r es la distancia entre el número complejo z y el origen. El ángulo phi es el ángulo contrario medido en radianes desde el eje x positivo al segmento de línea uniendo a z y el origen.\n",
    "\n",
    "Mientras lidiamos con números complejos, el módulo cmath puede ser de gran ayuda. El módulo de un número complejo puede ser calculado usando la función integrada abs() y su fase puede ser calculada usando la función phase(z) disponible en el módulo cmath. Puedes convertir un número complejo en forma rectangular a forma polar usando polar(z), la cuál devolverá un par (r, phi), en donde r es abs(z) y phi es phase(z).\n",
    "\n",
    "De manera similar, puedes convertir un número complejo en forma polar a rectangular usando rect(r, phi). El número complejo devuelto por esta función es r * (math.cos(phi) + math.sin(phi)*1j).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cmath\n",
    " \n",
    "print(cmath.polar(complex(1.0, 1.0)))\n",
    "# returna (1.4142135623730951, 0.7853981633974483)\n",
    " \n",
    "print(cmath.phase(complex(1.0, 1.0)))\n",
    "# returna 0.7853981633974483\n",
    " \n",
    "print(abs(complex(1.0, 1.0)))\n",
    "# returna 1.4142135623730951"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El módulo **cmath** también nos permite usar funciones matemáticas regulares con números complejos. Por ejemplo, puedes calcular la raíz cuadrada de un número complejo usando **sqrt(z)** o su coseno usando **cos(z)**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cmath\n",
    " \n",
    "print (cmath.sqrt(complex(25.0, 25.0)))\n",
    "# returna (5.49342056733905+2.2754493028111367j)\n",
    " \n",
    "print(cmath.cos(complex(25.0, 25.0)))\n",
    "# returna (35685729345.58163+4764987221.458499j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=\"#1D65DD\" size=3> Jerarquía de operaciones </font>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La jerarquía natural de las operaciones es la habitual: primero potencias, luego multiplicación y división, y por último sumas y restas. Se puede utilizar los paréntesis para cambiar el orden natural:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 3 * 2**3 + 5  # = 3 * 8 + 5 = 24 + 5 = 29\n",
    "print(x)\n",
    "\n",
    "x = (3 * 2)**(3 + 5)  # = 6 ** 8 = 1679616\n",
    "print(x)\n",
    "\n",
    "x = (5 + 2 ** math.sqrt(9) - 3) / 2 # = (5 + 2 ** 3 - 3) / 2 = (5 + 8 - 3) / 2 = 10 / 2 = 5\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: right\"> <font size=5>\n",
    "    <a href=\"#indice\"><i class=\"fa fa-arrow-circle-up\" aria-hidden=\"true\" style=\"color:#7F000E\"></i></a>\n",
    "</font></div>\n",
    "\n",
    "---\n",
    "\n",
    "<a id=\"section2B\"></a> \n",
    "## <font color=\"#1D65DD\" size=4> 2.2 Funciones y operaciones sobre Strings </font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los strings son cadenas de caracteres encerradas entre comillas simples `'Hola mundo!'` o dobles `\"Hola mundo!\"`. El carácter especial `\\` sirve para escapar o representar otros caracteres. Principalmente, las combinaciones más comunes son `\\\\`, `\\n` y `\\t`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Esto es un backslash: \\\\\")      # El primer backslash sirve para escapar al segundo. Como resultado se imprime uno.\n",
    "print(\"Esto es un salto de línea: \\nMás texto...\") #\n",
    "print(\"Esto es un tabulador\\tMás texto...\") #"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Ho\\\"''la\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Hasta ahora la función `print`ha sido utilizada con strings simples (o con otros tipos de datos que se castean automáticamente a strings). A veces es necesario formar strings más complejos, por ejemplo para ser imprimidos con la función `print`.\n",
    "\n",
    "Disponemos de dos operaciones básicas: **concatenación** y **formateo**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=\"#1D65DD\" size=3> Concatenación de Strings </font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si tenemos dos strings, concatenarlos significa formar un solo string, resultado de _\"pegar\"_ uno tras otro:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s1 = \"Hola \"\n",
    "s2 =\"Mundo!\"\n",
    "s_concatenado = s1 + s2\n",
    "print(s_concatenado) # Los dos strings se han concatenado, formando la cadena \"Hola Mundo!\"\n",
    "\n",
    "# Se puede concatenar un número indefinido de strings.\n",
    "print(\"Hola\" + \" \" + \"Mundo\" + \"!\")\n",
    "\n",
    "# Si queremos utilizar otras variables o expresiones de tipo distinto a string hay que castear\n",
    "# print(\"Éste es el módulo \" + 1) # Esto fallaría"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=\"#1D65DD\" size=3> Multiplicación de Strings </font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multiplicar un string por un número **entero** significa replicarlo varias veces:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print( \"=-=\" * 300 )  # Genera un string que contiene \"=-=\" 30 veces seguidas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"Hola {} {}\"\n",
    "s.format(\"Mundo\", 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=\"#1D65DD\" size=3> División de Strings </font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función **`split`** sirve para dividir un string usando un carácter como **separador** (genera una _lista_ de strings):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Rojo,Verde,Azul,Amarillo\".split(',')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=\"#1D65DD\" size=3> Unión de Strings </font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función **`join`** sirve para volver a unir una lista de strings en uno solo, usando un carácter como **separador**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista_strings = \"Rojo,Verde,Azul,Amarillo\".split(',')\n",
    "','.join(lista_strings)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=\"#1D65DD\" size=3> Limpiar Strings </font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función `strip` sirve para eliminar un carácter o múltiples consecutivos al principio y al final de un string. Es muy útil, por ejemplo, para limpiar espacios en blanco:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rojo, verde, azul, amarillo = \"            Rojo, Verde, Azul, Amarillo  \".split(',')\n",
    "print(rojo, verde, azul, amarillo)\n",
    "print(rojo)\n",
    "print(rojo.strip()+\".\")\n",
    "print(verde)\n",
    "print(verde.strip()+\".\")\n",
    "print(azul)\n",
    "print(azul.strip()+\".\")\n",
    "print(amarillo)\n",
    "print(amarillo.strip()+\".\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> Formateo de Strings </font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el caso anterior hemos introducido un número para concatenar con el string. Tener que hacer el cast a str es incómodo.\n",
    "\n",
    "Por ello, existe el **formateo** de strings, que consiste en definir _huecos_ en el string que serán rellenados con las variables indicadas. Se realiza con la función `str.format`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"Éste es el módulo {}\"\n",
    "print(s)                # Imprime la cadena tal cual, con las llaves\n",
    "print(str.format(s, 1)) # Format busca en el string las llaves, y las sustituye en orden por los argumentos de format\n",
    "\n",
    "# La función format la heredan todos los strings (hablaremos de qué significa esto en la siguiente sesión).\n",
    "# Esto permite llamar a la función str.format de una forma más cómoda a través del string\n",
    "print(s.format(1))      # Siendo s una variable tipo str, podemos llamar a la función format como s.format\n",
    "\n",
    "# Un ejemplo con más variables que sustituir\n",
    "s = \"Formateando esta {} por {} vez.\"\n",
    "print(s.format(\"cadena\", 2))\n",
    "\n",
    "# Se puede especificar el órden en el que se usarán los argumentos para sustituir en las llaves.\n",
    "# Para ello, se indica un número entre ellas, donde el primer elemento es el 0.\n",
    "s = \"Formateando esta {1} en orden, según especificado por {0}.\"\n",
    "print(s.format(\"usuario\", \"cadena\"))\n",
    "\n",
    "# También se puede dar un formato custom a las variables formateadas, por ejemplo imprimir un entero como flotante:\n",
    "print(\"Éste es un entero, impreso como entero: {:d}\".format(1))\n",
    "print(\"Éste es un entero, impreso como flotante: {:f}\".format(1))\n",
    "print(\"Éste es un entero, impreso como string (opción por defecto): {}\".format(1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<i class=\"fa fa-info-circle\" aria-hidden=\"true\"></i>\n",
    "    \n",
    "Existe información completa sobre formateo de strings en Python  (<a href=\"https://pyformat.info/\">enlace</a>).\n",
    "\n",
    "Existen básicamente dos tipos de formateos: usando el símbolo % y la función `format` (la usada anteriormente). `format` es la opción recomendada por ser más nueva y dar más posibilidades.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "<i class=\"fa fa-exclamation-circle\" aria-hidden=\"true\"></i>\n",
    "**format** es capaz de realizar un casting automáticamente si no pierde información. Es decir, si imprimimos un entero como flotante.\n",
    "\n",
    "Sin embargo, si perdemos información, es decir, imprimimos un flotante como entero, el código fallará (sería necesario hacer el casting manualmente). A continuación vemos un ejemplo:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Casteo sin pérdida de información: de int {:d} a float {:f}\".format(1, 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Devuelve error\n",
    "#print(\"Casteo con pérdida de información: de float {:f} a int {:d}\".format(1.0, 1.0))  # ¡Falla la ejecución!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<i class=\"fa fa-info-circle\" aria-hidden=\"true\"></i>\n",
    "    \n",
    "En el [PEP-498](https://www.python.org/dev/peps/pep-0498/) (viene de Python Enhancement Proposals), se incluye a partir de python 3.6 un formateo de string mucho menos \"verbose\":\n",
    "`f'El valor de la variable mi_variable es: {mi_variable}'`.\n",
    "\n",
    "Es decir, permite formatear los strings antepondiendo el caracter 'f' al string, e incluyendo los nombres de las variables (¡e incluso expresiones!) dentro de los corchetes. La conversion de formatos (castings) se puede realizar de la misma manera, incluyendo los ':' después de la expresión:\n",
    "`f'El valor de la variable mi_numero es: {mi_numero:f}'`\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mi_variable = \"Un texto\"\n",
    "print(f'El valor de la variable mi_variable es: {mi_variable}')\n",
    "mi_numero = 123.5\n",
    "print(f'El valor de la variable mi_numero es: {mi_numero:f}, y multiplicado por 2: {mi_numero*2:f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"{} - {} = {}\".format(7, 5, 7 - 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: right\"> <font size=5>\n",
    "    <a href=\"#indice\"><i class=\"fa fa-arrow-circle-up\" aria-hidden=\"true\" style=\"color:#7F000E\"></i></a>\n",
    "</font></div>\n",
    "\n",
    "---\n",
    "\n",
    "<a id=\"section2C\"></a> \n",
    "## <font color=\"#1D65DD\" size=4> 2.3 Operaciones con valores booleanos </font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Existen operaciones para operar con booleanos y formar expresiones booleanas más complejas. Éstas son de gran utilidad para formar condiciones, por ejemplo para bucles while y sentencias if-else (se verán más adelante).\n",
    "\n",
    "Los operadores básicos que veremos en este tutorial son:\n",
    "\n",
    "* **not**: niega el valor booleano\n",
    "* **and**: conjunción\n",
    "* **or**: disyunción\n",
    "\n",
    "_**Nota:** Todos estos operadores son infijos, (al igual que las operaciones de suma, multiplicación, ...)._"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# not\n",
    "b = True\n",
    "print(\"El valor real es: {}. El valor negado es: {}\".format(b, not b))\n",
    "\n",
    "# and\n",
    "b1 = True\n",
    "b2 = False\n",
    "print(\"{} and {} es {}\".format(b1, b2, b1 and b2))\n",
    "\n",
    "# or\n",
    "b1 = True\n",
    "b2 = False\n",
    "print(\"{} or {} es {}\".format(b1, b2, b1 or b2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# El orden de precedencia es similar a los operadores aritméticos, donde la negación es como la potencia, la \n",
    "# conjunción es como la multiplicación, la disyunción es como la suma\n",
    "\n",
    "print(True or False and False)   # Esto es igual que (True or (False and False)): True\n",
    "\n",
    "print((True or False) and False) # Esto es igual que ((True or False) and False): False\n",
    "\n",
    "print(not True or True)          # Esto es igual que ((not True) or True): True\n",
    "\n",
    "print(not (True or True))        # Esto es igual que (not (True or True)): False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "<h3><font color=\"#1D65DD\" size=4> <i class=\"fa fa-pencil-square-o\" aria-hidden=\"true\" style=\"color:#113D68\"></i> Ejercicio</font></h3>\n",
    "\n",
    "Implementar en una celda el código necesario para:\n",
    "\n",
    "* Asignar un número con decimal a una variable.\n",
    "* Castear esa entrada a entero (función `int`).\n",
    "* Almacenar en diferentes variables:\n",
    "  * El número al cuadrado (usando el operador infijo \\*\\*)\n",
    "  * La raíz cuadrada del número (math.sqrt)\n",
    "  * Su factorial (math.factorial)\n",
    "  * Un booleano indicando si el número es par (True) o impar (False): Hay que usar el operador infijo % para determinar el módulo de la división (ej: `5 % 3` devuelve 2, que es el resto)\n",
    "* Con esto generaremos un string, formateando los campos, respectivamente, a:\n",
    "  * int\n",
    "  * float\n",
    "  * int\n",
    "  * str (tipo por defecto)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "\"\"\"\n",
    "Completar el Ejercicio 1\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: left\"><font size=4> <i class=\"fa fa-check-square-o\" aria-hidden=\"true\" style=\"color:#113D68\"></i>\n",
    " </font></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: right\"> <font size=5>\n",
    "    <a href=\"#indice\"><i class=\"fa fa-arrow-circle-up\" aria-hidden=\"true\" style=\"color:#7F000E\"></i></a>\n",
    "</font></div>\n",
    "\n",
    "---\n",
    "<a id=\"section3\"></a>\n",
    "<h1><font color=\"#1D65DD\" size=5>3. Estructuras de control </font></h1>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las estructuras de control sirven para definir flujos de ejecución dentro de un programa. Las estructuras básicas de control son:\n",
    "* **If-else**: estructura condicional\n",
    "* **Bucle for**: estructura de bucle for\n",
    "* **Bucle while**: estructura de bucle while\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "<i class=\"fa fa-info-circle\" aria-hidden=\"true\"></i>\n",
    "En python no existen llaves como en otros lenguajes (java, C, ...) para definir (o delimitar )bloques de código. Por el contrario, en python existe la indentación, que consiste en <strong>4 espacios consecutivos</strong>, para definir los bloques de código.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La estructura condicional permite **bifurcar el flujo de la ejecución de un programa** en dos alternativas. Mediante el uso de una expresión booleana (que se resuelve como `True` o `False`), perimte ejecutar uno u otro bloque, asociados a cada uno de los posibles valores booleanos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "if condición booleana:\n",
    "    # indentación de 4 espacios para definir código dentro del if.\n",
    "    código ejecutado si condición es True\n",
    "else:\n",
    "    # indentación de 4 espacios para definir código dentro del else.\n",
    "    código ejecutado si condición es False\n",
    "\"\"\"\n",
    "\n",
    "x = int(input(\"Introduce un número entero\"))  # Nos aseguramos de que el número introducido sea un int\n",
    "\n",
    "if x % 2 == 0:\n",
    "    print(\"Has introducido un número par\")\n",
    "else:\n",
    "    print(\"Has introducido un número impar\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = int(input(\"Introduce un número entero \"))\n",
    "\n",
    "if x < 3:\n",
    "    print(\"Pequeño\")\n",
    "else:\n",
    "    if x < 7:\n",
    "        print(\"Medio\")\n",
    "    else:\n",
    "        print(\"Grande\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = int(input(\"Introduce un número entero \"))\n",
    "\n",
    "if x < 3:\n",
    "    y = x*2\n",
    "    print(f\"Pequeño: {y}\")\n",
    "elif x < 5:\n",
    "    print(\"Mediano\")\n",
    "elif x < 8:\n",
    "    print(\"Grande\")\n",
    "else:\n",
    "    print(\"Muy grande\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La estructura de bucle for permite **repetir un bloque de código** tantas veces como elementos tenga una **lista** (veremos estructuras de datos en el Tutorial de Python II). En cada iteración sobre el bucle, una variable tomará el valor de cada uno de los elementos de esa lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "for variable in lista:\n",
    "    # indentación de 4 espacios para definir código dentro del for.\n",
    "    código a ejecutar dentro del bucle, donde variable toma cada uno de los valores de la lista\n",
    "    (el código se ejecutará tantas veces como valores diferentes haya en la lista)\n",
    "\"\"\"\n",
    "for i in [1, 2, 3, 4]:\n",
    "#   print(\"Soy el número {:d}\".format(i))\n",
    "    print(f\"Soy el número {i:d}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La estructura de bucle for permite **repetir un bloque de código** en función de una expresión **booleana**. Al comienzo de cada iteración se comprobará el valor de esta expresión, y se continuará ejecutando el bucle si la condición es `True`, y se terminará en caso contrario (`False`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "while condición:\n",
    "    # indentación de 4 espacios para definir código dentro del for.\n",
    "    código a ejecutar dentro del bucle, donde variable toma cada uno de los valores de la lista\n",
    "    (el código se ejecutará tantas veces como valores diferentes haya en la lista)\n",
    "\"\"\"\n",
    "x = 1\n",
    "while x < 5:\n",
    "    print(\"Soy el número {:d}\".format(x))\n",
    "    x += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: right\"> <font size=5>\n",
    "    <a href=\"#indice\"><i class=\"fa fa-arrow-circle-up\" aria-hidden=\"true\" style=\"color:#004D7F\"></i></a>\n",
    "</font></div>\n",
    "\n",
    "---\n",
    "\n",
    "<h1><font color=\"#1D65DD\" size=5>4. Funciones built-in<a id=\"section4\"></a> </font></h1>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una **función** es un bloque que parte de unas entradas (argumentos), que son utilizados por un código que ejecuta internamente para devolver una salida. Por ejemplo, la función `sum(x, y)` es una función que recibe dos números `x` e `y`, y devuelve como salida la suma de ambos. El uso de una función se realiza mediante su nombre (`sum`) e introduciendo la lista de variables de entrada (**argumentos**), separadas por comas, entre paréntesis: por ejemplo al ejecutar `sum(2,3)` devuelve 5.\n",
    "\n",
    "En este [enlace](https://docs.python.org/3.6/library/functions.html) se puede ver la lista de funciones built-in en Python 3.6. Éstas son funciones que están disponibles desde que se inicia el intérprete. A continuación se describen las que pueden resultar de mayor interes durante el curso. Éstas son un subconjunto de las más importantes:\n",
    "\n",
    "* **abs**: Computa el valor absoluto\n",
    "* **bool**: Fuerza un elemento (cast) a ser de tipo booleano\n",
    "* **int**: Fuerza un elemento (cast) a ser de tipo entero\n",
    "* **float**: Fuerza un elemento (cast) a ser de tipo flotante\n",
    "* **str**: Fuerza un elemento (cast) a ser de tipo string\n",
    "* **divmod**: Calcula el módulo (resto de una división)\n",
    "* **input**: Permite solicitar un valor por teclado para, por ejemplo, signarlo a una variable. \n",
    "* **max** _(iterable)_: Computa el máximo entre los números pasados como argumentos\n",
    "* **min** _(iterable)_: Computa el mínimo entre los números pasados como argumentos\n",
    "* **pow**: Computa la potencia del primer argumento (base) con el segundo argumento (exponente)\n",
    "* **print**: Función que imprime en la salida el string pasado como argumento. Si no es un string, intentará castearlo a string.\n",
    "* **range** Genera un rango de enteros (secuencia de números enteros)\n",
    "* **round**: Redondea un número flotante a entero. **Utiliza el método de redondeo del banquero**.\n",
    "* **type**: Devuelve el tipo de la variable pasada como argumento.\n",
    "\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "<i class=\"fa fa-info-circle\" aria-hidden=\"true\"></i>\n",
    "    <strong>Nota 1</strong>: Las funciones en las que se indica la palabra <i>iterable</i> se volverán a utilizar en el Tutorial de Python II, donde se explicará qué significa <i>\"iterable\"</i>.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = int(input(\"Introduce un entero \"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> abs </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Función valor absoluto\n",
    "abs(-1)  # Devuelve 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> bool, int, float y str </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Constructores de elementos booleanos, enteros, float y strings\n",
    "\n",
    "# bool\n",
    "x = 0\n",
    "print( bool(x) )   # Castea el entero 0 a booleano (False)\n",
    "\n",
    "# int\n",
    "x = 2.5\n",
    "print( int(x) )    # Castea el número flotante a entero por truncamiento\n",
    "\n",
    "# float\n",
    "x = 1\n",
    "print( float(x) )  # Castea el número entero a flotante\n",
    "\n",
    "# str\n",
    "x = 3.14\n",
    "print( str(x) )    # Castea el flotante a string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> divmod u operador infijo % </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# divmod(dividendo, divisor). Devuelve tanto la división entera como el resto\n",
    "x = divmod(10, 3)\n",
    "print(x)  # Imprime la división entera y el módulo de 10 sobre 3: (3, 1)\n",
    "\n",
    "# Existe un operador que permite obtener únicamente el módulo\n",
    "# de forma más cómoda usando el símbolo %:\n",
    "x = 10 % 3\n",
    "print(x)  # Imprime el resto únicamente (1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> input </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# input() solicita un valor por teclado. En jupyter notebook aparece\n",
    "# un campo de texto en la sección de salida: se introduce el valor y se\n",
    "# confirma pulsando intro\n",
    "x = input()\n",
    "print(\"Has introducido el valor: \")\n",
    "print(x)\n",
    "\n",
    "# Se puede introducir un texto informativo en el input:\n",
    "x = input(\"Introduce un número entero \")\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> max / min </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# max y min\n",
    "a = 3\n",
    "b = 7\n",
    "c = 6\n",
    "\n",
    "print( max(a, b, c) )  # Imprime el valor máximo de a, b y c\n",
    "print( min(b, a, c) )  # Imprime el valor mínimo de a, b y c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> pow </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Función pow. Computa la potencia del primer argumento (base)\n",
    "# con el segundo argumento (exponente)\n",
    "\n",
    "print(pow(3, 4)) # Imprime 3^4\n",
    "\n",
    "# Existe un operador equivalente más intuitivo: el doble asterisco\n",
    "print( 3**4 )      # Imprime 3^4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> print() </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print. Como hemos estado utilizando, imprime lo que se le pasa como argumento\n",
    "print(\"Hola mundo\")\n",
    "\n",
    "# Se le puede pasar más de un argumento, y los concatena usando un espacio\n",
    "print(\"Hola\", \"mundo\")\n",
    "\n",
    "# Los argumentos pueden ser de diferentes tipos (los que no son String los convierte)\n",
    "print(2, \"más\", 2, \"son\", 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> range </font>\n",
    "\n",
    "<div class=\"alert alert-block alert-info\"><i class=\"fa fa-info-circle\" aria-hidden=\"true\"></i> En la siguiente sesión veremos en detalle los <strong>generadores</strong>.\n",
    "    \n",
    "Por ahora, nos basta con saber que es necesario combinar la función `range` con la función `list` (que veremos en la sección). \n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Range permite especificar una secuencia de enteros. Tiene 3 argumentos:\n",
    "# range(valor inicial inclusive, valor final exclusive, incremento)\n",
    "\n",
    "# Nota: utilizaremos la función list() para poder visualizar la secuencia\n",
    "# de valores devuelta por range. En el punto 4-A veremos la función list, \n",
    "# y en el Tutorial python II veremos por qué es necesaria junto con range.\n",
    "\n",
    "print( list(range(5, 10, 2)) )  # 5, 7 y 9\n",
    "\n",
    "print( list(range(10, 6, -1)) )  # 10, 9 y 8 y 7\n",
    "\n",
    "# Algunos argumentos se pueden omitir. Si solo se especifican 2, corresponden\n",
    "# con el valor inicial y final, y se supone el incremento = +1\n",
    "print( list(range(1, 3)) )  # 1 y 2\n",
    "\n",
    "# Por ello, si se empieza en 3 y se termina en 1 con incrementos de +1, la secuencia es vacía\n",
    "print( list(range(3, 1)) )  # Secuencia vacía\n",
    "\n",
    "# Si solo se especifica un argumento, éste es el valor final, siendo el valor\n",
    "# inicial 0, y el incremento +1\n",
    "print( list(range(5)) )  # 0, 1, 2, 3 y 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> round </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Función round. Redondea al entero siguiendo el método del banquero:\n",
    "# Se trata de un redondeo más justo. Es un redondeo típico si la parte\n",
    "# decimal es >.5 o <.5. Sin embargo, si es exactamente .5: si la parte\n",
    "# entera es par, se redondea como si fuese <.5, y si es impar como si fuese > .5\n",
    "\n",
    "# Si la parte entera es par\n",
    "print( round(10.4) )  # 10.4 se redondea a 10\n",
    "print( round(10.6) )  # 10.6 se redondea a 11\n",
    "# Si la parte entera es impar\n",
    "print( round(11.4) )  # 11.4 se redondea a 11\n",
    "print( round(11.6) )  # 11.6 se redondea a 12\n",
    "\n",
    "print(\"====\")\n",
    "# En cambio, si la parte decimal es .5 exactamente\n",
    "# Si la parte entera es par\n",
    "print( round(10.5) )  # 10.5 se redondea a 10\n",
    "print( round(-10.5) ) # -10.5 se redondea a -10\n",
    "# Si la parte entera es impar\n",
    "print( round(11.5) )  # 11.5 se redondea a 12\n",
    "print( round(-11.5) ) # -11.5 se redondea a -12"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> type </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Por último, la función type devuelve el tipo de la variable\n",
    "print( type(True) )         # Es un booleano\n",
    "print( type(2) )            # Es un entero\n",
    "print( type(1.0) )          # Es un flotante\n",
    "print( type(\"Hola mundo\") ) # Es un string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: right\"> <font size=5>\n",
    "    <a href=\"#indice\"><i class=\"fa fa-arrow-circle-up\" aria-hidden=\"true\" style=\"color:#004D7F\"></i></a>\n",
    "</font></div>\n",
    "\n",
    "---\n",
    "<a id=\"section5\"></a>\n",
    "<h1><font color=\"#1D65DD\" size=5>5. Funciones </font></h1>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las funciones permiten nombrar a bloques de código para ser reutilizados en múltiples partes de nuestro programa.\n",
    "\n",
    "Como vimos en el punto [4](#section4), éstas se caracterizan por un número de entradas (**argumentos**) y una **salida**.\n",
    "\n",
    "Se crean usando la palabra reserada **def** seguido del **nombre** de la función (para que sea un nombre válido, debe cumplir las mismas condiciones que el nombrado de variables), y **entre paréntesis el nombre de los argumentos separados por comas** (si no tiene argumentos, tan solo los paréntesis). Si la función tiene una salida (ésta es opcional) se usa **return** para especificar qué devuelve."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mi_funcion():\n",
    "    \"\"\"\n",
    "    Esto es un docstring.\n",
    "    Esta funcion no tiene argumentos ni salida.\n",
    "    \"\"\"\n",
    "    print(\"Mi primera función\")\n",
    "\n",
    "?mi_funcion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Para usarla, igual que con las fucniones build-in\n",
    "mi_funcion()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mi_funcion_suma(x, y):\n",
    "    \"\"\"\n",
    "    Esta función devuelve la suma de dos entradas\n",
    "    @param x: Primer número a sumar\n",
    "    @param y: Segundo número a sumar\n",
    "    :return: La suma de x e y\n",
    "    \"\"\"\n",
    "    return x + y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Para usarla, igual que con las fucniones build-in\n",
    "x = 5.3\n",
    "y = 7.9\n",
    "suma = mi_funcion_suma(x, y)\n",
    "print(\"La suma de {:f} y {:f} es {:f}\".format(x, y, suma))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Definición de una función más compleja (haciendo uso de la definida anteriormente)\n",
    "def mi_funcion_multiplica_enteros(x, y):\n",
    "    \"\"\"\n",
    "    Esta función devuelve la multiplicación de dos números enteros\n",
    "    @param x: Primer número a multiplicar (número entero)\n",
    "    @param y: Segundo número a multiplicar (número entero)\n",
    "    :return: La multiplicación de x e y (número entero)\n",
    "    \"\"\"\n",
    "    # Aseguramos que x e y son números enteros\n",
    "    x = int(x)\n",
    "    y = int(y)\n",
    "    # Hacemos uso de la función mi_funcion_suma para multiplicar\n",
    "    suma = 0\n",
    "    for _ in range(y):  # Itera sin tener en cuenta la variable\n",
    "        suma = mi_funcion_suma(suma, x)  # Acumula x y veces en la variable suma        \n",
    "    return suma    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5\n",
    "y = 7\n",
    "multiplicacion = mi_funcion_multiplica_enteros(x, y)\n",
    "print(\"La multiplicación de {:d} por {:d} es {:d}\".format(x, y, multiplicacion))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<i class=\"fa fa-info-circle\" aria-hidden=\"true\"></i>\n",
    "En el ejemplo anterior, el bucle for declara la variable de iteración como _. Ésta es una forma de declarar variables anónimas: de esta manera permite que la variable no se cree ni consuma espacio en memoria (útil cuando no vayamos a hacer uso de la variable)\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cuando se llama a una función, los argumentos pueden ser proporcionados en **orden** o por **nombre**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def suma(x, y):\n",
    "    return x + y\n",
    "\n",
    "print(suma(1,2))      # En orden\n",
    "print(suma(x=1, y=2)) # Por nombre\n",
    "print(suma(y=2, x=1)) # ¡Por nombre y cambiando el orden!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def suma2(y):\n",
    "    return suma(2, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mifuncion = lambda y: suma(2, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mifuncion(7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> ¿Los parámetros son pasados por valor o por referencia? </font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los argumentos a las funciones de Python se transfieren por **referencia**. Es decir, si la función cambia el valor de un argumento, el valor también se cambia fuera de la función. Esto se aclarará con el siguiente ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_list(nuevalista):\n",
    "    nuevalista.append([20,25,30]);\n",
    "    return\n",
    "numlist = [5,10,15];\n",
    "print (\"Valores antes de la llamada a la función\", numlist)\n",
    "update_list( numlist );\n",
    "print (\"Valores despues de la llamada a la función\", numlist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las funciones se pueden declarar con valores por defecto para ciertos parámetros. Sin embargo, los parámetros tienen que estar ordenados en este caso:\n",
    "\n",
    "* Primero los parámetros obligatorios (sin valores por defecto)\n",
    "* Después los parámetros opcionales (con valores por defecto)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mi_funcion(req1, req2, opt1=\"Opcional\", opt2=5):\n",
    "    print(\"Estos son los parametros introducidos: {}, {}, {} y {}\".format(req1, req2, opt1, opt2))\n",
    "\n",
    "mi_funcion('a', 'b')\n",
    "mi_funcion('a', 'b', \"Otra cosa\")\n",
    "mi_funcion('a', 'b', opt2=100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se puede forzar a que a partir de un punto, los parámetros deban ser referenciados **siempre** por nombre:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mi_funcion(x, *, y, z):\n",
    "    return x + y + z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mi_funcion(1, 2, 3)  # Falla, porque espera un único parámetro posicional"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mi_funcion(1, y=2, z=3)  # Imprime la suma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mi_funcion(z=1, y=2, 3)  # Falla, porque como hemos dicho los parámetros posicionales van siempre al principio!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"section5A\"></a> \n",
    "## <font color=\"#1D65DD\" size=5> Funciones - Avanzado</font>\n",
    "Internamente python utiliza listas para manejar los parametros posicionales, y un diccionario para referenciar los parámetros por nombre. Existen formas de especificar una lista de parámetros tanto posicionales (extra) como por nombre.\n",
    "\n",
    "También podemos usar la misma sintáxis para traducir listas y diccionarios a argumentos de funciones."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mi_suma(x, *more_numbers):\n",
    "    suma = x\n",
    "    for y in more_numbers:\n",
    "        suma += y\n",
    "    return suma\n",
    "mi_suma(1, 2, 3, 4, 5,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# También podemos pasar una lista de números a la llamada de la función:\n",
    "print(mi_suma(*[1, 2, 3, 4, 5]))\n",
    "print(mi_suma(1, *[2, 3, 4, 5]))  # También funciona esto!\n",
    "print(mi_suma(1, 2, 3, *[4, 5]))  # Y esto!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def describir_persona(nombre, **atributos):\n",
    "    if \"apellidos\" in atributos:\n",
    "        nombre_completo = f\"{nombre} {atributos['apellidos']}\"\n",
    "        del atributos['apellidos']\n",
    "    else:\n",
    "        nombre_completo = nombre\n",
    "    print(f\"Mi nombre es {nombre_completo}, y el resto de atributos son: {atributos}\")\n",
    "describir_persona(\"Yuri\", apellidos=\"Coicca\", Teléfono=991887269, direccion=\"C/ Eleazar Blanco 330\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Al igual que antes, también podemos pasar un diccionario de atributos a la llamada de la función:\n",
    "atributos = dict(\n",
    "    apellidos=\"Coicca\",\n",
    "    Teléfono=991887269,\n",
    "    direccion=\"C/ Eleazar Blanco 330\"\n",
    ")\n",
    "describir_persona(\"Yuri\", **atributos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# E incluso pasar todos los parámetros por nombre!\n",
    "atributos = dict(\n",
    "    nombre=\"Yuri\",\n",
    "    apellidos=\"Coicca\",\n",
    "    Teléfono=991887269,\n",
    "    direccion=\"C/ Eleazar Blanco 330\"\n",
    ")\n",
    "describir_persona(**atributos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"section5B\"></a> \n",
    "## <font color=\"#1D65DD\" size=5> Funciones inline \"lambda\" </font>\n",
    "Además de la definición estándar de funciones existe la posibilidad de construir funciones en una sola línea. Estas funciones se llaman `lambda`, y son funciones que ejecutan una expresión y devuelve ese resultado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejemplo de función lambda\n",
    "# Usando la expresión de potencia **, crear la función exp (e ** x)\n",
    "import math\n",
    "exp = lambda x: math.e ** x\n",
    "n = 5.7\n",
    "print(\"La exponencial de {:f} es: {:f}\".format(n, exp(n)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La ventaja del uso de estas funciones radica en la legibilidad y simplicidad de la escritura del código. A modo de ejemplo, vamos a declarar la función suma con y sin **`lambda`**: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = 10\n",
    "B = 20\n",
    "\n",
    "# Declarando la función\n",
    "def suma(x, y):\n",
    "    return x + y\n",
    "\n",
    "print(f\"{A} + {B} = {suma(A, B)}\")\n",
    "\n",
    "# Asignando a la variable suma la declaración lambda\n",
    "suma = lambda x, y: x + y\n",
    "\n",
    "print(f\"{A} + {B} = {suma(A, B)}\")"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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
}