Diploma PL Python Foundations Summer 2024.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "820c5c25-4e6c-4579-b8b3-86264e8ee257",
   "metadata": {},
   "source": [
    "<p><a name=\"contents\"></a></p>\n",
    "\n",
    "# **Diplomado en Lenguajes de Programación: Python, SQL & R.**\n",
    "# Notas por: **Emmanuel Rivera López.**\n",
    "## Verano 2024, `versión 1.0.`\n",
    "# **Lenguaje de Programación Python.** \n",
    "\n",
    "- <a href = \"#intro\"> 1. Introducción </a>\n",
    "    - <a href=\"#PhyEaster\"> 1.2 Primero lo primero...</a>\n",
    "- <a href=\"#DataStrPy\">2. Estructura de Datos en el Lenguaje de Programación Python.</a>\n",
    "    - <a href=\"#Int\">2.1. Números `(int, float)`.</a>\n",
    "      - <a href=\"#MathOp\">2.1.1. Operadores Aritméticos.</a>\n",
    "    - <a href=\"#varassign\">2.2. Declaración de Variables.</a>\n",
    "    - <a href=\"#Chains\">2.3. Cadenas.</a>\n",
    "    - <a href=\"#Lists\">2.4. Listas.</a>\n",
    "      - <a href=\"#lstindex\">2.4.1 Indexación de Listas.</a>\n",
    "    - <a href=\"#Arr\">2.5 Arreglos en Python.</a>\n",
    "- <a href=\"#Defunc\">3. Funciones Predefinidas.</a>\n",
    "- <a href=\"#Lib\">4. Bibliotecas y Módulos.</a>\n",
    "    - <a href=\"#Numpy\">4.1. Biblioteca `NumPy`.</a>\n",
    "    - <a href=\"#MtNp\">4.2. Métodos dentro de la Biblioteca `NumPy`.</a>\n",
    "- <a href=\"#dict\">5. Diccionarios.</a>\n",
    "    - <a href=\"#dict_att\">5.1. Atributos de los Diccionarios</a>\n",
    "- <a href=\"#refs\">6. Referencias y Cibergrafía.</a>>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf44b332-0f73-41ca-b7f8-7944544a495d",
   "metadata": {},
   "source": [
    "<b> Conocimientos Previos:</b> Es importante que tenga los conocimientos esenciales en programación básica <i> variables, estructuras de control, funciones, matrices y el procedimiento de importación de bibliotecas (o módulos, según sea el caso).</i>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "40e90be6-11a2-4252-9958-6a894330b2bd",
   "metadata": {},
   "source": [
    "<p><a name=\"intro\"></a></p>\n",
    "\n",
    "# **1. Introducción.**\n",
    "\n",
    "<p style=\"text-align: justify;\">\n",
    "El objetivo del primer módulo del Diplomado, es realizar una introducción al Lenguaje de Programación Python. Es importante considerar que se empleará a lo largo de estas sesiones la versión de <b> Python 3.12 </b>, se estudiará la sintaxis básica de del lenguaje, el manejo de cadenas, la creación de funciones, estructuras básicas de datos, importación y manejo de archivos, además de analizar las ventajas que este lenguaje ofrece a comparación de otros bien conocidos dentro del ámbito de la programación. <br><br>\n",
    "Dado esto, la primer interrogante que surge al introducirse a un nuevo lenguaje de programación, es, valga la redundancia, <i> ¿que es ese lenguaje de programación?, </i> lo cuál de manera natural lleva a preguntarse: \n",
    "</p>\n",
    "\n",
    "<p style=\"text-align: center;\">\n",
    "   <font size=\"+1\"><b> ¿Qué es el lenguaje Python y porque es importante para usted aprenderlo?</b></font>\n",
    "</p>\n",
    "<p style=\"text-align: justify;\">\n",
    "Python es un lenguaje de programación de alto nivel, multiparadigma cuya filosofía se basa principalmente en <font color = \"#2C2C69\"><b> su sintaxis ligera y alta versatilidad, la cuál permite máximizar la fácil lectura del mismo, </b></font> lo cuál podría decirse que aventaja a la estructura de lenguajes de programación cómo C, C++ o Java. La <b><i> programación en lenguajes de alto nivel </b></i> es mucho más fácil; escribir programas en un lenguaje de alto nivel\r\n",
    "toma menos tiempo, los programas son más cortos y más fáciles de leer, y es más probable que estos programas sean correctos. En segundo lugar, los lenguajes de alto nivel son portables, lo que significa que pueden ejecutarse en tipos diferentes de computadores sin modificación alguna o con pocas modificaciones <br>\n",
    "\n",
    "De lo anterior, se sigue que estas características permiten que Python no se limite al entorno dinámico que le proporciona al usuario, si no que a su vez <font color = \"#873D7D\"><b> el lenguaje de programación actúa cómo una solución completa, </b></font> esto por el hecho de que <font color = \"#A39512\"><b> el lenguaje de programación actúa cómo una solución completa, puede encargarse de gestión de servicios web, cómputo en la nube, manejo y procesamiento de datos, escritura de aplicaciones, tales cómo sitios web dinámicos, aplicaciones para sistemas operativos con interfaces gráficas e inclusive aplicaciones iOS y Android.</b></font>\n",
    "\r\n",
    "> \"The Python community invested in the mid-1990s in Numeric, an \"extension to Python to support numeric analysis as naturally as [M]atlab does\". Numeric later evolved into NumPy. Several years later, the plotting functionality from Matlab was ported to Python with matplotlib. Libraries for scientific computing were built around NumPy and matplotlib and bundled into the SciPy package, which was commercially supported by Enthought. Python's support for Matlab-like array manipulation and plotting is a major reason to prefer it over Perl and Ruby.\r\n",
    "\r\n",
    "> Today, the most popular alternatives to Python for data scientists are R, Matlab/Octave, and Mathematica/Sage. In addition to the work mentioned above to port features from Matlab into Python, recent work has ported several popular features from R and Mathematica into Python.\r\n",
    "\r\n",
    "> From R, the data frame and associated manipulations (from the plyr and reshape packages) have been implemented by the pandas library. The scikit-learn project presents a common interface to many machine learning algorithms, similar to the caret package in R.\"\r\n",
    "\r\n",
    "<div align=\"right\"><b>-Jeff Hammerbacher, Professor at Hammer Lab, founder at Cloudera, investor at Techammer</b></di\r",
    "</p>\n",
    ">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4caf1f8c-7757-46af-823c-c805167db633",
   "metadata": {},
   "source": [
    "<p><a name=\"PhyEaster\"></a></p>\n",
    "\n",
    "## **1.1. Primero lo primero...**\n",
    "Los desarrolladores de Python incluyeron ciertas curiosidades y sorpresas dentro de la estructura del lenguaje, a los cuales han llamado <b> Eastereggs (los clásicos huevos de Pascua que uno podría encontrarse en alguna película o videojuego). </b> A continuación, mostraré en consola algunos de los más representativos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a5566958-03f0-4ab1-8a23-fe1a04b13e2b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Zen of Python, by Tim Peters\n",
      "\n",
      "Beautiful is better than ugly.\n",
      "Explicit is better than implicit.\n",
      "Simple is better than complex.\n",
      "Complex is better than complicated.\n",
      "Flat is better than nested.\n",
      "Sparse is better than dense.\n",
      "Readability counts.\n",
      "Special cases aren't special enough to break the rules.\n",
      "Although practicality beats purity.\n",
      "Errors should never pass silently.\n",
      "Unless explicitly silenced.\n",
      "In the face of ambiguity, refuse the temptation to guess.\n",
      "There should be one-- and preferably only one --obvious way to do it.\n",
      "Although that way may not be obvious at first unless you're Dutch.\n",
      "Now is better than never.\n",
      "Although never is often better than *right* now.\n",
      "If the implementation is hard to explain, it's a bad idea.\n",
      "If the implementation is easy to explain, it may be a good idea.\n",
      "Namespaces are one honking great idea -- let's do more of those!\n"
     ]
    }
   ],
   "source": [
    "# Importa y devuelve en consola la filosofía tras el Lenguaje de Programación de Python. \n",
    "import this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f714999e-e96c-441f-b029-9c43fd314857",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Devuelve en consola \"Hello World\".\n",
    "import __hello__"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "308d3d2e-bfd5-4cd5-b2bf-e2dd28b4a02b",
   "metadata": {},
   "source": [
    "<p><a name=\"DataStrPy\"></a></p>\n",
    "\n",
    "# **2. Estructura de Datos en el Lenguaje de Programación Python**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b56173e6-b38c-4240-84ad-ad435f4b7acd",
   "metadata": {},
   "source": [
    "<p style=\"text-align: justify;\">\n",
    "Python no solo permite guardar un solo valor en una variable, sino que también soporta estructuras de datos que nos facilitan almacenar varios elementos dentro de una sola variable. Estas estructuras en Python funcionan como tipos de datos básicos, cada una con características particulares que las distinguen. <br>\n",
    "Recuerde que un 'string' o cadena de caracteres es una estructura que organiza el texto <b><i> como una secuencia de caracteres,</b></i> en Python, los objetos que organizarán los valores de un conjunto de datos <i> son los enteros, las listas, los arreglos, conjuntos y los diccionarios.</i>\n",
    "\n",
    "| Estructura | Sintaxis | Definición |  \r\n",
    "| ----- | ----- | ----- |\r\n",
    "| **List** | Las listas están encerradas dentro de corchetes: listExample = [1, 2, \"a\"] | Las listas son ordenadas y modificables. |  \r\n",
    "| **Tuple** | Las tuplas se encierran con paréntesis: tupleExample = (1, 2, \"a\") | Una tupla es ordenada y no puede ser modificada. |  \r\n",
    "| **Dictionary** | Los diccionarios se construyen usando llaves: dictionaryExample = {\"a\":1, \"b\":2} | Un diccionario no es ordenado, es modificable e indexado. Estos manejan llaves y valores. |  \r\n",
    "| **Set** | Los conjuntos se declaran usando también llaves: setExample = {1, 2, 3}. | Un conjunto es una colección no ordenada de elementos. Cada conjunto de elementos es único y se aconseja que no cambie, aunque un conjunto es modificable. |le. |le. |\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66eee028-f50d-4e46-9a5c-74152348ca78",
   "metadata": {},
   "source": [
    "<p><a name=\"Int\"></a></p>\n",
    "\n",
    "## **2.1. Números `int, float`**\n",
    "\n",
    "<p><a name=\"MathOp\"></a></p>\n",
    "\n",
    "### **2.1.1 Operadores Aritméticos.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "7a1321e6-8e2a-40cb-9743-faff66d9907e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "10\n",
      "2401\n",
      "0.058823529411764705\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(2+7)\n",
    "print(2*5)\n",
    "print(7**4)\n",
    "print(5/85)\n",
    "# El operador // implementa la función mayor entero y devuelve en consola el mayor inmediato anterior en función de los valores proporcionados por el usuario. \n",
    "8//3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ae98751-8e51-41cf-94e8-3cf082d3a225",
   "metadata": {},
   "source": [
    "<p><a name=\"varassign\"></a></p>\n",
    "\n",
    "## **2.2. Declaración de variables.**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea72cb70-1c76-4600-9e4e-3d561264faf2",
   "metadata": {},
   "source": [
    "Las variables (en Python) se declaran mediante el símbolo `=`; esto es, el usuario puede definir variables de la forma `variable_1 = object`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "329dd2c0-1baf-4b36-885a-122d02e380d1",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\r\n",
    "Este procedimiento de asignación es sensible a mayúsculas y minúsculas. Esto significa que si declaramos las variables<b> upsilon, Upsilon y UPSILON</b>` serán diferentes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "ff6f672a-2f7c-437c-ac1e-42f6ca1046a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Declaración y asignación de una variable en Python \n",
    "upsilon = 3.456789\n",
    "Upsilon = \"El alfabeto griego suele emplearse para denominaciones técnicas en la ciencia.\"\n",
    "UPSILON = 13 ** 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "135415bc-c3f7-494c-b94a-739b8dac7edf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.456789"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "upsilon"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "8ed30bbc-a96c-4b7e-8fec-43fc5fea6279",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'El alfabeto griego suele emplearse para denominaciones técnicas en la ciencia.'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Upsilon"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "b60b4da9-29db-4e6b-8502-7e05cde8c68e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "62748517"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "UPSILON"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "419393ee-1fcf-4fb2-a3e4-304500cdde06",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.95"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "altura = 1.95\n",
    "altura"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed708b8d-690f-4bea-b3bf-2d9f625f1748",
   "metadata": {},
   "source": [
    "<p><a name=\"Lists\"></a></p>\n",
    "\n",
    "## **2.4. Listas.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "db6c6aff-cf83-4c00-8fc3-aef15920d78c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "f80f806e-f406-4977-91d3-7555f315d39c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type([\"Mario\", \"Elizabeth\", \"Emmanuel\", \"Julio\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "68451c08-c389-497b-abbe-d763c8ec156d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-45, 3, 0, 1675, 143, 0.8945112, 6]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo de lista en la cuál las entradas de la misma son valores númericos, observe que estos no se limitan a enteros positivos, el usuario tiene la libertad de \n",
    "# ingresar valores negativos, racionales e irracionales. \n",
    "number_lst = [-45, 3, 0, 1675, 143, 0.8945112, 6]\n",
    "number_lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "7801d3a5-e803-4a1f-8054-c349d7313fab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['María', 'Ciel', 'Santiago']\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "string_lst = [\"María\", \"Ciel\", \"Santiago\"]\n",
    "print(string_lst)\n",
    "print(type(string_lst))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59bb377c-37b5-43a2-aef8-c479974e1c7d",
   "metadata": {},
   "source": [
    "### **2.4.1. Indexación de Listas.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "5a7cfaa9-ddfe-4ae0-8437-f61406bfe98c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['veteranvanoss', 'StragglyCrib1967', 'Rinkashisimo']"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "users_list = [\"veteranvanoss\", \"StragglyCrib1967\", \"Rinkashisimo\"]\n",
    "users_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "0e4b176a-3261-4767-ac75-685c9ae5ea8f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['RetroNumericMaster', 'veteranvanoss', 'StragglyCrib1967', 'Rinkashisimo']"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Insertar un nuevo usuario dentro de la lista en la primera posición. \n",
    "users_list.insert(0, \"RetroNumericMaster\")\n",
    "# Devuelve en consola la lista con el nuevo usuario.\n",
    "users_list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13178a94-207b-4deb-b1df-4b63214192df",
   "metadata": {},
   "source": [
    "<p><a name=\"Arr\"></a></p>\n",
    "\n",
    "## **2.5. Arreglos en Python.**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f8caf34-59ad-4222-99c7-226149bb1191",
   "metadata": {},
   "source": [
    "<b> ¿Qué es un vector? </b> <br>\n",
    "Es un elemento en un conjunto, generalmente dentro del espacio $\\mathbb{R}^{n}$. Un elemento de $\\mathbb{R}^{n}$ forman una ***tupla***. Em el Lenguaje de Programación de Python también existen tuplas, las cuáles no siguen la definición usual que se conoce dentro del campo de las Matemáticas. \n",
    "$$\\mathbf{x}=(x_{1},x_{2},\\ldots, x_{n})$$\n",
    "en donde cada entrada $x_{i}$ está en los reales. <br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "9e60bfeb-e428-4fbf-ae30-976547167e0e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Una tupla\n",
    "type((\"a\", \"b\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "2b5966be-9846-437e-afa0-02fe37d20685",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 4)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Defínanse dos tuplas dentro de Python para posteriormente sumarlas. En Python, al realizar la operación 'x+y', no se obtendrá el resultado usual de la suma de las\n",
    "# entradas de un espacio vectorial, si no las empleadas para el manejo y análisis de datos\n",
    "x = (1,2)\n",
    "y = (3,4)\n",
    "# Imprime en consola concatenando ambas tuplas.\n",
    "x+y"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf008b93-d4ff-42f9-a858-f330763c4d18",
   "metadata": {},
   "source": [
    "**Observación:** Sean $(x,y)\\in \\mathbb{R}^{n}$ dos vectores $\\mathbf{x}=(x_{1},x_{2}, \\ldots, x_{n}) \\quad \\text{ y } \\quad \\mathbf{y}=(y_{1},y_{2},\\ldots, y_{n})$ <br>\n",
    "Definimos la suma de $\\mathbf{x} \\text{ y } \\mathbf{y}$ como\n",
    "$$\\mathbf{x+y}=(x_{1}+y_{1},x_{2}+y_{2}, \\ldots, x_{n}+y_{n})$$\n",
    "y se definirá la **multiplicación por un escalar** cómo sigue; sea $\\lambda\\in \\mathbb{R}$, entonces \n",
    "$$\\lambda \\mathbf{x}=(\\lambda x_{1},\\lambda x_{2}, \\ldots, \\lambda x_{n})$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "716c7c22-f826-4317-a6b4-3f51c514681c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 1, -7, 4)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x + (1,-7,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "348a116f-e7bc-4f03-bcaf-9d427925d3fd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 1, 2, 1, 2)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 * x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f5ed897-4082-464f-9177-b37228d33d9c",
   "metadata": {},
   "source": [
    "Vamos a definir la operación vectorial a través de listas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "8e5afe05-d4a5-49f2-bda8-c1985a0be0dc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Definición de una función que permitirá realizar las operaciones nativas sin hacer uso de las bibliotecas dentro del lenguaje de Programación Python \n",
    "def prod(x, y):\n",
    "    z = x * y\n",
    "    return z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "e785779b-f4e0-4290-bbe1-7c48153f10be",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "72"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prod(6,12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "0fb805d3-61b9-4683-acd2-547e049abff4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 6, 8, -1, 9, -8, 1, 0, 10, 7]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L_1 = [3, 6, 8, -1, 9]\n",
    "L_2 = [-8, 1, 0 , 10, 7]\n",
    "L_1 + L_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "c6aaf134-dc1c-4d73-a456-0bfe465959d2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-5, 7, 8, 9, 16]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L_3 = [L_1[0] + L_2[0], L_1[1] + L_2[1], L_1[2] + L_2[2], L_1[3] + L_2[3], L_1[4] + L_2[4]]\n",
    "L_3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "40be0d0b-d33f-4d05-b9d6-15b437de1bf1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-5, 7, 8, 9, 16]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L_3i = [L_1[i] + L_2[i] for i in range(len(L_1))]\n",
    "L_3i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "1ddb787b-99fc-40bd-8c33-011e2596639e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[6, 12, 16, -2, 18]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L_4 = [2 * L_1[i] for i in range(len(L_1))]\n",
    "L_4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "5321788b-4903-4f2b-ad13-9399abfca22b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum_vec(S,T):\n",
    "    for i in range(len(S)):\n",
    "        vs = S[i] + T[i] \n",
    "        return vs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb3eb9d6-6700-4557-b434-7f75b284a325",
   "metadata": {},
   "source": [
    "<p><a name=\"Defunc\"></a></p>\n",
    "\n",
    "# **3. Funciones Predefinidas.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "670307a4-92f7-493b-8fc1-1934d054f00c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['ArithmeticError',\n",
       " 'AssertionError',\n",
       " 'AttributeError',\n",
       " 'BaseException',\n",
       " 'BaseExceptionGroup',\n",
       " 'BlockingIOError',\n",
       " 'BrokenPipeError',\n",
       " 'BufferError',\n",
       " 'BytesWarning',\n",
       " 'ChildProcessError',\n",
       " 'ConnectionAbortedError',\n",
       " 'ConnectionError',\n",
       " 'ConnectionRefusedError',\n",
       " 'ConnectionResetError',\n",
       " 'DeprecationWarning',\n",
       " 'EOFError',\n",
       " 'Ellipsis',\n",
       " 'EncodingWarning',\n",
       " 'EnvironmentError',\n",
       " 'Exception',\n",
       " 'ExceptionGroup',\n",
       " 'False',\n",
       " 'FileExistsError',\n",
       " 'FileNotFoundError',\n",
       " 'FloatingPointError',\n",
       " 'FutureWarning',\n",
       " 'GeneratorExit',\n",
       " 'IOError',\n",
       " 'ImportError',\n",
       " 'ImportWarning',\n",
       " 'IndentationError',\n",
       " 'IndexError',\n",
       " 'InterruptedError',\n",
       " 'IsADirectoryError',\n",
       " 'KeyError',\n",
       " 'KeyboardInterrupt',\n",
       " 'LookupError',\n",
       " 'MemoryError',\n",
       " 'ModuleNotFoundError',\n",
       " 'NameError',\n",
       " 'None',\n",
       " 'NotADirectoryError',\n",
       " 'NotImplemented',\n",
       " 'NotImplementedError',\n",
       " 'OSError',\n",
       " 'OverflowError',\n",
       " 'PendingDeprecationWarning',\n",
       " 'PermissionError',\n",
       " 'ProcessLookupError',\n",
       " 'RecursionError',\n",
       " 'ReferenceError',\n",
       " 'ResourceWarning',\n",
       " 'RuntimeError',\n",
       " 'RuntimeWarning',\n",
       " 'StopAsyncIteration',\n",
       " 'StopIteration',\n",
       " 'SyntaxError',\n",
       " 'SyntaxWarning',\n",
       " 'SystemError',\n",
       " 'SystemExit',\n",
       " 'TabError',\n",
       " 'TimeoutError',\n",
       " 'True',\n",
       " 'TypeError',\n",
       " 'UnboundLocalError',\n",
       " 'UnicodeDecodeError',\n",
       " 'UnicodeEncodeError',\n",
       " 'UnicodeError',\n",
       " 'UnicodeTranslateError',\n",
       " 'UnicodeWarning',\n",
       " 'UserWarning',\n",
       " 'ValueError',\n",
       " 'Warning',\n",
       " 'WindowsError',\n",
       " 'ZeroDivisionError',\n",
       " '__IPYTHON__',\n",
       " '__build_class__',\n",
       " '__debug__',\n",
       " '__doc__',\n",
       " '__import__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__spec__',\n",
       " 'abs',\n",
       " 'aiter',\n",
       " 'all',\n",
       " 'anext',\n",
       " 'any',\n",
       " 'ascii',\n",
       " 'bin',\n",
       " 'bool',\n",
       " 'breakpoint',\n",
       " 'bytearray',\n",
       " 'bytes',\n",
       " 'callable',\n",
       " 'chr',\n",
       " 'classmethod',\n",
       " 'compile',\n",
       " 'complex',\n",
       " 'copyright',\n",
       " 'credits',\n",
       " 'delattr',\n",
       " 'dict',\n",
       " 'dir',\n",
       " 'display',\n",
       " 'divmod',\n",
       " 'enumerate',\n",
       " 'eval',\n",
       " 'exec',\n",
       " 'execfile',\n",
       " 'filter',\n",
       " 'float',\n",
       " 'format',\n",
       " 'frozenset',\n",
       " 'get_ipython',\n",
       " 'getattr',\n",
       " 'globals',\n",
       " 'hasattr',\n",
       " 'hash',\n",
       " 'help',\n",
       " 'hex',\n",
       " 'id',\n",
       " 'input',\n",
       " 'int',\n",
       " 'isinstance',\n",
       " 'issubclass',\n",
       " 'iter',\n",
       " 'len',\n",
       " 'license',\n",
       " 'list',\n",
       " 'locals',\n",
       " 'map',\n",
       " 'max',\n",
       " 'memoryview',\n",
       " 'min',\n",
       " 'next',\n",
       " 'object',\n",
       " 'oct',\n",
       " 'open',\n",
       " 'ord',\n",
       " 'pow',\n",
       " 'print',\n",
       " 'property',\n",
       " 'range',\n",
       " 'repr',\n",
       " 'reversed',\n",
       " 'round',\n",
       " 'runfile',\n",
       " 'set',\n",
       " 'setattr',\n",
       " 'slice',\n",
       " 'sorted',\n",
       " 'staticmethod',\n",
       " 'str',\n",
       " 'sum',\n",
       " 'super',\n",
       " 'tuple',\n",
       " 'type',\n",
       " 'vars',\n",
       " 'zip']"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(__builtins__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "0f6bf8e3-5340-4988-9146-5e9d94d31b05",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function eval in module builtins:\n",
      "\n",
      "eval(source, globals=None, locals=None, /)\n",
      "    Evaluate the given source in the context of globals and locals.\n",
      "\n",
      "    The source may be a string representing a Python expression\n",
      "    or a code object as returned by compile().\n",
      "    The globals must be a dictionary and locals can be any mapping,\n",
      "    defaulting to the current globals and locals.\n",
      "    If only globals is given, locals defaults to it.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(eval)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "0525b565-ad5c-4391-acdb-007689d37372",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function pow in module builtins:\n",
      "\n",
      "pow(base, exp, mod=None)\n",
      "    Equivalent to base**exp with 2 arguments or base**exp % mod with 3 arguments\n",
      "\n",
      "    Some types, such as ints, are able to use a more efficient algorithm when\n",
      "    invoked using the three argument form.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(pow)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "caa74d7f-13b7-4f05-b609-6d3e2d52e906",
   "metadata": {},
   "source": [
    "<p><a name=\"Lib\"></a></p>\n",
    "\n",
    "# **4. Bibliotecas y Módulos.**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "191800b3-0a42-40bc-98eb-fdf3dc705f22",
   "metadata": {},
   "source": [
    "<p><a name=\"Numpy\"></a></p>\n",
    "\n",
    "## **4.1. Biblioteca NumPy**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "862d4a51-189e-4344-813c-ac96b1873088",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "76e9b677-b43b-4638-afb4-dff21f2589f0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-5,  7,  8,  9, 16])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Definiendo las nuevas variables A_1 y A_2, se están conviritiendo las listas en un vector mediante el uso de la biblioteca NumPy\n",
    "A_1 = np.array(L_1)\n",
    "A_2 = np.array(L_2)\n",
    "A_1 + A_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "7277427f-ae9e-42ed-b51c-75cd4bfc98f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "A_3 = np.array([4, 13.67])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "eabbdc70-6150-40a1-b8b6-8fe0211cb1fa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 9, 18, 24, -3, 27])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 * A_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "c36af62f-695e-4932-8240-4f1ed30e13f1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3,  9, 17, 16, 25])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_1.cumsum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "e215b828-20be-4f73-8544-f0060049d7ed",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([    3,    18,   144,  -144, -1296])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_1.cumprod()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "34c515ec-0a3d-489f-be79-c04358567598",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_1.mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9736809c-fe65-4f8c-910c-70b774acea76",
   "metadata": {},
   "source": [
    "<p><a name=\"MtNp\"></a></p>\n",
    "\n",
    "## **4.2 Métodos dentro de los atributos de la `Biblioteca NumPy`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "cbac9361-96d4-47a7-aad3-a16f8a170965",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# .ndim imprime ne consola la dimensión del vector cómo objeto en Python \n",
    "A_1.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "90bbc551-7858-4bee-88a5-ae7d53743f92",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5,)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_1.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e04b6141-bcec-4a25-874c-227ca7520f50",
   "metadata": {},
   "source": [
    "## **4.3. Matrices Reales.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "24f28d01-bcc4-476c-8fca-c9989bdf9b1c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [3, 8, 9]])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = np.array([[1,2,3], [3,8,9]])\n",
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "77783f51-a4ee-484b-a300-7259e9b6969b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 4,  0,  1],\n",
       "       [ 1,  2, -4]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N = np.array([[4,0,1], [1,2,-4]])\n",
    "N"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "834a0e36-a9c4-4573-9c72-aed34b386181",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5,  2,  4],\n",
       "       [ 4, 10,  5]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M + N"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "315ab48e-f56d-4197-a1c7-f44f5dda4436",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 6,  4,  7],\n",
       "       [ 7, 18, 14]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 * M + N "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6dbe8d2d-bbbd-4fba-b79d-36a6c1c9d0ea",
   "metadata": {},
   "source": [
    "### **Acessos a Elementos de arreglos**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "9dc52952-50f3-455f-8ab0-88b8677bb158",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_1[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "6e7c0fc3-5d12-40e9-af5c-856e99ef0bb3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 8, -1])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_1[2:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "292f4823-d892-4134-9ac1-cc89bbe8bbc4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3,  6,  8, -1,  9])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_1[0:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "c8e1b369-ce9d-4819-abbc-888c4244a860",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 8, -1,  9])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_1[2:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "4f17bc02-fb4e-414a-aaca-15ef9faa400c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 6])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_1[ :2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69c1cb5d-b48c-4d16-a367-84fbfb45a30c",
   "metadata": {},
   "source": [
    "<p><a name=\"dict\"></a></p>\n",
    "\n",
    "# **5. Diccionarios.**\n",
    "Son objetos en Python que se crean cómo sigue <br>\n",
    "$$\\{key: objects\\}$$\n",
    "<b> ¿Porque son importantes? </b> <br> \n",
    "Son el análogo al Javascript Object Notation (JSON)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "31f3dcaf-d9da-44e4-8422-0507dec834f5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "bd13ed1c-effa-44e4-871f-e238678a5456",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type({})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "c891555b-9dfd-4b7f-ba6f-33329b7accbd",
   "metadata": {},
   "outputs": [],
   "source": [
    "S_1 = {3, 5, 9, -7, 27}\n",
    "S_2 = {-10, -3, 0, 48.1}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "0d4f254f-9129-4332-a137-87570695c8b6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "set()"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S_1.intersection(S_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "38d98ea8-ad4e-45c2-a407-8237679ec5ea",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{-10, -7, -3, 0, 3, 5, 9, 27, 48.1}"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S_1.union(S_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "9e7ffc24-d2e4-438b-9a52-ae98e49df79d",
   "metadata": {},
   "outputs": [],
   "source": [
    "Clients = {\"Id\": \"2173\", \n",
    "           \"Client\": \"Emmanuel R. López\", \n",
    "           \"Nationality\": \"Mexican\" }"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56b1f535-f216-486a-a15f-7ac8c340c810",
   "metadata": {},
   "source": [
    "<p><a name=\"dict_att\"></a></p>\n",
    "\n",
    "## **5.1. Atributos de los Diccionarios.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "61ce5418-95c7-47d6-b7bf-75beea1581d2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(Clients.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "a5d696bf-e7c3-420b-8626-e855a7e2b8a9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Id', 'Client', 'Nationality']"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(Clients.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "ea3529e9-454c-4bc2-ae7a-eb9668c0ef4c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values(['2173', 'Emmanuel R. López', 'Mexican'])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Clients.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "7af1e4cc-081f-44b7-82b3-6f42139ae441",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('Id', '2173'), ('Client', 'Emmanuel R. López'), ('Nationality', 'Mexican')])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Clients.items()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "28154833-b53f-4595-8c1a-6789ef2167f1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Id', '2173'), ('Client', 'Emmanuel R. López'), ('Nationality', 'Mexican')]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(Clients.items())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "150a3689-ee3b-426e-ae9e-e8c705f5b9f4",
   "metadata": {},
   "source": [
    "# **Referencias y Cibergrafía:**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afe618af-53f6-48d7-8419-76ee93168146",
   "metadata": {},
   "source": [
    "[1] McKinney, Wes (2018) <i> \"Python for Data Analysis: Data wrangling with Pandas, Numpy and IPython\". </i> Ed. O'Reilly. <br> \n",
    "[2] Galindo López, Julio C. [Julio César Galindo López] <i> Diplomado en Lenguajes de Programación: Python, SQL & R.</i> Sesión 2 [Archivo de Vídeo]. <br>\n",
    "[3] Galindo López, Julio C. [Julio César Galindo López] <i> Diplomado en Lenguajes de Programación: Python, SQL & R.</i> Sesión 3 [Archivo de Vídeo]."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}