Clase_1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Clase_1.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/jisazac/pythonfinanzaseafit/blob/master/Clase_1.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8Eqn3RtteZei",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "<p><img alt=\"Colaboratory logo\" height=\"140px\" src=\"https://upload.wikimedia.org/wikipedia/commons/b/bf/EAFIT-2015.png\" align=\"left\" hspace=\"10px\" vspace=\"0px\"></p>\n",
        "\n",
        "<h1> Diplomado Python para Finanzas</h1>\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KvGkmbJKmJgO",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"contents\"></a></p>\n",
        "\n",
        "# Contenido Clase 1\n",
        "\n",
        "- <a href=\"#colabIntro\">1. Introducción al Colaboratory de Google</a><br>\n",
        "- <a href=\"#pythonIntro\">2. Introducción a Python</a><br>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fwCSPQiBuLQH",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"colabIntro\"></a></p>\n",
        "\n",
        "# 1) Introducción a Google Colaboratory\n",
        "\n",
        "[[Contenidos]](#contents)\n",
        "\n",
        "Este documento es un [Notebook de Jupyter](https://jupyter.org/), almacenado en el Colaboratory de Google. En lugar de una página estatica se trata de un ambiente interactivo en el cual puede ejecutar scripts en Python.\n",
        "\n",
        "A continuación se muestra una **celda de código** con un  script de Python que calcula un value, lo almacena en una variable y lo imprime en pantalla:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xlIqRThkfinx",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "56f2b262-4de2-4a69-d6c1-d30f4b07b698"
      },
      "source": [
        "# A continuación se realiza un cálculo sencillo del area de un cuadrado de lado 5 y se almacena dicho cálculo en la variable area, luego se imprime en pantalla\n",
        "\n",
        "area=5*5\n",
        "\n",
        "print(area)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "25\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F5cfOYAGg9XF",
        "colab_type": "text"
      },
      "source": [
        "Para ejecutar código en colab, se debe seleccionar la celda haciendo click  y lurgo  se debe hacer click el botón \"play\" a la izquierda de la celda; también puede usar el keyboard shortcut  \"Shift/Ctrl+Enter\".\n",
        "\n",
        "Todas las variables son almacenadas de forma global (mas adelante ahondaremos en este concepto), de tal manera que se puede usar y modificar en celdas diferentes. En los dos siguientes ejemplos se muestran modificaciones ejecutadas sobre la variable área"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3ZCDRslqkkev",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "419ebd91-131b-44d6-c894-821b9d49895b"
      },
      "source": [
        "print(\"Valor de la variable inicial\",area)\n",
        "\n",
        "#Primera  modificación  de la variable area\n",
        "\n",
        "area=area/2;\n",
        "\n",
        "print(\"Valor de la variable modificado\", area)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Valor de la variable inicial 25\n",
            "Valor de la variable modificado 12.5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PT5cUO0od2BT",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"pythonIntro\"></a></p>\n",
        "\n",
        "# 2) Introducción a Python\n",
        "\n",
        "[[Contenidos]](#contents)\n",
        "\n",
        "El objetivo de la presente sección es el de suministrar al lector una breve introducción al lenguaje Python, y ayudar a los principiantes a familiarizarse con dicho lenguaje."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cwM2hsafqGeb",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"sections\"></a></p>\n",
        "\n",
        "#Secciones\n",
        "\n",
        "- <a href=\"#whatwhy\">2.1. ¿Qué, cómo, por qué y cuando Python?</a><br>\n",
        "- <a href=\"#mods\">2.1. Módulos</a><br>\n",
        "- <a href=\"#ayuda\">2.2. Ayudas y descripciones</a><br>\n",
        "- <a href=\"#vars\">2.3. Elementos Básicos de Python</a><br>\n",
        " - <a href=\"#syms\">2.3.1. Nombres de variables</a><br>\n",
        "  - <a href=\"#asign\">2.3.2. Asignación</a><br>\n",
        "  - <a href=\"#ftypes\">2.3.3. Tipos de variables</a><br>\n",
        " - <a href=\"#mscut\">2.3.4. Atajos de operaciones matemáticas y asignaciones</a><br>\n",
        "- <a href=\"#sltd\">2.4. Strings, Listas y diccionarios</a><br>\n",
        " - <a href=\"#strings\">2.4.1. Strings</a><br>\n",
        " - <a href=\"#strings\">2.4.1.1 Ejercicios de práctica</a><br>\n",
        " - <a href=\"#alist\">2.4.2. List</a><br>\n",
        " - <a href=\"#alist\">2.4.2. Ejercicios de práctica</a><br>\n",
        " - <a href=\"#tuples\">2.4.3. Tuplas</a><br>\n",
        " - <a href=\"#diccionarios\">2.4.4. Diccionarios</a><br>\n",
        "  - <a href=\"#diccionarios\">2.4.4.1 Ejercicios de práctica</a><br>\n",
        " - <a href=\"#cond\">2.5. Condicionales: if, elif, else </a><br>\n",
        "- <a href=\"#iter\">2.7. Iteraciones y ciclos lógicos </a><br>\n",
        " - <a href=\"#cicl\">2.7.1 Ciclos for y while </a><br>\n",
        " - <a href=\"#contr\">2.7.2 Sentencias de control de bucles</a><br>\n",
        "- <a href=\"#func\">2.8. Funciones y clases </a><br>\n",
        " - <a href=\"#funci\">2.8.1. Funciones</a><br>\n",
        " - <a href=\"#funci\">2.8.1.1 Ejercicios de práctica</a><br>\n",
        " - <a href=\"#class\">2.8.2. Programación Orientada a Objetos (Clases) </a><br>\n",
        "- <a href=\"#inout\">2.9. Archivos de entrada y salida (I/O) </a><br>\n",
        " - <a href=\"#lecte\">2.9.1. Lectura de entrada de teclado </a><br>\n",
        " - <a href=\"#apyci\">2.9.2. Apertura y cierre de archivos</a><br>\n",
        " - <a href=\"#leyes\">2.9.3. Leer y escribir archivos </a><br>\n",
        " - <a href=\"#subar\">2.9.4. Subir y leer archivos </a><br>\n",
        " - <a href=\"#des\">2.9.9. Descargar archivos en el sistema local </a><br>\n",
        " - <a href=\"#goodr\">2.9.7. Google drive: Paquete Pydrive </a><br>\n",
        " - <a href=\"#git\">2.10.7. Github </a><br>\n",
        "\n",
        " - <a href=\"#numpy\">3.0. Numpy </a><br>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "55SMYA8wHnAc",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"whatwhy\"></a></p>\n",
        "\n",
        "##2.1. ¿Qué, cómo, por qué y cuándo Python?\n",
        "[[Secciones]](#sections)\n",
        "- <b>Popularidad:</b> En palabras de la revista The Economist: <em>\"Python is becoming the world’s most popular coding language\"</em>\n",
        "<br>\n",
        "<p><img alt=\"economist  logo\" width=\"700\" height=\"600\" src=\"https://www.economist.com/img/b/1280/1401/90/sites/default/files/20180728_WOC883.png\" align=\"center\" hspace=\"10px\" vspace=\"0px\"></p>\n",
        "<br>\n",
        "-<b>Lenguaje de alto nivel:</b> Facilita la lectura humana por encima de la lectura de máquina. Fácil de usar y fácil de aprender\n",
        "\n",
        "<br> \n",
        "<p><img alt=\"comparison  logo\" width=\"600\" height=\"200\" src=\"https://belitsoft.com/images/uploads/blog/Hello%20world%20JAva%20%2B%20Python.png\" align=\"center\" hspace=\"10px\" vspace=\"0px\"></p>\n",
        "\n",
        "\n",
        "<br> \n",
        "\n",
        "<p><b>Aspectos técnicos de Python </b></p>\n",
        "<ul> Lenguaje de programación de propósito general que puede ser utilizado efectivamente para construir  programas que no requieran acceso directo al hardware</ul>\n",
        "<ul> Lenguaje de programación orientado a objetos </ul>\n",
        "<ul> Amplia disponibilidad de librerias </ul>\n",
        "<ul> Código Open Source </ul>\n",
        " \n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4nNpYw-fkCzu",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"mods\"></a></p>\n",
        "\n",
        "##2.1. Módulos\n",
        "\n",
        "[[Secciones]](#sections)\n",
        "\n",
        "La mayoria de funcionalidades en Python estan proporcionadas por los módulos. Para poder usar un módulo en un programa de Python debe importarse mediante la sentencia **import**. Por ejemplo, para importa el módulo *math*, el cual contiene gran variedad de funciones matemáticas, podemos hacer lo siguiente"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZE_1fo7exqpJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import math"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GE-bHIc13zbr",
        "colab_type": "text"
      },
      "source": [
        "La línea de código anterior implica la importación de todo el módulo, haciéndolo disponible para su uso posterior dentro del programa. Por ejemplo, podemos usar funciones triconométricas para calcular algún valor y almacenarlo en una variable:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XitBm17m5a83",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "46bf9ec0-4069-4407-ab28-d7d5272ec464"
      },
      "source": [
        "# Calculemos el coseno de 2 * pi\n",
        "x = math.cos(2*math.pi)\n",
        "x"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1.0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HCVT2oSL5t-i",
        "colab_type": "text"
      },
      "source": [
        "En lugar podemos escoger importar unas cuantas funciones del módulo haciendo explicito cuales de ellas queremos importar, permitiendo al usuario tener claridad de los compromisos del programa. Por ejemplo, podemos elegir importar solo las funciones $cos$ y el valor de $\\pi$:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ByqZG1n-7cRB",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "f146858b-ef08-4fd7-bcdb-4d1aef10f8d8"
      },
      "source": [
        "from math import cos, pi\n",
        "\n",
        "x = cos(3*pi)\n",
        "x"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "-1.0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3sg_iNHt710g",
        "colab_type": "text"
      },
      "source": [
        "También es posible asignarle un nombre corto o de acceso a los modulos "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0iwmV-jb8yW_",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "289c5e68-1383-4ca2-baf6-e84c46d03dc2"
      },
      "source": [
        "import numpy as np\n",
        "from math import pi as number_pi\n",
        "\n",
        "#A continuación, convertímos el número pi de radianes a grados.\n",
        "\n",
        "x = np.rad2deg(number_pi)\n",
        "x"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "180.0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YeHNWODgmKvV",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"ayuda\"></a></p>\n",
        "\n",
        "## 2.2. Ayudas y descripciones\n",
        "\n",
        "[[Secciones]](#sections)\n",
        "\n",
        "Mediante el uso de la función **help**, se puede obtener una descripción de casi todas las funciones. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "x2g4OJvvmsNv",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 153
        },
        "outputId": "bcf7a783-d5dd-4407-925d-13d6a6aaae0c"
      },
      "source": [
        "help(math.log)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Help on built-in function log in module math:\n",
            "\n",
            "log(...)\n",
            "    log(x[, base])\n",
            "    \n",
            "    Return the logarithm of x to the given base.\n",
            "    If the base not specified, returns the natural logarithm (base e) of x.\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6qb0g9MmQqVD",
        "colab_type": "text"
      },
      "source": [
        "Tambien puede obtener la ayuda poniendo el sígno interrogante (?) al final de la expresión, así:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EZL2WjpUQYd3",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "math.log?"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4SdWFMpF_iyw",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"vars\"></a></p>\n",
        "\n",
        "## 2.3. Elementos Básicos de Python\n",
        "\n",
        "[[Secciones]](#sections)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OmG1xsWVBh3G",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"syms\"></a></p>\n",
        "\n",
        "### 2.3.1. Variables y tipos\n",
        "\n",
        "Los nombres de las variables en Python pueden contener caracteres alfanuméricos *a-z*, *A-Z*, *0-9* y algunos caracteres especiales como _. Los nombres de las variables deben comenzar con una letra y no con un numero.\n",
        "\n",
        "Por convención, los nombres de las **variables** comienzan con letras minúsculas, y los nombres de las **Clases** con letras mayúsculas.\n",
        "\n",
        "Adicionalmente, existe un número de palabras reservadas conocidas como **keywords** que no pueden ser usadas como nombres de variables. Estas palabras claves son:\n",
        "\n",
        "> `and, as, assert, break, class, continue, def, del, elif, else, except, exec, finally, for, from, global, if, import, in, is, lambda, not, or, pass, print, raise, return, try, while, with, yield`\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0tOzwypQG20y",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"asign\"></a></p>\n",
        "\n",
        "### 2.3.2. Asignación.\n",
        "\n",
        "En Python, el operado de asignación es \"=\".  Python es un lenguaje de tipado dinámico, de tal forma que no es necesario asignarle un tipo a la variable cuando es creada.\n",
        "\n",
        "La asignación de un valor a una variable crea la variable. Por ejemplo:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "65XTvJMTHH5w",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# asignación de el valor 1 a la variable x\n",
        "\n",
        "x = 1.0"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eTOeTstfKVgJ",
        "colab_type": "text"
      },
      "source": [
        "Aunque no se hizo explicito, la variable tiene un tipo asociado a ella. El tipo de la variable puede deducirse del valor que le fue asignado. También se puede consultar el tipo mediante la función `type`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QTB-K6oxKnEK",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "1968f79b-1d77-418f-b033-7f06ab4667e8"
      },
      "source": [
        "type(x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "int"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wjTTfD72Ktv5",
        "colab_type": "text"
      },
      "source": [
        "Si asignamos a la variable un nuevo valor, su tipo puede cambiar:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SkbRDe3hKz78",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "befbfc5b-a747-440f-e25b-fb83bd738f18"
      },
      "source": [
        "x = 1\n",
        "type(x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "int"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VyawEMh7LDkv",
        "colab_type": "text"
      },
      "source": [
        "Si intentamos usar una variable que no ha sido definida aun, obtenemos un error `NameError` (Nótese que usarémos en los notebooks los bloques `try/except` para tratar las excepciones, de tal forma que el notebook no se interrumpa). \n",
        "\n",
        "En el siguiente código, intentaremos usar la función `print` de tal forma que si ocurre la excepción `NameError`, se imprime un mensaje en pantalla; de lo contrario, se generará un error. Más adelante, en el presente notebook, se estudiará mas detalladamente el manejo de excepciones.\n",
        "\n",
        " "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "liKk4M_dLyfN",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "66840335-b6c3-42af-d578-2489d9b5beea"
      },
      "source": [
        "try:\n",
        "    print(y)\n",
        "except(NameError) as err:\n",
        "    print(\"NameError\", err)\n",
        "else:\n",
        "    raise"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "NameError name 'y' is not defined\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DrrYSJFGNlTQ",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"ftypes\"></a></p>\n",
        "\n",
        "### 2.3.3. Tipos de variables.\n",
        "\n",
        "En Python, los tipos pueden ser  escalares (scalar) o no-escalares (non-scalar). Consideremos los objetos escalares como la unidad no divisible (atomos) del lenguaje. \n",
        "Python tiene 4 tipos de objetos escalares\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "1.   Enteros **(int)**: Utilizados para denotar numeros enteros\n",
        "2.   Punto flotante **(float)**: Utilizados para representar numeros reales, traen consigo siempre un punto decimal  (ejm: 3.0, 5.734, -14.21)\n",
        "3.   Buleanos **(boolean)**: Utilizados para denotar **True** or **False** (Verdadero o Falso)\n",
        "4.   **None**:  Es un tipo con un unico valor (Ninguno)\n",
        "\n",
        "Veamos algunos ejemplos de estos tipos:\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AsH88KwXOjvT",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "ec3a8ca3-b875-417a-ab0e-0d7b101f7aed"
      },
      "source": [
        "# integers, int, enteros\n",
        "\n",
        "x = 3\n",
        "type(x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "int"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d0MOnaqlOtrc",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "bc41c1fe-2a9c-4acd-8b26-19b0322909a1"
      },
      "source": [
        "# float, flotante, reales\n",
        "\n",
        "x = 13.0\n",
        "type(x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "float"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "D4YDFbxpO1HX",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "a552241b-4da5-409e-d305-ba2c00e3ebe8"
      },
      "source": [
        "# boolean\n",
        "\n",
        "v1 = True\n",
        "v2 = False\n",
        "\n",
        "type(v1), type(v2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(bool, bool)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lIJQNuxDSb9Q",
        "colab_type": "text"
      },
      "source": [
        "**Operadoros para los tipos float e int**\n",
        "+ **i+j**: La suma de i y j. Si ambos son int el resultado es int, si al menos uno es float el resultado sera float\n",
        "+ **i-j**:La resta de i y j. Si ambos son int el resultado es int, si al menos uno es float el resultado sera float\n",
        "+ **i*j**:El producto de i y j. Si ambos son int el resultado es int, si al menos uno es float el resultado sera float\n",
        "+ **i//j**: Division entera, ejemplo, 6//4 da como resultado el int 1.\n",
        "+ **i/j**:Division flotante, en python 3 este resultado siempre sera float\n",
        "+ **i%j**: conocido como operador modulo, retorna el residuo del int i dividido el int j. \"i mod j\"\n",
        "+  i**j : i elevado a la j\n",
        "+ Operadores de comparación: == (igual), != (no igual), > (mayor que). < (menor que), >= (al menos), <= (a lo sumo)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a0aadW7WQ4MJ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "b694bc1b-5dd8-4adf-8b7e-8ba7a1d5217a"
      },
      "source": [
        "# Algunas operaciones basicas\n",
        "[1 + 4, 1 - 3.5, 14.0* 2, 5 % 3]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[5, -2.5, 28.0, 2]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e5nUz2kxAHwp",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "9a46d13f-c336-4208-97ab-bb451983e9a1"
      },
      "source": [
        "print(6/2)\n",
        "print(1/2.0)\n",
        "print(36//6)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3.0\n",
            "0.5\n",
            "6\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zJKMj5GKBmig",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "4f637ad4-2abe-4fde-9741-a6e22433aa54"
      },
      "source": [
        "# Potenciacion\n",
        "print(2**2)\n",
        "print(3**3.0)\n",
        "print(4**4.4)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "4\n",
            "27.0\n",
            "445.7218884076158\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "inA_zCFhCJMQ",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "*   Los booleanos pueden estar conectados o precedidos por palabras como `and`, `not`, `or`. ( Si, Y , No, O)\n",
        "\n",
        "<p><img alt=\"verdad  logo\" width=\"440\" height=\"200\" src=\"https://www.researchgate.net/profile/Marcen_Laguna/publication/327702158/figure/fig3/AS:671885788475392@1537201463034/Figura-3-Tablas-de-verdad-5.ppm\" align=\"center\" hspace=\"10px\" vspace=\"0px\"></p>\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d1L933QDB_jc",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "ca9eb676-b8bd-4362-cfb5-fefec6847fc1"
      },
      "source": [
        "True and False"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TV0VzdoNRPj7",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "e19944f9-e190-4a48-e41e-9a2dd65d8984"
      },
      "source": [
        "False or False"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DAvHDZZPDKY0",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "61c17005-9a10-41b6-e1ea-a4cfe1bae1f6"
      },
      "source": [
        "not False"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P_uDESoGDMt2",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "517afab4-cb75-4343-d17c-015856218897"
      },
      "source": [
        "True or False"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j4eUgIFhDOYF",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "0a557d0d-f48c-4573-9c66-d0cda00b1107"
      },
      "source": [
        "3>1,4<1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(True, False)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iBvOf56_INhS",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "80d13fcc-57a4-48d7-fc8b-160e3330cea3"
      },
      "source": [
        "2>3,2<2"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(False, False)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JUtV68qaIVPz",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "6f34ca02-c319-4f55-ef53-1e784ad7ed23"
      },
      "source": [
        "6<=6,4>=3"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(True, True)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Uf1ILoH1Idk-",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "9a69a392-0da1-46c8-ca90-123760febbf5"
      },
      "source": [
        "\n",
        "[3,2]==[3,2]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eeW5ikeSIm45",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "3b3e1cb9-9db0-438b-ddfe-c3c848375cbe"
      },
      "source": [
        "\n",
        "2 != 5"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "46t9Rw_FLLcm",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"mscut\"></a></p>\n",
        "\n",
        "### 2.3.4 Atajos de operaciones matemáticas y asignaciones.\n",
        "\n",
        "[[Secciones]](#sections)\n",
        "\n",
        "Por ejemplo, la siguiente asignación y operación:\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7NxR98r1J8aX",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "e4074162-ddbf-4773-d793-18acef373604"
      },
      "source": [
        "x = 1\n",
        "x = x+1\n",
        "print(x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E5QT3j8KUJ59",
        "colab_type": "text"
      },
      "source": [
        "<p><img alt=\"verdad  logo\" width=\"340\" height=\"300\" src=\"https://i.redd.it/uq7asmzqj3j51.png\" align=\"center\" hspace=\"10px\" vspace=\"0px\"></p>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Oh-Lc8DGMNLK",
        "colab_type": "text"
      },
      "source": [
        "el comando `x = x + 1`, puede ser abreviado como `x += 1`. Este tipo de abreviaciones funcionan con las siguientes operaciones `+=`, `-=`, y `/=`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4j9hXwTxMGUq",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "2f584fe6-60c6-4952-b1bf-e7b2ec34e924"
      },
      "source": [
        "x = 1\n",
        "x *= 1\n",
        "print(x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jUNSgddpO0g4",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"sltd\"></a></p>\n",
        "\n",
        "## 2.4. Strings, listas y diccionarios.\n",
        "\n",
        "[[Secciones]](#sections)\n",
        "\n",
        "Los strings, las listas y los diccionarios son ejemplos de **estructuras de datos**.  Una estructura de datos es un formato de almacenamiento, organizacion y gestión que permiten el acceso eficiente y tambien la modificacion de datos.  En otras palabras, una estructura de datos es la coleccion de **valores**, las **relaciones** entre ellos y las distintas **funciones y operaciones** que pueden aplicarse a ellos."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XKs1xyvfAARA",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"strings\"></a></p>\n",
        "\n",
        "###2.4.1 Strings\n",
        "En Python, un string (cadena) es la secuencia de caracteres introducida dentro de ya sean comillas o dobles o simples.\n",
        "Los string suelen utilizarse para guardar mensajes, palabras, etc.."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qnZEZqP0NQuD",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "a955aa78-96f7-4844-c84e-658ebc7b3b16"
      },
      "source": [
        "s = \"Hola mundo\"\n",
        "type(s)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "str"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yiMVrS5_Pl2e",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "026cd23a-daa1-443f-b0dc-53fe2444abef"
      },
      "source": [
        "# La funcion len nos permite conocer la longitud del string, es decir\n",
        "# el número de caracteres en el string\n",
        "len(s)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "svUlFngQP_cs",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "ef2279a2-4f64-40a2-f50e-95ec13216b1c"
      },
      "source": [
        "# Reemplazo de un substring dentro de un string\n",
        "s2 = s.replace(\"mundo\",\"alumnos\")\n",
        "print(s2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hola alumnos\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gq50T2VhQw6L",
        "colab_type": "text"
      },
      "source": [
        "Podemos indexar los caracteres en un string mediante el uso de `[]` \n",
        "**Se debe tener cuidado ya que la indexación en Python empieza en 0.**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MlrzwSMCQnay",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "9aa5c5b1-d746-43db-b736-96e2570fb6ec"
      },
      "source": [
        "s[0],s[1],s[2]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "('H', 'o', 'l')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 39
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_K2cMoanRTCt",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "e3001e00-b642-497b-9c1c-ace2d0cb0da0"
      },
      "source": [
        "s[0:4]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Hola'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 40
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EkH3jEk8SV8e",
        "colab_type": "text"
      },
      "source": [
        "Si omitimos en el intervalo el `start` o el `stop`, se toma por defecto el princio y el final de string, respectivamente"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fBnB-XMzSP7P",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "3ad4460c-7e4f-49f4-e7df-109aad468418"
      },
      "source": [
        "s[:4]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Hola'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 41
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uJvBDt9tSvL9",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "512fb30f-cd30-4a3d-d4cb-f82300d45f95"
      },
      "source": [
        "s[5:]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'mundo'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "D0Zw1I2eSzeQ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "eafbaa69-5776-4e30-a3ca-76809ad3b564"
      },
      "source": [
        "s[:]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Hola mundo'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f9pVKmtVTOQW",
        "colab_type": "text"
      },
      "source": [
        "También podemos definir el tamaño del step (paso) usando la sintaxis `[start:end:step]`(el valor por defecto del paso es 1)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5U5QyQ0dTIZo",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "902eda7d-cb01-474b-c8c9-3317a1cc6001"
      },
      "source": [
        "s[::1]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Hola mundo'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 44
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "blfs1ZIHT3AV",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "35897cfe-8611-45a7-bc0c-f4e4e9b0bf44"
      },
      "source": [
        "s[::3]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Hauo'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 45
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vrZ-PKelT-LG",
        "colab_type": "text"
      },
      "source": [
        "A esta técnica se le conoce con el nombre de **slicing**."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Eaq_DVzaHwDH",
        "colab_type": "text"
      },
      "source": [
        "**Ejemplos de formatos de strings**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "koP6MyTtT4yY",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "3fd0cf78-f45e-462f-8944-ecc1ce27f7d6"
      },
      "source": [
        "#Contatenación de strings con +\n",
        "print(\"Común\"+\"mente\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Comúnmente\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eFzpL-rk086J",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "fe901006-43de-4ea3-f74d-82dc8de61809"
      },
      "source": [
        "type(\"s\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "str"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_nxlbRWUIUNn",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "d0a6fa1a-9c5f-46ac-c2ad-6b876d714d96"
      },
      "source": [
        "#La función print puede concatenar dependiendo de como se introduzcan las entradas.\n",
        "\n",
        "\n",
        "print(\"Propia\" \"mente\")\n",
        "print(\"Común\",\"mente\")\n",
        "print((\"Mega\",\"mente\"))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Propiamente\n",
            "Común mente\n",
            "('Mega', 'mente')\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6QkG1qAjJeGV",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "00d971b4-4c7b-4140-ba5d-9289e93eccc9"
      },
      "source": [
        "# La función print convierte todos las entradas a strings\n",
        "print(\"Común\", 1.0, False)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Común 1.0 False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uJ7Mt4tyPKdl",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "11cab892-c7eb-4bb6-8430-e30f4cb05bb6"
      },
      "source": [
        "print(\"Las líneas nuevas son indicadas por \\nlos espacios por \\t.\")\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Las líneas nuevas son indicadas por \n",
            "los espacios por \t.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iEY9qBl9S6Bs",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "d56fe750-62e0-4151-d27c-73aee876ce21"
      },
      "source": [
        "strString = \"\"\"String\n",
        "con varias\n",
        "líneas de texto.\"\"\"\n",
        "print(strString)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "String\n",
            "con varias\n",
            "líneas de texto.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c5Y4DoLwdSKP",
        "colab_type": "text"
      },
      "source": [
        "**CHEATSHEET METODOS DE STRINGS**\n",
        "\n",
        "**Cases I**\n",
        "- **s.capitalize()** Mayuscula al principio: 'hello' => 'Hello'\n",
        "\n",
        "- **s.lower()** todo en minúscula: 'HELLO' => 'hello'\n",
        "- **s.swapcase()** Cambia todas los caracteres # 'Hello' => \"hELLO\"\n",
        "- **s.title()** Mayúsculas primeras letras # 'hello world' => 'Hello World'\n",
        "- **s.upper()** Todo Mayúscula # 'hello' => 'HELLO'\n",
        "\n",
        "**Operaciones secuenciales I**\n",
        "\n",
        "- **a in b** retorna true si b contiene a\n",
        "- **a + b** Concatena a y b\n",
        "- **len(s)** longitud de s\n",
        "- **min(s)** Caracter mas pequeño de s\n",
        "- **max(s)** Caracter mas grande de s\n",
        "\n",
        "**Operaciones secuenciales II**\n",
        "\n",
        "- **a not in b** retorna true si a no esta contenido en b\n",
        "- **s * n** (int) Retorna n copias de s concatenadas # 'hello' => 'hellohellohello'\n",
        "- **s[i:j:k]** Slices (rebanadas)  de s desde i hasta j con pasos de dimension k\n",
        "- **a.count(b)** Conteo de b en a\n",
        "\n",
        "**Whitespace I**\n",
        "**s.strip()** Remueve espacios en blanco al inicio y al final # ' hello ' => 'hello\n",
        "\n",
        "**Encontrar / Reemplazar I**\n",
        "- **a.index(b, i, j)** Index de primera ocurrencia de b en a luego del index i pero antes del index j\n",
        "- **a.find(b)** Encuentra y recupera el  index mas bajo de b en a\n",
        "\n",
        "- **a.replace(b, c)** Reemplaza b con c en s\n",
        "- **a.replace(b, c, n )** Reemplaza b con c en a n veces\n",
        "\n",
        "**Cases II**\n",
        "\n",
        "\n",
        "- **s.islower()** Retorna  true si s esta en minuscula\n",
        "\n",
        "- **s.isupper()** Retorna  true si s esta en mayuscula\n",
        "\n",
        "**Inspección I**\n",
        "\n",
        "- **a.endswith(b)** Retorna true si a termina con b\n",
        "- **s.isalnum()** Retorna true si s es alfanumerico\n",
        "- **s.isalpha()** Retorna true si s is alfabetico\n",
        "- **s.isdecimal()** Retorna true si s is decimal\n",
        "- **s.isnumeric()** Retorna true si s is numerico\n",
        "- **a.startswith(b)** Retorna true si a empieza con b\n",
        "\n",
        "**Splitting I**\n",
        "\n",
        "- **s.join('123')** Retorna s unido al objeto  iterable '123' # 'hello' => '1hello2hello3'\n",
        "- **s.split(sep, maxsplit)** Retorna lista de s partido por sep con la maxima cantidad de maxsplits llevados a cabo\n",
        "-  **s.splitlines()** Retorna una lista de lineas  en s # 'hello\\nworld' => ['hello', 'world']\n",
        "\n",
        "**Inspección II**\n",
        "\n",
        "- **s[i:j]**: Slice (Rebanada)  de s desde i hasta j\n",
        "- **s.isdigit()** Retorna  true si s es  digito\n",
        "- **s.lstrip()** Remueve  espacios en blancos precedentes de s # ' hello ' => 'hello '\n",
        "- **s.rstrip()** Remueve espacios en blanco de s # ' hello ' => ' hello'\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4O2HtGPvF07o",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"stringsexercises\"></a></p>\n",
        "\n",
        "###2.4.1.1 Ejercicios de práctica"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z9zbnBA6Jov_",
        "colab_type": "text"
      },
      "source": [
        "**Ejercicio 1: Dificultad Zero**\n",
        "\n",
        "Cuente el numero de letras que contiene su primer nombre, ejemplo: Juan deberia retornar 4"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WQ_yvOCFJ8_k",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Desarrolle aqui el ejercicio\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gHh8aS5zJ61p",
        "colab_type": "text"
      },
      "source": [
        "De click **aquí** para ver la respuesta.\n",
        "\n",
        "<!---\n",
        "# No esperaba verte tan rápido aquí :(\n",
        "\n",
        "nombre=\"Juan\"\n",
        "print(\"Mi nombre tiene \", len(nombre),\" letras\")\n",
        "\n",
        "--->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v5GvRDd4KQKh",
        "colab_type": "text"
      },
      "source": [
        "**Ejercicio 2: Dificultad Rookie**\n",
        "\n",
        "Considere el **string1** tal que \n",
        "\n",
        "**string1**=\"Muchos años después, frente al pelotón de fusilamiento, el coronel Aureliano Buendía había de recordar aquella tarde remota en que su padre lo llevó a conocer el hielo. Macondo era entonces una aldea de veinte casas de barro y cañabrava construidas a la orilla de un río de aguas diáfanas que se precipitaban por un lecho de piedras pulidas, blancas y enormes como huevos prehistóricos. El mundo era tan reciente, que muchas cosas carecían de nombre, y para mencionarlas había que señalarlas con el dedo.\"\n",
        "\n",
        "Encuentre e imprima:\n",
        "\n",
        "- Primera ocurrencia de la letra \"a\"\n",
        "- Numero de veces que aparece la letra \"a\"\n",
        "- imprima los primeros 5 caracteres\n",
        "- imprima los siguientes 5 caracteres\n",
        "- Imprima el  13avo caracter\n",
        "- Imprima los caracteres con posicionamiento impar\n",
        "- Imprima los ultimos 5 caracteres\n",
        "- Convierta todo a mayuscula\n",
        "- Convierta todo a minuscula\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iQlePj_IKzh0",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Desarolle aqui el ejercicio\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uue_ONCqPVED",
        "colab_type": "text"
      },
      "source": [
        "De click **aquí** para ver la respuesta.\n",
        "\n",
        "<!---\n",
        "# No esperaba verte tan rápido aquí :(\n",
        "s=\"Muchos años después, frente al pelotón de fusilamiento, el coronel Aureliano Buendía había de recordar aquella tarde remota en que su padre lo llevó a conocer el hielo. Macondo era entonces una aldea de veinte casas de barro y cañabrava construidas a la orilla de un río de aguas diáfanas que se precipitaban por un lecho de piedras pulidas, blancas y enormes como huevos prehistóricos. El mundo era tan reciente, que muchas cosas carecían de nombre, y para mencionarlas había que señalarlas con el dedo.\"\n",
        "\n",
        "\n",
        "# Primera ocurrencia de la letra \"a\"\n",
        "print(s.index(\"a\"))\n",
        "\n",
        "# Numero de veces que aparece la letra \"a\"\n",
        "print(\"a occurre %d times\" % s.count(\"a\"))\n",
        "\n",
        "# Slicing de nuestra frase\n",
        "# imprima los primeros 5 caracteres\n",
        "print(\"los primeros 5 caracteres son '%s'\" % s[:5]) # Start to 5\n",
        "# imprima los siguientes 5 caracteres\n",
        "print(\"los siguientes 5 caracteres son '%s'\" % s[5:10]) # 5 to 10\n",
        "# Imprima el  13avo caracter\n",
        "print(\"El  13avo caracter es '%s'\" % s[12]) \n",
        "#Imprima los caracteres con posicionamiento impar\n",
        "print(\"Los caracteres con posicionamiento impar son '%s'\" %s[1::2]) \n",
        "#imprima los ultimos 5 caracteres\n",
        "print(\"Los ultimos 5 caracteres son '%s'\" % s[-5:]) # \n",
        "\n",
        "# Convierta todo a mayuscula\n",
        "print(\"String en uppercase: %s\" % s.upper())\n",
        "\n",
        "# Convierta todo a minuscula\n",
        "print(\"String en lowercase: %s\" % s.lower())\n",
        "\n",
        "--->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_sILCqjxGJ2a",
        "colab_type": "text"
      },
      "source": [
        "**Ejercicio 3: Dificultad Hero**\n",
        "\n",
        "Reorganice el string \"AdoROprogRAmarenPyTHON\" de tal manera que todas las letras en minuscula queden de primeras. Es decir, si el string fuses TaCo, el resultado sería aoTC"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fuNxwKdRITnB",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Desarrolle aqui el ejercicio"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AQ25Fp39DhOh",
        "colab_type": "text"
      },
      "source": [
        "De click **aquí** para ver la respuesta.\n",
        "\n",
        "<!---\n",
        "# No esperaba verte tan rápido aquí :(\n",
        "\n",
        "string1 = \"AdoROprogRAmarenPyTHON\"\n",
        "lower = []\n",
        "upper = []\n",
        "for char in string1:\n",
        "    if char.islower():\n",
        "        lower.append(char)\n",
        "    else:\n",
        "        upper.append(char)\n",
        "string_ordenado = ''.join(lower + upper)\n",
        "print(\"Reorganizando caracteres dando  precedencia a las letras en minuscula:\")\n",
        "print(string_ordenado)\n",
        "\n",
        "--->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6dW4ET9EWgVR",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"alist\"></a></p>\n",
        "\n",
        "### 2.4.2. Listas\n",
        "\n",
        "[[Secciones]](#sections)\n",
        "\n",
        "Una lista es una  secuencia de datos llamados items o elementos. Los elementos pueden ser de cualquier tipo. Algunos ejemplos de listas en la vida real son:\n",
        "- Lista de compras\n",
        "- Lista de pendientes\n",
        "- Lista de invitados\n",
        "- Una receta de cocina\n",
        "\n",
        "\n",
        "Las listas son muy similares a los `strings` sin embargo los elementos de una lista pueden ser de cualquier tipo. Además, las listas son **mutables**. En cualquier momento de su vida, pueden insertarse elementos, removerse elementos,\n",
        "o reemplazarlos. La identidad de la lista se mantiene pero su estado, su longitud y su contenido puede variar.\n",
        "\n",
        "La sintaxis en Python es de la forma `[...]`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Hwhv9wrHYJzg",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "b4ded2e6-7f11-4df1-bd40-dbc45d99a305"
      },
      "source": [
        "l=[0,1,2,3]\n",
        "print(type(l))\n",
        "print(l)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'list'>\n",
            "[0, 1, 2, 3]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JrWYz65iV7jU",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "7ff7900e-dea7-4cef-8f43-6ce4f98fbc63"
      },
      "source": [
        "[1951,1969,1984] # Una lista de integers\n",
        "['apples','oranges','cherries'] # Una lista de strings"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['apples', 'oranges', 'cherries']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lXu438N9bSMz",
        "colab_type": "text"
      },
      "source": [
        "Veamos un claro ejemplo de la mutabilidad de las listas\n",
        "sea a=[\"perro\" , \"gato\", \"loro\"] y b=a"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xh_AXwFkbeDn",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "43d19b18-e3e7-472d-bff5-5dfa3a3a5612"
      },
      "source": [
        "a=[\"perro\",\"gato\",\"loro\"]\n",
        "b=a\n",
        "print(\"Esta es la lista b\",b)\n",
        "b[0]=\"rana\"\n",
        "print(\"Esta es la lista a\",a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Esta es la lista b ['perro', 'gato', 'loro']\n",
            "Esta es la lista a ['rana', 'gato', 'loro']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GZplNnmZb0f-",
        "colab_type": "text"
      },
      "source": [
        "Para evitar este tipo de situaciones que podrian generar errores en nuestros programas hacemos uso del metodo **.copy()**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3aIt89yHcA69",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "7cc04ce1-41af-4dd3-cfd4-72677995bee9"
      },
      "source": [
        "a=[\"perro\",\"gato\",\"loro\"]\n",
        "b=a.copy()\n",
        "print(\"Esta es la lista b\",b)\n",
        "b[0]=\"rana\"\n",
        "print(\"Esta es la lista a\",a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Esta es la lista b ['perro', 'gato', 'loro']\n",
            "Esta es la lista a ['perro', 'gato', 'loro']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3i2WvZruYaKL",
        "colab_type": "text"
      },
      "source": [
        "Podemos usar las mismas técnicas de *slicing* que usamos en los *strings*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9leGZY_AYWJM",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "80b6b94e-92b9-4237-b6a6-dd5b4c608229"
      },
      "source": [
        "l=[0,1,2,3,4]\n",
        "print(l[:])\n",
        "print(l[0:2])\n",
        "print(l[::2])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0, 1, 2, 3, 4]\n",
            "[0, 1]\n",
            "[0, 2, 4]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_5HL_B8fUH8d",
        "colab_type": "text"
      },
      "source": [
        "Los elementos de una lista no tiene que ser todos del mismo tipo"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "H0S4yEMrTyyT",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "l = [1, 'a', 1.0]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FQGdlXIYYlm9",
        "colab_type": "text"
      },
      "source": [
        "Las listas en Python pueden ser anidadas arbitrariamente:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sjoWVomcYNrt",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "c6b15bd7-07ed-4886-e1e2-547b2ad69043"
      },
      "source": [
        "nested_list = [1, [2, [3, [4, [5]]]]]\n",
        "nested_list"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, [2, [3, [4, [5]]]]]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yqiXn-TuZ744",
        "colab_type": "text"
      },
      "source": [
        "Las listas desempeñan un papel muy importante en Python y, por ejemplo, se utilizan en bucles y otras estructuras de control de flujo. Hay una serie de funciones convenientes para generar listas de varios tipos"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UQ0HNFX2bpBz",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "99b49f7f-d769-4a60-fc44-8a33eebddd1a"
      },
      "source": [
        "inicio = 1\n",
        "final = 24\n",
        "paso = 3\n",
        "\n",
        "list(range(inicio, final, paso))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 4, 7, 10, 13, 16, 19, 22]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EOFMKZP-bzoL",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "f4325f7e-4da5-4f0f-85a2-b2efdcf8d8d4"
      },
      "source": [
        "# Convertir un string en una lista  mediante list\n",
        "s=\"Hola mundo\"\n",
        "print(s)\n",
        "\n",
        "s2 = list(s)\n",
        "\n",
        "s2"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hola mundo\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['H', 'o', 'l', 'a', ' ', 'm', 'u', 'n', 'd', 'o']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jYRGhv46cGAu",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "b3905773-7598-41e9-baaa-5fe02cb55a99"
      },
      "source": [
        "# Ordenar una lista\n",
        "s2.sort()\n",
        "\n",
        "print(s2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[' ', 'H', 'a', 'd', 'l', 'm', 'n', 'o', 'o', 'u']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZawsQcrodRAw",
        "colab_type": "text"
      },
      "source": [
        "***Adición, inserción, modificación y remoción de elementos de una lista***\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "o-s0S91Lc01M",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "c66e7348-4cc5-4704-9ade-0e2bd4baddf4"
      },
      "source": [
        "# Creación de una lista vacía\n",
        "l = []\n",
        "\n",
        "# Adición de elementos usando `append`\n",
        "l.append(\"A\")\n",
        "l.append(\"d\")\n",
        "l.append(\"d\")\n",
        "\n",
        "print(l)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['A', 'd', 'd']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "saJ9epsOeOxx",
        "colab_type": "text"
      },
      "source": [
        "Podemos modificar una lista al asignar nuevos valores a elementos de esa lista.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E-fLwhIBd_HN",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "08df0f08-5675-432a-cbe2-5f918a7d05e8"
      },
      "source": [
        "l[1] = \"s\"\n",
        "l[2] = \"m\"\n",
        "\n",
        "print(l)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['A', 'p', 't']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TiowOaCUey5H",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "139c5fb8-2503-4a45-8a78-3fc624ccb63f"
      },
      "source": [
        "l[1:3] = [\"k\", \"j\"]\n",
        "\n",
        "print(l)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['A', 's', 'm']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "91f_Y7k-fy2E",
        "colab_type": "text"
      },
      "source": [
        "Inserción de elementos mediante `insert`.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UBkhSj1le9Ec",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "477411bc-38e6-4de3-fd35-fa8bbe12dcc0"
      },
      "source": [
        "l.insert(0, \"i\")\n",
        "l.insert(1, \"n\")\n",
        "l.insert(2, \"s\")\n",
        "l.insert(3, \"e\")\n",
        "l.insert(4, \"r\")\n",
        "l.insert(5, \"t\")\n",
        "\n",
        "print(l)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['i', 'n', 's', 'e', 'r', 't', 'i', 'n', 'e', 'r', 't', 'm']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A0JcCM5rgL0u",
        "colab_type": "text"
      },
      "source": [
        "Remoción del primer elemento de un valor específico mendiante `remove`\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DDPYDJiEgA_d",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "879bc32a-d018-4ee6-940d-deef560ad927"
      },
      "source": [
        "#l.remove(\"A\")\n",
        "ls=[l.remove(x) for x in l if x==\"s\"]\n",
        "print(l)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['i', 'n', 'e', 'r', 't', 'i', 'n', 'e', 'r', 't', 'm']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D3vNk4hzgkS_",
        "colab_type": "text"
      },
      "source": [
        "Remoción de un elemento en una posición específica usando `del`\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cpHwJ3qrgfjW",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "198a7b34-a329-4028-c868-4fbd62a924e7"
      },
      "source": [
        "del l[7]\n",
        "del l[6]\n",
        "\n",
        "print(l)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['i', 'n', 's', 'e', 'r', 't']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LBALzn2RWaLD",
        "colab_type": "text"
      },
      "source": [
        "La concatenacion y las comparaciones tambien puede ser utilizadas en listas\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MhKUvB5zWjdc",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "1995b525-ac85-4b1e-95ca-9c7150febbfd"
      },
      "source": [
        "first=[1,2,3]\n",
        "second=first+[5,6]\n",
        "print(second)\n",
        "first==second"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 2, 3, 5, 6]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sfE-IN17W92K",
        "colab_type": "text"
      },
      "source": [
        "Finalmente, el operador **in** puede ser utilizado para detectar la presencia o ausencia de un elemento:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7gD0rGCIXMhE",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "f07f67a4-a15a-4837-d54e-65f0d6778d81"
      },
      "source": [
        "3 in [1, 2,3]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LNcysiRTeLLK",
        "colab_type": "text"
      },
      "source": [
        "Abordemos un poco el concepto de **Lists Comprehension**, que no es otra cosa que una forma abreviada de aplicar transformaciones a un iterable como lo son las listas"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7cG2FNAoejEI",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "d6e06921-0ecf-4091-df5a-a7bdd4fdb8ae"
      },
      "source": [
        "# Supongamos que queremos recuperar una lista con los valores de\n",
        "List = [1, 2, 3, 4, 5, 6, 7]\n",
        "# elevados al cuadrado, para eso usamos\n",
        "List_cuad=[x*x for x in List]\n",
        "print(List_cuad)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 4, 9, 16, 25, 36, 49]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XTRgc3EVpuPb",
        "colab_type": "text"
      },
      "source": [
        "**CHEATSHEET METODOS DE LISTAS**\n",
        "\n",
        "- **a.append(b)**: agrega **b** al final de una lista\n",
        "- **a.count(b)**: cuenta la cantidad de veces que aparece **b** en la lista\n",
        "- **a.extend([L])**:extiende una lista agregando un iterable  **L** al final (otra lista, o un range)\n",
        "- **a.index(b)**: devuelve el index de la primera apariciÓn de **b**\n",
        "- **a.insert(n,b)**: Inserta el elemento **b** en la posiciÓn n \n",
        "- **a.pop()**: devuelve el último elemento de la lista, y lo borra de la lista\n",
        "- **a.remove(b)**:  borra la primera aparición de **b** en la lista\n",
        "- **a.reverse()**:  invierte el orden de los elementos de una lista\n",
        "- **a.sort()**: ordena los elementos de una lista"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_Sh0W6mUdtml",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"stringsexercises\"></a></p>\n",
        "\n",
        "###2.4.2.1 Ejercicios de práctica"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZeycLmu3dxQP",
        "colab_type": "text"
      },
      "source": [
        "**Ejercicio 1: Dificultad Zero**\n",
        "\n",
        "Para la lista c=[1,2,3,4,5,6,7] generere una lista **d** cuyos elementos sean la raiz cuadrada de los elementos de **c**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wprXxmiGfadc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Desarrolle aqui el ejercicio\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mbKUiEfpfcYR",
        "colab_type": "text"
      },
      "source": [
        "De click **aquí** para ver la respuesta.\n",
        "\n",
        "<!---\n",
        "# No esperaba verte tan rápido aquí :(\n",
        "\n",
        "c=[1,2,3,4,5,6,7]\n",
        "d=[x**0.5 for x in c]\n",
        "print(d)\n",
        "\n",
        "--->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2y7BuLcXf_a0",
        "colab_type": "text"
      },
      "source": [
        "**Ejercicio 2: Dificultad Rookie**\n",
        "\n",
        "Concatene las siguientes listas \n",
        "- a=[\"Esta \"]\n",
        "- b=[\"sesion\",\"metodologia\"]\n",
        "\n",
        "en una sola de esta forma\n",
        "- c=[\"Esta sesion\",\"Esta metodologia\"]"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ta8RMg7hhKwm",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Desarrolle aqui el ejercicio\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nozVoB6XRQDN",
        "colab_type": "text"
      },
      "source": [
        "De click **aquí** para ver la respuesta.\n",
        "\n",
        "<!---\n",
        "# No esperaba verte tan rápido aquí :(\n",
        "\n",
        "a=[\"Esta \"]\n",
        "b=[\"sesion\",\"metodologia\"]\n",
        "c = [x+y for x in a for y in b]\n",
        "print(c)\n",
        "\n",
        "--->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fh0ztuu2i8hy",
        "colab_type": "text"
      },
      "source": [
        "**Ejercicio 3: Dificultad Hero**\n",
        "Dada la siguiente lista, remueva todos los numeros que sean multiplos de 3\n",
        "- a=[1,33,45,26,11,107,100,44,63,99,283245372]"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j58TCXG8jqgQ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "8f683b2b-ec36-44d8-d90f-bb2cc10e9ec8"
      },
      "source": [
        "#Desarrolle aqui el ejercicio\n",
        "a=[1,33,45,26,11,107,100,44,63,99,283245372]\n",
        "b=[n for n in a if n%3 != 0]\n",
        "print(b)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 26, 11, 107, 100, 44]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ifK_--WJkEiC",
        "colab_type": "text"
      },
      "source": [
        "De click **aquí** para ver la respuesta.\n",
        "\n",
        "<!---\n",
        "# No esperaba verte tan rápido aquí :(\n",
        "\n",
        "a=[1,33,45,26,11,107,100,44,63,99,283245372]\n",
        "b=[n for n in a if n%3 != 0]\n",
        "print(b)\n",
        "\n",
        "--->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ume8zCYKkLuC",
        "colab_type": "text"
      },
      "source": [
        "**Ejercicio 4: Dificultad Leyenda**\n",
        "Dadas las siguientes listas representando matrices cuadradas, retorne para cada una de ellas el valor de la suma de los elementos en sus diagonales\n",
        "\n",
        "- a = [[1,22,44,8],[4,15,6,12],[7,5,9,34],[11,22,33,22]]\n",
        " \n",
        "- b = [[-5,0,5],[3,3,0],[0,1,0]]\n",
        " \n",
        "\n",
        " \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mw2XOBHXm_i9",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Desarrolle aqui el ejercicio\n",
        "a = [[1,22,44,8],[4,15,6,12],[7,5,9,34],[11,22,33,22]]\n",
        " \n",
        "b = [[-5,0,5],[3,3,0],[0,1,0]]\n",
        " \n",
        "\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XWf2bujHnPv6",
        "colab_type": "text"
      },
      "source": [
        "De click **aquí** para ver la respuesta.\n",
        "\n",
        "<!---\n",
        "# No esperaba verte tan rápido aquí :(\n",
        "\n",
        "Oops los ejercicios de dificultad leyenda no tienen codigo, solo la solución correcta\n",
        "suma_diagonal(a)=47\n",
        "suma_diagonal(b)=-2\n",
        "\n",
        "--->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eGNjSLD5hAZJ",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"tuples\"></a></p>\n",
        "\n",
        "### 2.4.3. Tuplas\n",
        "\n",
        "[[Secciones]](#sections)\n",
        "\n",
        "Las tuplas son como las listas, excepto que estas no pueden ser modificadas una vez se han creado, es decir, son inmutables.\n",
        "\n",
        "En Python, las tuplas son creadas usando la sintaxis (..., ..., ...), incluso ..., ...:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bgEZfnRug28T",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "30b1c356-a799-43af-fb1a-4584c448df70"
      },
      "source": [
        "point = (10, 20)\n",
        "\n",
        "print(type(point))\n",
        "print(point)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'tuple'>\n",
            "(10, 20)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DLeii7DbpA8M",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "d1f3378d-ad47-4124-ae81-0e00df988316"
      },
      "source": [
        "# otro ejemplo de tupla\n",
        "tupla = None, 54321, 'hola!'\n",
        "print(tupla)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(None, 54321, 'hola!')\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z5icqhC3iQ2-",
        "colab_type": "text"
      },
      "source": [
        "Si intentamos asignar un nuevo valos a un elemento de la tupla, obtenemos un error:\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JJiZW6yth9UR",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "58bfb2b3-05f7-4ccf-ef18-cea65417bd00"
      },
      "source": [
        "try:\n",
        "    point[0] = 20\n",
        "except(TypeError) as er:\n",
        "    print(\"TypeError:\", er)\n",
        "else:\n",
        "    raise\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "TypeError: 'tuple' object does not support item assignment\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2lqSe4AVoko3",
        "colab_type": "text"
      },
      "source": [
        "**CHEATSHEET METODOS DE STRINGS**\n",
        "\n",
        "- a.count(b): Cuenta las veces que aparece b en la tupla a\n",
        "- a.index(b): Devuelve el index de la  primera aparición de b  en la tupla.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Bi_inaQGod1B",
        "colab_type": "text"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5VnTnXrfjPBJ",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"diccionarios\"></a></p>\n",
        "\n",
        "### 2.4.4. Diccionarios\n",
        "\n",
        "[[Secciones]](#sections)\n",
        "\n",
        "Como vimos, las listas organizan sus elementos por posición. Esta forma de organizacion es útil cuando queremos ubicar el primer, último o cada uno de los elementos de una secuencia \n",
        "Sin embargo, la posición de un dato puede ser irrelevante en algunos casos y solemos estar mas interesados en su asociación con otro elemento de la estrucutrua de datos\n",
        "Es ahí que se utlizan los **diccionarios**, los cuales organizan su información por asociación y no por posición.\n",
        "\n",
        "Los diccionarios son parecidos a las listas, excepto que cada elemento es una pareja key-value. La sintaxis en los diccionarios es de la forma {key1 : value1, ...}:\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Rdi35F11idbZ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "250044b9-0453-4c80-d69c-8b6173a472e4"
      },
      "source": [
        "info={'Name':'Molly', 'Age':18}\n",
        "\n",
        "print(type(info))\n",
        "print(info)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'dict'>\n",
            "{'Name': 'Molly', 'Age': 18}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2PZL5oYdktwF",
        "colab_type": "text"
      },
      "source": [
        "A las entradas de los diccionarios solo puede accederse mediante el nombre de la key.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "93n0akRtj8nX",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "377d72cb-d883-405c-a64e-98c68772e517"
      },
      "source": [
        "info[\"Name\"]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Molly'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VKmRpnJLlKQE",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "07b4cd46-9f7a-42ff-b867-b17d52fd70eb"
      },
      "source": [
        "info[\"Name\"] = \"John\"\n",
        "info[\"Age\"] = 14\n",
        "\n",
        "# podemos agregar una nueva entrada\n",
        "info[\"Lastname\"] = \"White\"\n",
        "\n",
        "print(info)\n",
        "\n",
        "#Los diccionarios vacios pueden generarse como\n",
        "d={}\n",
        "d=dict()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'Name': 'John', 'Age': 14, 'Lastname': 'White'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rX3CemkSvFB6",
        "colab_type": "text"
      },
      "source": [
        "**CHEATSHEET METODOS DE DICCIONARIOS**\n",
        "- **d.clear()**:  remueve todos los elementos\n",
        "- **d.copy()**:  devuelve una copia  superficial (shallow) del tipo diccionario.\n",
        "- **dict.fromkeys(L)**: crea un nuevo diccionario con claves a partir de la secuencia L.\n",
        "- **d.get('key')**: devuelve el valor en base a una coincidencia de búsqueda, de lo contrario devuelve el objeto None\n",
        "- **d.has_key('key')**: devuelve una lista de pares de diccionarios (key, value), como 2-tupla.\n",
        "- **d.items()**: devuelve un iterador sobre los valores del diccionario\n",
        "- **d.keys()**: devuelve una lista con las keys del diccionario\n",
        "- **d.pop('key')**: remueve específicamente una key del diccionario y devuelve valor correspondiente\n",
        "- **d.popitem()**: método remueve y devuelve **algún** par (key, value) del diccionario como una 2-tupla\n",
        "- **d.values()**: devuelve una lista de los valores del diccionario\n",
        "- **len(d)**: Retorna la longitud del diccionario (numero de keys)\n",
        "- **del d['key']**: es la misma sentencia integrada del en el interprete Python pero aplicada al uso de la secuencia de tipo diccionario\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sIoOVuE_yNNa",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"stringsexercises\"></a></p>\n",
        "\n",
        "###2.4.4.1 Ejercicios de práctica"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Chrtdw5sySTr",
        "colab_type": "text"
      },
      "source": [
        "**Ejercicio 1: Dificultad Rookie**\n",
        "\n",
        "Combine las siguientes dos listas en un diccionario\n",
        "\n",
        "- keys = ['diez', 'veinte', 'treinta']\n",
        "- values = [10, 20, 30]\n",
        "\n",
        "resultado={\"diez\":10,\"veinte\":20,\"treinta\":30}"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ybZ96_zOyTEX",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Realice aqui el ejercicio"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0VHjV26E2UUx",
        "colab_type": "text"
      },
      "source": [
        "De click **aquí** para ver la respuesta.\n",
        "\n",
        "<!---\n",
        "# No esperaba verte tan rápido aquí :(\n",
        "\n",
        "keys = ['diez', 'veinte', 'treinta']\n",
        "values = [10, 20, 30]\n",
        "\n",
        "resultado=dict(zip(keys, values))\n",
        "print(resultado)\n",
        "\n",
        "\n",
        "--->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d1ewpyeJ3BKF",
        "colab_type": "text"
      },
      "source": [
        "**Ejercicio 2: Dificultad Hero**\n",
        "\n",
        "Combine los siguientes dos diccionarios en uno solo\n",
        "\n",
        "- dict1 = {'Diez': 10, 'Veinte': 20, 'Treinta': 30}\n",
        "- dict2 = {'Treinta': 30, 'Cuarenta': 40, 'Cincuenta': 50}\n",
        "\n",
        "resultado={'Diez': 10, 'Veinte': 20, 'Treinta': 30,'Cuarenta': 40, 'Cincuenta': 50}"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yFnnDcJl3bPL",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Desarrolle aqui el ejercicio\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JEPfWwts3eZz",
        "colab_type": "text"
      },
      "source": [
        "De click **aquí** para ver la respuesta.\n",
        "\n",
        "<!---\n",
        "# No esperaba verte tan rápido aquí :(\n",
        "\n",
        "dict1 = {'Diez': 10, 'Veinte': 20, 'Treinta': 30}\n",
        "dict2 = {'Treinta': 30, 'Cuarenta': 40, 'Cincuenta': 50}\n",
        "\n",
        "resultado = dict1.copy()\n",
        "resultado.update(dict2)\n",
        "print(resultado)\n",
        "\n",
        "--->\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zlcutRUm4Bkr",
        "colab_type": "text"
      },
      "source": [
        "**Ejercicio 3: Dificultad Leyenda**\n",
        "\n",
        "Extraiga la materia del icfes con el mayor puntaje\n",
        "\n",
        "icfes = {\n",
        "  'Fisica': 82,\n",
        "  'Matematicas': 65,\n",
        "  'Filosofia': 75,\n",
        "  'Quimica':44,\n",
        "  'Español':98\n",
        "}\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NkQKpfK85XrQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Desarrolle aqui el ejercicio\n",
        "icfes = {\n",
        "  'Fisica': 82,\n",
        "  'Matematicas': 65,\n",
        "  'Filosofia': 75,\n",
        "  'Quimica':44,\n",
        "  'Español':98\n",
        "}\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xWe_FsNE5sL5",
        "colab_type": "text"
      },
      "source": [
        "De click **aquí** para ver la respuesta.\n",
        "\n",
        "<!---\n",
        "# No esperaba verte tan rápido aquí :(\n",
        "\n",
        "Oops los ejercicios de dificultad leyenda no tienen codigo, solo la solución correcta\n",
        "\n",
        "Quimica\n",
        "\n",
        "--->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_VWsFlNkpNRl",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"controlFlow\"></a></p>\n",
        "\n",
        "## 2.5. Condicionales: if, elif, else\n",
        "\n",
        "[[Secciones]](#sections)\n",
        "\n",
        "La sintaxis en Python para la ejecución de una condición  consiste en las palabras claves `if`, `elif` (else if), `else`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CijMmkrpnwvN",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "ff5effb0-15da-4711-9478-c349df1d7f98"
      },
      "source": [
        "statement1 = False\n",
        "statement2 = False\n",
        "\n",
        "if statement1:\n",
        "    print(\"statement1 es Verdadero\")\n",
        "\n",
        "elif statement2:\n",
        "    print(\"statement2 es Verdadero\")\n",
        "\n",
        "else:\n",
        "    print(\"statement1 y statement2 son Falsos\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "statement1 y statement2 son Falsos\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g4MYOnbjgLqz",
        "colab_type": "text"
      },
      "source": [
        "También podemos tener sentencias if anidadas"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wzJJZCW5gUfl",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "6a6eba3f-3724-4bfc-d458-3c5a6439587b"
      },
      "source": [
        "val = 100\n",
        "if val < 200:\n",
        "  print(\"El valor es menor a 200\")\n",
        "  if val == 150:\n",
        "    print(\"es 150\")\n",
        "  elif val == 100:\n",
        "    print(\"es 100\")\n",
        "  elif val == 50:\n",
        "    print(\"es 50\")\n",
        "  elif val < 50:\n",
        "    print(\"el valor es menor a 50\")\n",
        "else:\n",
        "  print(\"El valor es mayor a 200\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "El valor es menor a 200\n",
            "es 100\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZGKALHQO6ftK",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Ve a la tienda y compra una caja de huevos, si hay leche trae 2 cajas\n",
        "hay_leche=True\n",
        "leches_compradas=0\n",
        "huevos_comprados=0\n",
        "if hay_leche:\n",
        "  leches_compradas+=0\n",
        "  huevos_comprados+=2\n",
        "else:\n",
        "  huevos_compradas+=0\n",
        "#print(\"Traje \", leches_compradas, \" de leche\")   \n",
        "#print(\"Traje \", huevos_comprados, \" cajas de huevos\")   "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IxgWwr6vYMCM",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"iter\"></a></p>\n",
        "\n",
        "## 2.6. Iteraciones y ciclos lógicos\n",
        "\n",
        "En general, las instrucciones se ejecutan secuencialmente, pero puede haber casos  en los que se  necesite ejecutar un bloque de código varias veces.  Una instrucción de bucle nos permite ejecutar una instrucción o un grupo de instrucciones varias veces."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bU9DzFzicuXY",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"cicl\"></a></p>\n",
        "\n",
        "### 2.7.1. Ciclos for y while"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A7mB-8Ldo9O2",
        "colab_type": "text"
      },
      "source": [
        "El ciclo **for** ejecuta una secuencia de sentencias un número determinado de veces. La forma general de una sentencia para el **for** es la siguiente:\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "evZDZJxIiy9f",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "58b5bac9-03a8-4df3-d617-911ed74225ef"
      },
      "source": [
        "\"\"\"\n",
        "for variable in sequence:\n",
        "     code block\n",
        "\"\"\"     "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'\\nfor variable in sequence:\\n     code block\\n'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hw_Zr8GljpKi",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "9dc3bbb2-3bbe-4c90-8f53-20e7d47855b8"
      },
      "source": [
        "range(10)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "range(0, 10)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HGzBCk8mczIu",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 187
        },
        "outputId": "7be6c183-8116-4151-f328-3aeb9155f5f8"
      },
      "source": [
        "suma=0\n",
        "for i in range(10):\n",
        "  suma+=i\n",
        "  print('i=',i,'suma=',suma)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "i= 0 suma= 0\n",
            "i= 1 suma= 1\n",
            "i= 2 suma= 3\n",
            "i= 3 suma= 6\n",
            "i= 4 suma= 10\n",
            "i= 5 suma= 15\n",
            "i= 6 suma= 21\n",
            "i= 7 suma= 28\n",
            "i= 8 suma= 36\n",
            "i= 9 suma= 45\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0leX5evmkofI",
        "colab_type": "text"
      },
      "source": [
        "También podemos iterar sobre listas"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3C6vX-KOkrH8",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        },
        "outputId": "4d3baaf4-838c-4be6-c967-bb172b5616d2"
      },
      "source": [
        "vocales=[\"a\",\"e\",\"i\", \"o\",\"u\"]\n",
        "for i in vocales:\n",
        "  print(i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "a\n",
            "e\n",
            "i\n",
            "o\n",
            "u\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Oxq9vHErojz2",
        "colab_type": "text"
      },
      "source": [
        "El ciclo **while** repite una sentencia o grupo de sentencias mientras una condición dada es **TRUE**. Antes de ejecutar el cuerpo del ciclo, python evalua la  condición \n",
        "\n",
        "**Ojo con los bucles infinitos!!**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SiD67duwleAu",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "4e8da536-d7a6-47fa-800f-76c174dd0931"
      },
      "source": [
        "c = 10\n",
        "while c > 0:\n",
        "  print('c=',c,'se cumple la condición')\n",
        "  c-=1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "c= 4 se cumple la condición\n",
            "c= 3 se cumple la condición\n",
            "c= 2 se cumple la condición\n",
            "c= 1 se cumple la condición\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "USL7zCWvpv6h",
        "colab_type": "text"
      },
      "source": [
        "Podemos tener varias condiciones"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Mx9taaJUp4Gk",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 187
        },
        "outputId": "3bb421b1-4c80-4b19-ac72-60f143f9a4b8"
      },
      "source": [
        "c = 10\n",
        "while c > 0:\n",
        "  if c > 1 and c!=5:\n",
        "    print (\"Voy a hacerlo \"+str(c-1)+\" veces más\")\n",
        "  elif c==5:\n",
        "    print('Voy en '+str(c-1))\n",
        "  else:\n",
        "    print (\"¡Este es el último!\")\n",
        "  c -= 1 #c=c-1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Voy a hacerlo 9 veces más\n",
            "Voy a hacerlo 8 veces más\n",
            "Voy a hacerlo 7 veces más\n",
            "Voy a hacerlo 6 veces más\n",
            "Voy a hacerlo 5 veces más\n",
            "Voy en 4\n",
            "Voy a hacerlo 3 veces más\n",
            "Voy a hacerlo 2 veces más\n",
            "Voy a hacerlo 1 veces más\n",
            "¡Este es el último!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hOLaH_FrpXlJ",
        "colab_type": "text"
      },
      "source": [
        "Podemos usar uno o más ciclos dentro de otro. Esto lo conocemos como ciclos anidados\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cVhZf3jPpkRi",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 187
        },
        "outputId": "d2797879-a28b-4ecb-f860-15dac0dd7d02"
      },
      "source": [
        "for i in range(2):\n",
        "  for j in range(5):\n",
        "    print(\"i: %d j: %d\" %(i,j))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "i: 0 j: 0\n",
            "i: 0 j: 1\n",
            "i: 0 j: 2\n",
            "i: 0 j: 3\n",
            "i: 0 j: 4\n",
            "i: 1 j: 0\n",
            "i: 1 j: 1\n",
            "i: 1 j: 2\n",
            "i: 1 j: 3\n",
            "i: 1 j: 4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9fPm2y08dG_4",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"contr\"></a></p>\n",
        "\n",
        "### 2.7.2. Sentencias break y continue (control de ciclo)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RXO98upa4bFY",
        "colab_type": "text"
      },
      "source": [
        "Las sentencias de control de ciclo cambian la ejecución de su secuencia normal. Cuando la ejecución deja un ámbito, todos los objetos automáticos que se crearon en ese ámbito se destruyen."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YpKFrGYh5Rhx",
        "colab_type": "text"
      },
      "source": [
        "La sentencia de control **break*** termina el ciclo actual y reanuda la ejecución en la siguiente instrucción.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yKQo-97mdNJw",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "ca4152eb-d181-4b6b-8de7-2b54aafbc483"
      },
      "source": [
        "for i in vocales:\n",
        "  if i==\"o\":\n",
        "    break\n",
        "  print(i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "a\n",
            "e\n",
            "i\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GkNGlxJ46S8-",
        "colab_type": "text"
      },
      "source": [
        "La sentencia de control *continue* rechaza todas las declaraciones restantes en la iteración actual del ciclo y mueve el control de nuevo a la parte superior de este\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KxBFJyYu6qiT",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "604a4fa1-288d-4f5d-df50-6ffb2b25d192"
      },
      "source": [
        "for i in vocales:\n",
        "  if i==\"o\":\n",
        "    continue\n",
        "  print(i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "a\n",
            "e\n",
            "i\n",
            "u\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vpfhHZd9eiOF",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"func\"></a></p>\n",
        "\n",
        "## 2.8. Funciones y clases"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UQMFQFuy9XCo",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"funci\"></a></p>\n",
        "\n",
        "### 2.8.1. Funciones\n",
        "\n",
        "Una función es un bloque de código organizado y reutilizable que se utiliza para realizar una única acción relacionada. Las funciones proporcionan una mejor modularidad para su aplicación y un alto grado de reutilización de código. De momento hemos utilizado funciones preconstruidas en python, llegó la hora de diseñar nuestras propias funciones (user defined functions)\n",
        "\n",
        ">`def NombreFuncion(arg1,arg2,...):`\n",
        ">> `Cuerpo de la funcion (sentencias)`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3aNX6kn2Cjuq",
        "colab_type": "text"
      },
      "source": [
        "Definamos la función exponencial $a^b$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9GaLlcUceoC2",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "22ff5c41-ba62-4235-8b9d-dbc27d5befa4"
      },
      "source": [
        "def Exp(a,b):\n",
        "  exp = a**b\n",
        "  print(exp)\n",
        "  return\n",
        "  \n",
        "Exp(2,2)  "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "69ukeYx6CweR",
        "colab_type": "text"
      },
      "source": [
        "La sentencia *return* termina la función,  devolviendo opcionalmente uno o varios valores. Una declaración de retorno sin argumentos es lo mismo que devolver *none* (como en el caso anterior)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cgWrwPmf-MCk",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "f8b8077a-08f8-445e-93b6-e7bb00673699"
      },
      "source": [
        "def Exp(a,b):\n",
        "  return a**b\n",
        "  \n",
        "def Exp2(a,b):\n",
        "  return a**b,a**b+1,a**b+2\n",
        "\n",
        "print(Exp(2,2),type(Exp(2,2)))\n",
        "\n",
        "print(Exp2(2,2),type(Exp2(2,2)))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "4 <class 'int'>\n",
            "(4, 5, 6) <class 'tuple'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MgpVBDsQt0oz",
        "colab_type": "text"
      },
      "source": [
        "#### Ejemplo 1\n",
        "Escriba una funcion que retorne el valor maximo entre 2 números"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hwBP3iMYuC0O",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "18c31a91-ccee-46f9-ec46-5b836320a6d8"
      },
      "source": [
        "def maximo(x,y):\n",
        "  if x >y:\n",
        "    return x\n",
        "  else:\n",
        "    return y \n",
        "\n",
        "print(max(100,99.99999999))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "100\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WA7hlUJ7ulDK",
        "colab_type": "text"
      },
      "source": [
        "#### Ejemplo 2\n",
        "Escriba una funcion que reciba el nombre y apellido de una persona y que permita imprimirlo con el nombre primero o viceversa"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3Utie__NuzR8",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "d53bb66e-602d-4afe-9045-4d8119369b0e"
      },
      "source": [
        "def printNombre(Nombre, Apellido,reverse=True):\n",
        "  if reverse:\n",
        "    print(Apellido + \" ,\"+Nombre)\n",
        "  else:\n",
        "    print(Nombre+ \" ,\"+ Apellido)  \n",
        "printNombre(\"Florentino\",\"Ariza\")    "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Ariza ,Florentino\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bHfT1rk4vJ8I",
        "colab_type": "text"
      },
      "source": [
        "En este ultimo ejemplo el argumento **reverse** se denomina keyword argument ya que es un parametro con valores predeterminados."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Uu_H_WD0v9fe",
        "colab_type": "text"
      },
      "source": [
        "#### Ejemplo 3\n",
        "Miremos el proximo ejemplo"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P8f2uDyKwEC9",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "bb9b1c8f-8687-4e11-ba0a-829d6af1b952"
      },
      "source": [
        "def f(x):\n",
        "  y=1\n",
        "  x=x+y \n",
        "  print(\"x= \" ,x)\n",
        "  return x\n",
        "\n",
        "x=3\n",
        "y=2\n",
        "z=f(x)\n",
        "print(\"z= \",z)\n",
        "print(\"x= \",x)\n",
        "print(\"y= \",y)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "x=  4\n",
            "z=  4\n",
            "x=  3\n",
            "y=  2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_8goYmPZwcNv",
        "colab_type": "text"
      },
      "source": [
        "¿Por que hay dos valores diferentes de x?\n",
        "\n",
        "La explicacion se debe al \"alcance\" (scope) de la funcion. Cada funcion crea en su interior un **espacio** definitorio de variables, tambien llamado **scope** .\n",
        "El argumento formal **x** y la variable local **y** existen solo dentro de la funcion f(). "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VIiBUVrgxhxd",
        "colab_type": "text"
      },
      "source": [
        "#### Recursividad\n",
        "\n",
        "Esta técnica tiene semejanza a las demostraciones por induccion en donde se requiere primero de un caso base que a veces especifica directamente los casos especiales, ademas se necesita un segundo componente que seria el caso **recursivo** (inductivo)\n",
        "\n",
        "Veamos como utilizar la recursividad para programar la funcion n! (factorial). Recordemos:\n",
        "\n",
        "- 3!=1 x 2 x 3\n",
        "- 0!=1\n",
        "- 4!=1 x 2 x 3 x 4"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pL4pzV41yl-F",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "fc0abfe9-e942-4981-955d-11af84040367"
      },
      "source": [
        "def factorial(n):\n",
        "  \"\"\"\n",
        "  Asumamos que n es un entero mayor a 0\n",
        "  \"\"\"\n",
        "  if n==1 or n==0: #Caso base\n",
        "    return 1\n",
        "  else:\n",
        "    return n*factorial(n-1)  #Caso inductivo\n",
        "factorial(3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vinHcyT0zbvd",
        "colab_type": "text"
      },
      "source": [
        "**OJO** Aplicar recursiones es diferente a iterar con ciclos"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZYdT7yy72p-C",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"functionexercises\"></a></p>\n",
        "\n",
        "###2.8.1.1 Ejercicios de práctica"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gD8bn-Zo23ky",
        "colab_type": "text"
      },
      "source": [
        "**Ejercicio 1: Dificultad Zero**\n",
        "\n",
        "Escriba una función que retorne el mayor de tres números"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Dctxj6oI3DxC",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Desarrolle aqui el ejercicio"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aQ2V_ZRz3EPH",
        "colab_type": "text"
      },
      "source": [
        "De click **aquí** para ver la respuesta.\n",
        "\n",
        "<!---\n",
        "# No esperaba verte tan rápido aquí :(\n",
        "\n",
        "def max_dos( x, y ):\n",
        "    if x > y:\n",
        "        return x\n",
        "    return y\n",
        "def max_tres( x, y, z ):\n",
        "    return max_dos( x, max_dos( y, z ) )\n",
        "\n",
        "\n",
        "--->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7EoNHLXx3x4Z",
        "colab_type": "text"
      },
      "source": [
        "**Ejercicio 2: Dificultad Rookie**\n",
        "\n",
        "Escriba una función que sume los valores de una lista que contiene numeros"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OtdGQA7X38Nh",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Desarrolle aqui el ejercicio"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ojvUXuCa3_UU",
        "colab_type": "text"
      },
      "source": [
        "De click **aquí** para ver la respuesta.\n",
        "\n",
        "<!---\n",
        "# No esperaba verte tan rápido aquí :(\n",
        "\n",
        "def suma(numeros):\n",
        "    total = 0\n",
        "    for x in numeros:\n",
        "        total += x\n",
        "    return total\n",
        "    \n",
        "--->\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fNLsCTyF4XSM",
        "colab_type": "text"
      },
      "source": [
        "**Ejercicio 3: Dificultad Rookie**\n",
        "\n",
        "Escriba una función que diga si un numero es par o impar"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Nz3xP3_R4jLs",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Desarrolle aqui el ejercicio\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HdfYYvgC44IK",
        "colab_type": "text"
      },
      "source": [
        "De click **aquí** para ver la respuesta.\n",
        "\n",
        "<!---\n",
        "# No esperaba verte tan rápido aquí :(\n",
        "\n",
        "def par_impar(x):\n",
        "  if x%2==0:\n",
        "    return(print(\"par\"))\n",
        "  else:\n",
        "    return(print(\"impar\"))\n",
        "par_impar(17)\n",
        "    \n",
        "--->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n_g_Ql-u5DKo",
        "colab_type": "text"
      },
      "source": [
        "**Ejercicio 4: Dificultad Rookie**\n",
        "\n",
        "Escriba una función que reciba una lista con numeros y retorne una nueva lista sin valores repetidos"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yOx2AxQW5xdt",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Desarrolle aqui el ejercicio"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NDQ30Byf52yk",
        "colab_type": "text"
      },
      "source": [
        "De click **aquí** para ver la respuesta.\n",
        "\n",
        "<!---\n",
        "# No esperaba verte tan rápido aquí :(\n",
        "\n",
        "def lista_sin_repetir(l):\n",
        "  x = []\n",
        "  for a in l:\n",
        "    if a not in x:\n",
        "      x.append(a)\n",
        "  return x\n",
        "    \n",
        "--->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TFtsvgPN6Ss_",
        "colab_type": "text"
      },
      "source": [
        "**Ejercicio 4: Dificultad Hero**\n",
        "\n",
        "Escriba una función que diga si un numero es primo"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "veklFRTO6bEm",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Desarrolle aqui el ejercicio\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JhJCYPs18uou",
        "colab_type": "text"
      },
      "source": [
        "**Ejercicio 5: Dificultad Leyenda**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y_k_hdVV-fHK",
        "colab_type": "text"
      },
      "source": [
        "Genere un numero aleatorio entre 1 y 9 (incluyendo al 1 y al 9). Pregunte al usuario por un numero, luego dgale si esta por debajo, o por encima, o finalmente correcto. (Pista: utilice la funcion **input** y el modulo **random** para este ejercicio)\n",
        "\n",
        "Extras:\n",
        "\n",
        "- El juego sigue actvo hasta que el jugador escriba “exit” o adivine el numero\n",
        "- Lleve registro del numero de intentos que le toma al jugador, imprima este valor cuando el juego termine."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ctcl7y2Z7i1Y",
        "colab_type": "text"
      },
      "source": [
        "De click **aquí** para ver la respuesta.\n",
        "\n",
        "<!---\n",
        "# No esperaba verte tan rápido aquí :(\n",
        "\n",
        "def es_primo(n):\n",
        "    if (n==1):\n",
        "        return False\n",
        "    elif (n==2):\n",
        "        return True;\n",
        "    else:\n",
        "        for x in range(2,int(n**0.5)):\n",
        "            if(n % x==0):\n",
        "                return False\n",
        "        return True    \n",
        "\n",
        "    \n",
        "--->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qA5jEatkIJUU",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "<p><a name=\"class\"></a></p>\n",
        "\n",
        "### 2.8.2 Programacion Orientada a Objetos (Clases)\n",
        "El paradigma de la programacion orientada a objetos se basa en la modelacion de datos y operaciones como uan pareja intimamente relacionada en lugar de elementos separados.\n",
        "\n",
        "Como primer ejemplo imagine una fotografia digital, la cual puede ser considerada por algunos como una simple coleccionde informacion (pixeles). Sin embargo, en un framework de programacion orientada a objetos la imagen es en realidad un objeto que puede soporta multiples operaciones en sí tales como rotacion, cambio de escala, filtros, etc.. \n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XpvNxBnGF9WP",
        "colab_type": "text"
      },
      "source": [
        "Las clases proporcionan un medio de agrupar datos y \"funcionalidad\". La creación de una nueva clase crea un nuevo tipo de objeto, lo que permite crear nuevas *instancias* de ese tipo. Cada instancia de la clase puede tener sus propios atributos. Las instancias de una clase también pueden tener *métodos* (definidos por su clase) para modificar su estado.\n",
        "\n",
        ">class Name():\n",
        ">>sentencias"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-loYl6I1JaGB",
        "colab_type": "text"
      },
      "source": [
        "Los atributos son como propiedades que queremos añadir a la clase "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IJEykQm3JtnC",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Creamos la clase television con la configuracion de fabrica\n",
        "class Television:\n",
        "  def __init__(self):\n",
        "    self._powerOn = False\n",
        "    self._muted = False\n",
        "    self._volume = 5\n",
        "    self._channel = 2\n",
        "    self._prevChan = 2\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YS5NKSJ4LXPb",
        "colab_type": "text"
      },
      "source": [
        "Dentro de las clases podemos definir funciones, conocidas como *métodos* "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bXc_GQGHKgV8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Creamos la clase television con la configuracion de fabrica\n",
        "class Television:\n",
        "  def __init__(self):\n",
        "    self._powerOn = False\n",
        "    self._muted = False\n",
        "    self._volume = 5\n",
        "    self._channel = 2\n",
        "    self._prevChan = 2\n",
        "  #Metodo de encendido y apagado\n",
        "  def togglePower(self):\n",
        "    self._powerOn = not self._powerOn\n",
        "  #Metodo de Mute\n",
        "  def toggleMute(self):\n",
        "    if self._powerOn:\n",
        "      self._muted = not self._muted\n",
        "\n",
        "  # Metodo para subir volumen\n",
        "  def volumeUp(self):\n",
        "    if self._powerOn:\n",
        "      if self._volume < 10:\n",
        "        self._volume += 1\n",
        "        self._muted = False\n",
        "        return self._volume\n",
        "  #Metodo para cambiar de canal\n",
        "  def channelUp(self):\n",
        "    if self._powerOn:\n",
        "      self._prevChan = self._channel # record the current value\n",
        "      if self._channel == 99:\n",
        "        self._channel = 2 # wrap around to minimum\n",
        "      else:\n",
        "        self._channel += 1\n",
        "      return self._channel\n",
        "  #Previous channel\n",
        "\n",
        "  def jumpPrevChannel(self):\n",
        "    if self._powerOn:\n",
        "      incoming = self._channel\n",
        "      self._channel = self._prevChan\n",
        "      self._prevChan = incoming\n",
        "      return self._channel\n",
        "\n",
        "  def __str__(self):\n",
        "    display = 'Power setting is currently ' + str(self._powerOn) +'\\n'\n",
        "    display += 'Volume setting is currently ' + str(self._volume) +'\\n'\n",
        "    display += 'Mute is currently ' + str(self._muted)\n",
        "    return display\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MZJkf1TLNb2l",
        "colab_type": "text"
      },
      "source": [
        "Los métodos necesitan tener un argumento convenientemente llamado self, que se refiere al objeto del método que está siendo llamado. Podemos pasar más de un argumento si así lo deseamos"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N4UVpxBDJuyS",
        "colab_type": "text"
      },
      "source": [
        "Utilicemos el televisor luego de sacarlo de la caja"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "naLjqVJeJzNH",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "televisor_sala=Television()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TBWOPyX6J4sB",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "68ec1726-0da1-4d6c-aafc-9f160584ac02"
      },
      "source": [
        "#Encendamos el televisor\n",
        "televisor_sala.togglePower()\n",
        "print(televisor_sala)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Power setting is currently True\n",
            "Volume setting is currently 5\n",
            "Mute is currently False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v4NvUW_MKF8z",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "f76e6a05-1f27-4935-cbce-ef530cec1d1d"
      },
      "source": [
        "#Subamos el volumen a 8\n",
        "televisor_sala.volumeUp()\n",
        "televisor_sala.volumeUp()\n",
        "televisor_sala.volumeUp()\n",
        "print(televisor_sala)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Power setting is currently True\n",
            "Volume setting is currently 8\n",
            "Mute is currently False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NsHJ6KxFLAeP",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "379804a2-9195-41ca-cbb7-231cb79e3791"
      },
      "source": [
        "#Pongamos el tour para ver a Nairo y a Egan\n",
        "televisor_sala.channelUp()\n",
        "print(televisor_sala)\n",
        "print(\"Canal\" , televisor_sala._channel)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Power setting is currently True\n",
            "Volume setting is currently 8\n",
            "Mute is currently False\n",
            "Canal 7\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MBpqZ2D_L1Mq",
        "colab_type": "text"
      },
      "source": [
        "#### Aplicacion financiera de OOP: HIPOTECAS (Caso Avanzado)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v2IjIJTLMVGR",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 119
        },
        "outputId": "9d0645d4-1b6f-4129-a8af-51d7227e9fe6"
      },
      "source": [
        "#Tomado de Guttag, J. V. (2013). Introduction to computation and programming using Python. Mit Press.\n",
        "import pylab\n",
        "def findPayment(loan, r, m):\n",
        "    \"\"\"Assumes: loan and r are floats, m an int\n",
        "    Returns the monthly payment for a mortgage of size\n",
        "    loan at a monthly rate of r for m months\"\"\"\n",
        "    return loan*((r*(1+r)**m)/((1+r)**m - 1))\n",
        "\n",
        "class Mortgage(object):\n",
        "    \"\"\"Abstract class for building different kinds of mortgages\"\"\"\n",
        "    def __init__(self, loan, annRate, months):\n",
        "        \"\"\"Create a new mortgage\"\"\"\n",
        "        self.loan = loan\n",
        "        self.rate = annRate/12.0\n",
        "        self.months = months\n",
        "        self.paid = [0.0]\n",
        "        self.owed = [loan]\n",
        "        self.payment = findPayment(loan, self.rate, months)\n",
        "        self.legend = None #description of mortgage\n",
        "\n",
        "    def makePayment(self):\n",
        "        \"\"\"Make a payment\"\"\"\n",
        "        self.paid.append(self.payment)\n",
        "        reduction = self.payment - self.owed[-1]*self.rate\n",
        "        self.owed.append(self.owed[-1] - reduction)\n",
        "\n",
        "    def getTotalPaid(self):\n",
        "        \"\"\"Return the total amount paid so far\"\"\"\n",
        "        return sum(self.paid)\n",
        "\n",
        "    def __str__(self):\n",
        "        return self.legend\n",
        "\n",
        "\n",
        "# fixed-rate mortgage\n",
        "class Fixed(Mortgage):\n",
        "    def __init__(self, loan, r, months):\n",
        "        Mortgage.__init__(self, loan, r, months)\n",
        "        self.legend = 'Fixed, ' + str(r*100) + '%'\n",
        "\n",
        "# fixed-rate mortgage with up-front points\n",
        "class FixedWithPts(Fixed):\n",
        "    def __init__(self, loan, r, months, pts):\n",
        "        Fixed.__init__(self, loan, r, months)\n",
        "        self.pts = pts\n",
        "        self.paid = [loan*(pts/100.0)]\n",
        "        self.legend += ', ' + str(pts) + ' points'\n",
        "\n",
        "# mortgage that changes interest rate after 48 months\n",
        "class TwoRate(Mortgage):\n",
        "    def __init__(self,loan,r,months,teaserRate,teaserMonths):\n",
        "        Mortgage.__init__(self, loan, teaserRate, months)\n",
        "        self.teaserMonths = teaserMonths\n",
        "        self.teaserRate = teaserRate\n",
        "        self.nextRate = r/12.0\n",
        "        self.legend = str(teaserRate*100)\\\n",
        "            + '% for ' + str(self.teaserMonths)\\\n",
        "            + ' months, then ' + str(r*100) + '%'\n",
        "\n",
        "    def makePayment(self):\n",
        "        if len(self.paid) == self.teaserMonths + 1:\n",
        "            self.rate = self.nextRate\n",
        "            self.payment = findPayment(self.owed[-1], self.rate,\n",
        "                                       self.months - \\\n",
        "                                       self.teaserMonths)\n",
        "        Mortgage.makePayment(self)\n",
        "\n",
        "\n",
        "# helper function to try out alternatives\n",
        "def compareMortgages(amt, years, fixedRate, pts, ptsRate,\n",
        "                     varRate1, varRate2, varMonths):\n",
        "    # create alternative mortgages\n",
        "    totMonths = years*12\n",
        "    fixed1 = Fixed(amt, fixedRate, totMonths)\n",
        "    fixed2 = FixedWithPts(amt, ptsRate, totMonths, pts)\n",
        "    twoRate = TwoRate(amt, varRate2, totMonths, varRate1,\n",
        "                      varMonths)\n",
        "    morts = [fixed1, fixed2, twoRate]\n",
        "    \n",
        "    # run experiment!\n",
        "    for m in range(totMonths):\n",
        "        for mort in morts:\n",
        "            mort.makePayment()\n",
        "            \n",
        "    # report results\n",
        "    for m in morts:\n",
        "        print (m)\n",
        "        print (' Total payments = $' + str(int(m.getTotalPaid())))\n",
        "\n",
        "# amount borrowed: $200,000\n",
        "# term: 30 years\n",
        "#  option 1: rate = 7%\n",
        "#  option 2: 3.25 points upfront, rate = 5%\n",
        "#  option 3: 48 months of rate = 5%, then rate = 9.5%\n",
        "\n",
        "compareMortgages(amt=200000, years=30,\n",
        "                 fixedRate=0.07,\n",
        "                 pts = 3.25, ptsRate=0.05,\n",
        "                 varRate1=0.045, varRate2=0.095, varMonths=48)\n",
        "  \n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Fixed, 7.000000000000001%\n",
            " Total payments = $479017\n",
            "Fixed, 5.0%, 3.25 points\n",
            " Total payments = $393011\n",
            "4.5% for 48 months, then 9.5%\n",
            " Total payments = $551444\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J7ZQBUmLX-5W",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"inout\"></a></p>\n",
        "\n",
        "## 2.9. Archivos de entrada y salida"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l77fqeASuu8M",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"lecte\"></a></p>\n",
        "\n",
        "### 2.9.1. Lectura de entrada de teclado\n",
        "\n",
        "Python proporciona una función integrada <code>input()</code> para leer una línea de texto de la entrada estándar"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_BlE3ChRwLWw",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "ac21f883-b075-4f73-fb50-d6b27ad8f769"
      },
      "source": [
        "a = input('Ingresa un número ')\n",
        "print('El número que ingresaste es:',a)\n",
        "type(a)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Ingresa un número 4\n",
            "El número que ingresaste es: 4\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "str"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 96
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VdQ-axsMvc3j",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "independientemente de lo que ingrese como entrada, la función <code>input()</code> siempre lo convierte en una cadena de caracteres. Podemos utilizar las funciones <code>int()</code> y <code>float()</code> para obtener enteros y números de punto flotante respectivamente"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PiGCw4Hhvjle",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "df5dbdd0-2247-4ea6-8c2b-1a077396e1de"
      },
      "source": [
        "numero_entero = int(input('Ingresa un número'))\n",
        "print(numero_entero,type(numero_entero))\n",
        "\n",
        "numero_pflotante = float(input('Ingresa un número'))\n",
        "print(numero_pflotante,type(numero_pflotante))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Ingresa in unúmero4\n",
            "4 <class 'int'>\n",
            "Ingresa un número1.2\n",
            "1.2 <class 'float'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ijXdq98t2MNv",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"apyci\"></a></p>\n",
        "\n",
        "### 2.9.2. Apertura y cierre de archivos\n",
        "\n",
        "Python proporciona funciones básicas y métodos necesarios para manipular archivos de forma predeterminada. Se puede realizar la mayor parte de la manipulación de archivos utilizando un objeto tipo <code>file</code>. Antes de poder leer o escribir un archivo, debemos abrirlo con la función <code> open() </code>incorporada de Python. Para cerrarlo utilizamos la función <code>close()</code>."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CbZ12uaW4Caf",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "2d58be53-c600-4f59-8d99-e24d09748e0b"
      },
      "source": [
        "fo = open(\"foo.txt\", \"w\")\n",
        "print(\"Nombre del archivo: \", fo.name)\n",
        "print('Modo con el que se abrió el archivo:',fo.mode)\n",
        "print('Cerrado:',fo.closed)\n",
        "fo.close()\n",
        "print('Cerrado:',fo.closed)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Nombre del archivo:  foo.txt\n",
            "Modo con el que se abrió el archivo: w\n",
            "Cerrado: False\n",
            "Cerrado: True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ytfz7pN746NF",
        "colab_type": "text"
      },
      "source": [
        "Modos comunes: w (Escritura), r (Lectura), a (Añadir)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WEzHJDo92r3N",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"leyes\"></a></p>\n",
        "\n",
        "### 2.9.3. Leer y escribir archivos\n",
        "\n",
        "El objeto <code>file</code> proporciona un conjunto de métodos de acceso para facilitar nuestras vidas. Veríamos cómo usar los métodos <code>write()</code> y <code>read()</code> para leer y escribir archivos."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uBBeOHSi6ZdQ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "c731731c-b375-4e77-d1dc-d1b433819e7a"
      },
      "source": [
        "fo = open(\"foo.txt\", \"w\")\n",
        "fo.write( \"¡Hola \\n mundo!\")\n",
        "fo.close()\n",
        "\n",
        "!cat foo.txt"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "¡Hola \n",
            " mundo!"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g0XC6crT7DQ0",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "aa1783e2-1cc1-4f71-e0a3-f3f22764944b"
      },
      "source": [
        "fo = open(\"foo.txt\", \"r\")\n",
        "\n",
        "print(fo.readline())\n",
        "\n",
        "#print(fo.read())\n",
        "\n",
        "#print(fo.read(2))\n",
        "\n",
        "fo.close()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "¡Hola \n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pikqdJs-YKu3",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"subar\"></a></p>\n",
        "\n",
        "### 2.9.4. Subir archivos locales\n",
        "\n",
        "El método <code>files.upload</code> devolverá un diccionario de los archivos que se han subido. Al diccionario se le asignará el nombre del archivo como clave y los valores serán los datos que se han subido (los archivos permanecen en la máquina virtual por 12 horas)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NTmx_P9EYDVd",
        "colab_type": "code",
        "colab": {
          "resources": {
            "http://localhost:8080/nbextensions/google.colab/files.js": {
              "data": "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",
              "ok": true,
              "headers": [
                [
                  "content-type",
                  "application/javascript"
                ]
              ],
              "status": 200,
              "status_text": ""
            }
          },
          "base_uri": "https://localhost:8080/",
          "height": 37
        },
        "outputId": "e0ebff2d-d112-4c06-b99c-1d434d592201"
      },
      "source": [
        "from google.colab import files\n",
        "\n",
        "uploaded = files.upload()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-e68815d1-5cac-4fa6-aa94-7f0150b8a416\" name=\"files[]\" multiple disabled />\n",
              "     <output id=\"result-e68815d1-5cac-4fa6-aa94-7f0150b8a416\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script src=\"/nbextensions/google.colab/files.js\"></script> "
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Izd6XV1VZC31",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"des\"></a></p>\n",
        "\n",
        "### 2.9.5. Descargar archivos en tu sistema local \n",
        "\n",
        "El método <code>files.download</code> invocará al navegador para que descargue el archivo en tu ordenador local."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yrPSVqGjY-JJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from google.colab import files\n",
        "\n",
        "with open('example.txt', 'w') as f:\n",
        "  f.write('some content')\n",
        "\n",
        "files.download('example.txt')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Nn1gvaOJ-TWs",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"goodr\"></a></p>\n",
        "\n",
        "### 2.9.6. Google drive: Paquete PyDrive"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zRhwvA69E1Mk",
        "colab_type": "text"
      },
      "source": [
        "Instalamos el paquete"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3MqqWLOc_g95",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "f82333cc-4bee-4aad-a2bd-fbf3ceff28f5"
      },
      "source": [
        "!pip install --upgrade --quiet PyDrive\n",
        "\n",
        "from pydrive.auth import GoogleAuth\n",
        "from pydrive.drive import GoogleDrive\n",
        "from google.colab import auth\n",
        "from oauth2client.client import GoogleCredentials"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[?25l\r\u001b[K     |▎                               | 10kB 19.9MB/s eta 0:00:01\r\u001b[K     |▋                               | 20kB 25.6MB/s eta 0:00:01\r\u001b[K     |█                               | 30kB 29.9MB/s eta 0:00:01\r\u001b[K     |█▎                              | 40kB 34.2MB/s eta 0:00:01\r\u001b[K     |█▋                              | 51kB 37.2MB/s eta 0:00:01\r\u001b[K     |██                              | 61kB 41.0MB/s eta 0:00:01\r\u001b[K     |██▎                             | 71kB 42.5MB/s eta 0:00:01\r\u001b[K     |██▋                             | 81kB 43.0MB/s eta 0:00:01\r\u001b[K     |███                             | 92kB 44.4MB/s eta 0:00:01\r\u001b[K     |███▎                            | 102kB 46.0MB/s eta 0:00:01\r\u001b[K     |███▋                            | 112kB 46.0MB/s eta 0:00:01\r\u001b[K     |████                            | 122kB 46.0MB/s eta 0:00:01\r\u001b[K     |████▎                           | 133kB 46.0MB/s eta 0:00:01\r\u001b[K     |████▋                           | 143kB 46.0MB/s eta 0:00:01\r\u001b[K     |█████                           | 153kB 46.0MB/s eta 0:00:01\r\u001b[K     |█████▎                          | 163kB 46.0MB/s eta 0:00:01\r\u001b[K     |█████▋                          | 174kB 46.0MB/s eta 0:00:01\r\u001b[K     |██████                          | 184kB 46.0MB/s eta 0:00:01\r\u001b[K     |██████▎                         | 194kB 46.0MB/s eta 0:00:01\r\u001b[K     |██████▋                         | 204kB 46.0MB/s eta 0:00:01\r\u001b[K     |███████                         | 215kB 46.0MB/s eta 0:00:01\r\u001b[K     |███████▎                        | 225kB 46.0MB/s eta 0:00:01\r\u001b[K     |███████▋                        | 235kB 46.0MB/s eta 0:00:01\r\u001b[K     |████████                        | 245kB 46.0MB/s eta 0:00:01\r\u001b[K     |████████▎                       | 256kB 46.0MB/s eta 0:00:01\r\u001b[K     |████████▋                       | 266kB 46.0MB/s eta 0:00:01\r\u001b[K     |█████████                       | 276kB 46.0MB/s eta 0:00:01\r\u001b[K     |█████████▎                      | 286kB 46.0MB/s eta 0:00:01\r\u001b[K     |█████████▋                      | 296kB 46.0MB/s eta 0:00:01\r\u001b[K     |██████████                      | 307kB 46.0MB/s eta 0:00:01\r\u001b[K     |██████████▎                     | 317kB 46.0MB/s eta 0:00:01\r\u001b[K     |██████████▋                     | 327kB 46.0MB/s eta 0:00:01\r\u001b[K     |███████████                     | 337kB 46.0MB/s eta 0:00:01\r\u001b[K     |███████████▎                    | 348kB 46.0MB/s eta 0:00:01\r\u001b[K     |███████████▋                    | 358kB 46.0MB/s eta 0:00:01\r\u001b[K     |████████████                    | 368kB 46.0MB/s eta 0:00:01\r\u001b[K     |████████████▎                   | 378kB 46.0MB/s eta 0:00:01\r\u001b[K     |████████████▋                   | 389kB 46.0MB/s eta 0:00:01\r\u001b[K     |█████████████                   | 399kB 46.0MB/s eta 0:00:01\r\u001b[K     |█████████████▎                  | 409kB 46.0MB/s eta 0:00:01\r\u001b[K     |█████████████▋                  | 419kB 46.0MB/s eta 0:00:01\r\u001b[K     |██████████████                  | 430kB 46.0MB/s eta 0:00:01\r\u001b[K     |██████████████▎                 | 440kB 46.0MB/s eta 0:00:01\r\u001b[K     |██████████████▋                 | 450kB 46.0MB/s eta 0:00:01\r\u001b[K     |███████████████                 | 460kB 46.0MB/s eta 0:00:01\r\u001b[K     |███████████████▎                | 471kB 46.0MB/s eta 0:00:01\r\u001b[K     |███████████████▋                | 481kB 46.0MB/s eta 0:00:01\r\u001b[K     |████████████████                | 491kB 46.0MB/s eta 0:00:01\r\u001b[K     |████████████████▎               | 501kB 46.0MB/s eta 0:00:01\r\u001b[K     |████████████████▋               | 512kB 46.0MB/s eta 0:00:01\r\u001b[K     |█████████████████               | 522kB 46.0MB/s eta 0:00:01\r\u001b[K     |█████████████████▎              | 532kB 46.0MB/s eta 0:00:01\r\u001b[K     |█████████████████▋              | 542kB 46.0MB/s eta 0:00:01\r\u001b[K     |██████████████████              | 552kB 46.0MB/s eta 0:00:01\r\u001b[K     |██████████████████▎             | 563kB 46.0MB/s eta 0:00:01\r\u001b[K     |██████████████████▋             | 573kB 46.0MB/s eta 0:00:01\r\u001b[K     |███████████████████             | 583kB 46.0MB/s eta 0:00:01\r\u001b[K     |███████████████████▎            | 593kB 46.0MB/s eta 0:00:01\r\u001b[K     |███████████████████▋            | 604kB 46.0MB/s eta 0:00:01\r\u001b[K     |████████████████████            | 614kB 46.0MB/s eta 0:00:01\r\u001b[K     |████████████████████▎           | 624kB 46.0MB/s eta 0:00:01\r\u001b[K     |████████████████████▋           | 634kB 46.0MB/s eta 0:00:01\r\u001b[K     |█████████████████████           | 645kB 46.0MB/s eta 0:00:01\r\u001b[K     |█████████████████████▎          | 655kB 46.0MB/s eta 0:00:01\r\u001b[K     |█████████████████████▋          | 665kB 46.0MB/s eta 0:00:01\r\u001b[K     |██████████████████████          | 675kB 46.0MB/s eta 0:00:01\r\u001b[K     |██████████████████████▎         | 686kB 46.0MB/s eta 0:00:01\r\u001b[K     |██████████████████████▋         | 696kB 46.0MB/s eta 0:00:01\r\u001b[K     |███████████████████████         | 706kB 46.0MB/s eta 0:00:01\r\u001b[K     |███████████████████████▎        | 716kB 46.0MB/s eta 0:00:01\r\u001b[K     |███████████████████████▋        | 727kB 46.0MB/s eta 0:00:01\r\u001b[K     |████████████████████████        | 737kB 46.0MB/s eta 0:00:01\r\u001b[K     |████████████████████████▎       | 747kB 46.0MB/s eta 0:00:01\r\u001b[K     |████████████████████████▋       | 757kB 46.0MB/s eta 0:00:01\r\u001b[K     |████████████████████████▉       | 768kB 46.0MB/s eta 0:00:01\r\u001b[K     |█████████████████████████▏      | 778kB 46.0MB/s eta 0:00:01\r\u001b[K     |█████████████████████████▌      | 788kB 46.0MB/s eta 0:00:01\r\u001b[K     |█████████████████████████▉      | 798kB 46.0MB/s eta 0:00:01\r\u001b[K     |██████████████████████████▏     | 808kB 46.0MB/s eta 0:00:01\r\u001b[K     |██████████████████████████▌     | 819kB 46.0MB/s eta 0:00:01\r\u001b[K     |██████████████████████████▉     | 829kB 46.0MB/s eta 0:00:01\r\u001b[K     |███████████████████████████▏    | 839kB 46.0MB/s eta 0:00:01\r\u001b[K     |███████████████████████████▌    | 849kB 46.0MB/s eta 0:00:01\r\u001b[K     |███████████████████████████▉    | 860kB 46.0MB/s eta 0:00:01\r\u001b[K     |████████████████████████████▏   | 870kB 46.0MB/s eta 0:00:01\r\u001b[K     |████████████████████████████▌   | 880kB 46.0MB/s eta 0:00:01\r\u001b[K     |████████████████████████████▉   | 890kB 46.0MB/s eta 0:00:01\r\u001b[K     |█████████████████████████████▏  | 901kB 46.0MB/s eta 0:00:01\r\u001b[K     |█████████████████████████████▌  | 911kB 46.0MB/s eta 0:00:01\r\u001b[K     |█████████████████████████████▉  | 921kB 46.0MB/s eta 0:00:01\r\u001b[K     |██████████████████████████████▏ | 931kB 46.0MB/s eta 0:00:01\r\u001b[K     |██████████████████████████████▌ | 942kB 46.0MB/s eta 0:00:01\r\u001b[K     |██████████████████████████████▉ | 952kB 46.0MB/s eta 0:00:01\r\u001b[K     |███████████████████████████████▏| 962kB 46.0MB/s eta 0:00:01\r\u001b[K     |███████████████████████████████▌| 972kB 46.0MB/s eta 0:00:01\r\u001b[K     |███████████████████████████████▉| 983kB 46.0MB/s eta 0:00:01\r\u001b[K     |████████████████████████████████| 993kB 46.0MB/s \n",
            "\u001b[?25h  Building wheel for PyDrive (setup.py) ... \u001b[?25l\u001b[?25hdone\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cF_5W_5rE3X6",
        "colab_type": "text"
      },
      "source": [
        "Nos autenticamos"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KiU3s2gKALvq",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "auth.authenticate_user()\n",
        "gauth = GoogleAuth()\n",
        "gauth.credentials = GoogleCredentials.get_application_default()\n",
        "drive = GoogleDrive(gauth)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5yUUmDgcE7Mo",
        "colab_type": "text"
      },
      "source": [
        "Subir un archivo al Drive"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TPkzJMQVAOyJ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "9b184425-e630-4f5a-ed53-331d38246abe"
      },
      "source": [
        "uploaded = drive.CreateFile({'title': 'Sample upload.txt'})\n",
        "uploaded.SetContentString('Sample upload file content')\n",
        "uploaded.Upload()\n",
        "print('Uploaded file with ID {}'.format(uploaded.get('id')))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Uploaded file with ID 1chgUFynYuS1sD4AsNbrU9R3JXTYE2nLM\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JEt98VsOFBAK",
        "colab_type": "text"
      },
      "source": [
        "Descargar un archivo del Drive"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MbI6V0SxARFB",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "73337121-43e4-4417-db7d-7d3f2e172384"
      },
      "source": [
        "i='1kKIxeYVO6Ixe4TNxrmwDgSvVrBMHel37'\n",
        "downloaded = drive.CreateFile({'id': i})\n",
        "downloaded.GetContentFile('Sample upload.txt') \n",
        "print('Downloaded content \"{}\"'.format(downloaded.GetContentString()))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Downloaded content \"Sample upload file content\"\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WyKkP9xYATfr",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#la \"id\" es lo que va después del = : https://drive.google.com/open?id=1kKIxeYVO6Ixe4TNxrmwDgSvVrBMHel37"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LHzmX7lUFdzN",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"git\"></a></p>\n",
        "\n",
        "### 2.9.7 Github"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4vB7YMcLFhm7",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "39ef6f10-de14-49d4-8ac1-2bc6ed81cb01"
      },
      "source": [
        "!git clone https://github.com/username/repositorio"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Cloning into 'repositorio'...\n",
            "fatal: could not read Username for 'https://github.com': No such device or address\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tGsUlQpLj3-t",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"numpy\"></a></p>\n",
        "\n",
        "## 3.0 Numpy\n",
        "\n",
        "[[Secciones]](#sections)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EJEWj-zHVYSZ",
        "colab_type": "text"
      },
      "source": [
        "El paquete (modulo) numpy es usado en practicamnte toda operacion numerica en python. Es un paquete que provee vectores, matrices y estrucutras de datos de altas dimensiones con buen desempeño. Esta implementado en C y fortran haciendo por tanto uso de una vectorizacion eficiente.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WuPj0YbiUK3-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Numpy suele importarse con la siguiente convencion (en todo el mundo!)\n",
        "import numpy as np"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WtVUXzjmoA_u",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"numpyarrays\"></a></p>\n",
        "\n",
        "### 3.1 Arrays"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1K-0DC2qWuvI",
        "colab_type": "text"
      },
      "source": [
        "El elemento basico de numpy son los arrays (arreglos). Un array  es un grid de valores, del mismo tipo, los cuales son indexados por una tupla de enteros no negativos. El número de dimensiones es el **rango** de la matriz; la **forma** (shape) de la matríz es una tupla de enteros dados por el tamaño del array a lo largo de cada dimensión.\n",
        "\n",
        "Podemos inicializar los arrays de numpy mediante listas de Python y acceder a los elementos mediante corchetes []\n",
        "\n",
        "<p><img alt=\"comparison  logo\" width=\"400\" height=\"200\" src=\"https://miro.medium.com/max/3184/1*X0Dg7QfSYtWhSAu-afi8-g.png\" align=\"center\" hspace=\"10px\" vspace=\"0px\"></p>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WHbqfSHgWQus",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        },
        "outputId": "cee78c06-16a4-4890-f7e1-d3fb4ee3d532"
      },
      "source": [
        "# Como se crean los arrays\n",
        "\n",
        "a = np.array([1,2,3]) # Creación de un array de rango 1\n",
        "b = np.array([(1.5,2,3), (4,5,6)], dtype = float) # Creación de un array de rango 2\n",
        "c = np.array([[(1.5,2,3), (4,5,6)], [(3,2,1), (4,5,6)]],dtype = float)\n",
        "print(\"array b\")\n",
        "print(b)\n",
        "print(type(b)) #\n",
        "print(b.shape) # Veamos la forma"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "array b\n",
            "[[1.5 2.  3. ]\n",
            " [4.  5.  6. ]]\n",
            "<class 'numpy.ndarray'>\n",
            "(2, 3)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UztKO2xllNyr",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "8f0c903c-f86d-4edd-f580-cfd672950776"
      },
      "source": [
        "c = np.array([[0,1,2,3],[4,5,6,7]])    # Creación de un array de rango 2\n",
        "print(c.shape)                     # Forma \"(2, 4)\"\n",
        "print(b[0, 0], b[0, 1], b[1, 0])   # Indexacion con enteros, impresión de los elementos 0, 1 y 4\n"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(2, 4)\n",
            "1.5 2.0 4.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5xo5p8CJXwGp",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 629
        },
        "outputId": "cdf4ce69-96a2-42d6-d2bc-ee52015e256f"
      },
      "source": [
        "# Atajos\n",
        "a=np.zeros((2,2)) # Imprime \"[[ 0.  0.]\n",
        "                #            [ 0.  0.]]\"\n",
        "print(\"Array con ceros\",a)\n",
        "print(\"------------\")\n",
        "\n",
        "b=np.ones((2,3,4),dtype=np.int16)  #Crea un array de unos\n",
        "print(\"Array de unos\", b)\n",
        "print(\"------------\")\n",
        "\n",
        "c = np.arange(0, 32, 2)                    # Creación de un vector lleno de una secuencia lineal\n",
        "print(\"Array de una secuencia lineal\" ,c)  # que comience en 0, finalice en 30, con paso 2.\n",
        "print(\"------------\")\n",
        "\n",
        "d = np.linspace(0, 1, 10)                   # Crea un vector de 10 valores espaciados \n",
        "print(\"Array de una secuencia lineal\",d)    # uniformemente entre 0 y 1.   \n",
        "print(\"------------\")\n",
        "\n",
        "e = np.full((2,2),7) # Crea un array de valores constantes\n",
        "print(\"Array de valores constantes\",e)\n",
        "print(\"------------\")\n",
        "\n",
        "f = np.eye(2) #Crea l matriz identidad de dimension  2X2 \n",
        "print(\"Matriz identidad 2x2\", f)\n",
        "print(\"------------\")\n",
        "\n",
        "g = np.random.random((2,2))                # Creación de una matriz de 2x2 de valores aleatorios.\n",
        "print(\"Array de números aleatorios(u)\", g) # distribuidos uniformemente.\n",
        "print(\"------------\")\n",
        "\n",
        "h = np.random.normal(0, 1, (3, 3))         # Creación una matriz 3x3 de valores aleatorios normalmente \n",
        "print(\"Array de números aleatorios(n)\", h) # distribuidos con media 0 y desviación estándar 1.\n",
        "print(\"------------\")\n",
        "\n",
        "i = np.random.randint(0, 10, (3, 3))       # Creación de una matriz 3x3 de números enteros aleatorios\n",
        "print(\"Array de números aleatorios(i)\",i)  # en el intervalo [0,10)\n",
        "print(\"------------\")\n",
        "\n",
        "j=np.empty((3,2))  #Crea un array vacio\n",
        "print(\"Array vacio\", j)"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Array con ceros [[0. 0.]\n",
            " [0. 0.]]\n",
            "------------\n",
            "Array de unos [[[1 1 1 1]\n",
            "  [1 1 1 1]\n",
            "  [1 1 1 1]]\n",
            "\n",
            " [[1 1 1 1]\n",
            "  [1 1 1 1]\n",
            "  [1 1 1 1]]]\n",
            "------------\n",
            "Array de una secuencia lineal [ 0  2  4  6  8 10 12 14 16 18 20 22 24 26 28 30]\n",
            "------------\n",
            "Array de una secuencia lineal [0.         0.11111111 0.22222222 0.33333333 0.44444444 0.55555556\n",
            " 0.66666667 0.77777778 0.88888889 1.        ]\n",
            "------------\n",
            "Array de valores constantes [[7 7]\n",
            " [7 7]]\n",
            "------------\n",
            "Matriz identidad 2x2 [[1. 0.]\n",
            " [0. 1.]]\n",
            "------------\n",
            "Array de números aleatorios(u) [[0.37994923 0.43258771]\n",
            " [0.61953416 0.8718526 ]]\n",
            "------------\n",
            "Array de números aleatorios(n) [[-1.60133181 -0.26946609  1.44999125]\n",
            " [ 1.10492876  1.0029791   0.73151984]\n",
            " [-0.80960126 -0.06894503  0.56802468]]\n",
            "------------\n",
            "Array de números aleatorios(i) [[9 7 8]\n",
            " [0 3 7]\n",
            " [3 1 7]]\n",
            "------------\n",
            "Array vacio [[1.39069238e-309 1.39069238e-309]\n",
            " [1.39069238e-309 1.39069238e-309]\n",
            " [1.39069238e-309 1.39069238e-309]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aUAVSSFjA8JF",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"arraysATT\"></a></p>\n",
        "\n",
        "###3.2. Atributos\n",
        "\n",
        "Cada array tiene como atributos: <code>ndim</code>  (el número de dimensiones), <code>shape</code> (el tamaño de cada dimensión) y <code>size</code> (el tamaño total de la matriz o número de elementos):\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1zx4b91dC5iX",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 204
        },
        "outputId": "07138c2a-b0f4-4ae2-a79b-0ffcabfe9616"
      },
      "source": [
        "v1 = np.random.randint(20, size=6)          # array unidimensional\n",
        "v2 = np.random.randint(20, size=(3, 4))     # array bidimensional\n",
        "v3 = np.random.randint(20, size=(3, 4, 5))  # array tridimensional\n",
        "\n",
        "print(\"x1 ndim: \", v1.ndim)\n",
        "print(\"x1 shape:\", v1.shape)\n",
        "print(\"x1 size: \", v1.size,\"\\n\")\n",
        "\n",
        "print(\"x2 ndim: \", v2.ndim)\n",
        "print(\"x2 shape:\", v2.shape)\n",
        "print(\"x2 size: \", v2.size, \"\\n\")\n",
        "\n",
        "print(\"x3 ndim: \", v3.ndim)\n",
        "print(\"x3 shape:\", v3.shape)\n",
        "print(\"x3 size: \", v3.size)"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "x1 ndim:  1\n",
            "x1 shape: (6,)\n",
            "x1 size:  6 \n",
            "\n",
            "x2 ndim:  2\n",
            "x2 shape: (3, 4)\n",
            "x2 size:  12 \n",
            "\n",
            "x3 ndim:  3\n",
            "x3 shape: (3, 4, 5)\n",
            "x3 size:  60\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T8-an6XDGizu",
        "colab_type": "text"
      },
      "source": [
        "Otros atributos incluyen <code>itemsize</code>, que enumera el tamaño (en bytes) de cada elemento del array,\n",
        "y <code>nbytes</code>, que enumera el tamaño total (en bytes) del array"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "84xkkKF6G_YU",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "d9f29c47-d995-4cbf-d83c-150eb4e2ae1e"
      },
      "source": [
        "print(\"itemsize:\", v3.itemsize, \"bytes\")\n",
        "print(\"nbytes:\", v3.nbytes, \"bytes\")"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "itemsize: 8 bytes\n",
            "nbytes: 480 bytes\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BEe6fe-PzXBf",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"arraysIDX\"></a></p>\n",
        "\n",
        "### 3.3 Indexación\n",
        "\n",
        "[[Contenidos]](#contents)\n",
        "\n",
        "Al igual que en las librerias estándar de Python, se puede acceder an n-ésimo componente de un array especificando el índice deseado entre [] corchotes"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X7-kPWAbI_Sq",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "be4bedfe-ee44-4f43-a159-5df96e631304"
      },
      "source": [
        "print(v1)\n",
        "\n",
        "print(v1[0])"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[17 15  8  1  2  3]\n",
            "17\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rCjdMfYHKBxm",
        "colab_type": "text"
      },
      "source": [
        "En el caso de un array multidimensional, se accede a los elementos utilizando los índices separados por comas"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5JDno9bhKRCS",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "e8cfff84-be19-4d26-8857-b0d3015f90a2"
      },
      "source": [
        "print(v2)\n",
        "\n",
        "print(v2[0,1])"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[14  9  2 13]\n",
            " [11  6  4 12]\n",
            " [13 11  4 13]]\n",
            "9\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H03qUs3PLdRP",
        "colab_type": "text"
      },
      "source": [
        "Recordemos que los arrays en NumPy tiene un tipo fijo. Si intentamos insertar un número de tipo flotante en un array de tipo entero, el valor se truncará"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Nchf3cKTLpJE",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "5ea7a398-7450-427d-c308-e4d63a22d67e"
      },
      "source": [
        "print(\"v1 original\") #Nuestro v1 contenia valores enteros\n",
        "print(v1)\n",
        "v1[0] = 3.1415\n",
        "print(\"v1 editado\") #Al ingresar un float igual se conserva el tipo int\n",
        "print(v1)"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "v1 original\n",
            "[17 15  8  1  2  3]\n",
            "v1 editado\n",
            "[ 3 15  8  1  2  3]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tpxd_MBXXebw",
        "colab_type": "text"
      },
      "source": [
        "En el caso tridimensional"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ng-oz5ObXd_s",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 340
        },
        "outputId": "ba546f28-6764-45d0-f03f-83f72ae6d095"
      },
      "source": [
        "print(v3,\"\\n\")\n",
        "\n",
        "print(\"Dos formas de acceder al mismo elemento: \\n\")\n",
        "print(\"v3[1][1][0] =\", v3[1][1][0])\n",
        "print(\"v3[1,1,0] =\", v3[1,1,0])"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[[ 4  9  1  4 10]\n",
            "  [ 3 12  9  3 10]\n",
            "  [14  9  8  5 11]\n",
            "  [19  0 10  5  6]]\n",
            "\n",
            " [[ 9  9  6  2 13]\n",
            "  [12 10  1  5  9]\n",
            "  [13  2  9 19  3]\n",
            "  [11 11  7  5 16]]\n",
            "\n",
            " [[14  2 17 14 17]\n",
            "  [ 0 16  7  8  0]\n",
            "  [ 2 15 17  1  5]\n",
            "  [ 0 12  4  1  9]]] \n",
            "\n",
            "Dos formas de acceder al mismo elemento: \n",
            "\n",
            "v3[1][1][0] = 12\n",
            "v3[1,1,0] = 12\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eEQEnHc_rcwf",
        "colab_type": "text"
      },
      "source": [
        "#### Ejercicios de practica\n",
        "\n",
        "Cree un array v4 de dimension 4 con numeros enteros entre 1 y 10 con forma (2,2). Luego, imprima los siguientes atributos\n",
        "para verificar su resultado:\n",
        " - ndim\n",
        " - shape\n",
        " - size\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4iDINN0DsKNb",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Desarrolle aqui el ejercicio\n"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t6g33AHWsOOR",
        "colab_type": "text"
      },
      "source": [
        "De click **aquí** para ver la respuesta.\n",
        "\n",
        "<!---\n",
        "# No esperaba verte tan rápido aquí :(\n",
        "\n",
        "v4=np.random.randint(10,size=(4,2,2))\n",
        "v4=np.random.randint(10,size=(4,2,2))\n",
        "print(v4)\n",
        "--->\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ef1KZw0JBfCK",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"arraysSLI\"></a></p>\n",
        "\n",
        "### 3.3 Segmentación\n",
        "\n",
        "[[Secciones]](#sections)\n",
        "\n",
        "La sintaxis de segmentación en NumPy e igual al de  las listas estándar en Python: <code>x[inicio:final:paso]</code>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F1UB_I8MNtvx",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 136
        },
        "outputId": "fa113787-7711-4f19-94ed-7ed0b6f3f409"
      },
      "source": [
        "x = np.arange(10)     \n",
        "\n",
        "print(x)\n",
        "\n",
        "print('Primeros 5 elementos ',x[:5])\n",
        "\n",
        "print('Elementos luego del índice 5 ',x[5:])\n",
        "\n",
        "print('Subarray medio ',x[4:7])\n",
        "\n",
        "print('Subarray medio2', x[4:-3])\n",
        "\n",
        "print('Elementos separados por dos elementos ',x[::2])\n",
        "\n",
        "print('Elementos separados por dos elementos comenzando en el index 1 ',x[1::2])"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0 1 2 3 4 5 6 7 8 9]\n",
            "Primeros cinco elementos  [0 1 2 3 4]\n",
            "Elementos luego del índice 5  [5 6 7 8 9]\n",
            "Subarray medio  [4 5 6]\n",
            "Subarray medio2 [4 5 6]\n",
            "Elementos separados por dos elementos  [0 2 4 6 8]\n",
            "Elementos separados por dos elementos comenzando en el index 1  [1 3 5 7 9]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3IxyCwGgP1BE",
        "colab_type": "text"
      },
      "source": [
        "Un caso  confuso es cuando el valor del paso es negativo. En este caso, los valores predeterminados para <code>inicio</code> y \n",
        "<code>final</code> se intercambian."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F_kJNMyNP8bs",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "312c6d82-123a-40dd-b979-eb282a925c06"
      },
      "source": [
        "print(x[::-1])      # Se reversan todos los elementos \n",
        "\n",
        "print(x[5::-2])     # Se reversan los elementos desde el índice 5 con paso 2 "
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[9 8 7 6 5 4 3 2 1 0]\n",
            "[5 3 1]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fuenNeduPVP2",
        "colab_type": "text"
      },
      "source": [
        "Para los arrays multidimensionales la segmentación se hace de una manera similar, por ejemplo:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YAVT_c6PPJG-",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 357
        },
        "outputId": "cb39bbe2-4756-4c9f-ce05-1c03d04368a1"
      },
      "source": [
        "print(\"Array v2\")\n",
        "print(v2)\n",
        "print(\"---------\")\n",
        "print('Dos filas, tres columnas')\n",
        "print(v2[:2, :3])  \n",
        "print(\"-------------------------------\")\n",
        "print('Todas las filas, dos columnas')\n",
        "print(v2[:, :2])      \n",
        "print(\"-------------------------------\")\n",
        "print('Dos filas, el resto de columnas con paso 2')\n",
        "print(v2[:2, ::2])        \n",
        "print(\"-------------------------------\")\n",
        "print('Primera fila')\n",
        "print(v2[0])"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Array v2\n",
            "[[14  9  2 13]\n",
            " [11  6  4 12]\n",
            " [13 11  4 13]]\n",
            "---------\n",
            "Dos filas, tres columnas\n",
            "[[14  9  2]\n",
            " [11  6  4]]\n",
            "-------------------------------\n",
            "Todas las filas, dos columnas\n",
            "[[14  9]\n",
            " [11  6]\n",
            " [13 11]]\n",
            "-------------------------------\n",
            "Dos filas, el resto de columnas con paso 2\n",
            "[[14  2]\n",
            " [11  4]]\n",
            "-------------------------------\n",
            "Primera fila\n",
            "[14  9  2 13]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gm-aZkm6VBQE",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 442
        },
        "outputId": "7e4651ac-517d-4547-dd64-ebf043bc7a91"
      },
      "source": [
        "print(v3)\n",
        "print(\"-------------------------------\")\n",
        "print('Tercer array, dos filas y tres columnas')\n",
        "print(v3[2,:2,:3])\n",
        "print(\"-------------------------------\")\n",
        "print('Hasta el 2do array, dos filas y dos columnas')\n",
        "print(v3[:2,:2,:2])"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[[ 4  9  1  4 10]\n",
            "  [ 3 12  9  3 10]\n",
            "  [14  9  8  5 11]\n",
            "  [19  0 10  5  6]]\n",
            "\n",
            " [[ 9  9  6  2 13]\n",
            "  [12 10  1  5  9]\n",
            "  [13  2  9 19  3]\n",
            "  [11 11  7  5 16]]\n",
            "\n",
            " [[14  2 17 14 17]\n",
            "  [ 0 16  7  8  0]\n",
            "  [ 2 15 17  1  5]\n",
            "  [ 0 12  4  1  9]]]\n",
            "-------------------------------\n",
            "Tercer array, dos filas y tres columnas\n",
            "[[14  2 17]\n",
            " [ 0 16  7]]\n",
            "-------------------------------\n",
            "Hasta el 2do array, dos filas y dos columnas\n",
            "[[[ 4  9]\n",
            "  [ 3 12]]\n",
            "\n",
            " [[ 9  9]\n",
            "  [12 10]]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CM0OAc5wa4-t",
        "colab_type": "text"
      },
      "source": [
        "Es importante tener en cuenta que la segmentación de arrays en NumPy devuelve **vistas**  en lugar de **copias** de los datos del array. Esto significa que cuando trabajamos con grandes conjuntos de datos, podemos acceder y procesar partes de estos conjuntos de datos sin la necesidad de copiar el búfer de datos subyacente."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3Y89Onz1bO1h",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 153
        },
        "outputId": "bdf18a91-a007-4692-e517-4d87f8e442c1"
      },
      "source": [
        "print('Array original \\n',v2)\n",
        "\n",
        "sub_array = v2[:2,:2]\n",
        "\n",
        "sub_array[0,0] = 999\n",
        "\n",
        "print('Array luego de modificar el subarray \\n',v2)"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Array original \n",
            " [[14  9  2 13]\n",
            " [11  6  4 12]\n",
            " [13 11  4 13]]\n",
            "Array luego de modificar el subarray \n",
            " [[999   9   2  13]\n",
            " [ 11   6   4  12]\n",
            " [ 13  11   4  13]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ztGzf48tb4U5",
        "colab_type": "text"
      },
      "source": [
        "A veces es útil copiar explícitamente los datos dentro de un array o un  subarray. Esto se puede hacer con el\n",
        "método <code>copy()</code>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DkFK83b5denr",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 119
        },
        "outputId": "9bf8a8db-8a85-43f4-fb5d-9c9fad8e2921"
      },
      "source": [
        "sub_array_copia = v2[:2,:2].copy()\n",
        "sub_array_copia[0,0] = 20\n",
        "\n",
        "print(sub_array_copia)\n",
        "print(5*'-')\n",
        "print(v2)"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[20  9]\n",
            " [11  6]]\n",
            "-----\n",
            "[[999   9   2  13]\n",
            " [ 11   6   4  12]\n",
            " [ 13  11   4  13]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9Ez4uourB6CM",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"arraysRES\"></a></p>\n",
        "\n",
        "### 3.4 Reshape\n",
        "\n",
        "[[Secciones]](#sections)\n",
        "\n",
        "Otro tipo útil de operación es el \"reshape\" o cambio de forma de un array, una operación semejante pero no limitada a la transposición de matrices. La forma más flexible de hacerlo es con el método <code>reshape()</code>. \n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gwJ2emt68ObB",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "07e1cc37-67b2-42e1-c635-208b34565876"
      },
      "source": [
        "grid = np.arange(1, 10).reshape((3, 3))            \n",
        "print(grid)\n",
        "\n",
        "a = np.array([[1,2,3], [4,5,6]]).reshape(1,6)\n",
        "print(a)"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[1 2 3]\n",
            " [4 5 6]\n",
            " [7 8 9]]\n",
            "[[1 2 3 4 5 6]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tLcXP-5n9KQ3",
        "colab_type": "text"
      },
      "source": [
        "Podemos convertir un array unidimensional en un vector fila o columna bidimensional \n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6Livw21U9TBQ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 136
        },
        "outputId": "8dd0be09-b55a-4a39-f731-9bbab778e776"
      },
      "source": [
        "x = np.array([1,2,3])\n",
        "\n",
        "fil_x = x.reshape((1,3))    # vector fila\n",
        "col_x = x.reshape((3,1))    # vector columna\n",
        "\n",
        "print(\"Vector Fila\")\n",
        "print(fil_x)\n",
        "print(\"---------\")\n",
        "print(\"Vector Columna\")\n",
        "print(col_x)"
      ],
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Vector Fila\n",
            "[[1 2 3]]\n",
            "---------\n",
            "Vector Columna\n",
            "[[1]\n",
            " [2]\n",
            " [3]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HpobXl09HLRj",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"arraysCON\"></a></p>\n",
        "\n",
        "### 3.5. Concatenación y división de arrays\n",
        "\n",
        "[[Secciones]](#sections)\n",
        "\n",
        "Numpy nos permite combinar varios arrays en uno solo o, por el contrario, dividir un array en varios. La concatenación, o unión de dos arrays en NumPy, se realiza principalmente a través de la función <code>np.concatenate</code>\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nRpkEwBSIU7e",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "9baf8d6f-6e7b-43b8-ea05-71169b185cf1"
      },
      "source": [
        "x = np.array([1, 2, 3])\n",
        "y = np.array([3, 2, 1])\n",
        "z = np.concatenate([x, y])\n",
        "print(z)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1 2 3 3 2 1]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BhwiTVYzItHY",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "También se puede utilizar para arrays bidimensionales"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ImZZ9zIVIz-z",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 136
        },
        "outputId": "72a1cb05-f392-40fb-d528-a4c99351630a"
      },
      "source": [
        "grid = np.array([[1, 2, 3], [4, 5, 6]])\n",
        "\n",
        "z1 = np.concatenate([grid,grid])            # concatenar a lo largo del primer eje\n",
        "print(z1)\n",
        "print('-------------------------')\n",
        "z2 = np.concatenate([grid,grid], axis=1)    # concatenar a lo largo del segundo eje\n",
        "print(z2)"
      ],
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[1 2 3]\n",
            " [4 5 6]\n",
            " [1 2 3]\n",
            " [4 5 6]]\n",
            "-------------------------\n",
            "[[1 2 3 1 2 3]\n",
            " [4 5 6 4 5 6]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6gC3eowqKuKY",
        "colab_type": "text"
      },
      "source": [
        "Para trabajar con arrays de dimensiones mixtas es recomendable usar las funciones  <code>np.vstack</code> y <code>np.hstack</code>. \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Tu-Dla5nK-zh",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 119
        },
        "outputId": "c5a4ac4a-9f1e-4006-e4ba-c53f846c4ee6"
      },
      "source": [
        "# Apilar verticalmente los arrays\n",
        "x = np.array([11, 44, 55])\n",
        "z1 = np.vstack([x,grid])\n",
        "print(z1)\n",
        "\n",
        "print('------------------------------')\n",
        "# Apilar horizontalmente los arrays\n",
        "y = np.array([[99], [99]])\n",
        "z2 = np.hstack([grid, y])\n",
        "print(z2)"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[11 44 55]\n",
            " [ 1  2  3]\n",
            " [ 4  5  6]]\n",
            "------------------------------\n",
            "[[ 1  2  3 99]\n",
            " [ 4  5  6 99]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "463MK3SkNX3D",
        "colab_type": "text"
      },
      "source": [
        "Lo opuesto a la concatenación es la división, que se implementa mediante las funciones <code>np.split</code>, <code>np.hsplit</code> y <code>np.vsplit</code>\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yysGRkhaNlc7",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "06d40d96-e8ce-4772-88ee-7e4aa7066986"
      },
      "source": [
        "x = [1, 2, 3, 99, 99, 3, 2, 1]\n",
        "x1, x2, x3 = np.split(x, [3, 5])\n",
        "print(x1, x2, x3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1 2 3] [99 99] [3 2 1]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "jDAhKsOXd9VI"
      },
      "source": [
        "Note que las funciones `np.hsplit` y `np.vsplit` son similares"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iN0f1cVvN4Zj",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 108
        },
        "outputId": "e8f3ef31-55d5-4351-a250-3b6b5822e3f6"
      },
      "source": [
        "grilla = np.arange(16).reshape((4, 4))\n",
        "\n",
        "sup, inf = np.vsplit(grilla, [2])\n",
        "print(sup)\n",
        "print(5*'-')\n",
        "print(inf)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[0 1 2 3]\n",
            " [4 5 6 7]]\n",
            "-----\n",
            "[[ 8  9 10 11]\n",
            " [12 13 14 15]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GTbRCocjOS_R",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 181
        },
        "outputId": "b12e201f-6f34-49c8-a924-3f159a63e497"
      },
      "source": [
        "izq, der = np.hsplit(grilla, [2])\n",
        "print(izq)\n",
        "print(5*'-')\n",
        "print(der)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 0  1]\n",
            " [ 4  5]\n",
            " [ 8  9]\n",
            " [12 13]]\n",
            "-----\n",
            "[[ 2  3]\n",
            " [ 6  7]\n",
            " [10 11]\n",
            " [14 15]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4CFfCTUfg-EH",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"arrayMath\"></a></p>\n",
        "\n",
        "\n",
        "### 3.6. Operaciones vectorizadas\n",
        "[[Secciones]](#sections)\n",
        "\n",
        "El cálculo con arrays en NumPy puede ser muy rápido o muy lento. La clave para hacerlo rápido es usar operaciones **vectorizadas**, generalmente implementadas a través de las funciones **universales** de NumPy (ufuncs)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XJNXfC8J8A_O",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "0abc813a-a9a2-4f48-81f3-8da0cea35fff"
      },
      "source": [
        "#Estrategia Iterativa (No hago uso de vectorizacion)\n",
        "def compute_reciprocals(values):\n",
        "  #Creamos un array vacio para almacenar nuestros calculos\n",
        "  output = np.empty(len(values))\n",
        "  for i in range(len(values)):\n",
        "    #Para cada valor calculamos su reciproco (inverso multiplicativo)\n",
        "    output[i] = 1.0 / values[i]\n",
        "  return output\n",
        "\n",
        "\n",
        "big_array = np.random.randint(1, 100, size=1000000) \n",
        "\n",
        "print(\"Tiempo de la estrategia iterativa\")\n",
        "%timeit compute_reciprocals(big_array)          # calculo en ciclo\n",
        "print(\"Tiempo de la estrategia usando vectorización\")\n",
        "%timeit (1.0 / big_array)                       # calculo vectorizado"
      ],
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Tiempo de la estrategia iterativa\n",
            "1 loop, best of 3: 1.9 s per loop\n",
            "Tiempo de la estrategia usando vectorización\n",
            "100 loops, best of 3: 2.08 ms per loop\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FM8EdbgL-4QG",
        "colab_type": "text"
      },
      "source": [
        "Las operaciones vectorizadas en NumPy se implementan a través de las **ufuncs** (funciones universales), cuyo objetivo  es ejecutar rápidamente operaciones de forma repetida sobre valores de arrays. Las operaciones con **ufuncs** aplican tnato para arrays unidimensionales como para arrays multidimensionales. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xyfbKnVC_mW0",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        },
        "outputId": "3012d1e9-eb69-4192-806b-a620898e04c5"
      },
      "source": [
        "print(np.arange(5) / np.arange(1, 6))         # Operación sobre array unidimensional\n",
        "\n",
        "print('-----------------------')\n",
        "x = np.arange(9).reshape((3, 3))              # Operación sobre array multidimensional\n",
        "print(2**x)"
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0.         0.5        0.66666667 0.75       0.8       ]\n",
            "-----------------------\n",
            "[[  1   2   4]\n",
            " [  8  16  32]\n",
            " [ 64 128 256]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d-jGhCb5Aayf",
        "colab_type": "text"
      },
      "source": [
        "Los cálculos que usan vectorización a través de ufuncs son casi siempre **más eficientes** que su contraparte implementada a través de ciclos, especialmente a medida que los arrays crecen en tamaño. **Consejo:** Cada vez que se vea un ciclo de este tipo en un script de Python, debe considerarse la posibilidad de reemplazarlo con una expresión vectorizada."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "59bWwCsfAzGH",
        "colab_type": "text"
      },
      "source": [
        "### 3.7. Ufuncs\n",
        "Se puede consultar mas sobre las funciones universales de numpy en el siguiente enlace:\n",
        "https://docs.scipy.org/doc/numpy/reference/ufuncs.html"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sdFATPpfCEk6",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 357
        },
        "outputId": "fee53838-d782-45c9-8a9d-e149b0b88d14"
      },
      "source": [
        "x = np.arange(1,5)\n",
        "print(x)\n",
        "\n",
        "# Operadores aritméticos\n",
        "print(\"Operadores Aritmeticos\")\n",
        "print('x+2 ',np.add(x,2))\n",
        "print('x-2 ',np.subtract(x,2))\n",
        "print('-x ',np.negative(x))\n",
        "print('x*2 ',np.multiply(x,2))\n",
        "print('x/2 ',np.divide(x,2))\n",
        "print('x^2 ',np.power(x,2))\n",
        "print(\"----------------------\")\n",
        "# Funciones trigonométricas\n",
        "print(\"Funciones trigonométricas\")\n",
        "theta = np.linspace(0,np.pi,3)\n",
        "\n",
        "print('sin(theta)',np.sin(theta))\n",
        "print('cos(theta)',np.cos(theta))\n",
        "print(\"----------------------\")\n",
        "print(\"Exponenciales y logaritmos\")\n",
        "# Exponenciales y logaritmos\n",
        "print(\"e^x =\", np.exp(x))\n",
        "print(\"2^x =\", np.exp2(x))\n",
        "print(\"3^x =\", np.power(3, x))\n",
        "\n",
        "print(\"ln(x) =\", np.log(x))\n",
        "print(\"log2(x) =\", np.log2(x))\n",
        "print(\"log10(x) =\", np.log10(x))"
      ],
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1 2 3 4]\n",
            "Operadores Aritmeticos\n",
            "x+2  [3 4 5 6]\n",
            "x-2  [-1  0  1  2]\n",
            "-x  [-1 -2 -3 -4]\n",
            "x*2  [2 4 6 8]\n",
            "x/2  [0.5 1.  1.5 2. ]\n",
            "x^2  [ 1  4  9 16]\n",
            "----------------------\n",
            "Funciones trigonométricas\n",
            "sin(theta) [0.0000000e+00 1.0000000e+00 1.2246468e-16]\n",
            "cos(theta) [ 1.000000e+00  6.123234e-17 -1.000000e+00]\n",
            "----------------------\n",
            "Exponenciales y logaritmos\n",
            "e^x = [ 2.71828183  7.3890561  20.08553692 54.59815003]\n",
            "2^x = [ 2.  4.  8. 16.]\n",
            "3^x = [ 3  9 27 81]\n",
            "ln(x) = [0.         0.69314718 1.09861229 1.38629436]\n",
            "log2(x) = [0.        1.        1.5849625 2.       ]\n",
            "log10(x) = [0.         0.30103    0.47712125 0.60205999]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y9M0gTBl61gy",
        "colab_type": "text"
      },
      "source": [
        "### 3.8. Operaciones Básicas.\n",
        "\n",
        "Las operaciones matematicas basicas entre arrays, son operaciones **elemento a elemento** (elementwise):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3WDg1X327shT",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 476
        },
        "outputId": "47d5e239-b224-4925-d082-c0f0ffb18ef9"
      },
      "source": [
        "x = np.array([[1,2],[3,4]], dtype=np.float64)\n",
        "y = np.array([[5,6],[7,8]], dtype=np.float64)\n",
        "\n",
        "# Suma elemento a elemento\n",
        "print(\"Suma elemento a elemento\")\n",
        "print(x + y)\n",
        "print(np.add(x, y))\n",
        "print(\"----------------------\")\n",
        "\n",
        "# Resta elemento a elemento.\n",
        "print(\"Resta elemento a elemento.\")\n",
        "print(x - y)\n",
        "print(np.subtract(x, y))\n",
        "print(\"----------------------\")\n",
        "\n",
        "# Multiplicación elemento a elemento.\n",
        "print(\"Multiplicación elemento a elemento.\")\n",
        "print(x * y)\n",
        "print(np.multiply(x, y))\n",
        "print(\"----------------------\")\n",
        "\n",
        "# División elemento a elemento.\n",
        "print(\"División elemento a elemento.\")\n",
        "print(x / y)\n",
        "print(np.divide(x, y))\n",
        "print(\"----------------------\")\n",
        "\n",
        "print(\"Raiz cuadrada a cada elmento.\")\n",
        "# Raiz cuadrada a cada elmento.\n",
        "print(np.sqrt(x))"
      ],
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Suma elemento a elemento\n",
            "[[ 6.  8.]\n",
            " [10. 12.]]\n",
            "[[ 6.  8.]\n",
            " [10. 12.]]\n",
            "----------------------\n",
            "Resta elemento a elemento.\n",
            "[[-4. -4.]\n",
            " [-4. -4.]]\n",
            "[[-4. -4.]\n",
            " [-4. -4.]]\n",
            "----------------------\n",
            "Multiplicación elemento a elemento.\n",
            "[[ 5. 12.]\n",
            " [21. 32.]]\n",
            "[[ 5. 12.]\n",
            " [21. 32.]]\n",
            "----------------------\n",
            "División elemento a elemento.\n",
            "[[0.2        0.33333333]\n",
            " [0.42857143 0.5       ]]\n",
            "[[0.2        0.33333333]\n",
            " [0.42857143 0.5       ]]\n",
            "----------------------\n",
            "Raiz cuadrada a cada elmento.\n",
            "[[1.         1.41421356]\n",
            " [1.73205081 2.        ]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hjEETdx_8wyF",
        "colab_type": "text"
      },
      "source": [
        "Nótese que la multiplicación mediante el operador `*` corresponde a una multiplicación elemento a elemento entre dos arrays. En Python, la multiplicación matricial entre dos arrays se realiza mediante la función punto (`dot`)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "GnH9g3-cOS9V",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 306
        },
        "outputId": "f58e23de-5518-463d-d7fb-4150737a62ba"
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "x = np.array([[8,2],[5,4]])\n",
        "y = np.array([[10,32],[7,8]])\n",
        "\n",
        "v = np.array([9,10])\n",
        "w = np.array([11, 12])\n",
        "\n",
        "# Producto entre vectores\n",
        "print(\"Producto vector-vector\",v.dot(w))\n",
        "print(\"Producto vector-vector\", np.dot(v, w),\"\\n\")\n",
        "print(\"----------------------\")\n",
        "# Producto matriz/vector;\n",
        "print(\"Producto matriz/vector \\n\",x.dot(v))\n",
        "print(\"Producto matriz/vector \\n\", np.dot(x, v),\"\\n\")\n",
        "print(\"----------------------\")\n",
        "# Producto matrix/matrix ; \n",
        "print(\"Producto matriz/matriz \\n\",x.dot(y),\"\\n\")\n",
        "print(\"Producto matriz/matriz \\n\",np.dot(x, y))"
      ],
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Producto vector-vector 219\n",
            "Producto vector-vector 219 \n",
            "\n",
            "----------------------\n",
            "Producto matriz/vector \n",
            " [92 85]\n",
            "Producto matriz/vector \n",
            " [92 85] \n",
            "\n",
            "----------------------\n",
            "Producto matriz/matriz \n",
            " [[ 94 272]\n",
            " [ 78 192]] \n",
            "\n",
            "Producto matriz/matriz \n",
            " [[ 94 272]\n",
            " [ 78 192]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "363CkXHPNcXL",
        "colab_type": "text"
      },
      "source": [
        "Python proporciona algunas funciones para realizar operaciones sobre los arrays. \n",
        "Por ejemplo, la función `sum` realiza una suma sobre todos los elementos del array:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wDmks3LyNtAI",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "603b0f22-188d-48a7-f42b-e5af156eff84"
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "x = np.array([[1,2],[3,4]])\n",
        "\n",
        "print(\"Suma total de los elementos del array\", np.sum(x))  # Calculo de la suma de todos los elementos.\n",
        "print(\"Suma de cada columna\",np.sum(x, axis=0))  # Suma de cada columna\n",
        "print(\"Suma de cada fila\",np.sum(x, axis=1))  # Suma de cada fila"
      ],
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Suma total de los elementos del array 10\n",
            "Suma de cada columna [4 6]\n",
            "Suma de cada fila [3 7]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9KxDpyp1PAMS",
        "colab_type": "text"
      },
      "source": [
        "Para muchas más funciones pueden consultar [este enlace](https://docs.scipy.org/doc/numpy/reference/routines.math.html)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GrBf6Ya90lbM",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"bcasting\"></a></p>\n",
        "\n",
        "### 3.9. Broadcasting.\n",
        "\n",
        "[[Secciones]](#sections)\n",
        "\n",
        "El Broadcasting es una potente herramienta que nos permite trabajar en numpy con arrays de diferentes tamaños para realizar operaciones aritméticas. A menudo tenemos un array mas pequeño y otro de tamaño mayor, de tal forma que queremos usar el array más pequeño varias veces para realizar algunas operaciones en el array mas grande.\n",
        "\n",
        "<p><img alt=\"comparison  logo\" width=\"400\" height=\"200\" src=\"https://1.bp.blogspot.com/-BwqTkW7_hxk/XuTCd6axFBI/AAAAAAAAEB4/Izf7AH2tEmsbIPY0h0UFPIsDltFgHp0_gCK4BGAsYHg/s799/broadcasting%2Bnumpy.png\" align=\"center\" hspace=\"10px\" vspace=\"0px\"></p>\n",
        "\n",
        "\n",
        "\n",
        "Supongamos, por ejemplo, que se quiere adicionar un vector constante a cada fila de una matriz. Podemos realizar esto de la siguiente forma:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i2dGNyrbdHau",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 204
        },
        "outputId": "3c7c2d38-3df6-4a72-de56-4d976dba6c5a"
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "x = np.arange(start = 1, stop = 13, step = 1).reshape((4,3)); # Array de 4x3 \n",
        "y = np.array([1,0,1]) # Vector fila\n",
        "v = np.empty_like(x) #Array vacio de la mismas dimensiones que x\n",
        "\n",
        "# Modificación del array x, sumando en cada fila el vector fila y.\n",
        "\n",
        "for i in range(len(x)):\n",
        "  v[i,:] = x[i,:]+y\n",
        "\n",
        "print(\"Array Original\")\n",
        "print(x)\n",
        "print(\"\")\n",
        "print(\"Array luego de adicionar valores\")\n",
        "print(v)"
      ],
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Array Original\n",
            "[[ 1  2  3]\n",
            " [ 4  5  6]\n",
            " [ 7  8  9]\n",
            " [10 11 12]]\n",
            "\n",
            "Array luego de adicionar valores\n",
            "[[ 2  2  4]\n",
            " [ 5  5  7]\n",
            " [ 8  8 10]\n",
            " [11 11 13]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4NgtnTSQjxJe",
        "colab_type": "text"
      },
      "source": [
        "A continuación se muestra la solución al anterior problema usando broadcasting:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8RKjPJa2kEzP",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 87
        },
        "outputId": "700e5573-02d9-4d41-e820-c1faebb591ee"
      },
      "source": [
        "x = np.arange(start = 1, stop = 13, step = 1).reshape((4,3)); # Array de 4x3 \n",
        "y = np.array([1,0,1]) # Vector fila\n",
        "\n",
        "v = x+y\n",
        "print(v)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 2  2  4]\n",
            " [ 5  5  7]\n",
            " [ 8  8 10]\n",
            " [11 11 13]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NQnxhbtOqZLc",
        "colab_type": "text"
      },
      "source": [
        "<p><a name=\"tnumpy\"></a></p>\n",
        "\n",
        "### 3.99. Ejercicios de Práctica \n",
        "\n",
        "[[Secciones]](#sections)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FXWWkC-i6Y--",
        "colab_type": "text"
      },
      "source": [
        "**Ejercicio 1: Dificultad Zero**\n",
        "\n",
        "Demuestre que la multiplicación de una matriz $A$ de $7\\times7$ por la matriz identidad $I$ es igual a la matriz $A$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zq5TihU556a5",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Desarrolle aqui su ejercicio"
      ],
      "execution_count": 42,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "halmL7ZA6r8X",
        "colab_type": "text"
      },
      "source": [
        "De click **aquí** para ver la respuesta.\n",
        "\n",
        "<!---\n",
        "# No esperaba verte tan rápido aquí :(\n",
        "\n",
        "identdad = np.eye(7,7)\n",
        "A1 = np.random.rand(7,7)\n",
        "A2 = A1.dot(identity)\n",
        "if A2==A1:\n",
        "    print('Correcto')\n",
        "else:\n",
        "    print('No es correcto')\n",
        "\n",
        "print(\"La matriz A1 es \", A1)\n",
        "print(\"La matriz A2 es \", A2)\n",
        "\n",
        "--->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "mViTA3nz7JXG"
      },
      "source": [
        "**Ejercicio 2: Dificultad Zero**\n",
        "\n",
        "Escriba un programa de NumPy  que genere un array que contenga los enteros del 30 al 70"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "DmC-Mknl7JXL",
        "colab": {}
      },
      "source": [
        "#Desarrolle aqui su ejercicio"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "La9LYWvS7JXR"
      },
      "source": [
        "De click **aquí** para ver la respuesta.\n",
        "\n",
        "<!---\n",
        "# No esperaba verte tan rápido aquí :(\n",
        "\n",
        "import numpy as np\n",
        "array=np.arange(30,71)\n",
        "print(\"Array de los enteros de 30 a 70\")\n",
        "print(array)\n",
        "\n",
        "--->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "YUGoYbgU7k5C"
      },
      "source": [
        "**Ejercicio 3: Dificultad Zero**\n",
        "\n",
        "Escriba un programa de NumPy  que genere un array que contenga los enteros pares del 30 al 70"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "70NDemqv7k5K",
        "colab": {}
      },
      "source": [
        "#Desarrolle aqui su ejercicio"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "mutvwklM7k5X"
      },
      "source": [
        "De click **aquí** para ver la respuesta.\n",
        "\n",
        "<!---\n",
        "# No esperaba verte tan rápido aquí :(\n",
        "\n",
        "import numpy as np\n",
        "array=np.arange(30,71,2)\n",
        "print(\"Array de los enteros pares del 30 al 70\")\n",
        "print(array) \n",
        "\n",
        "--->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "tpvChPhi8vaF"
      },
      "source": [
        "**Ejercicio 3: Dificultad Rookie**\n",
        "\n",
        "Escriba un programa de NumPy  que calcule la multiplicacion de dos matrices dadas"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "nYDihDJe8vaR",
        "colab": {}
      },
      "source": [
        "#Desarrolle aqui su ejercicio\n"
      ],
      "execution_count": 44,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "_aYQ99tc8vaY"
      },
      "source": [
        "De click **aquí** para ver la respuesta.\n",
        "\n",
        "<!---\n",
        "# No esperaba verte tan rápido aquí :(\n",
        "\n",
        "import numpy as np\n",
        "p = [[1, 0], [0, 1]]\n",
        "q = [[1, 2], [3, 4]]\n",
        "print(\"matriz original:\")\n",
        "print(p)\n",
        "print(q)\n",
        "result1 = np.dot(p, q)\n",
        "print(\"Resultado\")\n",
        "print(result1)\n",
        "\n",
        "--->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "Hh89hyjl9sMp"
      },
      "source": [
        "**Ejercicio 4: Dificultad Rookie**\n",
        "\n",
        "Escriba un programa de NumPy  que calcule el determinante de una matriz cuadrada dada"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "saM65l-U9sMu",
        "colab": {}
      },
      "source": [
        "#Desarrolle aqui su ejercicio\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "9GIYdBg-9sM1"
      },
      "source": [
        "De click **aquí** para ver la respuesta.\n",
        "\n",
        "<!---\n",
        "# No esperaba verte tan rápido aquí :(\n",
        "\n",
        "import numpy as np\n",
        "from numpy import linalg as LA\n",
        "a = np.array([[1, 0], [1, 2]])\n",
        "print(\"Original 2-d array\")\n",
        "print(a)\n",
        "print(\"Determinant de un array 2-D \")\n",
        "print(np.linalg.det(a))\n",
        "\n",
        "--->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "xLx4xUBo-Jvx"
      },
      "source": [
        "**Ejercicio 5: Dificultad Rookie**\n",
        "\n",
        "Escriba un programa de NumPy programa que calcule la inversa de una matriz dada"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "2kxRrU8l-Jvz",
        "colab": {}
      },
      "source": [
        "#Desarrolle aqui su ejercicio\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "VE66ke56-Jv3"
      },
      "source": [
        "De click **aquí** para ver la respuesta.\n",
        "\n",
        "<!---\n",
        "# No esperaba verte tan rápido aquí :(\n",
        "\n",
        "import numpy as np\n",
        "m = np.array([[1,2],[3,4]])\n",
        "print(\"Original matrix:\")\n",
        "print(m)\n",
        "result =  np.linalg.inv(m)\n",
        "print(\"Inversa de la  matriz:\")\n",
        "print(result)\n",
        "\n",
        "--->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "foxxLag--ZD7"
      },
      "source": [
        "**Ejercicio 6: Dificultad Hero**\n",
        "\n",
        "Escriba un programa de NumPy que convierta un array de tipo entero a uno de tipo flotante"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "sRkCzlpM-ZD-",
        "colab": {}
      },
      "source": [
        "#Desarrolle aqui su ejercicio\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "PM_5ysqP-ZEF"
      },
      "source": [
        "De click **aquí** para ver la respuesta.\n",
        "\n",
        "<!---\n",
        "# No esperaba verte tan rápido aquí :(\n",
        "\n",
        "import numpy as np\n",
        "a = [1, 2, 3, 4]\n",
        "print(\"Array entero\")\n",
        "print(a)\n",
        "x = np.asfarray(a)\n",
        "print(\"Array convertido  a float type:\")\n",
        "print(x)\n",
        "--->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "ul1Xj6B7_7qc"
      },
      "source": [
        "**Ejercicio 7: Dificultad Hero**\n",
        "\n",
        "Escriba un programa de NumPy que  a grados centigrados valores ingresados en grados  Fahrenheit. Los grados centigrados deben almacenarse en un numpy array"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "IVeL1fUN_7qo",
        "colab": {}
      },
      "source": [
        "#Desarrolle aqui su ejercicio\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "kEQlQ5WG_7qx"
      },
      "source": [
        "De click **aquí** para ver la respuesta.\n",
        "\n",
        "<!---\n",
        "# No esperaba verte tan rápido aquí :(\n",
        "\n",
        "import numpy as np\n",
        "fahrenheit_values = [0, 12, 45.21, 34, 99.91]\n",
        "F = np.array(fahrenheit_values)\n",
        "print(\"Valores en:\")\n",
        "print(F)\n",
        "print(\"Valores en  Centigrados:\") \n",
        "print(5*F/9 - 5*32/9)\n",
        "--->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "duVSO5mvBIKs"
      },
      "source": [
        "**Ejercicio 7: Dificultad Leyenda**\n",
        "\n",
        "Escriba un programa de NumPy que  a grados centigrados valores ingresados en grados  Fahrenheit. Los grados centigrados deben almacenarse en un numpy array"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "nMqYO76SBIKw",
        "colab": {}
      },
      "source": [
        "#Desarrolle aqui su ejercicio\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "TIIEu9MWBIK2"
      },
      "source": [
        "De click **aquí** para ver la respuesta.\n",
        "\n",
        "<!---\n",
        "# No esperaba verte tan rápido aquí :(\n",
        "\n",
        "import numpy as np\n",
        "fahrenheit_values = [0, 12, 45.21, 34, 99.91]\n",
        "F = np.array(fahrenheit_values)\n",
        "print(\"Valores en:\")\n",
        "print(F)\n",
        "print(\"Valores en  Centigrados:\") \n",
        "print(5*F/9 - 5*32/9)\n",
        "--->"
      ]
    }
  ]
}