From d0d4f3d288809c25b1c062da315a5dd33e939328 Mon Sep 17 00:00:00 2001
From: Oscar Gonzalez <fraknot@gmail.com>
Date: Mon, 4 Aug 2025 16:35:38 -0600
Subject: [PATCH] Corrige frozenset en tabla de tipos de datos

---
 06_tipos_de_datos_en_python.ipynb | 874 +++++++++++++++---------------
 1 file changed, 437 insertions(+), 437 deletions(-)

diff --git a/06_tipos_de_datos_en_python.ipynb b/06_tipos_de_datos_en_python.ipynb
index 1682399..bc2d330 100644
--- a/06_tipos_de_datos_en_python.ipynb
+++ b/06_tipos_de_datos_en_python.ipynb
@@ -1,437 +1,437 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "[![pythonista.io](imagenes/pythonista.png)](https://www.pythonista.io)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Tipos de datos en Python 3."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Python ha evolucionado para ofrecer poderosos tipos de datos que lo diferencian de otros lenguajes de programación por su sencillez y flexibilidad.\n",
-    "\n",
-    "Aún cuando Python cuenta con una amplia biblioteca que incluye muy diversos tipos de datos, ofrece ciertos tipos básicos."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "##  Particularidades los tipos de datos en Python.\n",
-    "\n",
-    "### Tipos dinámicos.\n",
-    "\n",
-    "Python es un lenguaje que no requiere que se defina el tipo de un objeto. El intérprete \"infiere\" el tipo de dato del que se trata.\n",
-    "    \n",
-    "### Fuertemente tipado.\n",
-    "\n",
-    "Existen operaciones que no están permitidas entre tipos que no sean compatibles.\n",
-    "\n",
-    "### Los tipos son clases.\n",
-    "\n",
-    "En Python todos sus elementos son objetos y los datos, una vez identificados, se convierten en objetos instanciados del tipo al que pertenecen. "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Tabla de tipos de datos básicos de Python 3.\n",
-    "\n",
-    "La siguiente tabla resume y describe los tipos de datos básicos de Python 3. \n",
-    "\n",
-    "|Tipo de dato|Colección|Indexable|Mutable|Contenido|Ejemplo|\n",
-    "|:-----------:|:--:|:--:|:--:|:----:|:-----|\n",
-    "|```int```|NO|NO|NO|Números enteros|```-12```|\n",
-    "|```float```|NO|NO|NO|Números de punto flotante|```4.361```|\n",
-    "|```complex```|NO|NO|NO|Números complejos|```(41.6-11.3j)```|\n",
-    "|```bool```|NO|NO|NO|Valores booleanos|```True```|\n",
-    "|```NoneType```|NO|NO|NO|Sin valor|```None```|\n",
-    "|```str```|SÍ|Numérico|NO|Caracteres Unicode|```'Gödel'```|\n",
-    "|```bytes```|SÍ|Numérico|NO|Caracteres ASCII|```b'Hola'```|\n",
-    "|```bytearray```|SÍ|Numérico|SÍ|Caracteres ASCII|```bytearray(b'Hola')```|\n",
-    "|```list```|SÍ|Numérico|SÍ|Cualquier objeto|```[1, 2.0, 'Tres']```|\n",
-    "|```tuple```|SÍ|Numérico|NO|Cualquier objeto|```(1, 2.0, 'Tres')```|\n",
-    "|```dict```|SÍ|Por clave|Sí|Pares *clave:valor*|```{'nombre':'Juan', 'promedio':10}```|\n",
-    "|```set```|SÍ|NO|SÍ|Objetos inmutables|```{1, False, 'María'}```|\n",
-    "|```frozenset```|SÍ|NO|NO|Objetos inmutables|```frozenset({{1, False, 'María'})```|\n",
-    "\n",
-    "* **Las colecciones** son objetos que contienen a otros objetos. A los objetos contenidos también se les refiere como elementos.\n",
-    "\n",
-    "* **Los tipos indexables** tienen la capacidad de asignar a cada uno de los elementos que contienen un identificador único (índice) que puede consistir en un número entero o una clave dependiendo del tipo del que se trate.\n",
-    "\n",
-    "* **Los tipos mutables** permiten eliminar, sustituir e incluso añadir elementos a su contenido."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "\n",
-    "## Números enteros (```int```).\n",
-    "\n",
-    "Python identifica a los número enteros como un tipo de dato el cual puede ser expresado de la siguiente manera. \n",
-    "\n",
-    "* Decimal: ```24```, ```60```.\n",
-    "* Binario: ```0b010011```, ```0b1101```. \n",
-    "* Hexadecimal: ```0x18```, ```0x3cf4```.\n",
-    "* Octal: ``0o30``, ```0o74```.\n",
-    "\n",
-    "Python 2 también identifica a un tipo llamado entero largo (```long```), al cual se le añade la letra ```L``` al final de número, pero ya no es reconocido por Python 3. "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Ejemplos:**"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "* La siguiente celda define al número ```24```."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "24"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "* La siguiente celda define al número ```139``` en formato binario."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "scrolled": true
-   },
-   "outputs": [],
-   "source": [
-    "0b10001011"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "* La siguiente celda define al número ```1522``` en formato hexadecimal."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "0x5f2"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "* La siguiente celda define al número ```159``` en formato octal."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "0o237"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Números de punto flotante (``float``).\n",
-    "\n",
-    "Los objetos tipo ``float`` corresponden al conjunto de los números reales.\n",
-    "\n",
-    "**Ejemplos:**\n",
-    "\n",
-    "* ```3.141595``` \n",
-    "* ```12.``` \n",
-    "* ```-45.35```"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### Precisión de los números flotantes.\n",
-    "\n",
-    "Hay que tomar en cuenta que la precisión de los números dependen en gran medida de la capacidad del equipo de cómputo, por lo que en ocasiones una operación con números de tipo ```float``` no dará el resultado exacto, sino una aproximación."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Ejemplo:**"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "* La siguiente expresión da por resultado un número racional que corresponde a una suceción infinita del dígito ```6``` después del punto decimal."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "2 / 3"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "En este caso, es imposible para Python calcular una sucesión infinita de ```6``` y por ende, el intérprete truncó el número a 16 decimales."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Números complejos (```complex```).\n",
-    "\n",
-    "Los objetos de tipo ```complex``` corresponden al conjunto de los números complejos.\n",
-    "\n",
-    "Siempre que el componente en los números reales sea distinto de ```0```, los objetos de tipo ```complex``` se expresarán como un par de números de tipo ```float``` separados por el operador de adición ```+```, en el que el primer número corresponde al componente en los números reales y el componente en los números imaginarios es identificado añadiéndole la letra ```j``` al final.\n",
-    "\n",
-    "La sintaxis estricta es la siguiente:\n",
-    "\n",
-    "\n",
-    "* Cuando el componente imaginario es postivo.\n",
-    "\n",
-    "```\n",
-    "(<real>+<imaginario>j)\n",
-    "```\n",
-    "\n",
-    "* Cuando el componente imaginario es negativo.\n",
-    "\n",
-    "```\n",
-    "(<real>-<imaginario>j)\n",
-    "\n",
-    "```\n",
-    "\n",
-    "* Cuando el componente real es igual a ```0```.\n",
-    "\n",
-    "```\n",
-    "<imaginario>j\n",
-    "```\n",
-    "\n",
-    "Donde:\n",
-    "\n",
-    "* ```<real>``` es el componente real del número compejo.\n",
-    "* ```<imaginario>``` es el componente imaginario del número complejo."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Ejemplos:**"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "* La siguiente celda muestra la forma estricta en la que se define un objeto tipo  ```complex```."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "(2+5j)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "* Las siguientes expresiones implican operaciones aritméticas con números imaginarios, las cuales dan por resultado objetos tipo  ```complex```."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "1.323 - 1j "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "-2.9j - 23.03"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "12.4 + 0j"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "* En caso de que sólo se defina el componente imaginario, el resultado sólo será ```15j```."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "15j"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Valores booleanos (```bool```).\n",
-    "\n",
-    "El tipo ```bool``` es una especie de tipo numérico que es utilizado para evaluar expresiones lógicas y tiene dos valores: ```True``` y ```False```.\n",
-    "\n",
-    "* Si una expresión lógica se cumple, el resultado es ```True```.\n",
-    "* Si una expresión lógica NO se cumple, el resultado es ```False```.\n",
-    "* ```False``` equivale numéricamente a ```0```. \n",
-    "* Cualquier otro valor no vacío equivale a ```True``` y su valor por defecto es ```1```.\n",
-    "\n",
-    "**Nota:** Las expresiones lógicas se estudiarán más adelante."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Ejemplos:**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "True"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "False"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## ```NoneType```.\n",
-    "\n",
-    "El único objeto de este tipo es ```None``` y representa un valor nulo. \n",
-    "\n",
-    "Una expresión que dé por resultado ```None``` no es desplegado por el intérprete."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Ejemplo:**"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "* La siguiente celda incluye al objeto ```None```, pero al ejecutarla, no se despliega nada."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "None"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<p style=\"text-align: center\"><a rel=\"license\" href=\"http://creativecommons.org/licenses/by/4.0/\"><img alt=\"Licencia Creative Commons\" style=\"border-width:0\" src=\"https://i.creativecommons.org/l/by/4.0/80x15.png\" /></a><br />Esta obra está bajo una <a rel=\"license\" href=\"http://creativecommons.org/licenses/by/4.0/\">Licencia Creative Commons Atribución 4.0 Internacional</a>.</p>\n",
-    "<p style=\"text-align: center\">&copy; José Luis Chiquete Valdivieso. 2020.</p>"
-   ]
-  }
- ],
- "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.9.2"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 1
-}
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[![pythonista.io](imagenes/pythonista.png)](https://www.pythonista.io)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Tipos de datos en Python 3."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Python ha evolucionado para ofrecer poderosos tipos de datos que lo diferencian de otros lenguajes de programación por su sencillez y flexibilidad.\n",
+    "\n",
+    "Aún cuando Python cuenta con una amplia biblioteca que incluye muy diversos tipos de datos, ofrece ciertos tipos básicos."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "##  Particularidades los tipos de datos en Python.\n",
+    "\n",
+    "### Tipos dinámicos.\n",
+    "\n",
+    "Python es un lenguaje que no requiere que se defina el tipo de un objeto. El intérprete \"infiere\" el tipo de dato del que se trata.\n",
+    "    \n",
+    "### Fuertemente tipado.\n",
+    "\n",
+    "Existen operaciones que no están permitidas entre tipos que no sean compatibles.\n",
+    "\n",
+    "### Los tipos son clases.\n",
+    "\n",
+    "En Python todos sus elementos son objetos y los datos, una vez identificados, se convierten en objetos instanciados del tipo al que pertenecen. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Tabla de tipos de datos básicos de Python 3.\n",
+    "\n",
+    "La siguiente tabla resume y describe los tipos de datos básicos de Python 3. \n",
+    "\n",
+    "|Tipo de dato|Colección|Indexable|Mutable|Contenido|Ejemplo|\n",
+    "|:-----------:|:--:|:--:|:--:|:----:|:-----|\n",
+    "|```int```|NO|NO|NO|Números enteros|```-12```|\n",
+    "|```float```|NO|NO|NO|Números de punto flotante|```4.361```|\n",
+    "|```complex```|NO|NO|NO|Números complejos|```(41.6-11.3j)```|\n",
+    "|```bool```|NO|NO|NO|Valores booleanos|```True```|\n",
+    "|```NoneType```|NO|NO|NO|Sin valor|```None```|\n",
+    "|```str```|SÍ|Numérico|NO|Caracteres Unicode|```'Gödel'```|\n",
+    "|```bytes```|SÍ|Numérico|NO|Caracteres ASCII|```b'Hola'```|\n",
+    "|```bytearray```|SÍ|Numérico|SÍ|Caracteres ASCII|```bytearray(b'Hola')```|\n",
+    "|```list```|SÍ|Numérico|SÍ|Cualquier objeto|```[1, 2.0, 'Tres']```|\n",
+    "|```tuple```|SÍ|Numérico|NO|Cualquier objeto|```(1, 2.0, 'Tres')```|\n",
+    "|```dict```|SÍ|Por clave|Sí|Pares *clave:valor*|```{'nombre':'Juan', 'promedio':10}```|\n",
+    "|```set```|SÍ|NO|SÍ|Objetos inmutables|```{1, False, 'María'}```|\n",
+    "|```frozenset```|SÍ|NO|NO|Objetos inmutables|```frozenset({1, False, 'María'})```|\n",
+    "\n",
+    "* **Las colecciones** son objetos que contienen a otros objetos. A los objetos contenidos también se les refiere como elementos.\n",
+    "\n",
+    "* **Los tipos indexables** tienen la capacidad de asignar a cada uno de los elementos que contienen un identificador único (índice) que puede consistir en un número entero o una clave dependiendo del tipo del que se trate.\n",
+    "\n",
+    "* **Los tipos mutables** permiten eliminar, sustituir e incluso añadir elementos a su contenido."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "\n",
+    "## Números enteros (```int```).\n",
+    "\n",
+    "Python identifica a los número enteros como un tipo de dato el cual puede ser expresado de la siguiente manera. \n",
+    "\n",
+    "* Decimal: ```24```, ```60```.\n",
+    "* Binario: ```0b010011```, ```0b1101```. \n",
+    "* Hexadecimal: ```0x18```, ```0x3cf4```.\n",
+    "* Octal: ``0o30``, ```0o74```.\n",
+    "\n",
+    "Python 2 también identifica a un tipo llamado entero largo (```long```), al cual se le añade la letra ```L``` al final de número, pero ya no es reconocido por Python 3. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Ejemplos:**"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* La siguiente celda define al número ```24```."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "24"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* La siguiente celda define al número ```139``` en formato binario."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "0b10001011"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* La siguiente celda define al número ```1522``` en formato hexadecimal."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "0x5f2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* La siguiente celda define al número ```159``` en formato octal."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "0o237"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Números de punto flotante (``float``).\n",
+    "\n",
+    "Los objetos tipo ``float`` corresponden al conjunto de los números reales.\n",
+    "\n",
+    "**Ejemplos:**\n",
+    "\n",
+    "* ```3.141595``` \n",
+    "* ```12.``` \n",
+    "* ```-45.35```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Precisión de los números flotantes.\n",
+    "\n",
+    "Hay que tomar en cuenta que la precisión de los números dependen en gran medida de la capacidad del equipo de cómputo, por lo que en ocasiones una operación con números de tipo ```float``` no dará el resultado exacto, sino una aproximación."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Ejemplo:**"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* La siguiente expresión da por resultado un número racional que corresponde a una suceción infinita del dígito ```6``` después del punto decimal."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "2 / 3"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "En este caso, es imposible para Python calcular una sucesión infinita de ```6``` y por ende, el intérprete truncó el número a 16 decimales."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Números complejos (```complex```).\n",
+    "\n",
+    "Los objetos de tipo ```complex``` corresponden al conjunto de los números complejos.\n",
+    "\n",
+    "Siempre que el componente en los números reales sea distinto de ```0```, los objetos de tipo ```complex``` se expresarán como un par de números de tipo ```float``` separados por el operador de adición ```+```, en el que el primer número corresponde al componente en los números reales y el componente en los números imaginarios es identificado añadiéndole la letra ```j``` al final.\n",
+    "\n",
+    "La sintaxis estricta es la siguiente:\n",
+    "\n",
+    "\n",
+    "* Cuando el componente imaginario es postivo.\n",
+    "\n",
+    "```\n",
+    "(<real>+<imaginario>j)\n",
+    "```\n",
+    "\n",
+    "* Cuando el componente imaginario es negativo.\n",
+    "\n",
+    "```\n",
+    "(<real>-<imaginario>j)\n",
+    "\n",
+    "```\n",
+    "\n",
+    "* Cuando el componente real es igual a ```0```.\n",
+    "\n",
+    "```\n",
+    "<imaginario>j\n",
+    "```\n",
+    "\n",
+    "Donde:\n",
+    "\n",
+    "* ```<real>``` es el componente real del número compejo.\n",
+    "* ```<imaginario>``` es el componente imaginario del número complejo."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Ejemplos:**"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* La siguiente celda muestra la forma estricta en la que se define un objeto tipo  ```complex```."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "(2+5j)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* Las siguientes expresiones implican operaciones aritméticas con números imaginarios, las cuales dan por resultado objetos tipo  ```complex```."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "1.323 - 1j "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "-2.9j - 23.03"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "12.4 + 0j"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* En caso de que sólo se defina el componente imaginario, el resultado sólo será ```15j```."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "15j"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Valores booleanos (```bool```).\n",
+    "\n",
+    "El tipo ```bool``` es una especie de tipo numérico que es utilizado para evaluar expresiones lógicas y tiene dos valores: ```True``` y ```False```.\n",
+    "\n",
+    "* Si una expresión lógica se cumple, el resultado es ```True```.\n",
+    "* Si una expresión lógica NO se cumple, el resultado es ```False```.\n",
+    "* ```False``` equivale numéricamente a ```0```. \n",
+    "* Cualquier otro valor no vacío equivale a ```True``` y su valor por defecto es ```1```.\n",
+    "\n",
+    "**Nota:** Las expresiones lógicas se estudiarán más adelante."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Ejemplos:**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "True"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "False"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## ```NoneType```.\n",
+    "\n",
+    "El único objeto de este tipo es ```None``` y representa un valor nulo. \n",
+    "\n",
+    "Una expresión que dé por resultado ```None``` no es desplegado por el intérprete."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Ejemplo:**"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* La siguiente celda incluye al objeto ```None```, pero al ejecutarla, no se despliega nada."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "None"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<p style=\"text-align: center\"><a rel=\"license\" href=\"http://creativecommons.org/licenses/by/4.0/\"><img alt=\"Licencia Creative Commons\" style=\"border-width:0\" src=\"https://i.creativecommons.org/l/by/4.0/80x15.png\" /></a><br />Esta obra está bajo una <a rel=\"license\" href=\"http://creativecommons.org/licenses/by/4.0/\">Licencia Creative Commons Atribución 4.0 Internacional</a>.</p>\n",
+    "<p style=\"text-align: center\">&copy; José Luis Chiquete Valdivieso. 2020.</p>"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python [conda env:base] *",
+   "language": "python",
+   "name": "conda-base-py"
+  },
+  "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.12.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}