Taller_01_ConceptosBasicos.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/gabrielawad/Fundamentos-de-Python/blob/main/Taller_01_ConceptosBasicos.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## *«Si tiene solución, entonces no hay de qué preocuparse; si no tiene solución, no tiene caso lamentarse».*\n",
        "\n",
        "### [Shantideva](https://es.wikipedia.org/wiki/Shantideva)"
      ],
      "metadata": {
        "id": "ubYFVYE834aw"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mCkyuX8p2SYu"
      },
      "source": [
        "# Taller 01 Conceptos básicos\n",
        "En este taller aprenderá los conceptos básicos de Python 3 relativos a variables escalares y arreglos.\n",
        "\n",
        "Se invita a consultar información adicional en los siguientes enlaces:\n",
        "\n",
        "\n",
        "*   [Python.org Estructuras de datos](https://docs.python.org/3/tutorial/datastructures.html)\n",
        "*   [Programiz Python Datatypes](https://www.programiz.com/python-programming/numbers)\n",
        "*   [w3schools Python reference](https://www.w3schools.com/python/python_reference.asp)\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Pruebas de escritorio\n",
        "\n",
        "Las pruebas de escritorio permiten verificar si un algoritmo produce el resultado correcto, aunque no evalúan su diseño o eficiencia. Estas pruebas consisten en ejecutar cada instrucción del algoritmo paso a paso, tal como se encuentra escrita, y comparar el resultado obtenido con el resultado esperado.\n",
        "\n",
        "Por ejemplo, para realizar una prueba de escritorio sobre un algoritmo que calcula el área de un triángulo, podemos utilizar un triángulo con base, altura y área conocidas. Ingresamos los valores de la base y la altura en el algoritmo, y luego comparamos el área calculada con el valor conocido. Si ambos resultados coinciden, podemos concluir que el algoritmo funciona correctamente.\n",
        "\n",
        "Es importante notar que estas pruebas no detectan operaciones innecesarias dentro del algoritmo. Por ejemplo, el algoritmo podría incluir pasos adicionales para calcular la longitud de los otros dos lados del triángulo, lo cual no contribuye al objetivo de hallar el área. Aunque esas operaciones no son necesarias, no interfieren en el resultado final."
      ],
      "metadata": {
        "id": "0VDd-87C0NGL"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w0t0Fl-Hyo_H"
      },
      "source": [
        "# Instalación del Tutor Magic\n",
        "El Tutor Magic le permitirá realizar pruebas de escritorio de sus programas.\n",
        "\n",
        "El primer paso es instalar el Tutor Magic en Google Colaboratory.\n",
        "\n",
        "La siguiente celda se debe ejecutar cada vez que abra este notebook para poder que funcione el tutor magic en Google Colaboratory"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6kexUkZ5yvPm"
      },
      "source": [
        "# Instalar el tutormagic\n",
        "!pip install tutormagic\n",
        "\n",
        "# Cargar la extensión\n",
        "%load_ext tutormagic"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5kyR0iZJ0Zji"
      },
      "source": [
        "## Ejemplo de funcionamiento de Tutor Magic\n",
        "El siguiente ejemplo le permitirá apreciar el funcionamiento del Tutor Magic"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kmSm0WM80Z4S"
      },
      "source": [
        "# La primera línea activa el tutor magic para el ejemplo específico\n",
        "%%tutor --lang python3 -s\n",
        "\n",
        "# Ejercicio de prueba de escritorio\n",
        "\n",
        "# Crear la variable i y asignarle un valor\n",
        "i = 3\n",
        "\n",
        "# Crear la variable j y asignarle un valor\n",
        "j = 5\n",
        "\n",
        "# Crear la variable k y asignarle como valor la suma de i y j\n",
        "k = i + j\n",
        "\n",
        "# Actualizar el valor de j\n",
        "j = k / 2\n",
        "\n",
        "# Actualizar el valor de i\n",
        "i = i - 1\n",
        "\n",
        "# Crear la variable m y asignarle como valor la suma de i con el triple de k\n",
        "m = i + (k * 3)\n",
        "\n",
        "# Crear la variable n y asignarle como valor el producto de k con la suma de i  con tres\n",
        "n = k * (3 + i)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Ingreso y salida de datos\n",
        "\n",
        "Un programa debe ser capaz de interactuar con el usuario. Esto implica que el usuario debe ingresar la información requerida (datos de entrada), para que el programa ejecute las instrucciones y produzca un resultado (datos de salida).\n",
        "\n",
        "Por ello, es fundamental saber cómo solicitar y mostrar información al usuario. En Python 3, las instrucciones más comunes para este propósito son **input()** para recibir información y  **print()** para mostrar información.\n",
        "\n",
        "###Sintaxis de la instrucción **input()**:\n",
        "\n",
        "```python\n",
        "variable = input(\"mensaje\")\n",
        "```\n",
        "\n",
        "**input()** mostrará en pantalla el mensaje (un texto tipo *string*) contenido dentro de los paréntesis, con el propósito de guiar al usuario sobre qué información se necesita.\n",
        "\n",
        "La información recibida se almacena en una variable. Cabe destacar que **input()** siempre devuelve una cadena (*string*), lo que significa que la variable que almacena el resultado será de tipo *string*, limitando su uso en cálculos matemáticos.\n",
        "\n",
        "Para solucionar esto, es necesario convertir la cadena a un tipo de dato numérico. Por ahora, veremos cómo convertir a tipos enteros (*int*) y reales (*float*). Para hacerlo, basta con utilizar las funciones **int()** o **float()**, según corresponda, envolviendo la instrucción **input()** entre paréntesis:\n",
        "\n",
        "```python\n",
        "# Lectura de una variable tipo string\n",
        "variable1 = input(\"mensaje\")    \n",
        "\n",
        "# Lectura de una variable convertida a tipo int\n",
        "variable2 = int(input(\"mensaje\"))  \n",
        "\n",
        "# Lectura de una variable convertida a tipo float\n",
        "variable3 = float(input(\"mensaje\"))\n",
        "```\n",
        "### Sintaxis de la instrucción **print()**:\n",
        "\n",
        "```python\n",
        "print(variable1, variable2, ..., variableN)\n",
        "```\n",
        "\n",
        "**print()** mostrará en pantalla cada una de las variables incluidas dentro de los paréntesis, separadas por comas (,)."
      ],
      "metadata": {
        "id": "1YXEw5zi1xOM"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TPWVdRmC7HPS"
      },
      "source": [
        "# Formas alternativas de la función **print()**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uqNT2mQCHr-Z"
      },
      "source": [
        "## Formateo con **%s**\n",
        "\n",
        "La opción **%s** se utiliza en Python para insertar valores en una cadena formateada, reemplazando el marcador **%s**` con el valor de una variable.\n",
        "\n",
        "Esta técnica es muy útil para trabajar con cadenas de texto, pero los valores numéricos también pueden ser convertidos automáticamente a cadenas de texto.\n",
        "\n",
        "**Ejemplo:**\n",
        "\n",
        "```python\n",
        "\n",
        "# Crear variable de nombre y asignar un valor\n",
        "nombre = \"Juan\"\n",
        "\n",
        "# Crear una variable para la edad y asignar un valor\n",
        "edad = 25\n",
        "\n",
        "# Generar un texto  que incluya el contenido de las variables\n",
        "print(\"Nombre: %s, Edad: %s\" % (nombre, edad))\n",
        "```\n",
        "\n",
        "**Descripción:**\n",
        "En este caso, **%s** actúa como un marcador de posición para las variables **nombre** y **edad**, que son insertadas en la cadena en el orden en que aparecen dentro del paréntesis."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oSgxkBC7H0Qi"
      },
      "source": [
        "# Programa para calcular el área de un cuadrado\n",
        "\n",
        "# Creación de la variable lado y asignación de un valor a dicha variable\n",
        "lado = 5\n",
        "\n",
        "# Cálculo del área del cuadrado\n",
        "area = lado * lado\n",
        "\n",
        "# Mostrar el resultado en pantalla con la opción %s\n",
        "print(\"El área del cuadrado es %s.\" % (area))\n",
        "\n",
        "print(\"El área del cuadrado es %s.\" %(\"%.2f\"%area))\n",
        "\n",
        "print(\"El área del cuadrado de lado %s es %s.\" %(lado, area))\n",
        "\n",
        "print(\"El área del cuadrado de lado %s es %s.\"%(\"%.2f\"% lado, \"%.2f\"% area))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t4ypnJZK7QhQ"
      },
      "source": [
        "## Formateo con **str.format()**\n",
        "\n",
        "El método **str.format()** permite insertar valores dentro de una cadena utilizando marcadores **{}**.\n",
        "\n",
        "Estos marcadores se reemplazan por los valores de las variables, que se colocan dentro del método **format()**. Es una manera flexible y legible de formatear cadenas.\n",
        "\n",
        "**Ejemplo:**\n",
        "\n",
        "```python\n",
        "\n",
        "# Crear la variable nombre y asignarle un valor\n",
        "nombre = \"Juan\"\n",
        "\n",
        "# Crear la variable edad y asignarle un valor\n",
        "edad = 25\n",
        "\n",
        "# Generar un texto  que incluya el contenido de las variables\n",
        "print(\"Nombre: {}, Edad: {}\".format(nombre, edad))\n",
        "```\n",
        "\n",
        "**Descripción:**  \n",
        "En este caso, los corchetes **{}** son marcadores de posición que se reemplazan por los valores de las variables **nombre** y **edad**. El método **format()** coloca los valores en el orden en que se mencionan, lo que permite incluir fácilmente múltiples variables en una cadena de texto.\n",
        "\n",
        "Es una opción útil para controlar cómo se muestran los datos, y permite más personalización en comparación con el operador **%**."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mf1eC8vT7hhY"
      },
      "source": [
        "# Programa para calcular el área de un cuadrado\n",
        "\n",
        "# Creación de la variable lado y asignación de un valor a dicha variable\n",
        "lado = 5\n",
        "\n",
        "# Cálculo del área del cuadrado\n",
        "area = lado * lado\n",
        "\n",
        "# Otra forma de mostrar el resultado en pantalla con la opción str.format()\n",
        "print(\"El área del cuadrado es {}.\" .format(area))\n",
        "\n",
        "print(\"El área del cuadrado es {}.\" .format(\"%.2f\"%area))\n",
        "\n",
        "print(\"El área del cuadrado de lado {} es {}.\".format(lado, area))\n",
        "\n",
        "print(\"El área del cuadrado de lado {} es {}.\".format(\"%.2f\"% lado, \"%.2f\"% area))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ojAwirS17iax"
      },
      "source": [
        "## Formateo con **f-Strings**\n",
        "\n",
        "Las **f-strings**, introducidas en Python 3.6, permiten incluir expresiones directamente dentro de cadenas de texto.\n",
        "\n",
        "Para utilizar **f-strings**, se debe anteponer la letra **f** a la cadena, lo que permite insertar variables y expresiones en el formato **{}**.\n",
        "\n",
        "**Ejemplo:**\n",
        "\n",
        "```python\n",
        "# Crear la variable nombre y asignarle un valor\n",
        "nombre = \"Juan\"\n",
        "\n",
        "# Crear la variable edad y asignarle un valor\n",
        "edad = 25\n",
        "\n",
        "# Generar un texto  que incluya el contenido de las variables\n",
        "print(f\"Nombre: {nombre}, Edad: {edad}\")\n",
        "```\n",
        "\n",
        "**Descripción:**  \n",
        "En este ejemplo, los marcadores **{}** se reemplazan directamente por los valores de las variables **nombre** y **edad**.\n",
        "\n",
        "Las **f-strings** son muy útiles por su legibilidad y simplicidad, permitiendo insertar incluso expresiones más complejas dentro de las llaves, como cálculos o llamadas a funciones."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2jDdHd329sn7"
      },
      "source": [
        "# Programa para calcular el área de un cuadrado\n",
        "\n",
        "# Creación de la variable lado y asignación de un valor a dicha variable\n",
        "lado = 5\n",
        "\n",
        "# Cálculo del área del cuadrado\n",
        "area = lado * lado\n",
        "\n",
        "# Otra forma de mostrar el resultado en pantalla con el formateo con f-strings\n",
        "print(f\"El área del cuadrado es {area}.\")\n",
        "\n",
        "print(f'El área del cuadrado es {\"%.2f\"% area}.')\n",
        "\n",
        "print(f\"El área del cuadrado de lado {lado} es {area}.\")\n",
        "\n",
        "print(f'El área del cuadrado de lado {\"%.2f\"% lado} es {\"%.2f\"% area}.')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Algoritmos\n",
        "\n",
        "Un algoritmo es una secuencia de instrucciones que se desarrollan en un orden específico con el propósito de resolver un problema o realizar una tarea. Por ejemplo, consideremos un algoritmo para encender un automóvil:\n",
        "\n",
        "1. Abrir la puerta.\n",
        "2. Entrar al automóvil y tomar asiento.\n",
        "3. Insertar la llave en el encendido.\n",
        "4. Girar la llave en sentido horario y mantenerla hasta que el automóvil encienda.\n",
        "\n",
        "Los pasos descritos tienen un orden lógico y deben ejecutarse secuencialmente. Si intentamos realizar alguno de ellos fuera de este orden, no obtendremos el resultado deseado. Por ejemplo, no podemos girar la llave sin haberla insertado previamente, ni entrar al automóvil sin abrir la puerta.\n",
        "\n",
        "Para diseñar un buen algoritmo, es fundamental responder a las siguientes preguntas:\n",
        "\n",
        "- **¿Cuál es mi objetivo?**\n",
        "- **¿Con qué información cuento para alcanzarlo?** (datos de entrada)\n",
        "- **¿Qué información obtendré al alcanzar mi objetivo?** (datos de salida)\n",
        "- **¿Qué cálculos o procesos debo realizar?**\n",
        "\n",
        "Estas preguntas ayudan a estructurar el algoritmo de manera efectiva y garantizan que se aborden todos los aspectos necesarios para alcanzar el resultado esperado."
      ],
      "metadata": {
        "id": "nR4E0Jvk-FRS"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Variables\n",
        "\n",
        "Todo lenguaje de programación necesita la capacidad de acceder y modificar información. Esto se logra mediante el uso de **variables**.\n",
        "\n",
        "Las variables son contenedores que almacenan datos y pueden cambiar a lo largo de la ejecución del programa.\n",
        "\n",
        "Para utilizar una variable en un programa, es necesario declararla primero. Esto implica asignar un nombre a la variable y, en algunos lenguajes, especificar su tipo de dato.\n",
        "\n",
        "Una vez declarada, la variable puede ser utilizada para almacenar, recuperar y modificar información según sea necesario en el desarrollo del programa."
      ],
      "metadata": {
        "id": "Y1rl6VNm-xRe"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RuLnxv_rFc3S"
      },
      "source": [
        "Aquí tienes el texto ajustado para mejorar la redacción y el enfoque pedagógico:\n",
        "\n",
        "---\n",
        "\n",
        "### Declaración de Variables\n",
        "\n",
        "Para declarar una variable, primero debemos asignarle un nombre que utilice letras y números, sin espacios. Es importante recordar que las mayúsculas y minúsculas son significativas en los nombres de las variables.\n",
        "\n",
        " Una vez que hemos elegido un nombre, le asignamos un valor utilizando el operador **=**. Este proceso permite que el programa reserve un bloque de memoria para la variable y almacene el valor en dicho bloque.\n",
        "\n",
        "A diferencia de otros lenguajes de programación, en Python 3 **no es posible declarar una variable sin asignarle un valor**. Esto significa que cada variable debe ser inicializada en el momento de su declaración.\n",
        "\n",
        "Existen varios tipos de variables, dependiendo del tipo de información con la que deseamos trabajar dentro de un programa, como númericas, (enteros, reales), cadenas de texto, entre otros."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UdCeLc6SrSyX"
      },
      "source": [
        "Aquí tienes el texto ajustado para mejorar la redacción y el enfoque pedagógico:\n",
        "\n",
        "---\n",
        "\n",
        "### Numérica\n",
        "\n",
        "Las variables de tipo numérico se utilizan para almacenar números. En Python 3, existen dos categorías principales: **números enteros** y **números reales**.\n",
        "\n",
        "- Los números enteros se denominan **int**. Estos no requieren ninguna notación especial al momento de ser declarados.\n",
        "  \n",
        "- Los números reales se denominan **float**. Para declarar un **float**, se debe incluir un punto (**.**) como separador de decimales.\n",
        "\n",
        "Si deseamos representar una cantidad entera como un **float**, es necesario añadir el punto al final de la parte entera. Por ejemplo, para representar el número entero **5** como un **float**, se escribiría **5.0**."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vG9cYZHfrSyX"
      },
      "source": [
        "# El Tutor Magic habilita la prueba de escritorio interactiva. Es necesario que haya ejecutado\n",
        "# previamente la importación del metakernel\n",
        "%%tutor --lang python3 -s\n",
        "\n",
        "# Ejecute estas instrucciones y observe el resultado obtenido\n",
        "\n",
        "# Crear las variables\n",
        "miVariableEntera = 1\n",
        "miVariableReal = 2.0\n",
        "producto = 4.3 * -2.0\n",
        "\n",
        "# Mostras las variables\n",
        "print(\"miVariableEntera: \", miVariableEntera)\n",
        "print(\"miVariableReal: \",miVariableReal)\n",
        "print(\"producto: \", producto)\n",
        "\n",
        "# Mostrar el resultado de una operación entre variables\n",
        "print(\"La suma entre dos variables: \", miVariableEntera + miVariableReal)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "33sjTORJrSyX"
      },
      "source": [
        "Aquí tienes el texto ajustado para mejorar la redacción y el enfoque pedagógico:\n",
        "\n",
        "---\n",
        "\n",
        "### String\n",
        "\n",
        "Las variables de tipo **string** se utilizan para almacenar texto o cadenas de caracteres.\n",
        "\n",
        "Un **string** es una forma particular de lista; específicamente, es una lista de caracteres que **no puede ser modificada** una vez creada.\n",
        "\n",
        "Para evitar la tarea de escribir cada carácter individualmente, como se haría con una lista, en los strings simplemente se escribe el texto deseado entre comillas y se asigna a una variable.\n",
        "\n",
        "Por ejemplo:\n",
        "\n",
        "```python\n",
        "# Crear una variable tipo string\n",
        "mensaje = \"Hola, mundo\"\n",
        "```\n",
        "\n",
        "En este caso, **mensaje** es una variable de tipo string que almacena la cadena de texto \"Hola, mundo\"."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UbrMxonkrSyX"
      },
      "source": [
        "# Ejecute estas instrucciones y observe el resultado obtenido\n",
        "\n",
        "# Crear variables tipo string\n",
        "string1 = \"Hola\"\n",
        "stringDeNumeros = \"112341352573568\"\n",
        "\n",
        "# Mostrar las variables\n",
        "print(string1)\n",
        "print(stringDeNumeros)\n",
        "\n",
        "# Mostrar el resultado de concatenar dos strings\n",
        "print(\"Los dos strings combinados: \" + string1+stringDeNumeros)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "llqRnEierSyX"
      },
      "source": [
        "Aquí tienes el texto ajustado para mejorar la redacción y el enfoque pedagógico:\n",
        "\n",
        "---\n",
        "\n",
        "### Booleanas\n",
        "\n",
        "Las variables de tipo **booleano** almacenan un valor de **True** o **False**. Se utilizan para almacenar los resultados de comparaciones y condiciones lógicas.\n",
        "\n",
        "Es importante destacar que ni **True** ni **False** se comportan como variables. Cuando se escriben correctamente, el intérprete de Python las reconoce como palabras clave y no se pueden utilizar como nombres de variables.\n",
        "\n",
        "En los siguientes ejemplos, tanto **True** como **False** no están escritos entre comillas y comienzan con mayúscula. Esto se debe a que no son strings ni otro tipo de variable; son **valores de verdad**.\n",
        "\n",
        "Por ejemplo:\n",
        "\n",
        "```python\n",
        "# resultado será True\n",
        "resultado = (5 > 3)  \n",
        "\n",
        "# es_falso será False\n",
        "es_falso = (5 <= 3)  \n",
        "```\n",
        "\n",
        "En este caso, **resultado** almacena el valor **True** porque la comparación es correcta, mientras que **es_falso** almacena **False** debido a que la comparación es incorrecta."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T4M-_d_xrSyX"
      },
      "source": [
        "# Ejecute estas instrucciones y observe el resultado obtenido\n",
        "# Crear la variable resultado\n",
        "resultado = (5 > 3)\n",
        "\n",
        "# Crear la variable es_falso\n",
        "es_falso = (5 <= 3)\n",
        "\n",
        "# Mostrar las variables\n",
        "print(\"5 > 3: \", resultado)\n",
        "print(\"5 <= 3: \", es_falso)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2SwisKuvrSyX"
      },
      "source": [
        "### Fechas\n",
        "\n",
        "Python 3 permite manejar fechas mediante el tipo de dato **date**. Para utilizar las funcionalidades necesarias para trabajar con fechas se debe importar la librería **datetime** al inicio del código:\n",
        "\n",
        "```python\n",
        "# Importar la librería requerida\n",
        "import datetime\n",
        "```\n",
        "\n",
        "Esto importará las bibliotecas requeridas para la manipulación de fechas."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BhiZTr6vrSyX"
      },
      "source": [
        "# El Tutor Magic habilita la prueba de escritorio interactiva. Es necesario que haya ejecutado\n",
        "# previamente la importación del metakernel\n",
        "#%%tutor --lang python3 -s\n",
        "\n",
        "# Ejecute estas instrucciones y observe el resultado obtenido\n",
        "\n",
        "# Importar la librería datetime para trabajar con fechas\n",
        "import datetime as dt\n",
        "\n",
        "# Crear un objeto datetime.date\n",
        "fecha = dt.date(1989, 7, 31)\n",
        "\n",
        "# Mostrar el objeto\n",
        "print(\"Esto es una fecha:\", fecha)\n",
        "\n",
        "# Crear una fecha\n",
        "fecha_actual = dt.datetime.now()\n",
        "\n",
        "# Mostrar el objeto\n",
        "print(\"La fecha actual es:\", fecha_actual)\n",
        "\n",
        "# Sumar cinco días a la fecha actual\n",
        "nueva_fecha = fecha_actual + dt.timedelta(days=5)\n",
        "\n",
        "# Mostrar el nuevo objeto\n",
        "print(\"La nueva fecha es:\", nueva_fecha)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d8ULHa9kGxvo"
      },
      "source": [
        "# Operadores Numéricos\n",
        "\n",
        "Python 3 ofrece una variedad de operadores matemáticos básicos para realizar cálculos.\n",
        "\n",
        "A continuación se presentan los principales operadores numéricos:\n",
        "\n",
        "- **`=`**: Operador de asignación. Se utiliza para asignar un valor a una variable.\n",
        "  \n",
        "- **`+`**: Operador de suma. Sirve para sumar dos números.\n",
        "\n",
        "- **`-`**: Operador de resta. Permite restar un número de otro.\n",
        "\n",
        "- **`*`**: Operador de multiplicación. Utilizado para multiplicar dos números.\n",
        "\n",
        "- **`/`**: Operador de división. Divide dos números y retorna el resultado como un **float**.\n",
        "\n",
        "- **`//`**: Operador de división entera. Realiza una división y retorna solo la parte entera del resultado como un **int**.\n",
        "\n",
        "- **`%`**: Operador de módulo. Calcula el residuo de una división entre dos números."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wkLPn7YQrSyn"
      },
      "source": [
        "# El Tutor Magic habilita la prueba de escritorio interactiva. Es necesario que haya ejecutado\n",
        "# previamente la importación del metakernel\n",
        "# %%tutor --lang python3 -s\n",
        "\n",
        "# Ejecute estas instrucciones y observe el resultado obtenido\n",
        "\n",
        "# El operador potencia es '**'. Se imprime 27 (3 al cubo)\n",
        "print(3**3)\n",
        "\n",
        "# Se elimina la parte decimal de la división. Se imprime 5.\n",
        "print(11//2)\n",
        "\n",
        "# Se presenta el residuo de una división. En el caso de 16 dividido 5, el resultado es 5 residuo 1.\n",
        "print(16%5)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JgsKqdwirSyn"
      },
      "source": [
        "# Operadores para Strings\n",
        "\n",
        "En Python 3, hay varias formas de manipular cadenas de caracteres. Dos de los operadores principales son:\n",
        "\n",
        "- **`+`**: Operador de **concatenación**. Se utiliza para unir dos cadenas de caracteres diferentes. Por ejemplo:\n",
        "\n",
        "  ```python\n",
        "  # Crear variables como cadena de texto\n",
        "  saludo = \"Hola, \"\n",
        "  nombre = \"Juan\"\n",
        "\n",
        "  # Concatenar las variables\n",
        "  mensaje = saludo + nombre  \n",
        "  ```\n",
        "\n",
        "- **`*`**: Operador de **repetición**. Sirve para repetir una cadena de caracteres un número específico de veces. Por ejemplo:\n",
        "\n",
        "  ```python\n",
        "  # Crear la variable como cadena de texto\n",
        "  repetir = \"Hola! \"\n",
        "\n",
        "  # Crear una variable que triplica el contenido de otra\n",
        "  resultado = repetir * 3  \n",
        "  ```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Iam42BSPrSyn"
      },
      "source": [
        "# Ejecute estas instrucciones y observe el resultado obtenido\n",
        "\n",
        "# Crear dos variables del tipo string\n",
        "string1 = \"Hola\"\n",
        "string2 = \"Mundo\"\n",
        "\n",
        "# Concatenar dos strings\n",
        "string3 = string1+string2\n",
        "\n",
        "# Mostrar el resultado\n",
        "print(\"Resultado de concatenar dos strings:\", string3)\n",
        "\n",
        "# Repetir una string\n",
        "string4 = string3*3\n",
        "\n",
        "# Mostrar el resultado\n",
        "print(\"Resultado de repetir una string:\", string4)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RY6-fLg1XOsA"
      },
      "source": [
        "# El vacío es diferente del cero\n",
        "\n",
        "Es diferente un variable, o un objeto vacío, que una variable, o un objeto, que tenga asignado el valor de cero (0).\n",
        "\n",
        "Otra forma de entender esa diferencia, en términos más coloquiales, la aportó **Benjamín Arias Fuentes** (período 2020-02): \"El cero es la plata en la cuenta, y el vacío es lo que me dejó ella cuando se fue.\"\n",
        "\n",
        "Los siguientes códigos le permitirán observar la diferencia."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q-kuABOhXTtk"
      },
      "source": [
        "# El Tutor Magic habilita la prueba de escritorio interactiva. Es necesario que haya ejecutado\n",
        "# previamente la importación del metakernel\n",
        "%%tutor --lang python3 -s\n",
        "\n",
        "# Crear una variable vacía y mostrar su tipo\n",
        "a = None\n",
        "print(\"El valor de a es %s.\" % a)\n",
        "ta = type(a)\n",
        "print(\"El tipo de a es %s.\" % ta)\n",
        "\n",
        "# Crear una lista vacia y mostrar su tipo\n",
        "b =[]\n",
        "print(\"El valor de b es %s.\" % b)\n",
        "tb = type(b)\n",
        "print(\"El tipo de b es %s.\" % tb)\n",
        "\n",
        "# Crear una variable numerica y mostrar su tipo\n",
        "c =0\n",
        "print(\"El valor de c es %s.\" % c)\n",
        "tc = type(c)\n",
        "print(\"El tipo de c es %s.\" % tc)\n",
        "\n",
        "# Crear una variable string y mostrar su tipo\n",
        "d =\"0\"\n",
        "print(\"El valor de d es %s.\" % d)\n",
        "td = type(d)\n",
        "print(\"El tipo de d es %s.\" % td)\n",
        "\n",
        "# Crear una variable float y mostrar su tipo\n",
        "e =0.0\n",
        "print(\"El valor de e es %s.\" % e)\n",
        "te = type(e)\n",
        "print(\"El tipo de e es %s.\" % te)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lK5Ufi3LXyFx"
      },
      "source": [
        "# El Tutor Magic habilita la prueba de escritorio interactiva. Es necesario que haya ejecutado\n",
        "# previamente la importación del metakernel\n",
        "%%tutor --lang python3 -s\n",
        "\n",
        "# Crear una lista\n",
        "datos = [None, [], 0, \"0\", 0.0]\n",
        "\n",
        "# Crea la variable pos para identificar la posición de un elemento\n",
        "pos=0\n",
        "\n",
        "# Ciclo for que recorre los contenidos de la lista datos\n",
        "for i in datos:\n",
        "  # Muestra la posición, el valor de i y el tipo de i\n",
        "  print(\"El valor en la posición %s de datos es %s y su tipo es %s.\" %(pos, i, type(i)))\n",
        "\n",
        "  # Actualiza la posición\n",
        "  pos +=1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X5I-xJP7XzOc"
      },
      "source": [
        "# El Tutor Magic habilita la prueba de escritorio interactiva. Es necesario que haya ejecutado\n",
        "# previamente la importación del metakernel\n",
        "#%%tutor --lang python3 -s\n",
        "\n",
        "# Crea la función tipo de dato\n",
        "def tipoDato(a):\n",
        "    \"\"\"Muestra el valor y el tipo de dato de un objeto.\n",
        "\n",
        "    Args:\n",
        "        a: El objeto cuyo valor y tipo se desea mostrar.\n",
        "\n",
        "    Returns:\n",
        "        None: Esta función no retorna ningún valor.\n",
        "\n",
        "    Example:\n",
        "        >>> tipoDato(5)\n",
        "        El valor del dato es 5 y su tipo es <class 'int'>.\n",
        "\n",
        "        >>> tipoDato(\"Hola\")\n",
        "        El valor del dato es Hola y su tipo es <class 'str'>.\n",
        "    \"\"\"\n",
        "    print(\"El valor del dato es %s y su tipo es %s.\" % (a, type(a)))\n",
        "\n",
        "\n",
        "datos = [None, [], 0, \"0\", 0.0]\n",
        "\n",
        "# Crear ciclo for que invoca una función y la aplica a los elementos\n",
        "for i in datos:\n",
        "  tipoDato(i)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3sIF_KrYgXId"
      },
      "source": [
        "# Listas\n",
        "\n",
        "Las listas son un tipo de **estructura de datos** que permite almacenar múltiples valores en un orden específico.\n",
        "\n",
        "Cada posición en la lista puede contener cualquier tipo de dato: números, strings, e incluso otras listas.\n",
        "\n",
        "Las listas son muy útiles para manejar datos complejos de forma organizada.\n",
        "\n",
        "Es importante destacar que una lista puede estar vacía, es decir, no contener ningún elemento.\n",
        "\n",
        "Para crear una lista en Python, se colocan los elementos separados por comas dentro de corchetes (**[]**). Por ejemplo:\n",
        "\n",
        "```python\n",
        "# Crear una lista\n",
        "mi_lista = [1, 2, 3, \"hola\", True]\n",
        "```\n",
        "\n",
        "En este caso, **mi_lista** contiene cinco elementos de diferentes tipos: enteros, cadenas de texto y un valor booleano."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ixE6PMU9gXId"
      },
      "source": [
        "# Ejecute estas instrucciones y observe el resultado obtenido\n",
        "\n",
        "# Crear listas\n",
        "lista_letras = [\"a\",\"b\",\"c\"]\n",
        "lista_numeros = [3.0, 3.1, 4.4]\n",
        "lista_mixta = [\"Brasil\", \"Alemania\", 7, 1]\n",
        "\n",
        "# Mostrar listas\n",
        "print(lista_letras)\n",
        "print(lista_numeros)\n",
        "print(lista_mixta)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-cYgYPeIgXIt"
      },
      "source": [
        "## Acceder a los elementos de una lista\n",
        "\n",
        "En Python puedes acceder a los elementos individuales de una lista para utilizarlos o modificarlos durante la ejecución de un programa.\n",
        "\n",
        "Como las listas tienen un orden definido, cada posición en la lista está asociada a un número, conocido como **índice**. Es importante recordar que **el primer elemento tiene el índice [0]**, lo que significa que el segundo elemento tendrá el índice [1], y así sucesivamente.\n",
        "\n",
        "Siguiendo este principio, si una lista tiene **n** elementos, **el último elemento se encuentra en la posición [n-1]**.\n",
        "\n",
        "Por ejemplo, para acceder al tercer elemento de la lista **lista_nueva**, se utilizaría la siguiente notación:\n",
        "\n",
        "```python\n",
        "# Crear una lista\n",
        "lista_nueva = [10, \"Python\", 3.14, True]\n",
        "\n",
        "# Acceder al tercer elemento de lista_nueva que es 3.14\n",
        "tercer_elemento = lista_nueva[2]  \n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IEO76DN0gXIt"
      },
      "source": [
        "# Ejecute estas instrucciones y observe el resultado obtenido\n",
        "# Mostrar el elemento en la posición 2 de lista_mixta\n",
        "print(lista_mixta[2])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1JJ7ozwXgXIt"
      },
      "source": [
        "De esta forma, estaría recuperando el número 7 para utilizar dentro del código.\n",
        "\n",
        "Se debe tener cuidado de <b>no ingresar un índice que se salga del tamaño de la lista.</b>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F_SxT1m7gXIt"
      },
      "source": [
        "# Ejecute estas instrucciones y observe el resultado obtenido\n",
        "# Mostrar el elemento en la posición 4 de lista_mixta\n",
        "print(lista_mixta[4])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6EYFyPEoZfJ0"
      },
      "source": [
        "Se obtiene un mensaje de error porque el índice es mayor al tamaño de la lista. Recuerde que las posiciones de una lista se enumeran desde cero y que el índice [4] estaría invocando la quinta posición de la lista."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JOEy0HF5gXIt"
      },
      "source": [
        "## Las variables tipo **string** son listas\n",
        "\n",
        "Un caso particular de las listas en Python son las variables de tipo **string**. Un string es, en esencia, una cadena de caracteres que se puede visualizar como una lista en la que cada carácter ocupa una posición. Esto significa que puedes acceder a cada carácter de un string de la misma manera que lo harías con una lista.\n",
        "\n",
        "La principal diferencia entre un string y una lista de caracteres es que **los strings son inmutables**, es decir, no se pueden modificar directamente.\n",
        "\n",
        "Si necesitas cambiar el contenido de un string, deberás crear una nueva cadena asignándole un nuevo valor. En cambio, las listas sí son mutables, lo que significa que puedes modificar sus elementos individuales sin necesidad de crear una lista nueva.\n",
        "\n",
        "A pesar de esta diferencia, los strings y las listas comparten muchas características en su manejo dentro de Python. Puedes acceder a sus elementos por índice, iterar sobre ellos, y aplicar varias funciones similares."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K4UkXNSrHsbc"
      },
      "source": [
        "# Crear una variable string\n",
        "nombre = \"Luisa Fernanda\"\n",
        "\n",
        "# Mostrar el elemento en la posición 1\n",
        "print(nombre[1])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ra_DFnP0Htjj"
      },
      "source": [
        "# Tuplas\n",
        "\n",
        "Las tuplas son en esencia conjuntos de elementos que están emparejados y no se pueden modificar. Si un string es una lista de caracteres inmutable, entonces una tupla es una lista de cualquier cosa inmutable. Exceptuando la inhabilidad para modificar y actualizar la información dentro de una tupla, estas funcionan igual que una lista. Para diferenciarlas a la hora de declarlas, se utilizan paréntesis en lugar de brackets."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OfgM6i_EgXIt"
      },
      "source": [
        "# Ejecute estas instrucciones y observe el resultado obtenido\n",
        "\n",
        "# Crear tuplas\n",
        "tupla_letras = (\"a\",\"b\",\"c\")\n",
        "tupla_numeros = (3.0, 3.1, 4.4)\n",
        "tupla_mixta = (\"Brasil\", \"Alemania\", 7, 1)\n",
        "\n",
        "# Mostrar tuplas y contenidos en posiciones específicas\n",
        "print(tupla_letras)\n",
        "print(tupla_letras [2])\n",
        "print(tupla_numeros)\n",
        "print(tupla_numeros [0])\n",
        "print(tupla_mixta)\n",
        "print(tupla_mixta [1])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zdNsPpwqgXIt"
      },
      "source": [
        "# Matrices y tablas\n",
        "\n",
        "Al inicio se expuso que los elementos de una lista podían ser cualquier cosa. Sucede que estos elementos también pueden ser otras listas. Las tablas son listas donde cada posición es una lista de igual tamaño. Cada posición de estas listas se encuentra en una columna. Las matrices son el caso particular de tablas donde cada elemento es un número."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7iuhPta3IMZw"
      },
      "source": [
        "### Ejemplo de matrices y tablas\n",
        "Para manejar las notas de sus estudiantes, un profesor tiene una lista donde tiene el nombre de cada uno de sus estudiantes y las calificaciones que obtuvieron en cada uno de tres exámenes.\n",
        "\n",
        "Se puede tomar a cada estudiante individual como una lista que contiene el nombre de cada uno y sus calificaciones, de la siguiente forma:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eFVcuqMRgXIt"
      },
      "source": [
        "# Ejecute estas instrucciones y observe el resultado obtenido\n",
        "\n",
        "# Crear listas con datos de los estudiantes\n",
        "estudiante0 = [\"Jorge Cardona\", 4.3, 3.2, 3.7]\n",
        "estudiante1 = [\"Marta Restrepo\", 4.4, 4.8, 4.1]\n",
        "estudiante2 = [\"Jaime Escobar\", 3.0, 2.7, 3.3]\n",
        "\n",
        "# Mostrar el contenido de la lista en la ubicación 1\n",
        "print (estudiante1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bCB3Bzp_gXI8"
      },
      "source": [
        "A partir de estos estudiantes, se puede crear una lista que tenga a cada uno de los estudiantes como elemento. Recuerde que una lista puede almacenar cualquier cosa en cada una de sus posiciones, incluyendo otras listas:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8Rp-_S_9gXI8"
      },
      "source": [
        "# Ejecute estas instrucciones y observe el resultado obtenido\n",
        "\n",
        "# Crear una lista que contiene otra listas\n",
        "lista_estudiantes = [estudiante0, estudiante1, estudiante2]\n",
        "\n",
        "# Mostrar el contenido de la lista\n",
        "print (lista_estudiantes)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8BwMDE9OgXI8"
      },
      "source": [
        "# Ejecute estas instrucciones y observe el resultado obtenido\n",
        "\n",
        "# Mostrar el contenido de la lista en la ubicación 2\n",
        "print(lista_estudiantes[2])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UxVqf-B4gXI8"
      },
      "source": [
        "# Ejecute estas instrucciones y observe el resultado obtenido\n",
        "\n",
        "# Mostrar un elemento específico de la lista.\n",
        "# El primer número indica la lista seleccionada, y el segundo número indica la ubicación\n",
        "# del elemento\n",
        "print(lista_estudiantes[1][0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "De esta forma, se accede a estudiante1 e inmediatamente se accede a la primera posición de esta lista, la cual contiene el nombre de Marta Restrepo."
      ],
      "metadata": {
        "id": "mfoq6vQ-zoRB"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AeDvUQrxgXJM"
      },
      "source": [
        "# Diccionarios\n",
        "\n",
        "Hasta ahora, hemos visto cómo las listas utilizan números (índices) para identificar la posición de cada elemento. Sin embargo, en algunos casos resulta más intuitivo usar nombres para describir los diferentes elementos.\n",
        "\n",
        "Por ejemplo, cuando se trabaja con información de estudiantes, tiene mucho más sentido referirse a datos como \"Nombre\", \"Examen1\", \"Examen2\" y \"Examen3\", en lugar de identificar esa información con números en una lista.\n",
        "\n",
        "Aquí es donde los **diccionarios** resultan útiles. Los diccionarios permiten almacenar pares de **clave-valor**, donde cada elemento está identificado por una clave (generalmente una palabra), en lugar de un índice numérico. Esto hace que los datos sean más fáciles de entender y manejar.\n",
        "\n",
        "La sintaxis para declarar un diccionario es similar a la de una lista, pero en lugar de corchetes (**[]**), se utilizan llaves (**{}**).\n",
        "\n",
        "Por ejemplo:\n",
        "\n",
        "```python\n",
        "# Crear un diccionario\n",
        "estudiante = {\n",
        "    \"Nombre\": \"Juan\",\n",
        "    \"Examen1\": 85,\n",
        "    \"Examen2\": 90,\n",
        "    \"Examen3\": 88\n",
        "}\n",
        "```\n",
        "\n",
        "En este caso, cada clave como `\"Nombre\"` está asociada a un valor, lo que permite acceder fácilmente a la información utilizando las claves en lugar de números."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k-PPZvI9gXJM"
      },
      "source": [
        "# Ejecute estas instrucciones y observe el resultado obtenido\n",
        "\n",
        "# Crear un diccionario\n",
        "diccionario = {\"un_elemento\": 3, \"otro_elemento\": \"Hola!\"}\n",
        "\n",
        "# Mostrar el contenido del diccionario\n",
        "print(diccionario)\n",
        "\n",
        "# Accedemos a \"otro_elemento\":\n",
        "print(\"Imprimiendo otro_elemento: \", diccionario[\"otro_elemento\"])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IDUgEdVEaSdg"
      },
      "source": [
        "# Sets\n",
        "\n",
        "Un **set** es una colección no ordenada y sin elementos duplicados. Los **sets** permiten verificar y eliminar elementos repetidos.\n",
        "\n",
        "Este tipo de objetos permiten realizar las operaciones tradicionales entre conjuntos: unión, intersección, diferencia y diferencia simétrica."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Gg9I_ENcaV9u"
      },
      "source": [
        "# Ejecute estas instrucciones y observe el resultado obtenido\n",
        "\n",
        "# Los set se crean usando {}\n",
        "# Crear un set\n",
        "cosas = {\"cepillo\", \"cama\", \"crema\"}\n",
        "\n",
        "# Mostrar el contenido del set\n",
        "print(\"El contenido del set es:\", cosas)\n",
        "\n",
        "# Mostrar el tipo de dato\n",
        "print(\"El tipo de objeto es\", type(cosas))\n",
        "\n",
        "# Crear una lista\n",
        "canasta = ['manzana', 'naranja', 'manzana', 'pera', 'naranja', 'banano']\n",
        "\n",
        "# Mostrar el contenido de canasta\n",
        "print(\"El contenido de canasta es:\", canasta)\n",
        "\n",
        "# Convertir una lista en un set\n",
        "canasta2 = set(canasta)\n",
        "\n",
        "# Mostrar el tipo de canasta2\n",
        "print(type(canasta2))\n",
        "\n",
        "# Mostrar el contenido de canasta2\n",
        "print(\"El contenido de canasta2 es:\", canasta2)\n",
        "\n",
        "print(\"Observe que se eliminaron los documentos repetidos.\")\n",
        "\n",
        "# Ejemplos de operaciones entre sets\n",
        "\n",
        "# Crear y mostrar sets\n",
        "a = set('abracadabra')\n",
        "print (\"El contenido de a es:\", a)\n",
        "\n",
        "b = set('alacazam')\n",
        "print (\"El contenido de b es:\", b)\n",
        "\n",
        "# Intersección entre a y b\n",
        "ambos = a&b\n",
        "print(\"Los elementos comunes entre a y b son: \", ambos)\n",
        "\n",
        "# Unión entre a y b\n",
        "union = a|b\n",
        "print(\"El resultado de unir a y b es: \", union)\n",
        "\n",
        "# Diferencia entre a y b\n",
        "dif= a-b\n",
        "print(\"La diferencia entre a y b es: \", dif)\n",
        "\n",
        "# Diferencia simétrica entre a y b\n",
        "dif2 = a^b\n",
        "print (\"Los elementos que están en a o en b, pero no en los dos son: \", dif2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "edw26Ib_gXJM"
      },
      "source": [
        "# Vectores\n",
        "\n",
        "Los **vectores** son un concepto que puede parecer abstracto al principio. Imagina que tienes una tabla, como la lista de estudiantes que describimos anteriormente.\n",
        "\n",
        "Ahora, supón que tienes varias de esas tablas, cada una representando una materia diferente.\n",
        "\n",
        "Finalmente, si necesitas tener una lista que contenga todas esas tablas, estarías utilizando lo que se conoce como un **vector de orden 3**.\n",
        "\n",
        "En esencia, los vectores son listas que contienen otras listas, que a su vez pueden contener más listas. Este proceso puede continuar indefinidamente: un vector de dimensión 1 es simplemente una lista, un vector de dimensión 2 es una lista de listas (o una tabla), y un vector de dimensión 3 es una lista de tablas.\n",
        "\n",
        "Para acceder a los elementos de un vector, se utiliza la misma notación que para las tablas, pero debes añadir un corchete por cada nivel de anidación. Ten en cuenta que al acceder a un nivel superior, estarás obteniendo una lista completa y no un único elemento en particular."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WgW7sawigXJM"
      },
      "source": [
        "# Ejecute estas instrucciones y observe el resultado obtenido\n",
        "\n",
        "# Crear un vector\n",
        "vector = [lista_estudiantes, diccionario]\n",
        "\n",
        "# Mostrar el vector y algunos de sus contenidos\n",
        "print(\"El vector completo:\\n\", vector, \"\\n\")\n",
        "print(\"El segundo elemento del primer índice del vector:\\n\", vector[0][1], \"\\n\")\n",
        "print(\"Un elemento particular del diccionario utilizado:\\n\", vector[1][\"un_elemento\"])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JZo35J7IgXJM"
      },
      "source": [
        "# Operaciones básicas</font></h2>\n",
        "\n",
        "## Modificar a un elemento:\n",
        "Ya se ha visto cómo acceder a elementos puntuales de las listas. Tenga en cuenta que al acceder a un elemento particular de una lista, puede también modificarlo asignándole un valor nuevo directamente:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nm9RJkOcgXJM"
      },
      "source": [
        "# Ejecute estas instrucciones y observe el resultado obtenido\n",
        "\n",
        "# Mostrar una lista\n",
        "print(lista_numeros)\n",
        "\n",
        "# Modificar el valor de un elemento de la lista que se encuentra en la ubicación 1\n",
        "lista_numeros[1] = -99\n",
        "\n",
        "# Mostrar una lista\n",
        "print(lista_numeros)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0ESQhp_2gXJM"
      },
      "source": [
        "A continuación se presentan otras <b>operaciones comunes</b>:\n",
        "\n",
        "### <h3><font color=\"navy\">Concatenación:</font></h3>\n",
        "Consiste en unir dos listas. Para ello, se utiliza la siguiente notación:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3H3EZwuvgXJM"
      },
      "source": [
        "# Ejecute estas instrucciones y observe el resultado obtenido\n",
        "\n",
        "# Crear dos listas\n",
        "lista1 = [1, 3, 5]\n",
        "lista2 = [2, 4, 6]\n",
        "\n",
        "# Concatenar dos listas\n",
        "lista3 = lista1 + lista2\n",
        "\n",
        "# Mostrar la lista concatenada\n",
        "print(lista3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FRNtxd5TgXJM"
      },
      "source": [
        "### <h3><font color=\"navy\">Adición de un elemento:</font></h3>\n",
        "Tanto para listas como diccionarios, se puede adicionar un elemento a ellos si fuera necesario.\n",
        "\n",
        "Para las listas, se utiliza la siguiente notación:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c1kIUGtAgXJM"
      },
      "source": [
        "# Ejecute estas instrucciones y observe el resultado obtenido\n",
        "\n",
        "# Mostrar lista original\n",
        "print(\"Antes: \", lista1)\n",
        "\n",
        "# Agregar un elemento a la lista\n",
        "lista1 = lista1 + [7]\n",
        "\n",
        "# Mostrar lista actualizada\n",
        "print(\"Después: \", lista1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lvB6pu6FgXJc"
      },
      "source": [
        "Esto adicionará un elemento nuevo al final de la lista. En el caso de los diccionarios, simplemente se declara una nueva posición con su índice:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qbeB6SImgXJc"
      },
      "source": [
        "# Ejecute estas instrucciones y observe el resultado obtenido\n",
        "\n",
        "# Mostrar diccionario original\n",
        "print(\"Antes: \", diccionario)\n",
        "\n",
        "# Agregar un ínidce con su respctivo contenido\n",
        "diccionario[\"nuevo_indice\"] = \"Nuevo elemento\"\n",
        "\n",
        "# Mostrar diccionario actualizado\n",
        "print(\"Después: \", diccionario)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YUG03XBjgXJc"
      },
      "source": [
        "### <h3><font color=\"navy\">Eliminar un elemento:</font></h3>\n",
        "Similar a adicionar un elemento, utilizamos el operador **:** para hacerlo. Si qusieramos eliminar el tercer elemento de lista1, debemos de indicarlo con el indice <i>i</i> del elemento que queremos eliminar. Siempre tendremos el indice <i>i</i> a la izquierda y el indice <i>i+1</i> a la derecha, de esta forma:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nvjvXtm5gXJc"
      },
      "source": [
        "# Ejecute estas instrucciones y observe el resultado obtenido\n",
        "\n",
        "# Se quiere eliminar el tercer elemento, aquel en el indice 2\n",
        "\n",
        "# Mostrar lista original\n",
        "print(\"Antes: \", lista1)\n",
        "\n",
        "# Eliminar un elemento de la lista\n",
        "lista1[2:3] = []\n",
        "\n",
        "# Mostrar lista actualizada\n",
        "print(\"Después: \", lista1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Dea1I1megXJc"
      },
      "source": [
        "### Igualar listas: la misma lista con dos nombres diferentes\n",
        "Si igualamos dos listas tendremos dos variables que almacenan la misma lista, por tanto, al modificar un elemento de la lista se verán afectadas ambas variables. Se puede observar en este ejemplo:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rGfT48tjgXJc"
      },
      "source": [
        "# La primera línea activa el tutor magic para el ejemplo específico\n",
        "#%%tutor --lang python3 -s\n",
        "\n",
        "# Ejecute estas instrucciones y observe el resultado obtenido\n",
        "\n",
        "# Crear una lista\n",
        "lista_1= [\"Fátima\", \"Lourdes\", 66, 45.8, True, [0, 1, 2, 3, 4],\n",
        " {\"departamento\": \"Antioquia\", \"municipio\": \"Urrao\"}]\n",
        "\n",
        "# La siguiente instrucción hace que ambas listas sean la misma lista con diferente nombre.\n",
        "# no crea una lista independiente\n",
        "lista_2 = lista_1\n",
        "\n",
        "# Mostrar las dos listas\n",
        "print(\"Estas son las listas originales:\")\n",
        "print(\"Esto es lista_1: \", lista_1)\n",
        "print(\"Esto es lista_2: \", lista_2, \"\\n\")\n",
        "\n",
        "# Modificar el valor de un elemento de la lista_2 que se encuentra en la ubicación 1\n",
        "lista_2[1] = -9999\n",
        "\n",
        "# Mostrar las dos listas\n",
        "print(\"Estas son las listas actualizadas:\")\n",
        "print(\"Esto es lista_1: \", lista_1)\n",
        "print(\"Esto es lista_2: \", lista_2, \"\\n\")\n",
        "\n",
        "# Modificar el valor de un elemento de la lista_1 que se encuentra en la ubicación 6\n",
        "lista_1[6] = \"Cambio lo que yo quiera\"\n",
        "\n",
        "# Mostrar las dos listas actualizadas\n",
        "print(\"Estas son las listas aún más actualizadas:\")\n",
        "print(\"Ahora esto es lista_1: \", lista_1)\n",
        "print(\"Ahora esto es lista_2: \", lista_2, \"\\n\")\n",
        "\n",
        "# Agregar un elemento a la lista_1\n",
        "lista_1.append(\"Agregué un elemento\")\n",
        "\n",
        "# Mostrar las dos listas actualizadas\n",
        "print(\"Estas son las listas después de agregar elementos:\")\n",
        "print(\"Esto es lista_1 extendida: \", lista_1)\n",
        "print(\"Esto es lista2 extendida: \", lista_2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CtECWcQ6QjNi"
      },
      "source": [
        "### Copiar una lista: dos listas independientes\n",
        "Crear una copia de una lista que funciona de manera independiente a la original. Se puede observar en este ejemplo:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LZv_aAoTQ3H_"
      },
      "source": [
        "# La primera línea activa el tutor magic para el ejemplo específico\n",
        "#%%tutor --lang python3 -s\n",
        "\n",
        "# Ejecute estas instrucciones y observe el resultado obtenido\n",
        "\n",
        "# Crear una lista\n",
        "lista_3 = [\"Fátima\", \"Lourdes\", 66, 45.8, True, [0, 1, 2, 3, 4],\n",
        "           {\"departamento\": \"Antioquia\", \"municipio\": \"Urrao\"}]\n",
        "\n",
        "# La siguiente instrucción crea una lista con el mismo contenido que la original,\n",
        "# pero independiente de esta.\n",
        "lista_4 = lista_3.copy()\n",
        "\n",
        "# Mostrar las dos listas\n",
        "print(\"Estas son las listas originales:\")\n",
        "print(\"Esto es lista_3: \", lista_3)\n",
        "print(\"Esto es lista_4: \", lista_4, \"\\n\")\n",
        "\n",
        "# Modificar el valor de un elemento de la lista_4 que se encuentra en la ubicación 1\n",
        "lista_4[1] = -888\n",
        "\n",
        "# Mostrar las dos listas\n",
        "print(\"Estas son las listas actualizadas:\")\n",
        "print(\"Esto es lista_3: \", lista_3)\n",
        "print(\"Esto es lista_4: \", lista_4, \"\\n\")\n",
        "\n",
        "# Modificar el valor de un elemento de la lista_3 que se encuentra en la ubicación 6\n",
        "lista_3[6] = \"Cambio lo que yo quiera\"\n",
        "\n",
        "# Mostrar las dos listas actualizadas\n",
        "print(\"Estas son las listas más actualizadas:\")\n",
        "print(\"Ahora esto es lista_3: \", lista_3)\n",
        "print(\"Ahora esto es lista_4:\", lista_4, \"\\n\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VSoMJx_9gXJc"
      },
      "source": [
        "### <h3><font color=\"navy\">Repeticiones:</font></h3>\n",
        "A veces se desea repetir algo varias veces dentro de una lista. Por ejemplo, si se fuera a representar un parqueadero de carros completamente vacío, quizá se desearía tener una lista donde cada posición corresponda a un espacio y se informe si se encuentra disponible o no.\n",
        "\n",
        "La siguiente instrucción genera una lista de 100 posiciones donde cada una de ellas contiene la palabra \"Disponible.\""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HBGjlYzOgXJc"
      },
      "source": [
        "# Ejecute estas instrucciones y observe el resultado obtenido\n",
        "\n",
        "# Crear una lista\n",
        "lista_nueva = [\"Disponible\"]*10\n",
        "\n",
        "# Mostrar la lista\n",
        "print(lista_nueva)\n",
        "\n",
        "# Motras las posiciones 2, 3 y 4 de la lista.\n",
        "print(lista_nueva[2:5])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F4DQErSWGOsh"
      },
      "source": [
        "#Métodos\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ft_Xu13oGayH"
      },
      "source": [
        "## Métodos de cadenas de texto\n",
        "[Python String Methods](https://www.w3schools.com/python/python_ref_string.asp)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M9hkJQAmGugt"
      },
      "source": [
        "# Crear una cadena de texto\n",
        "cadena =\"Programar es simple y divertido\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VPUEYfAtGWrz"
      },
      "source": [
        "## Métodos de listas/arreglos\n",
        "[Python List/Array Methods](https://www.w3schools.com/python/python_ref_list.asp)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LY44kgN8G9fm"
      },
      "source": [
        "# Crear dos listas\n",
        "listaW=[\"a\",\"e\",\"i\",\"0\",\"u\"]\n",
        "print(\"listaW original: \", listaW)\n",
        "\n",
        "listaX=[\"b\",\"c\",\"d\"]\n",
        "\n",
        "# Agregar elementos al final de una lista con método append\n",
        "listaW.append(8)\n",
        "print(\"listaW modificada con append: \", listaW)\n",
        "\n",
        "# Agregar elementos al final de una lista con asignación\n",
        "listaW[len(listaW):]=[9]\n",
        "print(\"listaW modificada con asignación: \", listaW)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xynb5yGpG-O3"
      },
      "source": [
        "## Métodos de diccionarios\n",
        "[Python Dictionary Methods](https://www.w3schools.com/python/python_ref_dictionary.asp)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "__bbbDplHSDg"
      },
      "source": [
        "# Crear un diccionario\n",
        "dicEjemplo ={\"tipo mascota\": \"gato\", \"nacimiento\": 2020, \"género\": \"femenino\",\n",
        "             \"origen\": \"adoptada\", \"vacunas\": {\"Rinotraqueitis\":[\"Sí\", \"15 de octubre de 2021\"],\n",
        "                                               \"Calicivirus\": \"No\", \"Rabia\":\"No\"} }\n",
        "# Mostrar el diccionario\n",
        "print(dicEjemplo)\n",
        "\n",
        "# Mostrar el valor de una clave en particular\n",
        "print(dicEjemplo[\"vacunas\"])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vlukVw2cHTvg"
      },
      "source": [
        "## Métodos de tuplas\n",
        "[Python Tuple Methods](https://www.w3schools.com/python/python_ref_tuple.asp)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E4Aiw_gvHj4c"
      },
      "source": [
        "# Crear una tupla\n",
        "tupla_nueva=(\"a\",\"e\",\"i\",\"0\",\"u\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EI4esFvyHlKF"
      },
      "source": [
        "## Métodos de sets\n",
        "[Python Set Methods](https://www.w3schools.com/python/python_ref_set.asp)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yGuPZbRpHmd3"
      },
      "source": [
        "# Crear un set\n",
        "set_nuevo={\"a\",\"b\",\"c\",\"d\"}"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}