python_iq_introduccion.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "python_iq_introduccion.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "uydALjBx3gZ9",
        "AF8QwoTG39kO",
        "QZrtSSGdui7U",
        "Le-7Uwn46uwy",
        "Q0IrwMQ_zwGO",
        "3yKCFcat7cb4",
        "a83T30JL-Y8i",
        "EmIX3MhcQ_xH",
        "H9z6rDf-FJLd"
      ],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.8.8"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/andresf-sierra/python_iq_meetup/blob/master/python_iq_introduccion.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uydALjBx3gZ9"
      },
      "source": [
        "# **Introducción y Conceptos Básicos de Python para IQ**\n",
        "\n",
        "####  ***Andrés F. Sierra***\n",
        "\n",
        "  *Estudiante de Ingeniería Química y Ciencia de Datos*\n",
        "\n",
        "  *Campus Rep 2021* \n",
        "\n",
        "  *Diplomado en Análisis de Datos y Machine Learning en Python*\n",
        "  \n",
        "\n",
        " <!-- badges: start -->\n",
        "[![Andres Sierra](https://img.shields.io/badge/LinkedIn-blue?&logoColor=white)](https://www.linkedin.com/in/andresf-sierra/) \n",
        "[![Andres Sierra](https://img.shields.io/badge/GitHub-green?&logoColor=white)](https://github.com/andresf-sierra)\n",
        "<!-- badges: end -->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AF8QwoTG39kO"
      },
      "source": [
        "# 1) Introducción a Google Colab\n",
        "\n",
        "\n",
        "**Colaboratory**, o mejor conocido como **Colab**, provee de un entorno interactivo a nivel de **archivo**. Dentro de él podrás **escribir** y **ejecutar código** python de una forma **sencilla** y **colaborativa** en tiempo real **sin** ninguna **configuración** extra.\n",
        "\n",
        "El componente de trabajo **clave** en **Colab** son los **notebooks**, también conocidos como libretas interactivas o bloc de notas. Un notebook es una herramienta en la que puedes combinar **código ejecutable** y **texto enriquecido** en un sólo lugar. Además, podrás incluir **imágenes**, **HTML**, **LaTeX** y mucho más.\n",
        "\n",
        "---\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QZrtSSGdui7U"
      },
      "source": [
        "## Ejecución y edición de celdas\n",
        "\n",
        "###  Celdas de código\n",
        "\n",
        "A continuación encontrarás una **celda de código** en la que podrás ejecutar una sencilla instrucción en `Python`\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QqB6Z0EtvKdC",
        "outputId": "5da06558-ecb3-4efa-923d-ea1de9845ef4"
      },
      "source": [
        "print(\"Curso basico de phyton\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Curso basico de phyton\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cZ2A8cnwvrmt"
      },
      "source": [
        "Interactuar con las **celdas de código** es tan sencillo como dar clic en ella y presionar `Command/Ctrl + Enter`para **ejecutarla** y simplemente `escribir` para **editarla**."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tZgn2E3dviX6"
      },
      "source": [
        "> Edita, ejecuta, observa y repite. Ese es el ciclo de trabajo en los **notebooks**."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AlXhOMPIx7AJ"
      },
      "source": [
        "Ahora hagamos una conversión de unas sencillas unidades, números de segundos en un día"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ldB3rUz938-t",
        "outputId": "0876826e-5f8e-4d52-f1f6-5171db59c8e8"
      },
      "source": [
        "secs_per_day = 60*60*24 #[seg*min*h]\n",
        "\n",
        "print(secs_per_day)"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "86400\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3Mja1zi5zECA",
        "outputId": "5f38e830-7a16-4e7c-b25f-858b08200b7e"
      },
      "source": [
        "print(f'Un día tiene {secs_per_day} segundos')"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Un día tiene 86400 segundos\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Me6q8uc2mlBT"
      },
      "source": [
        "Hola, estoy contento con mis primeros pasos en el aprendizaje de Phyton\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jLW_ikKynxBO"
      },
      "source": [
        "He ejecutado mis primeras celdas de **Python** en **Colab**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CEFm3KdvV0VN"
      },
      "source": [
        "Hola, ya di mis primeros pasos en **Colab**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Le-7Uwn46uwy"
      },
      "source": [
        "# 2) Introducción a Python"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q0IrwMQ_zwGO"
      },
      "source": [
        "### Variables\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.\n",
        "\n",
        "Entre las características más destacables de las sesiones interactivas dentro de los notebooks es que las variables que definas en una celda pueden ser utilizadas después en otras:\n",
        "\n",
        "**Asignamos** a dos variables un texto (*string*)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2yH3UfjU3Zi2"
      },
      "source": [
        "mi_primera_variable = \"Esta es mi primera variable\"\n",
        "mi_segunda_variable = \"esta es mi segunda variable\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XXnqTaJI5XiX",
        "outputId": "5eda9907-50fb-4e26-d741-8ecd1cac54f2"
      },
      "source": [
        "print(f'{mi_primera_variable} {mi_segunda_variable}')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Esta es mi primera variable esta es mi segunda variable\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L6DVY12V5_Yo"
      },
      "source": [
        "También podemos agrupar el resultado en una nueva variable."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "y0ZK9pLk6G3M",
        "outputId": "2f103bd2-d383-4b00-9f8b-57d04c114720"
      },
      "source": [
        "mi_tercera_variable = mi_primera_variable + mi_segunda_variable\n",
        "print(mi_tercera_variable)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Esta es mi primera variableesta es mi segunda variable\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3yKCFcat7cb4"
      },
      "source": [
        "### Tipos de variables\n",
        "\n",
        "En Python, los tipos fundamentales son \n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "1.   Enteros (int).\n",
        "2.   Punto flotante (float).\n",
        "3.   Buleanos (boolean)\n",
        "4.   Cadena de caracteres (strings).\n",
        "\n",
        "Veamos algunos ejemplos de estos tipos:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BYgU9nbV7psQ"
      },
      "source": [
        "Enteros (int)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_vEWNXYu7n0E",
        "outputId": "4dd560f4-0119-4aaa-d466-8366088a4e04"
      },
      "source": [
        "edad = 20  \n",
        "type(edad)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "int"
            ]
          },
          "execution_count": 14,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7IgzGN0Q8B_w"
      },
      "source": [
        "Punto flotante (float)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TDz7OQGM8GS1",
        "outputId": "effe1c1a-77f3-453e-9ebd-018930635253"
      },
      "source": [
        "estatura = 1.70\n",
        "type(estatura)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "float"
            ]
          },
          "execution_count": 17,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r6PRe32h8Qiz"
      },
      "source": [
        "Buleanos (boolean)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8cnyT7AM8bfr",
        "outputId": "7cb51824-b08f-44d6-ca2f-47d86cf30ee1"
      },
      "source": [
        "aprendo_python = True\n",
        "type(aprendo_python)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "bool"
            ]
          },
          "execution_count": 20,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e0ATAtF_8m-a"
      },
      "source": [
        "Cadenas de texto (Strings)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uuAWh8JP8p3P",
        "outputId": "2256ba08-8911-44da-a930-727710cee6f5"
      },
      "source": [
        "materia_dificil = \"Fenomenos de Transporte\"\n",
        "type(materia_dificil) "
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "str"
            ]
          },
          "execution_count": 23,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a83T30JL-Y8i"
      },
      "source": [
        "## Operadores y comparadores\n",
        "\n",
        "| Operadores      | aritméticos |\n",
        "|-----------------|-------------|\n",
        "| Suma            |      +      |\n",
        "| Resta           |      -      |\n",
        "| Multiplicación  |      *      |\n",
        "| División        |      /      |\n",
        "| División entera | //          |\n",
        "| Negación        | -           |\n",
        "| Exponente       | **          |\n",
        "| Módulo          | %           |\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OIamOaKQ-05k",
        "outputId": "ed7fa2f3-fdba-4a90-cf8b-7e52deb7321f"
      },
      "source": [
        "2/2 "
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "execution_count": 26,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WZ-73XeBCdg7"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rUQbby0u_JRB"
      },
      "source": [
        "\n",
        "\n",
        "*   Los buleanos están conectados o precedidos por palabras como `and`, `not`, `or`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lbz4kmUz_KJe",
        "outputId": "74aca0aa-9cf0-42fb-b25c-c7c25e554f64"
      },
      "source": [
        "True and False"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "execution_count": 27,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZK51eS4FC8Ad",
        "outputId": "76762030-80b5-46a1-f67d-22586793c8ce"
      },
      "source": [
        "not False"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 28,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yBdELniUDB9m",
        "outputId": "5b19efc1-2014-4e77-8f63-be3460af40ff"
      },
      "source": [
        "True or False"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 42,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kX0qEu0xDGmX"
      },
      "source": [
        "*   Operadores de comparación `>`, `<`, `>=`(mayor o igual), `<=` (menor o igual), `==` (igual), `!=`(no igual) y `is` (identico).\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8OORYpyHDHJ9",
        "outputId": "48c45c22-3eed-4db1-dd57-aaae66b80f37"
      },
      "source": [
        "2!=3"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 29,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gAm3gYjbDLiS",
        "outputId": "488a5cac-a910-415b-cb72-96bbf6b21c71"
      },
      "source": [
        "2>3,2<2"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(False, False)"
            ]
          },
          "execution_count": 44,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "x_x3-RfuDN32",
        "outputId": "dbe6d137-ca88-4277-e9ee-9b054dc048ac"
      },
      "source": [
        "4<=4,4>=4"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(True, True)"
            ]
          },
          "execution_count": 45,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6aVZalRzDWfm",
        "outputId": "456b49ed-aed3-4389-ef8d-20a8c1ef7409"
      },
      "source": [
        "#igual a\n",
        "[3.0,2]==[3,2]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 47,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "epiq3gNYDXR0",
        "outputId": "94a1a6ff-3674-4d8e-982d-9cc859ba6292"
      },
      "source": [
        "# Not equal to\n",
        "\n",
        "2 != 5"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 48,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EmIX3MhcQ_xH"
      },
      "source": [
        "## Funciones\n",
        "Una función es un bloque de código organizado y reutilizable, usado para realizar una única acción relacionada. Las funciones proporcionan una mejor modularidad para su aplicación y un alto grado de reutilización del código.\n",
        "\n",
        "\n",
        ">`def Nombre(arg1,arg2,...):`\n",
        ">> `sentencias`\n",
        "\n",
        "De esta forma, se representa una función normalmente.\n",
        "\n",
        "Ahora, definamos la función exponencial de $a^{b}$\n",
        "\n",
        "- Primero, definimos la función, le ponemos un nombre e ingresamos los argumentos que tiene esta función.\n",
        "- Siguiendo sintáxis, escribimos la escuación que representa a nuestra función.\n",
        "- Retornamos el valor de la función para que haga la operación\n",
        "- Por último llamamos la función con los valores de los parámetros de entrada que deseamos.\n",
        "\n",
        "La sentencia *return* termina la función,  devolviendo opcionalmente uno o varios valores. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ursGAhb1VRTc",
        "outputId": "aaf02f20-2e7d-42a0-fd84-856aa82cdc6f"
      },
      "source": [
        "def Exp(a,b):\n",
        "  exp = a**b\n",
        "  return exp\n",
        "\n",
        "print(Exp(2,2)) "
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NQzozpyVZeHg"
      },
      "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": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KK-kG3sIZKM3",
        "outputId": "2995767b-a039-4068-8156-e5949cd86ea9"
      },
      "source": [
        "def Exp(a,b):\n",
        "  return a**b\n",
        "\n",
        "print(Exp(2,2))  "
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QsYs5Fhuai9f",
        "outputId": "46c36c27-ac0c-4b20-dea8-ae06e9c55a82"
      },
      "source": [
        "def Exp2(a,b):\n",
        "  return a**b, a**b+1, a**b+2\n",
        "\n",
        "print(Exp2(2,2))  "
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(4, 5, 6)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "06wka_2Ba18J"
      },
      "source": [
        "---\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tu2Ki06EXt2A"
      },
      "source": [
        "# 3) Ejemplos en la Ingeniería Química\n",
        "\n",
        "### Definamos y evaluemos una función\n",
        "\n",
        "Como aplicación usemos la ecuación de **Arrhenius** que determina cómo la rapidez de una reacción química se ve afectada por la temperatura y que se define como:\n",
        "\\begin{equation}\n",
        "k=A\\exp\\left(-\\frac{E_a}{k_B T}\\right),\n",
        "\\end{equation}\n",
        "en donde $A$ es una constante, $E_a$ es la energía de activación, $k_B$ es la constante de Bolztmann y $T$ es la temperatura. \n",
        "\n",
        "---\n",
        "\n",
        "Crearemos una función para la ecuación de **Arrehenius** que tendrá cómo parámetro de entrada la Temperatura y la energía de activación."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N9yhVDQEa9tN"
      },
      "source": [
        "Recordemos siempre importar las librerías.\n",
        " "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XkmgpHF7MZ7n"
      },
      "source": [
        "import numpy as np"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yZaeDfcKeN0y"
      },
      "source": [
        "Una vez creada la función con `def` + `nombre_función`  y pasémos sus argumentos o parámetros `temp, actEnergia`, procedemos a definir los valores que conocemos de la ecuación, los cuales son $k_{B}$ y $A$. \n",
        "Y por último, retornamos la evaluación de la función."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q1WS1xY8MZ7o"
      },
      "source": [
        "def arrhenius(temp, actEnergia):\n",
        "    kB = 1.380449e-23 #[J/K]\n",
        "    A = 1\n",
        "    return A*np.exp(- actEnergia/(kB*temp))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rM0AraiCYMG-"
      },
      "source": [
        "Ahora, hacemos una prueba con Temperatura de 100 y con una energía de activación de 1e-21"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5Dk5OmSdMZ7w",
        "outputId": "68e38178-9b12-43a9-e345-d02b0ee462a2"
      },
      "source": [
        "arrhenius(100, 1e-21)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "0.4846142874547784"
            ]
          },
          "execution_count": 20,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v9rXzeb3MZ7x"
      },
      "source": [
        "Ahora vamos a crear una conjunto de temperaturas a evaluar en la función que hemos creado. Para esto usaremos el comando `np.linspace` el cual nos ayuda a crear una arreglo numérico. Este arreglo numérico tendrá la característica que empezará a 250, terminará a 450 y en ese rango solo quiero 50 valores. O sea, `inicio=250, final=450, n=50`. Una vez creado el arreglo numérico de las tempraturas, evaluamos en nuestra función. \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K4pvVdqPMZ75",
        "outputId": "610ecfa6-2047-4bd3-8804-d0137bd8284c"
      },
      "source": [
        "temp_array = np.linspace(250, 450, 50)\n",
        "arrhenius(temp_array, 1e-21)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([0.74844258, 0.75193454, 0.75533162, 0.75863758, 0.76185603,\n",
              "       0.76499035, 0.76804379, 0.7710194 , 0.77392011, 0.77674869,\n",
              "       0.77950778, 0.78219988, 0.78482741, 0.78739263, 0.78989772,\n",
              "       0.79234477, 0.79473575, 0.79707256, 0.79935701, 0.80159083,\n",
              "       0.80377567, 0.80591313, 0.80800473, 0.8100519 , 0.81205605,\n",
              "       0.81401852, 0.81594059, 0.81782347, 0.81966837, 0.82147641,\n",
              "       0.82324867, 0.82498621, 0.82669004, 0.82836112, 0.83000038,\n",
              "       0.83160872, 0.83318701, 0.83473608, 0.83625672, 0.83774971,\n",
              "       0.8392158 , 0.8406557 , 0.84207011, 0.8434597 , 0.84482511,\n",
              "       0.84616697, 0.84748587, 0.84878241, 0.85005714, 0.85131061])"
            ]
          },
          "execution_count": 22,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oX0QyshPMZ75"
      },
      "source": [
        "Cómo podemos observar, al evaluar el arreglo numérico del rango de temperaturas dentro de la función creada para la ecuación de Arrhenius, obtenemos fácilmente la evaluación de todas las tempraturas dadas con un valor de energía de activación.\n",
        "\n",
        "Si deseo comprobar si en verdad mi array cumple con las especifiaciones que le he dado, ejecuto el método `len()`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tEMgBN_lMZ76",
        "outputId": "0b7d3a45-7eea-431e-9e69-47c740234d91"
      },
      "source": [
        "len(temp_array)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "50"
            ]
          },
          "execution_count": 23,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uHIyMHutMZ76"
      },
      "source": [
        "Ahora podemos crear un arreglo numérico de las energías de activación utilizando el mismo método anterior.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QIvsATUNMZ7-",
        "outputId": "de3b892e-d791-4e30-cf01-4ed9871aa8e5"
      },
      "source": [
        "energias_array = np.linspace(-10,10,50)*1e-21\n",
        "arrhenius(273, energias_array) "
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([14.20348186, 12.74554168, 11.43725421, 10.26325811,  9.20976879,\n",
              "        8.26441666,  7.41610177,  6.65486359,  5.97176397,  5.35878226,\n",
              "        4.80872108,  4.31512186,  3.87218895,  3.47472163,  3.11805301,\n",
              "        2.79799524,  2.51079033,  2.25306606,  2.02179632,  1.81426565,\n",
              "        1.62803732,  1.4609247 ,  1.31096564,  1.17639937,  1.05564589,\n",
              "        0.94728735,  0.85005145,  0.7627965 ,  0.68449798,  0.61423654,\n",
              "        0.5511872 ,  0.49460967,  0.44383963,  0.39828097,  0.35739875,\n",
              "        0.32071296,  0.28779284,  0.25825186,  0.23174317,  0.2079555 ,\n",
              "        0.18660956,  0.16745471,  0.15026604,  0.13484173,  0.12100068,\n",
              "        0.10858036,  0.09743495,  0.08743357,  0.07845881,  0.07040527])"
            ]
          },
          "execution_count": 24,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2II1F46sMZ8H",
        "outputId": "34058143-4361-4d33-b43d-25200d154037"
      },
      "source": [
        "arrhenius(temp_array, energias_array)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([18.1307239 , 15.40497079, 13.15660703, 11.29171092,  9.73666802,\n",
              "        8.43341742,  7.33588973,  6.40731941,  5.61820353,  4.94474141,\n",
              "        4.36763464,  3.87115878,  3.44244119,  3.0708961 ,  2.74778044,\n",
              "        2.46584272,  2.21904433,  2.00233701,  1.81148462,  1.64291957,\n",
              "        1.4936268 ,  1.3610496 ,  1.24301283,  1.13766014,  1.04340241,\n",
              "        0.95887523,  0.88290381,  0.81447379,  0.75270702,  0.69684124,\n",
              "        0.64621316,  0.60024418,  0.55842836,  0.52032231,  0.48553657,\n",
              "        0.4537283 ,  0.42459508,  0.39786958,  0.37331501,  0.35072127,\n",
              "        0.32990153,  0.31068938,  0.29293634,  0.27650966,  0.2612905 ,\n",
              "        0.24717227,  0.23405921,  0.22186517,  0.2105125 ,  0.19993116])"
            ]
          },
          "execution_count": 25,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H9z6rDf-FJLd"
      },
      "source": [
        "---\n",
        "\n",
        "\n",
        "### Volumen molar y factor de compresibilidad a partir de la ecuación de Van Der Waals\n",
        "\n",
        "#### **Problema:**\n",
        "\n",
        "Utilice la ecuación de estado de Van der Waals, dada por:\n",
        "\n",
        "$$\\left(P+\\frac{a}{V^2}\\right)\\left(V-b\\right)=RT$$\n",
        "\n",
        "$$a=\\frac{27}{64}\\left(\\frac{R^2T^2_c}{P_c}\\right)$$\n",
        "\n",
        "$$b=\\frac{RT_c}{8P_c}$$\n",
        "\n",
        "Dónde\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "* $P$ es la presión en atm\n",
        "* $V$ es el volumen molar en litros/g-mol\n",
        "* $T$ es la temperatura en Kelvin\n",
        "* $R$ es la constante de gas ideal (R = 0.08206 atm.litros/g-mol.K)\n",
        "* $T_c$ es la temperatura crítica (405.5 K para el amoniaco)\n",
        "* $P_c$ es la presión crítica (111.3 atm para el amoniaco)\n",
        "\n",
        "\n",
        "La presión reducida es:\n",
        "\n",
        "$$P_r=\\frac{P}{P_c}$$\n",
        "\n",
        "Y la compresibilidad es:\n",
        "\n",
        "$$Z=\\frac{PV}{RT}$$\n",
        "\n",
        "- **Calcule** el volumen molar y el factor de compresibilidad del amoníaco gaseoso a 56 atm y 450 K utilizando la ecuación de estado de Van der Waals.\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7Ac4ObA_IBQS"
      },
      "source": [
        "---\n",
        "**Solución**\n",
        "\n",
        "Como tenemos que reordenar la ecuación, podemos utilizar el paquete sympy para que haga el álgebra por nosotros:\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eaIcSJJYILmQ"
      },
      "source": [
        "import sympy"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K8ivSjaAIRWt"
      },
      "source": [
        "P,V,N,R,T,a,b,Pc,Pr,Tc,Z = sympy.symbols('P V N R T a b Pc Pr Tc Z')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C4P0YXovIUAy"
      },
      "source": [
        "eq1 = sympy.Eq((P+a/V**2)*(V-b),R*T) #Van der Waals\n",
        "a_def = sympy.Eq(27/64*(R**2*Tc**2/Pc),a) #Factor a\n",
        "b_def = sympy.Eq(R*Tc/(8*Pc),b) #Factor b"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gRLHEWOwIZHD"
      },
      "source": [
        "\n",
        "Confirmemos que hemos introducido las ecuaciones"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 48
        },
        "id": "OS9lzcvJIako",
        "outputId": "d56084f4-8fa9-4019-bab5-12c94e943555"
      },
      "source": [
        "eq1\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/latex": [
              "$\\displaystyle \\left(P + \\frac{a}{V^{2}}\\right) \\left(V - b\\right) = R T$"
            ],
            "text/plain": [
              "Eq((P + a/V**2)*(V - b), R*T)"
            ]
          },
          "execution_count": 52,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        },
        "id": "zUqlWn77IiTD",
        "outputId": "f3a2e3b3-d42e-41f4-e2a6-42f1de1f6402"
      },
      "source": [
        "a_def\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/latex": [
              "$\\displaystyle \\frac{0.421875 R^{2} Tc^{2}}{Pc} = a$"
            ],
            "text/plain": [
              "Eq(0.421875*R**2*Tc**2/Pc, a)"
            ]
          },
          "execution_count": 53,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        },
        "id": "ZwRR6EVFIj1-",
        "outputId": "3832b793-730e-4963-93bb-4361ec80cadd"
      },
      "source": [
        "b_def"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/latex": [
              "$\\displaystyle \\frac{R Tc}{8 Pc} = b$"
            ],
            "text/plain": [
              "Eq(R*Tc/(8*Pc), b)"
            ]
          },
          "execution_count": 54,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "prm0CiZIIm2T"
      },
      "source": [
        "Podemos obtener los valores de $a$ y $b$ con la sustitución:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 58
        },
        "id": "NwQSBEl8Ik0i",
        "outputId": "c1ee15ba-a028-4bb2-bbaa-4ce193e9fe6b"
      },
      "source": [
        "eq1_subs = eq1.subs({a:27/64*(R**2*Tc**2/Pc),b:R*Tc/(8*Pc)})\n",
        "eq1_subs"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/latex": [
              "$\\displaystyle \\left(P + \\frac{0.421875 R^{2} Tc^{2}}{Pc V^{2}}\\right) \\left(V - \\frac{R Tc}{8 Pc}\\right) = R T$"
            ],
            "text/plain": [
              "Eq((P + 0.421875*R**2*Tc**2/(Pc*V**2))*(V - R*Tc/(8*Pc)), R*T)"
            ]
          },
          "execution_count": 55,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BbNIFZTfI4ql"
      },
      "source": [
        "Solución para a)\n",
        "\n",
        "Sustituye la presión y la temperatura dadas para la parte a:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u8IxpDpzJKas"
      },
      "source": [
        "\n",
        "eq1_subs_part_a = eq1_subs.subs({P:56,R:0.08206,T:450,Pc:111.3,Tc:405.5})"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gUq5O2nBJoxs"
      },
      "source": [
        "A continuación, podemos sustituir los otros valores, y resolver para $V$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 37
        },
        "id": "hI0lfPVmJp6u",
        "outputId": "6ae5b640-84d9-413d-a138-9e886c1507cf"
      },
      "source": [
        "root = sympy.solveset(eq1_subs_part_a,symbol = V, domain=sympy.S.Reals)\n",
        "root.args[0]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/latex": [
              "$\\displaystyle 0.574891913557151$"
            ],
            "text/plain": [
              "0.574891913557151"
            ]
          },
          "execution_count": 57,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4M-aQaasJwRX"
      },
      "source": [
        "Resolviendo para $Z$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 37
        },
        "id": "I8G3aCi0J0pj",
        "outputId": "b2d19627-36d3-4e77-89bb-8a8bd96c7448"
      },
      "source": [
        "\n",
        "(P*V/(R*T)).subs({P:56,R:0.08206,T:450,V:root.args[0]})"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/latex": [
              "$\\displaystyle 0.871826770633966$"
            ],
            "text/plain": [
              "0.871826770633966"
            ]
          },
          "execution_count": 58,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ykr2AkOkJ7Av"
      },
      "source": [
        "Repositorio para los notebooks y scripts usados en el Meetup de Introducción y Conceptos Básicos de Python para Ingenieros Químicos, realizado con Platzi Campus Rep"
      ]
    }
  ]
}