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/talleresGoogleColab/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",
      "metadata": {
        "id": "0kAE2aCyrSyX"
      },
      "source": [
        "# Pruebas de escritorio\n",
        "Para comprobar si un algoritmo funciona o no (pero no para ver si está bien diseñado), se realizan pruebas de escritorio. Estas consisten en realizar todas las instrucciones del algoritmo como este las presenta, una a una, y ver si el resultado obtenido es el resultado esperado. \n",
        "\n",
        "Para realizar una prueba de escritorio a nuestro algoritmo de calcular el área de un triángulo, podemos tomar un triángulo con base, altura y área conocidas e ingresar los valores de su base y altura a nuestro algoritmo, para finalmente comparar los dos valores de las áreas. Si son iguales, sabemos que el algoritmo produce el resultado esperado.\n",
        "\n",
        "Esto no tiene en cuenta operaciones ociosas o inútiles dentro del algoritmo. Por ejemplo, podríamos tener varios pasos dentro del algoritmo que nos calculen la longitud de los otros dos lados del triángulo. Estos pasos no contribuyen a nuestro objetivo (encontrar el área) y se podrían eliminar del algoritmo, pero no afectan el resultado que obtenemos."
      ]
    },
    {
      "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",
        "i = 3\n",
        "j = 5\n",
        "k = i + j\n",
        "j = k / 2 \n",
        "i = i - 1\n",
        "m = i + (k * 3)\n",
        "n = k * (3 + i)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "epbf3UCArSyX"
      },
      "source": [
        "# Ingreso y salida de datos\n",
        "Un programa debe tener la capacidad de comunicarse con el usuario. El usuario le ingresará la información requerida (datos de entrada) para ejecutar las sentencias y obtener un resultado satisfactorio (datos de salida). Por esta razón es necesario comprender cómo pedir y mostrar información al usuario; lo más habitual en el lenguaje Python 3 es implementar las sentencias print() para mostrar e input() para obtener información del usuario.\n",
        "\n",
        "Sintaxis de la sentencia print():\n",
        "\n",
        "print (valiable1,variable2,….,variableN)\n",
        "\n",
        "print() mostrará por pantalla cada una de las variables contenidas dentro de los paréntesis, nótese que cada variable está separada por una coma (,).             \n",
        "\n",
        "Sintaxis de la sentencia input():\n",
        "\n",
        "variable = input (\"mensaje\")\n",
        "\n",
        "input() mostrará por pantalla el mensaje (variable tipo string) contenido dentro de los paréntesis, con el fin de indicarle al usuario, de una manera clara, qué información se pretende obtener de él. La información recibida debe ser almacenada en una variable; input() genera una cadena con los datos obtenidos, es decir, la Variable antes de los paréntesis será definida de tipo string, anulando la posibilidad de ser utilizada para cálculos matemáticos. Para resolver este problema se debe convertir esta cadena a un tipo de dato numérico. \n",
        "Por ahora veremos cómo cambiar a tipo entero (int) y a real (float), para hacerlo basta con poner la palabra int o float (según sea el caso) seguida de la sentencia input() encerrada entre paréntesis:\n",
        " \n",
        "variable1 = input (\"mensaje\")    # lectura de variable tipo string\n",
        "\n",
        "variable2 = int ( input (\"mensaje\"))  # lectura de variable tipo int\n",
        "\n",
        "variable3 = float (input (\"mensaje\")) # lectura de variable tipo float"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TPWVdRmC7HPS"
      },
      "source": [
        "# Formas alternativas de la función **print()**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uqNT2mQCHr-Z"
      },
      "source": [
        "## Opción %s"
      ]
    },
    {
      "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",
        "# otra forma de mostrar el resultado en pantalla\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": [
        "## 0pción str.format()"
      ]
    },
    {
      "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\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": [
        "## Opción f-Strings"
      ]
    },
    {
      "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\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",
      "metadata": {
        "id": "ofCHkOBVrSyH"
      },
      "source": [
        "# Algoritmos\n",
        "Un algoritmo es una lista de instrucciones que serán desarrolladas en un orden específico con el objetivo de resolver un problema o realizar una operación. Por ejemplo, un algoritmo para encender el carro puede ser:\n",
        "\n",
        "1.\tAbrir la puerta.\n",
        "2.\tEntrar al carro y tomar asiento.\n",
        "3.\tInsertar la llave en el switch.\n",
        "4.\tGirar la llave en sentido horario y mantenerla hasta que el carro encienda.\n",
        "\n",
        "Los pasos anteriormente descritos tienen un orden lógico en el que son ejecutados, y para este algoritmo en particular, si intentamos realizar alguno de ellos en desorden no obtendríamos el resultado que queremos. Antes de girar la llave debemos haberla insertado. No podemos entrar al carro sin haber abierto la puerta.\n",
        "\n",
        "Generalmente, el buen diseño de un algoritmo se basa en responder las siguientes preguntas:\n",
        "\n",
        "* ¿Cuál es mi objetivo?\n",
        "* ¿Con qué información cuento para alcanzarlo? (datos de entrada)\n",
        "* ¿Que información voy a obtener al alcanzar mi objetivo? (datos de salida)\n",
        "* ¿Qué cálculos o procesos debo realizar?\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "25pCFXshFUU6"
      },
      "source": [
        "# Variables\n",
        "Un lenguaje de programación, sea cual sea, necesita poder tener acceso a y tener la capacidad de modificar información. Esto se logra por medio del uso de variables. Para utilizar una variable dentro de un programa, es necesario declararla primero. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RuLnxv_rFc3S"
      },
      "source": [
        "### Declaración de Variables\n",
        "Para declarar una variable, primero debemos darle un nombre cualquiera a la variable utilizando letras y números sin espacios, teniendo en cuenta que las mayúsculas importan. Luego de darle un nombre a la variable, se le asigna un valor por medio del operador “=”.  De esta forma, el programa puede separar un bloque de memoria para la variable y guardar en dicho bloque el valor de esta. A diferencia de otros lenguajes de programación, en Python 3 no se puede declarar una variable sin asignarle un valor. \n",
        "\n",
        "Existen varios tipos de variables, según el tipo de información con la que se desee trabajar dentro de un programa."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UdCeLc6SrSyX"
      },
      "source": [
        "\n",
        "### Numérica\n",
        "Las variables de tipo numérico se utilizan para almacenar números. En Python 3, estas pueden ser números enteros o números reales. Los números enteros en Python 3 se denominan int. No necesitan nomenclatura adicional a la hora de ser declarados. Los números reales en Python 3 se denominan float. Para declarar un float, basta con incluir un punto como separador de decimales. Si tenemos una cantidad entera que queremos representar como un float, debemos de incluir el separador de decimales al final de la parte entera de la variable."
      ]
    },
    {
      "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",
        "\n",
        "\n",
        "# Ejecute estas instrucciones y observe el resultado obtenido\n",
        "miVariableEntera = 1\n",
        "miVariableReal = 2.0\n",
        "producto = 4.3 * -2.0\n",
        "\n",
        "print(\"miVariableEntera: \", miVariableEntera)\n",
        "print(\"miVariableReal: \",miVariableReal)\n",
        "print(\"producto: \", producto)\n",
        "print(\"La suma entre dos variables: \", miVariableEntera + miVariableReal)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "33sjTORJrSyX"
      },
      "source": [
        "### String\n",
        "Las variables de tipo string se utilizan para almacenar texto, o cadenas de caracteres. Una string es un caso muy particular de una lista; es una lista de caracteres de texto que **no puede ser modificada**. Para evitarse la tarea de tener que escribir cada carácter individualmente como lo haríamos normalmente para una lista, en los strings basta con escribir el texto que se desee almacenar entre comillas y asignarle una variable. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UbrMxonkrSyX"
      },
      "source": [
        "\n",
        "# Ejecute estas instrucciones y observe el resultado obtenido\n",
        "string1 = \"Hola\"\n",
        "stringDeNumeros = \"112341352573568\"\n",
        "print(string1)\n",
        "print(stringDeNumeros)\n",
        "print(\"Los dos strings combinados: \" + string1+stringDeNumeros)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "llqRnEierSyX"
      },
      "source": [
        "### Booleanas\n",
        "Son variables que almacenan un valor de <i>True</i> o <i>False</i>. Generalmente utilizadas para almacenar resultados de comparaciones.\n",
        "\n",
        "Nótese que ni <i>True</i> ni <i>False</i> se comportan como variables. Siempre que se escriban correctamente, el intérprete las toma como palabras claves propias de Python y nunca serán utilizadas como variables. En los dos ejemplos, tanto <i>True</i> como <i>False</i> no están escritos entre comillas y comienzan con una mayúscula. Esto es porque no son strings ni otras variables; son valores de verdad. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T4M-_d_xrSyX"
      },
      "source": [
        "# Ejecute estas instrucciones y observe el resultado obtenido\n",
        "x = True\n",
        "y = False\n",
        "print(\"x es: \", x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2SwisKuvrSyX"
      },
      "source": [
        "### Fechas\n",
        "Python 3 puede manejar fechas por medio del tipo de dato <i>date</i>. Se debe incluir la linea <i>import datetime</i> al comienzo del código para incluir las librerias necesarias para manejar las fechas. \n",
        "\n",
        "Para modificar una fecha, el tipo de dato <i>timedelta</i> se puede utilizar. Se pueden sumar días y semanas.\n"
      ]
    },
    {
      "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",
        "import datetime\n",
        "x = datetime.date(2008, 8, 13)\n",
        "print(x)\n",
        "\n",
        "y = x + datetime.timedelta(days = 3, weeks = 5)\n",
        "print(y)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d8ULHa9kGxvo"
      },
      "source": [
        "# Operadores Numéricos\n",
        "Los operadores matemáticos básicos que tiene Python 3 son:\n",
        "* \" = \" : El operador de asignación. Sirve para asignarle un valor a una variable.\n",
        "* \" + \" : Sirve para sumar dos números.\n",
        "* \" - \" : Sirve para restar dos números.\n",
        "* \" * \" : Sirve para multiplicar dos números.\n",
        "* \" / \" : Divide dos números. Retorna el resultado como un float.\n",
        "* \" // \" : División entera entre dos números. Retorna la parte entera del valor de una división como un int.\n",
        "* \" % \" : Calcula el residuo de una división."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wkLPn7YQrSyn"
      },
      "source": [
        "# %%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",
        "Hay muchas formas de manipular cadenas de caracteres en Python 3. Sin embargo, de momento nos enfocaremos en dos:\n",
        "\n",
        "* \" + \": El operador de **concatenar**. Sirve para unir dos cadenas de caracteres diferentes.\n",
        "* \" * \": El operador de **repetición**. Sirve para repetir una cadena de caracteres N cantidad de veces.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Iam42BSPrSyn"
      },
      "source": [
        "# Ejecute estas instrucciones y observe el resultado obtenido\n",
        "\n",
        "string1 = \"Hola\"\n",
        "string2 = \"Mundo\"\n",
        "string3 = string1+string2\n",
        "print(string3)\n",
        "\n",
        "string4 = string3*3\n",
        "print(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",
        "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",
        "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",
        "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",
        "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",
        "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",
        "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",
        "  # 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",
        "  '''Función para mostrar los datos contenidos en un objeto y su tipo'''\n",
        "  print(\"El valor del dato es %s y su tipo es %s.\" %( a, type(a)))\n",
        "\n",
        "datos = [None, [], 0, \"0\", 0.0]\n",
        "\n",
        "# ciclo for que invoca una función y la aplica a los element\n",
        "for i in datos:\n",
        "  tipoDato(i)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3sIF_KrYgXId"
      },
      "source": [
        "# Listas\n",
        "\n",
        "Las listas son un tipo de variable utilizado para representar estructuras y datos complejos. Una lista es un conjunto de varios objetos en un orden particular. En cada posición de la lista se puede almacenar una variable, la cual puede ser cualquier cosa. Vale aclarar que una lista puede estar vacía (no contener nada en ninguna posición).\n",
        "\n",
        "Para crear una lista se escriben los elementos, separados por comas, entre brackets de la siguiente manera:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ixE6PMU9gXId"
      },
      "source": [
        "# Ejecute estas instrucciones y observe el resultado obtenido\n",
        "listaLetras = [\"a\",\"b\",\"c\"]\n",
        "listaNumeros = [3.0, 3.1, 4.4]\n",
        "listaMixta = [\"Brasil\", \"Alemania\", 7, 1]\n",
        "\n",
        "print(listaLetras)\n",
        "print(listaNumeros)\n",
        "print(listaMixta)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-cYgYPeIgXIt"
      },
      "source": [
        "## Acceder a los elementos de una lista\n",
        "Se puede acceder a los elementos individuales de una lista para utilizarlos o actualizarlos durante la ejecución del programa. Como las listas tienen un orden, cada posición dentro de una lista tiene un numero asociado a ella: <b>la primera posición es considerada como la posición [0]</b>, y de ahí en adelante aumentan de uno en uno.\n",
        "Siguiendo este razonamiento, si la lista tiene n elementos, <b>la ubicacion del último elemento es [n-1].</b>\n",
        "\n",
        "Para recuperar el tercer elemento de listaMixta,  se podría utilizar la siguiente notación:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IEO76DN0gXIt"
      },
      "source": [
        "# Ejecute estas instrucciones y observe el resultado obtenido\n",
        "print(listaMixta[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",
        "print(listaMixta[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 son las variables de tipo string. Un string es una cadena de caracteres, la cual fácilmente se podría representar como una lista. La principal diferencia entre una lista que tiene caracteres en cada posición y un string es que la lista puede ser modificada. Es decir, se puede cambiar el contenido de cada posición dentro de una lista, mientras que para un string es necesario asignarle un valor completamente nuevo a la variable. Exceptuando esto, los strings y las listas se manejan (básicamente) de  la misma forma en Python."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K4UkXNSrHsbc"
      },
      "source": [
        "nombre = \"Luisa Fernanda\"\n",
        "\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",
        "tuplaLetras = (\"a\",\"b\",\"c\")\n",
        "tuplaNumeros = (3.0, 3.1, 4.4)\n",
        "tuplaMixta = (\"Brasil\", \"Alemania\", 7, 1)\n",
        "\n",
        "print(tuplaLetras)\n",
        "print(tuplaLetras [2])\n",
        "print(tuplaNumeros)\n",
        "print(tuplaNumeros [0])\n",
        "print(tuplaMixta)\n",
        "print(tuplaMixta [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",
        "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",
        "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",
        "listaEstudiantes = [estudiante0, estudiante1, estudiante2]\n",
        "print (listaEstudiantes)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8BwMDE9OgXI8"
      },
      "source": [
        "# Ejecute estas instrucciones y observe el resultado obtenido\n",
        "\n",
        "print(listaEstudiantes[1])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ux6278IDgXI8"
      },
      "source": [
        "Sin embargo, esto genera una lista diferente; particularmente, produce una lista con los datos de estudiante2. Si se quiere obtener el nombre, se requiere utilizar la misma notación en conjunto con la primera:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UxVqf-B4gXI8"
      },
      "source": [
        "# Ejecute estas instrucciones y observe el resultado obtenido\n",
        "print(listaEstudiantes[1][0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AeDvUQrxgXJM"
      },
      "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.\n",
        "\n",
        "# Diccionarios\n",
        "\n",
        "Hasta ahora, se ha visto cómo las listas utilizan una notación con números para indicar la posición de un elemento dentro de ellas. Sin embargo, a veces tiene más sentido utilizar nombres para diferenciar los diferentes elementos que se encontrarían dentro de una lista. Siguiendo con el ejemplo de estudiantes, tendría mucho más sentido hablar de que un estudiante tiene “Nombre, Examen1, Examen2 y Examen3\" a que esos cuatro pedazos de información estén almacenados en una lista e identificados con números.\n",
        "\n",
        "Los diccionarios permiten hacer exactamente eso: crear una lista donde cada elemento tiene su posición identificada no por un orden numérico, sino por palabras. La declaración es similar a la de una lista pero se utilizan corchetes {}:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k-PPZvI9gXJM"
      },
      "source": [
        "# Ejecute estas instrucciones y observe el resultado obtenido\n",
        "diccionario = {\"unElemento\":3, \"otroElemento\":\"Hola!\"} \n",
        "print(diccionario)\n",
        "\n",
        "# Accedemos a \"otroElemento\":\n",
        "print(\"Imprimiendo otroElemento: \", diccionario[\"otroElemento\"])"
      ],
      "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 duplicados.\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": [
        "# los set se crean usando {}\n",
        "cosas = {\"cepillo\", \"cama\", \"crema\"}\n",
        "\n",
        "print(type(cosas))\n",
        "\n",
        "print(cosas)\n",
        "\n",
        "canasta = ['manzana', 'naranja', 'manzana', 'pera', 'naranja', 'banano']\n",
        "\n",
        "print (canasta)\n",
        "\n",
        "# los conjuntos también se pueden crear con la función set()\n",
        "canasta2 = set(canasta)\n",
        "\n",
        "print(type(canasta2))\n",
        "print(canasta2)\n",
        "\n",
        "\n",
        "# Ejemplos de operaciones entre conjuntos\n",
        "\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",
        "# interseccion\n",
        "ambos = a&b\n",
        "print(\"Los elementos comunes entre a y b son: \", ambos)\n",
        "\n",
        "# union\n",
        "union = a|b\n",
        "print(\"El resultado de unir a y b es: \", union)\n",
        "\n",
        "# diferencia\n",
        "dif= a-b\n",
        "print(\"La diferencia entre a y b es: \", dif)\n",
        "\n",
        "# diferencia simétrica\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",
        "Finalmente, un concepto algo abstracto. Imagine que tienen una tabla, como la lista de estudiantes descrita anteriormente. Ahora, imagine que tiene varias de esas tablas, como si fuera una por materia. Finalmente, imagine que necesita tener una lista con todas esas tablas. Esta lista es lo que se conoce como un vector de orden 3.\n",
        "\n",
        "Los vectores son en esencia, listas de listas de listas de listas… y se accede a cada uno de sus elementos de la misma forma que se enunció para las tablas, sólo que con un bracket por cada nivel. Debe de recordar que a cada nivel, estará obteniendo una lista y no un elemento en particular. Las listas son el caso particular de un vector de dimensión 1, y las tablas y matrices el de un vector de dimensión 2.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WgW7sawigXJM"
      },
      "source": [
        "# Ejecute estas instrucciones y observe el resultado obtenido\n",
        "vector = [listaEstudiantes, diccionario]\n",
        "\n",
        "print(\"El vector completo:\\n\", vector)\n",
        "print(\"\\n\")\n",
        "print(\"El segundo elemento del primer indice del vector:\\n\", vector[0][1])\n",
        "print(\"\\n\")\n",
        "print(\"Un elemento particular del diccionario utilizado.\\n\", vector[1][\"unElemento\"])"
      ],
      "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",
        "print(listaNumeros)\n",
        "listaNumeros[1] = -99\n",
        "print(listaNumeros)"
      ],
      "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",
        "lista1 = [1, 3, 5]\n",
        "lista2 = [2, 4, 6]\n",
        "lista3 = lista1 + lista2\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",
        "print(\"Antes: \", lista1)\n",
        "lista1 = lista1 + [7]\n",
        "print(\"Después: \", lista1)\n"
      ],
      "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",
        "print(\"Antes: \", diccionario)\n",
        "diccionario[\"nuevoIndice\"] = \"Nuevo Elemento\"\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",
        "# Se quiere eliminar el tercer elemento, aquel en el indice 2\n",
        "print(\"Antes: \", lista1)\n",
        "lista1[2:3] = []\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",
        "lista1 = [\"Fátima\", \"Lourdes\", 66, 45.8, True, [0, 1, 2, 3, 4], {\"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",
        "lista2 = lista1\n",
        "lista2[1] = 0\n",
        "print(\"Esto es lista1: \",lista1)\n",
        "print(f\"Esto es lista2: {lista2}\")\n",
        "\n",
        "lista1[6] = \"Cambio lo que yo quiera\"\n",
        "print(\"Ahora esto es lista1: \",lista1)\n",
        "print(f\"Ahora esto es lista2: {lista2}\")\n",
        "\n",
        "lista1.append(\"Agregué un elemento\")\n",
        "print(\"Esto es lista1 extendida: \",lista1)\n",
        "print(f\"Esto es lista2 extendida: {lista2}\")"
      ],
      "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",
        "lista3 = [\"Fátima\", \"Lourdes\", 66, 45.8, True, [0, 1, 2, 3, 4], {\"departamento\": \"Antioquia\", \"municipio\": \"Urrao\"}]\n",
        "\n",
        "\n",
        "# la siguiente instrucción crea una lista con el mismo contenido que la original, pero independiente de esta.\n",
        "# no crea una lista independiente\n",
        "lista4 = lista3.copy()\n",
        "lista4[1] = 0\n",
        "print(\"Esto es lista3: \",lista3)\n",
        "print(f\"Esto es lista4: {lista4}\")\n",
        "\n",
        "lista3[6] = \"Cambio lo que yo quiera\"\n",
        "print(\"Ahora esto es lista3: \",lista3)\n",
        "print(f\"Ahora esto es lista4: {lista4}\")"
      ],
      "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",
        "listaNueva = [\"Disponible\"]*10\n",
        "# Imprimimos las posiciones 2, 3 y 4 de la lista.\n",
        "print(listaNueva[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": [
        "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": [
        "# inicializar 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\n",
        "# con método append\n",
        "listaW.append(8)\n",
        "print(\"listaW modificada con append: \", listaW)\n",
        "\n",
        "# con asignación\n",
        "listaW[len(listaW):]=[9]\n",
        "print(\"listaW modificada con asignación: \", listaW)\n"
      ],
      "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": [
        "dicEjemplo ={\"tipo mascota\": \"gato\", \"nacimiento\": 2020, \"género\": \"femenino\", \"origen\": \"adoptada\", \"vacunas\": {\"Rinotraqueitis\":[\"Sí\", \"15 de octubre de 2021\"], \"Calicivirus\": \"No\", \"Rabia\":\"No\"} }\n",
        "print(dicEjemplo)\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": [
        "# inicializar una tupla\n",
        "tuplaNueva=(\"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": [
        "setNuevo={\"a\",\"b\",\"c\",\"d\"}"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}