MOD3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Fundamentos de Programación en Python: Módulo 3**\n",
    "\n",
    "En este módulo, aprenderás sobre:\n",
    "\n",
    "Valores booleanos.\n",
    "Instrucciones if-elif-else.\n",
    "Bucles while y for.\n",
    "Control de flujo.\n",
    "Operaciones lógicas y bit a bit.\n",
    "Listas y arreglos.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Preguntas y respuestas***\n",
    "\n",
    "Un programador escribe un programa y el programa hace preguntas.\n",
    "\n",
    "Una computadora ejecuta el programa y proporciona las respuestas. El programa debe ser capaz de reaccionar de acuerdo con las respuestas recibidas.\n",
    "\n",
    "Afortunadamente, las computadoras solo conocen dos tipos de respuestas:\n",
    "\n",
    "- Si, es cierto.\n",
    "- No, esto es falso."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "#ejm:  ¿Son dos valores iguales?\n",
    "#R//: Para hacer esta pregunta, se utiliza el == Operador (igual igual). Este operador compara los valores de dos operandos (variables,números,...)\n",
    "#2 == 2  #compara 2 y 2\n",
    "#2 == 2.\n",
    "#2 == 1\n",
    "\n",
    "var = 0 # asignando 0 a var\n",
    "print(var == 0)\n",
    "\n",
    "var = 1 # asignando 1 a var\n",
    "print(var == 0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#El operador != (no es igual a) también compara los valores de dos operandos. \n",
    "#Aquí está la diferencia: si son iguales, el resultado de la comparación es False. Si no son iguales, el resultado de la comparación es True.\n",
    "var = 0 # asignando 0 a var\n",
    "print(var != 0)\n",
    "\n",
    "var = 1 # asignando 1 a var\n",
    "print(var != 0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "could not convert string to float: ''",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32mc:\\Users\\USUARIO\\Documents\\Rutas de formación en programación\\Python\\Cisco\\MOD3.ipynb Celda 5\u001b[0m in \u001b[0;36m<cell line: 7>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/USUARIO/Documents/Rutas%20de%20formaci%C3%B3n%20en%20programaci%C3%B3n/Python/Cisco/MOD3.ipynb#W4sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m \u001b[39m#También se puede hacer una pregunta de comparación con los operadores: > (mayor que), < (menor que), >= (mayor o igual que) y <= (menor o igual que):\u001b[39;00m\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/USUARIO/Documents/Rutas%20de%20formaci%C3%B3n%20en%20programaci%C3%B3n/Python/Cisco/MOD3.ipynb#W4sZmlsZQ%3D%3D?line=2'>3</a>\u001b[0m \u001b[39m\"\"\" print(1 <= 3)\u001b[39;00m\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/USUARIO/Documents/Rutas%20de%20formaci%C3%B3n%20en%20programaci%C3%B3n/Python/Cisco/MOD3.ipynb#W4sZmlsZQ%3D%3D?line=3'>4</a>\u001b[0m \u001b[39ma = 6.\u001b[39;00m\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/USUARIO/Documents/Rutas%20de%20formaci%C3%B3n%20en%20programaci%C3%B3n/Python/Cisco/MOD3.ipynb#W4sZmlsZQ%3D%3D?line=4'>5</a>\u001b[0m \u001b[39mprint(a<5)\u001b[39;00m\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/USUARIO/Documents/Rutas%20de%20formaci%C3%B3n%20en%20programaci%C3%B3n/Python/Cisco/MOD3.ipynb#W4sZmlsZQ%3D%3D?line=5'>6</a>\u001b[0m \u001b[39mprint(2>3) \"\"\"\u001b[39;00m\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Users/USUARIO/Documents/Rutas%20de%20formaci%C3%B3n%20en%20programaci%C3%B3n/Python/Cisco/MOD3.ipynb#W4sZmlsZQ%3D%3D?line=6'>7</a>\u001b[0m n \u001b[39m=\u001b[39m \u001b[39mfloat\u001b[39;49m(\u001b[39minput\u001b[39;49m(\u001b[39m'\u001b[39;49m\u001b[39mEscribe un número:\u001b[39;49m\u001b[39m'\u001b[39;49m))\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/USUARIO/Documents/Rutas%20de%20formaci%C3%B3n%20en%20programaci%C3%B3n/Python/Cisco/MOD3.ipynb#W4sZmlsZQ%3D%3D?line=7'>8</a>\u001b[0m \u001b[39mprint\u001b[39m(n\u001b[39m>\u001b[39m\u001b[39m100\u001b[39m)\n",
      "\u001b[1;31mValueError\u001b[0m: could not convert string to float: ''"
     ]
    }
   ],
   "source": [
    "#También se puede hacer una pregunta de comparación con los operadores: > (mayor que), < (menor que), >= (mayor o igual que) y <= (menor o igual que):\n",
    "\n",
    "\"\"\" print(1 <= 3)\n",
    "a = 6.\n",
    "print(a<5)\n",
    "print(2>3) \"\"\"\n",
    "n = float(input('Escribe un número:'))\n",
    "print(n>100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los operadores de comparación (o también denominados relacionales) se utilizan para comparar valores."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**prioridad y enlace de las operaciones (actualizado con los operadores de comparación)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\" \n",
    "Prioridad\tOperador\n",
    "0\t           ()      #\n",
    "1\t          +, -\t   unario\n",
    "2\t           **\t\n",
    "3\t        *, /, %\t\n",
    "4\t          +, -\t   binario \n",
    "5\t      <, <=, >, >=\t\n",
    "6\t         ==, !=\n",
    "\"\"\"\n",
    "#De acuerdo con las reglas aritméticas, las sub-expresiones dentro de los paréntesis siempre se calculan primero.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Condiciones y ejecución condicional**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***declaración condicional if***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "bat"
    }
   },
   "outputs": [],
   "source": [
    "\"\"\" Si (if) el clima es bueno, saldremos a caminar.\n",
    "\n",
    "if ClimaEsBueno:\n",
    "    irAcaminar() \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Si la expresión (una pregunta o una respuesta) representa la verdad (es decir, su valor no es igual a cero o es \"True\"),la(s) declaración(es) con sangría se ejecutará.\n",
    "- Si la expresión (una pregunta o una respuesta) no representa la verdad (es decir, su valor es igual a cero o es \"False\"), las declaraciones con sangría se omitirá , y la siguiente instrucción ejecutada será la siguiente al nivel de la sangría original."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "bat"
    }
   },
   "outputs": [],
   "source": [
    "\"\"\" Si (if) el clima es bueno, saldremos a caminar después, almorzaremos: \"\"\"\n",
    "\n",
    "if ClimaEsBueno: ---> evalúa una expresión de prueba (condición)\n",
    "    irAcaminar() --> se ejecuta si la expresión de prueba es Verdadera. \n",
    "almorzar() --> Almorzar no es una actividad condicional y no depende del clima, se ejecutara en cualquier caso."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Declaración condicional if-else***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python también nos permite expresar un plan alternativo si no se cumplen las condiciones. Podemos decir, por ejemplo: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "bat"
    }
   },
   "outputs": [],
   "source": [
    "\"\"\"Si el clima es bueno, saldremos a caminar, de lo contrario, iremos al cine.\"\"\"\n",
    "\n",
    "if condición_true_or_false:\n",
    "    ejecuta_si_condición_true\n",
    "else: \n",
    "    ejecuta_si_condición_false "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Si la condición se evalúa como Verdadero (su valor no es igual a cero), la instrucción ejecuta_si_condición_true se ejecuta, y la declaración condicional llega a su fin.\n",
    "- Si la condición se evalúa como Falso (es igual a cero), la instrucción ejecuta_si_condición_false se ejecuta, y la declaración condicional llega a su fin."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "bat"
    }
   },
   "outputs": [],
   "source": [
    "\"\"\"Si el clima es bueno, saldremos a caminar. De lo contrario, iremos al cine. \n",
    "\"\"\"No importa si el clima es bueno o malo, almorzaremos después (después de la caminata o después de ir al cine).\"\"\"\n",
    "\n",
    "if climaEsBueno:\n",
    "    irACaminar()\n",
    "else:\n",
    "    irAlCine()\n",
    "almorzar()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Declaraciones if-else anidadas***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "bat"
    }
   },
   "outputs": [],
   "source": [
    "\"\"\"Si hay buen clima, saldremos a caminar. Si encontramos un buen restaurante, almorzaremos allí. De lo contrario, vamos a comer un sandwich. \n",
    "\"\"\"Si hay mal clima, iremos al cine. Si no hay boletos, iremos de compras al centro comercial más cercano.\n",
    "\n",
    "if climaEsBueno:\n",
    "    irACaminar()\n",
    "    if encontramosBuenRestaurante:\n",
    "        almorzar()\n",
    "    else:\n",
    "        comerSandwich() \n",
    "else:\n",
    "    if hayBoletosDisponibles:\n",
    "        irAlCine()\n",
    "    else:\n",
    "        irDeCompras() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Declaración elif***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es una forma más corta de else-if. \n",
    "\n",
    "elif se usa para verificar más de una condición, y para detener cuando se encuentra la primera declaración verdadera."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "bat"
    }
   },
   "outputs": [],
   "source": [
    "\"si hay buen clima, saldremos a caminar, \n",
    "\"de lo contrario, si obtenemos entradas, iremos al cine, \n",
    "\"de lo contrario, si hay mesas libres en el restaurante, vamos a almorzar; \n",
    "\"si todo falla, regresaremos a casa y jugaremos ajedrez.\n",
    "\n",
    "if climaBueno:\n",
    "    iraCaminar()\n",
    "elif hayBoletosDisponibles:\n",
    "    IralCine()\n",
    "elif mesasLibres:\n",
    "    almorzar()\n",
    "else:\n",
    "    jugarAjedrezEnCasa() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La forma de ensamblar las siguientes declaraciones if-elif-else a veces se denomina cascada.\n",
    "\n",
    "Se debe prestar atención adicional a este caso:\n",
    "\n",
    "No debes usar else sin un if precedente.\n",
    "Else siempre es la última rama de la cascada , independientemente de si has usado elif o no.\n",
    "Else es una parte opcional de la cascada, y puede omitirse.\n",
    "Si hay una rama else en la cascada, solo se ejecuta una de todas las ramas.\n",
    "Si no hay una rama else, es posible que no se ejecute ninguna de las opciones disponibles.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El número más grande es: 8\n"
     ]
    }
   ],
   "source": [
    "#lee dos números\n",
    "numero1 = int (input(\"Ingresa el primer número:\"))\n",
    "numero2 = int (input(\"Ingresa el segundo número:\"))\n",
    "\n",
    "#elegir el número más grande\n",
    "if numero1> numero2:\n",
    "    nmasGrande = numero1\n",
    "else:\n",
    "    nmasGrande = numero2\n",
    "\n",
    "#imprimir el resultado\n",
    "print(\"El número más grande es:\", nmasGrande)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nota: si alguna de las ramas de if-elif-else contiene una sola instrucción, puedes codificarla de forma más completa (no es necesario que aparezca una línea con sangría después de la palabra clave):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El número más grande es:  8\n"
     ]
    }
   ],
   "source": [
    "#lee dos números\n",
    "numero1 = int(input(\"Ingresa el primer número:\"))\n",
    "numero2 = int(input(\"Ingresa el segundo número:\"))\n",
    "\n",
    "# elegir el número más grande\n",
    "if numero1 > numero2: nmasGrande = numero1\n",
    "else: nmasGrande = numero2\n",
    "\n",
    "#imprimir el resultado\n",
    "print(\"El número más grande es: \", nmasGrande)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El número más grande es: 5\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "#elegir el número más grande\n",
    "#lee tres números\n",
    "numero1 = int (input(\"Ingresa el primer número:\"))\n",
    "numero2 = int (input(\"Ingresa el segundo número:\"))\n",
    "numero3 = int (input(\"Ingresa el tercer número:\"))\n",
    "\n",
    "#asumimos temporalmente que el primer número\n",
    "#es el más grande\n",
    "#lo verificaremos pronto\n",
    "nmasGrande = numero1\n",
    "\n",
    "#comprobamos si el segundo número es más grande que el mayor número actual\n",
    "#y actualiza el número más grande si es necesario\n",
    "if numero2 > nmasGrande:\n",
    "    nmasGrande = numero2\n",
    "\n",
    "#comprobamos si el tercer número es más grande que el mayor número actual\n",
    "#y actualiza el número más grande si es necesario\n",
    "if numero3 > nmasGrande:\n",
    "    nmasGrande = numero3\n",
    "\n",
    "#imprimir el resultado\n",
    "print(\"El número más grande es:\", nmasGrande)\n",
    "\n",
    "#Nota:cada declaración if se prueba por separado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# lee tres números\n",
    "numero1 = int(input(\"Ingresa el primer número:\"))\n",
    "numero2 = int(input(\"Ingresa el segundo número:\"))\n",
    "numero3 = int(input(\"Ingresa el tercer número:\"))\n",
    "\n",
    "# verifica cuál de los números es el mayor\n",
    "# y pásalo a la variable de mayor número\n",
    "\n",
    "numeroMayor = max(numero1,numero2,numero3) #esta es una función incorporada de python. \n",
    "\n",
    "# imprimir el resultado\n",
    "print(\"El número más grande es:\", numeroMayor) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "planta = str(input('introduce el nombre de tu planta:'))\n",
    "\n",
    "if planta == 'Espatifilo':\n",
    "    print(\"Si, ¡El Espatifilo es la mejor planta de todos los tiempos!\")\n",
    "elif planta == 'espatifilo':\n",
    "    print(\"No, ¡quiero un gran Espatifilo!\")\n",
    "else:\n",
    "    print(\"¡Espatifilo! ¡No [planta]!\")\n",
    "\n",
    "#=\n",
    "\"\"\" if planta == 'Espatifilo':\n",
    "    print(\"Si, ¡El Espatifilo es la mejor planta de todos los tiempos!\")\n",
    "else:\n",
    "    if planta == 'espatifilo':\n",
    "      print(\"No, ¡quiero un gran Espatifilo!\")\n",
    "    else:\n",
    "      print(\"¡Espatifilo! ¡No [planta]!\") \"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuatro\n",
      "cinco\n"
     ]
    }
   ],
   "source": [
    "#declaraciones condicionales en cascada anidadas:\n",
    "x = \"1\"\n",
    "\n",
    "if x == 1:\n",
    "    print(\"uno\")\n",
    "elif x == \"1\":\n",
    "    if int (x)> 1:\n",
    "        print(\"dos\")\n",
    "    elif int (x) < 1:\n",
    "        print(\"tres\")\n",
    "    else:\n",
    "        print(\"cuatro\")\n",
    "if int (x) == 1:\n",
    "    print(\"cinco\")\n",
    "else:\n",
    "    print(\"seis\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "#calculadora de impuestos.\n",
    "ingreso=float(input(\"Ingrese el ingreso anual:\"))\n",
    "exencionfiscal= 556 + (2/100)\n",
    "if ingreso <= 85528:\n",
    "    impuesto = 0.18*ingreso - exencionfiscal\n",
    "else:\n",
    "    impuesto = 14839+(2/100)+(0.32*(ingreso-85528))\n",
    "\n",
    "impuesto=round(impuesto, 0)\n",
    "if impuesto <= 0:\n",
    "   impuesto = 0.0\n",
    "    \n",
    "print(\"El impuesto es: \", impuesto, \"pesos\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "este es un: Año común\n"
     ]
    }
   ],
   "source": [
    "\n",
    "#determinar si un año es común o bisiesto:\n",
    "año = int(input(\"Introduzca un año:\"))\n",
    "\n",
    "if año%4 != 0: año = 'Año común'\n",
    "elif año%100 !=0: año = 'Año bisiesto'\n",
    "elif año%100 !=0: año = 'Año común'\n",
    "else:\n",
    "    año = 'Año bisiesto'\n",
    "\n",
    "print('este es un: '+ año)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ciclos o bucles en el código con while**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "bat"
    }
   },
   "outputs": [],
   "source": [
    "while expresión_condicional:\n",
    "    instrucción"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si se observan algunas similitudes con la instrucción if, está bien. De hecho, la diferencia sintáctica es solo una: usa la palabra while en lugar de la palabra if.\n",
    "\n",
    "La diferencia semántica es más importante: cuando se cumple la condición, if realiza sus declaraciones sólo una vez; while repite la ejecución siempre que la condición se evalúe como True."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "es importante tener en cuenta que:\n",
    "\n",
    "- Si deseas ejecutar más de una declaración dentro de un while, debes (como con if) poner sangría a todas las instrucciones de la misma manera.\n",
    "- Una instrucción o conjunto de instrucciones ejecutadas dentro del while se llama el cuerpo del ciclo.\n",
    "- Si la condición es False (igual a cero) tan pronto como se compruebe por primera vez, el cuerpo no se ejecuta ni una sola vez.\n",
    "- El cuerpo debe poder cambiar el valor de la condición, porque si la condición es True al principio, el cuerpo podría funcionar continuamente hasta el infinito. Observa que hacer una cosa generalmente disminuye la cantidad de cosas por hacer.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "bat"
    }
   },
   "outputs": [],
   "source": [
    "while expresión_condicional:\n",
    "    instrucción_uno\n",
    "    instruccion_dos\n",
    "    instrucción_tres\n",
    "    :\n",
    "    :\n",
    "    instrucción_n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Un bucle o ciclo infinito***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un ciclo infinito, también denominado ciclo sin fin, es una secuencia de instrucciones en un programa que se repite indefinidamente (ciclo sin fin).\n",
    "\n",
    "Este es un ejemplo de un ciclo que no puede finalizar su ejecución:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "while True:\n",
    "    print(\"Estoy atrapado dentro de un ciclo\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este ciclo imprimirá infinitamente \"Estoy atrapado dentro de un ciclo\". En la pantalla. Para finalizar tu programa, simplemente se presiona Ctrl-C (o Ctrl-Break en algunas computadoras). Esto provocará la excepción KeyboardInterrupt y permitirá que el programa salga del ciclo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El número más grande es: 8\n"
     ]
    }
   ],
   "source": [
    "# Almacenaremos el número más grande actual aquí\n",
    "numero_Mayor = -999999999\n",
    "\n",
    "# Ingresa el primer valor\n",
    "numero = int(input (\"Introduzca un número o escriba -1 para detener:\"))\n",
    "\n",
    "# Si el número no es igual a -1, continuaremos\n",
    "while numero != -1:\n",
    "    # ¿Es el número más grande que el número más grande?\n",
    "    if numero > numero_Mayor:\n",
    "        # Sí si, actualiza el mayor númeroNúmero\n",
    "        numero_Mayor = numero\n",
    "    # Ingresa el siguiente número\n",
    "    numero = int (input(\"Introduce un número o escribe -1 para detener:\"))\n",
    "\n",
    "# Imprimir el número más grande\n",
    "print(\"El número más grande es:\", numero_Mayor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Números impares:  3\n",
      "Números pares:  3\n"
     ]
    }
   ],
   "source": [
    "# programa que lee una secuencia de números\n",
    "# y cuenta cuántos números son pares y cuántos son impares\n",
    "# programa termina cuando se ingresa cero\n",
    "\n",
    "numerosImpares = 0\n",
    "numerosPares = 0\n",
    "\n",
    "# lee el primer número\n",
    "numero = int (input (\"Introduce un número o escriba 0 para detener:\"))\n",
    "\n",
    "# 0 termina la ejecución\n",
    "while numero != 0:  #= while numero:\n",
    "    # verificar si el número es impar\n",
    "    if numero % 2 == 1:   #= if numero % 2:\n",
    "        # aumentar el contador de números impares\n",
    "        numerosImpares += 1\n",
    "    else:\n",
    "        # aumentar el contador de números pares\n",
    "        numerosPares += 1\n",
    "    # lee el siguiente número\n",
    "    numero = int (input (\"Introduce un número o escriba 0 para detener:\"))\n",
    "\n",
    "# imprimir resultados\n",
    "print(\"Números impares: \", numerosImpares)\n",
    "print(\"Números pares: \", numerosPares)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dentro del ciclo:  5\n",
      "Dentro del ciclo:  4\n",
      "Dentro del ciclo:  3\n",
      "Dentro del ciclo:  2\n",
      "Dentro del ciclo:  1\n",
      "Fuera del ciclo 0\n"
     ]
    }
   ],
   "source": [
    "contador = 5\n",
    "while contador: \n",
    "    print(\"Dentro del ciclo: \", contador)\n",
    "    contador -= 1\n",
    "print(\"Fuera del ciclo\", contador)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "+==================================+\n",
      "| Bienvenido a mi juego, muggle!   |\n",
      "| Introduce un número entero       |\n",
      "| y adivina qué número he          |\n",
      "| elegido para ti.                 |\n",
      "| Entonces,                        |\n",
      "| ¿Cuál es el número secreto?      |\n",
      "+==================================+\n",
      "\n",
      "¡Ja, ja! ¡Estás atrapado en mi ciclo!\n",
      "¡Ja, ja! ¡Estás atrapado en mi ciclo!\n",
      "¡Bien hecho, muggle! Eres libre ahora\n"
     ]
    }
   ],
   "source": [
    "numeroSecreto = 777\n",
    "\n",
    "print(\n",
    "\"\"\"\n",
    "+==================================+\n",
    "| Bienvenido a mi juego, muggle!   |\n",
    "| Introduce un número entero       |\n",
    "| y adivina qué número he          |\n",
    "| elegido para ti.                 |\n",
    "| Entonces,                        |\n",
    "| ¿Cuál es el número secreto?      |\n",
    "+==================================+\n",
    "\"\"\")\n",
    "\n",
    "numeroUsuario = int(input('Ingrese un número entero:'))\n",
    "while numeroUsuario != numeroSecreto:\n",
    "    print(\"¡Ja, ja! ¡Estás atrapado en mi ciclo!\")\n",
    "    numeroUsuario = int(input('Ingrese un número entero:'))\n",
    "\n",
    "print(\"¡Bien hecho, muggle! Eres libre ahora\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ciclos(bucles) en el código con for**\n",
    "\n",
    "Imagina que el cuerpo de un ciclo debe ejecutarse exactamente cien veces. Si deseas utilizar el ciclo while para hacerlo, puede tener este aspecto:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 0\n",
    "while i < 100:\n",
    "    # hacer_algo()\n",
    "    i += 1 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El ciclo for proviene de la observación de que a veces es más importante contar los \"giros o vueltas\" del ciclo que verificar las condiciones.\n",
    "Utilicemos este tipo de ciclo para llevar a cabo la misma tarea:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range (100): #esta es una función incorporada de python. \n",
    "    #hacer algo()\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hay algunos elementos nuevos;\n",
    "\n",
    "- La palabra reservada for abre el ciclo for; nota - No hay condición después de eso; no tienes que pensar en las condiciones, ya que se verifican internamente, sin ninguna intervención.\n",
    "- Cualquier variable después de la palabra reservada for es la variable de control del ciclo; cuenta los giros del ciclo y lo hace automáticamente.\n",
    "- La palabra reservada in introduce un elemento de sintaxis que describe el rango de valores posibles que se asignan a la variable de control.\n",
    "- La función range() (esta es una función muy especial) es responsable de generar todos los valores deseados de la variable de control; en nuestro ejemplo, la función creará (incluso podemos decir que alimentará el ciclo con) valores subsiguientes del siguiente conjunto: 0, 1, 2 .. 97, 98, 99; nota: en este caso, la función range() comienza su trabajo desde 0 y lo finaliza un paso (un número entero) antes del valor de su argumento.\n",
    "- La palabra clave pass dentro del cuerpo del ciclo - no hace nada en absoluto; es una instrucción vacía : la colocamos aquí porque la sintaxis del ciclo for exige al menos una instrucción dentro del cuerpo (por cierto, if, elif, else y while expresan lo mismo)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El valor de i es actualmente 0\n",
      "El valor de i es actualmente 1\n",
      "El valor de i es actualmente 2\n",
      "El valor de i es actualmente 3\n",
      "El valor de i es actualmente 4\n",
      "El valor de i es actualmente 5\n",
      "El valor de i es actualmente 6\n",
      "El valor de i es actualmente 7\n",
      "El valor de i es actualmente 8\n",
      "El valor de i es actualmente 9\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    print(\"El valor de i es actualmente\", i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El valor de i es actualmente 2\n",
      "El valor de i es actualmente 3\n",
      "El valor de i es actualmente 4\n",
      "El valor de i es actualmente 5\n",
      "El valor de i es actualmente 6\n",
      "El valor de i es actualmente 7\n"
     ]
    }
   ],
   "source": [
    "#La invocación de la función range() puede estar equipada con dos argumentos, no solo uno:\n",
    "\n",
    "for i in range (2, 8):\n",
    "    print(\"El valor de i es actualmente\", i)\n",
    "\n",
    "#Nota: la función range() solo acepta enteros como argumentos y genera secuencias de enteros."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El valor de i es actualmente 2\n"
     ]
    }
   ],
   "source": [
    "for i in range(2, 5, 3): \n",
    "    print(\"El valor de i es actualmente\", i)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El tercer argumento indica el paso, que en realidad significa la diferencia entre cada número en la secuencia de números generados por la función. range(start, stop, step)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nota: el conjunto generado por range() debe ordenarse en un orden ascendente. No hay forma de forzar el range() para crear un conjunto en una forma diferente. Esto significa que el segundo argumento de range() debe ser mayor que el primero.\n",
    "Por lo tanto, tampoco habrá salida aquí:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(2, 1):\n",
    "    print (\"El valor de i es actualmente\", i) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 a la potencia de 0 es 1\n",
      "2 a la potencia de 1 es 2\n",
      "2 a la potencia de 2 es 4\n",
      "2 a la potencia de 3 es 8\n",
      "2 a la potencia de 4 es 16\n",
      "2 a la potencia de 5 es 32\n",
      "2 a la potencia de 6 es 64\n",
      "2 a la potencia de 7 es 128\n",
      "2 a la potencia de 8 es 256\n",
      "2 a la potencia de 9 es 512\n",
      "2 a la potencia de 10 es 1024\n",
      "2 a la potencia de 11 es 2048\n",
      "2 a la potencia de 12 es 4096\n",
      "2 a la potencia de 13 es 8192\n",
      "2 a la potencia de 14 es 16384\n",
      "2 a la potencia de 15 es 32768\n"
     ]
    }
   ],
   "source": [
    "#Escribir algunas las 16 primeras potencias de dos:\n",
    "\n",
    "pow = 1\n",
    "for exp in range(16):\n",
    "    print (\"2 a la potencia de\", exp, \"es\", pow)\n",
    "    pow *= 2 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time #hemos imprimido el módulo time\n",
    "\n",
    "    # Escribe un ciclo for que cuente hasta cinco.\n",
    "    # Cuerpo del ciclo: imprime el número de iteración del ciclo y la palabra \"Mississippi\".\n",
    "    # Cuerpo del ciclo - uso: time.sleep (1)\n",
    "for conteo in range(1,6,1):\n",
    "    print(conteo,\"Mississippi\")\n",
    "    time.sleep(1) #invovamos el método sleep()\n",
    "# Escribe una función de impresión con el mensaje final.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En conclusión:\n",
    "\n",
    "El ciclo for ejecuta un conjunto de sentencias muchas veces; se suele usar para iterar sobre una secuencia (por ejemplo, una lista, un diccionario, una tupla o un conjunto; pronto hablaremos de ello) u otros objetos que son iterables (por ejemplo, cadenas). Puedes usar el ciclo for para iterar sobre una secuencia de números usando la función incorporada range"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Las declaraciones break y continue***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hasta ahora, hemos tratado el cuerpo del ciclo como una secuencia indivisible e inseparable de instrucciones que se realizan completamente en cada giro del ciclo. Sin embargo, como desarrollador, podrías enfrentar las siguientes opciones:\n",
    "\n",
    "1. Parece que no es necesario continuar el ciclo en su totalidad; se debe abstener de seguir ejecutando el cuerpo del ciclo e ir más allá.\n",
    "2. Parece que necesitas comenzar el siguiente giro del ciclo sin completar la ejecución del turno actual.\n",
    "\n",
    "Python proporciona dos instrucciones especiales para la implementación de estas dos tareas. Estas dos instrucciones son:\n",
    "\n",
    "1. break: Sale del ciclo inmediatamente, e incondicionalmente termina la operación del ciclo; el programa comienza a ejecutar la instrucción más cercana después del cuerpo del ciclo.\n",
    "2. continue: Se comporta como si el programa hubiera llegado repentinamente al final del cuerpo; el siguiente turno se inicia y la expresión de condición se prueba de inmediato."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ambas palabras son palabras clave reservadas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La instrucción de ruptura:\n",
      "Dentro del ciclo. 1\n",
      "Dentro del ciclo. 2\n",
      "Fuera del ciclo.\n"
     ]
    }
   ],
   "source": [
    "# break - ejemplo\n",
    "\n",
    "print(\"La instrucción de ruptura:\")\n",
    "for i in range(1,6):\n",
    "    if i == 3:\n",
    "        break\n",
    "    print(\"Dentro del ciclo.\", i)\n",
    "print(\"Fuera del ciclo.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La instrucción continue:\n",
      "Dentro del ciclo. 1\n",
      "Dentro del ciclo. 2\n",
      "Dentro del ciclo. 4\n",
      "Dentro del ciclo. 5\n",
      "Fuera del ciclo.\n"
     ]
    }
   ],
   "source": [
    "# continue - ejemplo\n",
    "\n",
    "print(\"La instrucción continue:\")\n",
    "for i in range(1,6):\n",
    "    if i == 3:\n",
    "        continue\n",
    "    print(\"Dentro del ciclo.\", i)\n",
    "print(\"Fuera del ciclo.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No ha ingresado ningún número\n"
     ]
    }
   ],
   "source": [
    "numeroMayor = -99999999\n",
    "contador = 0\n",
    "\n",
    "while True:\n",
    "    numero = int (input (\"Ingresa un número o escribe -1 para finalizar el programa:\"))\n",
    "    if numero == -1:\n",
    "        break\n",
    "        #continue\n",
    "\n",
    "    contador = 1\n",
    "    if numero > numeroMayor:\n",
    "        numeroMayor = numero\n",
    "\n",
    "if contador != 0:\n",
    "    print(\"El número más grande es\", numeroMayor)\n",
    "else:\n",
    "    print(\"No ha ingresado ningún número\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "palabra = input('Escriba una palabra')\n",
    "\n",
    "while True:\n",
    "    if palabra == \"chupacabra\":\n",
    "        break\n",
    "    palabra = input('Escriba una palabra')\n",
    "\n",
    "print('¡Has dejado el ciclo con éxito')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "J\n",
      "N\n",
      "T\n",
      "H\n",
      "N\n"
     ]
    }
   ],
   "source": [
    "# Indicar al usuario que ingrese una palabra\n",
    "# y asignarlo a la variable userWord.\n",
    "\n",
    "userWord = input(\"ingrese una palabra\")\n",
    "userWord = userWord.upper() #convierte todas las letras de la palabra ingresada en mayúsculas; upper() es un método de cadena\n",
    "for letra in userWord:\n",
    "    if letra in 'AEIOU':\n",
    "        continue\n",
    "    print(letra)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "JNTHN\n"
     ]
    }
   ],
   "source": [
    "#El mismo código pero más presentable. \n",
    "palabraSinVocal = ''\n",
    "\n",
    "userWord = input(\"ingrese una palabra\")\n",
    "userWord = userWord.upper() \n",
    "for letra in userWord:\n",
    "    if letra in 'AEIOU':\n",
    "        continue\n",
    "    palabraSinVocal = palabraSinVocal + letra\n",
    "print(palabraSinVocal)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "else: 5\n"
     ]
    }
   ],
   "source": [
    "i = 1 #El estado de while es Falso al principio\n",
    "while i < 5:\n",
    "    print (i)\n",
    "    i += 1\n",
    "else:\n",
    "    print(\"else:\", i) \n",
    "#La rama else del ciclo siempre se ejecuta una vez, \n",
    "#independientemente de si el ciclo ha entrado o no en su cuerpo ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "else: 4\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    print(i)\n",
    "else:\n",
    "    print(\"else:\", i) #La variable i conserva su último valor. \"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "else: 111\n"
     ]
    }
   ],
   "source": [
    "i = 111\n",
    "for i in range(2, 1):\n",
    "    print(i)\n",
    "else:\n",
    "    print(\"else:\", i)\n",
    "#Cuando el cuerpo del ciclo no se ejecuta, la variable de control conserva el \n",
    "#valor que tenía antes del ciclo.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nota: si la variable de control no existe antes de que comience el ciclo, \n",
    "#no existirá cuando la ejecución llegue a la rama else.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La altura de la pirámide es: 5 m\n"
     ]
    }
   ],
   "source": [
    "\n",
    "bloques = int(input(\"Ingrese el número de bloques:\"))\n",
    "distribuidor, altura, num = 0,0,1\n",
    "\n",
    "while distribuidor >= 0:\n",
    "    distribuidor = int(bloques - num)\n",
    "    if distribuidor < 0:\n",
    "        break  \n",
    "    num += 1\n",
    "    altura += 1\n",
    "    bloques = distribuidor\n",
    "\n",
    "print(\"La altura de la pirámide es:\", altura, \"m\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "joti-b\n"
     ]
    }
   ],
   "source": [
    "correo = input('Ingrese su dirección de correo electrónico')\n",
    "name = ''\n",
    "for ch in correo:\n",
    "    if ch == \".\":\n",
    "        continue\n",
    "    if ch == \"@\":\n",
    "        break\n",
    "    name = name + ch\n",
    "print(name)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for ch in \"john.smith@pythoninstitute.org\":\n",
    "    if ch == \"@\":\n",
    "        break\n",
    "    print(ch, end=\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x165x318x651x"
     ]
    }
   ],
   "source": [
    "for digit in \"0165031806510\":\n",
    "    if digit == \"0\":\n",
    "       digit = \"x\"\n",
    "    print(digit, end=\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Conjunciones y disyunciones**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Operadores lógicos***:\n",
    "\n",
    "***Operador de conjunción and (y)***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un operador de conjunción lógica en Python es la palabra y. Es un operador binario con una prioridad inferior a la expresada por los operadores de comparación. Nos permite codificar condiciones complejas sin el uso de paréntesis como este:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "contador > 0 and valor == 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si consideramos la conjunción de A and B, el conjunto de valores posibles de argumentos y los valores correspondientes de conjunción se ve de la siguiente manera:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "bat"
    }
   },
   "outputs": [],
   "source": [
    "\n",
    "Argumento A \tArgumento B \tA and B \n",
    "False\t        False\t        False\n",
    "False\t        True\t        False\n",
    "True\t        False\t        False\n",
    "True\t        True\t        True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Operador de disyunción or (o)***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un operador de disyunción es la palabra or. Es un operador binario con una prioridad más baja que and (al igual que + en comparación con *). Su tabla de verdad es la siguiente:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "bat"
    }
   },
   "outputs": [],
   "source": [
    "Argumento A \tArgumento B \tA or B \n",
    "False\t        False\t        False\n",
    "False\t        True\t        True\n",
    "True\t        False\t        True\n",
    "True\t        True\t        True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Operador not (no)***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Además, hay otro operador que se puede aplicar para condiciones de construcción. Es un operador unario que realiza una negación lógica. Su funcionamiento es simple: convierte la verdad en falso y lo falso en verdad.\n",
    "\n",
    "Este operador se escribe como la palabra not, y su prioridad es muy alta: igual que el unario + y -. Su tabla de verdad es simple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "bat"
    }
   },
   "outputs": [],
   "source": [
    "Argumento\tnot Argumento \n",
    "False\t    True\n",
    "True\t    False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "var = 1\n",
    "print(var > 0)\n",
    "print(not (var <= 0))\n",
    "\n",
    "print(var != 0)\n",
    "print(not (var == 0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Como se relacionan estos operadores entre si? Las leyes de De Morgan. Dicen que:\n",
    "\n",
    "- La negación de una conjunción es la disyunción de las negaciones.\n",
    "\n",
    "- La negación de una disyunción es la conjunción de las negaciones.\n",
    "\n",
    "Escribamos lo mismo usando Python:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "not (p and q) == (not p) or (not q) \n",
    "not (p or q) == (not p) and (not q)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Valores lógicos vs. bits individuales**\n",
    "\n",
    "Los operadores lógicos toman sus argumentos como un todo, independientemente de cuántos bits contengan. Los operadores solo conocen el valor: cero (cuando todos los bits se restablecen) significa False; no cero (cuando se establece al menos un bit) significa True.\n",
    "\n",
    "El resultado de sus operaciones es uno de estos valores: False o True. Esto significa que este fragmento de código asignará el valor True a la variable j si i no es cero; de lo contrario, será False.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "i = 1\n",
    "j = not not i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Operadores bitwise***\n",
    "\n",
    "Sin embargo, hay cuatro operadores que le permiten manipular bits de datos individuales. Se denominan operadores bitwise. Cubren todas las operaciones que mencionamos anteriormente en el contexto lógico, y un operador adicional. Este es el operador xor (como en o exclusivo ), y se denota como ^ (signo de intercalación).\n",
    "\n",
    "Aquí están todos ellos:\n"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "\n",
    "&  (ampersand) - conjunción a nivel de bits.\n",
    "|  (barra vertical) - disyunción a nivel de bits.\n",
    "~  (tilde) - negación a nivel de bits.\n",
    "^  (signo de intercalación) - exclusivo a nivel de bits o (xor).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<img src=\"https://unipython.com/wp-content/uploads/2019/05/Screenshot-from-2019-05-23-00-46-10.png\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agreguemos un comentario importante: los argumentos de estos operadores deben ser enteros. No debemos usar flotantes aquí.\n",
    "\n",
    "La diferencia en el funcionamiento de los operadores lógicos y de bits es importante: los operadores lógicos no penetran en el nivel de bits de su argumento. Solo les interesa el valor entero final.\n",
    "\n",
    "Los operadores bitwise son más estrictos: tratan con cada bit por separado. Si asumimos que la variable entera ocupa 64 bits (lo que es común en los sistemas informáticos modernos), puede imaginar la operación a nivel de bits como una evaluación de 64 veces del operador lógico para cada par de bits de los argumentos. Su analogía es obviamente imperfecta, ya que en el mundo real todas estas 64 operaciones se realizan al mismo tiempo (simultáneamente)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "' i\\t             000000000000000000000000000  01111  \\nj\\t             000000000000000000000000000  10110  \\nbit = i & j \\t 000000000000000000000000000  00110   '"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "i = 15\n",
    "j = 22 \n",
    "\n",
    "#Si asumimos que los enteros se almacenan con 32 bits, la imagen a nivel de bits de las dos variables será la siguiente:\n",
    "\"\"\"\"\n",
    "i: 00000000000000000000000000001111\n",
    "j: 00000000000000000000000000010110 \n",
    "\n",
    "\"\"\"\n",
    "OpLog = i and j  #OpLog: True\n",
    "\n",
    "bit = i & j \n",
    "print(bit)\n",
    "\n",
    "#El operador & operará con cada par de bits correspondientes por separado, produciendo los valores de los bits relevantes del resultado. \n",
    "#Por lo tanto, el resultado será el siguiente:\n",
    "\"\"\"\n",
    "i\t             000000000000000000000000000  01111  \n",
    "j\t             000000000000000000000000000  10110  \n",
    "bit = i & j \t 000000000000000000000000000  00110  \n",
    "\"\"\"\n",
    "\n",
    "#Estos bits corresponden al valor entero de seis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "-16\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'i\\t            0000000000000000000000000000  1111  \\n   bitneg = ~i \\t    1111111111111111111111111111  0000  \\n'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "i = 15\n",
    "j = 22 \n",
    "\n",
    "logneg = not i \n",
    "print(logneg)\n",
    "\n",
    "bitneg = ~i \n",
    "print(bitneg)\n",
    "\n",
    "\n",
    "\"\"\"i\t            0000000000000000000000000000  1111  \n",
    "   bitneg = ~i \t    1111111111111111111111111111  0000  \n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "31\n",
      "-16\n",
      "31\n",
      "8\n",
      "128\n"
     ]
    }
   ],
   "source": [
    "x = 15 #el cual es  0000 1111  en binario.\n",
    "y = 16 #el cual es  0001 0000  en binario.\n",
    "\n",
    "print(x & y)\n",
    "print(x | y)\n",
    "print(~x)\n",
    "print(x^y)\n",
    "print(y >> 1) #hace un desplazamiento bit a bit a la derecha\n",
    "print(y<<3) #hace un desplazamiento bit a bit a la izquierda\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "y = 0\n",
    "\n",
    "z = ((x == y) and (x == y)) or not(x == y)    \n",
    "print(not(z))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 5 -5 1 1 16\n",
      "17.0\n"
     ]
    }
   ],
   "source": [
    "x = 4             #100\n",
    "y = 1             #101\n",
    "\n",
    "a = x & y         #100\n",
    "b = x | y         #101\n",
    "c = ~ x           #011\n",
    "d = x ^ 5         #001\n",
    "e = x >> 2        #001\n",
    "f = x << 2        #10000\n",
    "\n",
    "print(a, b, c, d, e, f) \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y aquí está la tabla de prioridades actualizada , que contiene todos los operadores presentados hasta ahora:"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "vscode": {
     "languageId": "bat"
    }
   },
   "source": [
    "Prioridad\tOperador\t\n",
    "1\t        ! ~ (tipo) ++ -- + - \tunario\n",
    "2\t        **\t\n",
    "3\t        * / % \t\n",
    "4\t        + - \t                binario\n",
    "5\t        << >> \t\n",
    "6\t        <<=>> = \t\n",
    "7\t        == != \t\n",
    "8\t        &\t\n",
    "9\t        |\t\n",
    "10\t        &&\t\n",
    "11\t        ||\t\n",
    "12\t        = += -= *= /= %= &= ^= |= >>= <<="
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Listas**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La lista es un tipo de dato en Python que se utiliza para almacenar múltiples objetos. Es una colección ordenada y mutable de elementos separados por comas entre corchetes, por ejemplo:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "miLista = [1, None, True, \"Soy una cadena\", 256, 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Las listas pueden estar anidadas, por ejemplo: \n",
    "\n",
    "miLista = [1, 'a', [\"lista\", 64, [0, 1], False]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Vamos a crear una variable llamada numeros; se le asigna no solo un número, sino que se llena con una lista que consta de cinco valores (nota: la lista comienza con un corchete abierto y termina con un corchete cerrado ; el espacio entre los corchetes es llenado con cinco números separados por comas).\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numeros = [ 10, 5, 7, 2, 1] \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Digamos lo mismo utilizando una terminología adecuada: numeros es una lista que consta de cinco valores, todos ellos números. También podemos decir que esta declaración crea una lista de longitud igual a cinco (ya que contiene cinco elementos); nuestra lista es una colección de elementos, pero cada elemento es un escalar.\n",
    "Los elementos dentro de una lista pueden tener diferentes tipos . Algunos de ellos pueden ser enteros, otros son flotantes y otros pueden ser listas.\n",
    "\n",
    "Python ha adoptado una convención que indica que los elementos de una lista están siempre numerados desde cero. Esto significa que el elemento almacenado al principio de la lista tendrá el número cero. Como hay cinco elementos en nuestra lista, al último de ellos se le asigna el número cuatro. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Listas de indexación***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Contenido de la lista original: [10, 5, 7, 2, 1]\n",
      "Nuevo contenido de la lista: [111, 5, 7, 2, 1]\n",
      "Nuevo contenido de la lista: [111, 1, 7, 2, 1]\n",
      "El primer elemento de la lista es:  111\n",
      "El último elemento de la lista es:  1\n",
      "El primer elemento de la lista es:  111\n",
      "\n",
      "Longitud de la lista: 5\n"
     ]
    }
   ],
   "source": [
    "\n",
    "          #0   1  2  3  4\n",
    "          #-5 -4 -3 -2 -1 \n",
    "numeros = [10, 5, 7, 2, 1]\n",
    "print(\"Contenido de la lista original:\", numeros) # imprime el contenido de la lista original\n",
    "\n",
    "numeros[0] = 111 \n",
    "print(\"Nuevo contenido de la lista:\", numeros) # contenido de la lista actual.\n",
    "\n",
    "numeros[1] = numeros[4]  # copiando el valor del quinto elemento al segundo\n",
    "print(\"Nuevo contenido de la lista:\", numeros) # imprimiendo el contenido de la lista actual.\n",
    "\n",
    "print(\"El primer elemento de la lista es: \", numeros[0]) # accediendo al primer elemento de la lista.\n",
    "\n",
    "print(\"El último elemento de la lista es: \",numeros[-1]) #los índices negativos son válidos\n",
    "print(\"El primer elemento de la lista es: \", numeros[-5])\n",
    "\n",
    "print(\"\\nLongitud de la lista:\", len(numeros)) # imprimiendo la longitud de la lista. La función len() toma el nombre de la lista como un argumento \n",
    "                                               # y devuelve el número de elementos almacenados actualmente dentro de la lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El valor dentro de los corchetes que selecciona un elemento de la lista se llama un índice, mientras que la operación de seleccionar un elemento de la lista se conoce como indexación. Todos los índices utilizados hasta ahora son literales. Sus valores se fijan en el tiempo de ejecución, pero cualquier expresión también puede ser un índice. Esto abre muchas posibilidades.\n",
    "\n",
    "Por otra parte, la longitud de una lista puede variar durante la ejecución. Se pueden agregar nuevos elementos a la lista, mientras que otros pueden eliminarse de ella. Esto significa que la lista es una entidad muy dinámica."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Longitud de la nueva lista: 4\n",
      "\n",
      "Nuevo contenido de la lista: [111, 7, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "del numeros[1] # eliminando el segundo elemento de la lista\n",
    "print(\"Longitud de la nueva lista:\", len(numeros)) # imprimiendo nueva longitud de la lista\n",
    "print(\"\\nNuevo contenido de la lista:\", numeros) # imprimiendo el contenido de la lista actual\n",
    "\n",
    "#Nota: del es una instrucción, no una función !!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list assignment index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_6140/902447508.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m#print(numeros[4])\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mnumeros\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;31m#hemos eliminado uno de los elementos de la lista; ahora solo hay cuatro elementos en la lista.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;31m#Esto significa que el elemento número cuatro no existe.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mIndexError\u001b[0m: list assignment index out of range"
     ]
    }
   ],
   "source": [
    "#print(numeros[4])\n",
    "numeros[4] = 1 \n",
    "\n",
    "#hemos eliminado uno de los elementos de la lista; ahora solo hay cuatro elementos en la lista. \n",
    "#Esto significa que el elemento número cuatro no existe.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'lst' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_6140/527831612.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mlst\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;32mdel\u001b[0m \u001b[0mlst\u001b[0m \u001b[1;31m#elimina la lista 'lst'.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlst\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'lst' is not defined"
     ]
    }
   ],
   "source": [
    "lst = []\n",
    "del lst #elimina la lista 'lst'. \n",
    "print(lst) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Digite un número que reemplace el número central en la lista9\n",
      "[1, 2, 9, 4]\n",
      "Longitud actual de la lista:  4\n"
     ]
    }
   ],
   "source": [
    "listaSombrero = [1, 2, 3, 4, 5] # Esta es una lista existente de números ocultos en el sombrero.\n",
    "listaSombrero[2]= int(input('Digite un número que reemplace el número central en la lista'))\n",
    "#Elimine el último elemento de la lista\n",
    "del listaSombrero[-1]\n",
    "print(listaSombrero)\n",
    "print('Longitud actual de la lista: ', len(listaSombrero))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "[111, 1, 7, 2, 1, 4]\n",
      "7\n",
      "['Hola', 111, 1, 7, 2, 1, 4]\n"
     ]
    }
   ],
   "source": [
    "#Agregar elementos a una lista: métodos append() e insert()\n",
    "\n",
    "\n",
    "numeros.append(4)\n",
    "\n",
    "print(len(numeros))\n",
    "print(numeros)\n",
    "\n",
    "\n",
    "numeros.insert(0,'Hola') #El primer argumento es la ubicación del elemento a insertar, la cuál puede existir o no en la lista. El segundo argumento es el elemento. \n",
    "print(len(numeros))\n",
    "print(numeros)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un método es un tipo específico de función. Un método es propiedad de los datos para los que trabaja, mientras que una función es propiedad de todo el código.\n",
    "\n",
    "Una invocación de un método típico usualmente se ve así:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "bat"
    }
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'data' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32mc:\\Users\\USUARIO\\Documents\\Rutas de formación en programación\\Python\\Cisco\\MOD3.ipynb Celda 122\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Users/USUARIO/Documents/Rutas%20de%20formaci%C3%B3n%20en%20programaci%C3%B3n/Python/Cisco/MOD3.ipynb#Y232sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m resultado \u001b[39m=\u001b[39m  data\u001b[39m.\u001b[39mmethod(arg)\n",
      "\u001b[1;31mNameError\u001b[0m: name 'data' is not defined"
     ]
    }
   ],
   "source": [
    "resultado =  data.method(arg)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nota: el nombre del método está precedido por el nombre de los datos que posee el método. A continuación, se agrega un punto, seguido del nombre del método y un par de paréntesis que encierran los argumentos.\n",
    "\n",
    "El método se comportará como una función, pero puede hacer algo más: puede cambiar el estado interno de los datos a partir de los cuales se ha invocado.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En general, una invocación de función típica puede tener este aspecto:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "bat"
    }
   },
   "outputs": [],
   "source": [
    "resultado =  funcion(argumento)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos iniciar la vida de una lista creándola vacía (esto se hace con un par de corchetes vacíos) y luego agregar nuevos elementos según sea necesario."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n",
      "[5, 4, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "miLista = [] # creando una lista vacía\n",
    "\n",
    "for i in range (5):\n",
    "    miLista.append (i+1)\n",
    "\n",
    "print(miLista)\n",
    "\n",
    "miLista = [] # creando una lista vacía\n",
    "\n",
    "for i in range(5):\n",
    "    miLista.insert(0, i + 1)\n",
    "\n",
    "print(miLista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "27\n",
      "27\n"
     ]
    }
   ],
   "source": [
    "#calcular la suma de todos los valores almacenados en la lista miLista.\n",
    "\n",
    "miLista = [10, 1, 8, 3, 5]\n",
    "suma = 0\n",
    "\n",
    "for i in range(len(miLista)):\n",
    "    suma += miLista[i]\n",
    "\n",
    "print(suma)\n",
    "\n",
    "#El cilo for puede entregar todos los elementos de la lista de una manera más práctica:\n",
    "suma= 0\n",
    "for i in miLista:\n",
    "    suma += i\n",
    "\n",
    "print(suma)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nota: La instrucción for especifica la variable utilizada para navegar por la lista (i) seguida de la palabra clave  in  y el nombre de la lista siendo procesado (miLista). A la variable i se le asignan los valores de todos los elementos de la lista subsiguiente, y el proceso ocurre tantas veces como hay elementos en la lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 3, 8, 1, 10]\n",
      "[10, 1, 8, 3, 5]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "#intercambiar elementos de una lista\n",
    "miLista = [10, 1, 8, 3, 5]\n",
    "\n",
    "miLista [0], miLista [4] = miLista [4], miLista [0]\n",
    "miLista [1], miLista [3] = miLista [3], miLista [1]\n",
    "\n",
    "print(miLista) \n",
    "\n",
    "#intercambiar elementos de una lista de n elementos:\n",
    "\n",
    "longitud = len(miLista)\n",
    "\n",
    "for i in range (longitud//2):\n",
    "    miLista[i], miLista[longitud-i-1] = miLista[longitud-i-1], miLista[i]\n",
    "          \n",
    "print(miLista) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Paso 1: []\n",
      "Paso 2: ['John Lennon', 'Paul McCartney', 'George Harrison']\n",
      "Paso 3: ['John Lennon', 'Paul McCartney', 'George Harrison', 'Stu Sutcliffe', 'Pete Best']\n",
      "Paso 4: ['John Lennon', 'Paul McCartney', 'George Harrison']\n",
      "Paso 5: ['John Lennon', 'Paul McCartney', 'George Harrison', 'Ringo Starr']\n",
      "Los Fab 4\n"
     ]
    }
   ],
   "source": [
    "# paso 1\n",
    "beatles = []\n",
    "print(\"Paso 1:\", beatles)\n",
    "\n",
    "# paso 2\n",
    "beatles.append('John Lennon')\n",
    "beatles.append('Paul McCartney')\n",
    "beatles.append('George Harrison')\n",
    "print(\"Paso 2:\", beatles)\n",
    "\n",
    "# paso 3\n",
    "newMembers = ['Stu Sutcliffe', 'Pete Best']\n",
    "for i in newMembers:\n",
    "    beatles.append(i)\n",
    "print(\"Paso 3:\", beatles)\n",
    "\n",
    "# etapa 4\n",
    "del beatles[3]\n",
    "del beatles[3]\n",
    "print(\"Paso 4:\", beatles)\n",
    "\n",
    "# paso 5\n",
    "beatles.insert(3,'Ringo Starr')\n",
    "print(\"Paso 5:\", beatles)\n",
    "\n",
    "# probando la longitud de la lista\n",
    "print(\"Los Fab\", len(beatles))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ordenamiento de listas**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Ordenamiento burbuja***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[8, 6, 2, 4, 10]\n"
     ]
    }
   ],
   "source": [
    "miLista = [8, 10, 6, 2, 4] # lista para ordenar\n",
    "\n",
    "for i in range(len(miLista) - 1): # necesitamos (5 - 1) comparaciones\n",
    "    if miLista[i] > miLista[i + 1]: # compara elementos adyacentes\n",
    "        miLista[i], miLista [i + 1] = miLista[i + 1], miLista[i] # si terminamos aquí significa que tenemos que intercambiar los elementos.\n",
    "\n",
    "print(miLista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El anterior código acaba de ejecutar solo el primer paso. Ejecutemos el resto de los pasos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "miLista = [8, 10, 6, 2, 4] # lista para ordenar\n",
    "swapped = True # lo necesitamos verdadero (True) para ingresar al bucle while\n",
    "\n",
    "while swapped:\n",
    "    swapped = False # no hay swaps hasta ahora\n",
    "    for i in range(len(miLista) - 1):\n",
    "        if miLista[i] > miLista[i + 1]:\n",
    "            swapped= True # ocurrió el intercambio!\n",
    "            miLista[i], miLista[i + 1] = miLista[i + 1], miLista[i]\n",
    "\n",
    "print(miLista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Ordenado:\n",
      "[1.0, 1.0, 2.0, 3.0, 3.0, 4.0, 6.0, 9.0]\n"
     ]
    }
   ],
   "source": [
    "miLista = []\n",
    "swapped = True\n",
    "num = int (input(\"¿Cuántos elementos deseas ordenar?:\"))\n",
    "\n",
    "for i in range(num):\n",
    "    val = float(input(\"Introduce un elemento de la lista:\"))\n",
    "    miLista.append(val)\n",
    "\n",
    "while swapped:\n",
    "    swapped = False\n",
    "    for i in range(len(miLista) - 1):\n",
    "        if miLista[i] > miLista[i + 1]:\n",
    "            swapped = True\n",
    "            miLista[i], miLista[i + 1] = miLista[i + 1], miLista[i]\n",
    "\n",
    "print(\"\\nOrdenado:\")\n",
    "print(miLista)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sin embargo, Python puede ordenar una lista tan solo invocanto el método sort()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "miLista = [8, 10, 6, 2, 4]\n",
    "miLista.sort() \n",
    "print(miLista) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "a = 3\n",
    "b = 1\n",
    "c = 2\n",
    "\n",
    "lst = [a, c, b]\n",
    "lst.sort()\n",
    "\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También hay un método de lista llamado reverse(), que se puede usar para invertir la lista, por ejemplo:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 3, 1, 2, 4]\n",
      "[4, 2, 1, 3, 5]\n"
     ]
    }
   ],
   "source": [
    "lst = [5, 3, 1, 2, 4]\n",
    "print(lst)\n",
    "    \n",
    "lst.reverse()\n",
    "print (lst) # salida: [4, 2, 1, 3, 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['', 'C', 'B', 'A']\n"
     ]
    }
   ],
   "source": [
    "a = \"A\"\n",
    "b = \"B\"\n",
    "c = \"C\"\n",
    "d = \"\"\n",
    "\n",
    "lst = [a, b, c, d]\n",
    "lst.reverse ()\n",
    "\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Almacenamiento en listas***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "#¿Cuál es la salida del siguiente fragmento de código?\n",
    "Var1 = 1\n",
    "Var2 = Var1\n",
    "Var1 = 2\n",
    "print(Var2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2]\n"
     ]
    }
   ],
   "source": [
    "#¿Cuál es la salida del siguiente fragmento de código?\n",
    "#¿Imprimirá el valor que esperamos?\n",
    "lista1 = [1]\n",
    "lista2 = lista1\n",
    "lista1[0] = 2\n",
    "print(lista2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La parte sorprendente es el hecho de que el programa mostrará como resultado: [2], no [1], que parece ser la solución obvia.\n",
    "\n",
    "Las listas (y muchas otras entidades complejas de Python) se almacenan de diferentes maneras que las variables ordinarias (escalares).\n",
    "\n",
    "Se podría decir que:\n",
    "\n",
    "- El nombre de una variable ordinaria es el nombre de su contenido.\n",
    "- El nombre de una lista es el nombre de una ubicación de memoria donde se almacena la lista.\n",
    "\n",
    "La asignación: lista2 = lista1 copia el nombre de la matriz, no su contenido. En efecto, los dos nombres (lista1 y lista2) identifican la misma ubicación en la memoria de la computadora. Modificar uno de ellos afecta al otro, y viceversa.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['C']\n"
     ]
    }
   ],
   "source": [
    "l1 = [\"A\", \"B\", \"C\"]\n",
    "l2 = l1\n",
    "l3 = l2\n",
    "\n",
    "del l1[0]\n",
    "del l2[0]\n",
    "\n",
    "print(l3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['B', 'C']\n"
     ]
    }
   ],
   "source": [
    "l1 = [\"A\", \"B\", \"C\"]\n",
    "l2 = l1  #no hace una copia de la lista l1, pero hace que las variables \n",
    "         #l1 y l2 apunten a la misma lista en la memoria \n",
    "l3 = l2  #no hace una copia de la lista l2, pero hace que las variables \n",
    "         #l2 y l3 apunten a la misma lista en la memoria \n",
    "\n",
    "del l1[0]\n",
    "del l2    #elimina 'l2'\n",
    "\n",
    "print(l3)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "¿Como copiar el contenido de la lista y no el nombre de la matrz?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "l1 = [\"A\", \"B\", \"C\"]\n",
    "l2 = l1\n",
    "l3 = l2\n",
    "\n",
    "del l1[0]\n",
    "del l2[:] #elimina los elementos de 'l2'\n",
    "\n",
    "print(l3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['A', 'B', 'C']\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "l1 = [\"A\", \"B\", \"C\"]\n",
    "l2 = l1[:] #hace una copia de la lista l1\n",
    "l3 = l2[:] #hace una copia de la lista l2\n",
    "\n",
    "del l1[0]\n",
    "del l2[0]\n",
    "\n",
    "print(l3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1]\n",
      "[8, 6]\n",
      "[10, 8, 6]\n",
      "[4, 2]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "#segmento(rodaja, rebanada o slicing) de una lista ([:])\n",
    "\n",
    "#miLista[inicio:fin]\n",
    "#inicio es el índice del primer elemento incluido en la rodaja.\n",
    "#fin es el índice del primer elemento no incluido en la rodaja.\n",
    "\n",
    "# Copiando toda la lista\n",
    "lista1 = [1]\n",
    "lista2 = lista1[:]\n",
    "lista1[0] = 2\n",
    "print(lista2)\n",
    "\n",
    "# Copiando parte de la lista\n",
    "miLista = [10, 8, 6, 4, 2]\n",
    "nuevaLista = miLista[1:3]\n",
    "print(nuevaLista)\n",
    "\n",
    "miLista = [10, 8, 6, 4, 2]\n",
    "nuevaLista = miLista [:3]\n",
    "          #= miLista [0:3]\n",
    "print(nuevaLista)\n",
    "\n",
    "miLista = [10, 8, 6, 4, 2]\n",
    "nuevaLista = miLista[3:]\n",
    "          #= miLista[3:len(miLista)]\n",
    "print(nuevaLista)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[8, 6, 4]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "#con indices negativos\n",
    "miLista = [10, 8, 6, 4, 2]\n",
    "nuevaLista = miLista [1:-1] \n",
    "          #= miLista [1:4]\n",
    "print(nuevaLista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una rodaja de este tipo crea una nueva lista (de destino), tomando elementos de la lista de origen: los elementos de los índices desde el principio hasta el fin-1.\n",
    "\n",
    "Nota: no hasta el fin, sino hasta fin-1. Un elemento con un índice igual a fin es el primer elemento el cual no participa en la segmentación."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "#Con indices negativos:\n",
    "miLista = [10, 8, 6, 4, 2]\n",
    "nuevaLista = miLista [-1:1]\n",
    "print(nuevaLista)\n",
    "\n",
    "#Nota:Si el inicio especifica un elemento que se encuentra más allá del descrito \n",
    "#por el fin (desde el punto de vista inicial de la lista), la rodaja estará vacía:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La instrucción del descrita anteriormente puede eliminar más de un elemento de la lista a la vez, también puede eliminar rodajas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 4, 2]\n",
      "[]\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'miLista' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_12660/4072822146.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      9\u001b[0m \u001b[1;31m#eliminando la lista\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     10\u001b[0m \u001b[1;32mdel\u001b[0m \u001b[0mmiLista\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 11\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmiLista\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     12\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'miLista' is not defined"
     ]
    }
   ],
   "source": [
    "miLista = [10, 8, 6, 4, 2]\n",
    "del miLista[1:3] \n",
    "print(miLista)\n",
    "\n",
    "#eliminando todo el contenido de la lista. \n",
    "del miLista[:] \n",
    "print(miLista)\n",
    "\n",
    "#eliminando la lista\n",
    "del miLista     #eliminará la lista, no su contenido.\n",
    "print(miLista)\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17\n",
      "17\n"
     ]
    }
   ],
   "source": [
    "#encontrar el mayor de la lista:\n",
    "miLista = [17, 3, 11, 5, 1, 9, 7, 15, 13]\n",
    "Max = miLista[0]\n",
    "\n",
    "\n",
    "for i in miLista:\n",
    "    if i > Max:\n",
    "      Max = i\n",
    "\n",
    "print(Max) \n",
    "#El programa anterior realiza una comparación innecesaria, cuando el primer elemento se compara consigo mismo.\n",
    "#Omitamos esa comparación:\n",
    "for i in miLista[1:]: #= for i in range(1, len(miLista))\n",
    "    if i > Max:\n",
    "      Max = i\n",
    "\n",
    "print(Max) \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Elemento encontrado en el índice 4\n"
     ]
    }
   ],
   "source": [
    "#Encontremos la ubicación de un elemento dado dentro de una lista:\n",
    "\n",
    "miLista = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "Encontrar = 5\n",
    "Encontrado = False\n",
    "\n",
    "\n",
    "for i in range(len(miLista)):\n",
    "    Encontrado = miLista[i] == Encontrar #: Encontrado = valor booleano. \n",
    "    if Encontrado:\n",
    "        break\n",
    "\n",
    "if Encontrado:\n",
    "    print(\"Elemento encontrado en el índice\", i)\n",
    "else:\n",
    "    print(\"ausente\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El método index() permite obtener el indice de determinado elemento. Es claro que si dicho elemento no existe dentro de la lista, arrojará un error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Elemento encontrado en el índice 4\n"
     ]
    }
   ],
   "source": [
    "\n",
    "i = miLista.index(5)\n",
    "print(\"Elemento encontrado en el índice\", i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***suma y multiplicación de listas***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "[1, 10, 100, 1000, 10000]\n",
      "[1, 10, 100, 1, 10, 100, 1, 10, 100]\n"
     ]
    }
   ],
   "source": [
    "miLista = [1, 10, 100]\n",
    "\n",
    "t1 = miLista + [1000, 10000]\n",
    "t2 = miLista * 3\n",
    "\n",
    "print(len(t2))\n",
    "print(t1)\n",
    "print(t2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Los operadores in y not***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "miLista = [0, 3, 12, 8, 2]\n",
    "\n",
    "print(5 in miLista)\n",
    "print(5 not in miLista)\n",
    "print(12 in miLista)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La lista solo con elementos únicos:\n",
      "[1, 2, 3, 4, 5, 6, 8, 9, 10, 22]\n"
     ]
    }
   ],
   "source": [
    "#eliminar todas las repeticiones de números de la lista.\n",
    "\n",
    "miLista = [3,4,22,10,10,5,6,2,1,10,5,8,9]\n",
    "miListaVacia = []\n",
    "for i in miLista:\n",
    "    if i in miListaVacia:\n",
    "        continue\n",
    "    miListaVacia.append(i)\n",
    "\n",
    "miListaVacia.sort()\n",
    "    \n",
    "print(\"La lista solo con elementos únicos:\")\n",
    "print(miListaVacia)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Anidación de listas (listas dentro de listas)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Compresión de listas***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una comprensión de lista es en realidad una lista, pero se creó sobre la marcha durante la ejecución del programa, y no se describe de forma estática."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "bat"
    }
   },
   "outputs": [],
   "source": [
    "\n",
    "row = []                     \n",
    "for i in range(8):                 ---------->    row = [PEON_BLANCO for i in range(8)] \n",
    "    row.append(PEON_BLANCO)   \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n",
      "[1, 2, 4, 8, 16, 32, 64, 128]\n",
      "[1, 9, 25, 49, 81]\n"
     ]
    }
   ],
   "source": [
    "#Ejemplo # 1:\n",
    "\n",
    "cuadrados = [x ** 2 for x in range(10)]\n",
    "\n",
    "#El fragmento de código genera una lista de diez elementos y rellena con cuadrados de diez \n",
    "#números enteros que comienzan desde cero (0, 1, 4, 9, 16, 25, 36, 49, 64, 81)\n",
    "\n",
    "print(cuadrados)\n",
    "\n",
    "#Ejemplo # 2:\n",
    "\n",
    "dos = [2 ** i for i in range(8)]\n",
    "\n",
    "#El fragmento crea un arreglo de ocho elementos que contiene las primeras \n",
    "#ocho potencias del numero dos (1, 2, 4, 8, 16, 32, 64, 128)\n",
    "\n",
    "print(dos)\n",
    "\n",
    "#Ejemplo # 3:\n",
    "\n",
    "probabilidades = [x for x in cuadrados if x % 2 != 0] \n",
    "\n",
    "#El fragmento hace una lista con solo los elementos impares de la lista cuadrados.\n",
    "\n",
    "print(probabilidades)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Arreglos bidimensionales***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY'], ['EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY'], ['EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY'], ['EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY'], ['EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY'], ['EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY'], ['EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY'], ['EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY']]\n"
     ]
    }
   ],
   "source": [
    "tablero  = []\n",
    "\n",
    "for i in range(8):\n",
    "    fila = ['EMPTY' for i in range(8)]\n",
    "    tablero.append(fila)\n",
    "\n",
    "print(tablero)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos observar lo siguiente:\n",
    "\n",
    "- La parte interior del bucle crea una fila que consta de ocho elementos(cada uno de ellos es igual a EMPTY) y lo agrega a la lista del tablero.\n",
    "- La parte exterior se repite ocho veces.\n",
    "- En total, la lista tablero consta de 64 elementos (todos iguales a EMPTY)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como las listas de comprensión puede ser anidadas, podemos acortar la creación del tablero de la siguiente manera:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY'], ['EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY'], ['EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY'], ['EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY'], ['EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY'], ['EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY'], ['EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY'], ['EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY']]\n"
     ]
    }
   ],
   "source": [
    "tablero = [['EMPTY' for i in range(8)] for j in range(8)]\n",
    "\n",
    "#La parte interna crea una fila, y la parte externa crea una lista de filas.\n",
    "\n",
    "print(tablero)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['TORRE', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'TORRE'], ['EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY'], ['EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY'], ['EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'PEON', 'EMPTY', 'EMPTY', 'EMPTY'], ['EMPTY', 'EMPTY', 'CABALLO', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY'], ['EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY'], ['EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY'], ['TORRE', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'EMPTY', 'TORRE']]\n"
     ]
    }
   ],
   "source": [
    "#si tablero[] representará un tablero de ajedrez...\n",
    "\n",
    "#ubiquemos unas cuantas piezas en determinados campos del tablero:\n",
    "\n",
    "tablero[0][0] = 'TORRE'\n",
    "tablero[0][7] = 'TORRE'\n",
    "tablero[7][0] = 'TORRE'\n",
    "tablero[7][7] = 'TORRE'\n",
    "\n",
    "tablero[4][2] = 'CABALLO'\n",
    "\n",
    "tablero[3][4] = 'PEON'\n",
    "\n",
    "#El acceso al campo seleccionado del tablero requiere dos índices: el primero selecciona la fila; \n",
    "#el segundo: el número del campo dentro de la fila, el cual es un número de columna.\n",
    "\n",
    "print(tablero)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['TORRE', '-', '-', '-', '-', '-', '-', 'TORRE'], ['-', '-', '-', '-', '-', '-', '-', '-'], ['-', '-', '-', '-', '-', '-', '-', '-'], ['-', '-', '-', '-', 'PEON', '-', '-', '-'], ['-', '-', 'CABALLO', '-', '-', '-', '-', '-'], ['-', '-', '-', '-', '-', '-', '-', '-'], ['-', '-', '-', '-', '-', '-', '-', '-'], ['TORRE', '-', '-', '-', '-', '-', '-', 'TORRE']]\n"
     ]
    }
   ],
   "source": [
    "EMPTY = \"-\"\n",
    "TORRE = \"TORRE\"\n",
    "PEON = 'PEON'\n",
    "CABALLO = 'CABALLO'\n",
    "tablero = []\n",
    "\n",
    "for i in range(8):\n",
    "    fila = [EMPTY for i in range(8)]\n",
    "    tablero.append (fila)\n",
    "\n",
    "tablero[0][0] = TORRE\n",
    "tablero[0][7] = TORRE\n",
    "tablero[7][0] = TORRE\n",
    "tablero[7][7] = TORRE\n",
    "\n",
    "tablero[4][2] = CABALLO\n",
    "\n",
    "tablero[3][4] = PEON\n",
    "\n",
    "print(tablero)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Arreglo tridimensionales***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Imaginemos una urbanización compuestas por tres edificios, cada uno tiene 15 pisos y cada piso tiene 20 habitaciones...\n",
    "habitaciones = range(20)\n",
    "pisos = range(15)\n",
    "edificio = range(3)\n",
    "\n",
    "urbanizacion = [[[False for k in habitaciones] for j in pisos] for i in edificio] \n",
    "                 #False = 'desocupado'\n",
    "\n",
    "#Por ahora, todas las habitaciones de la urbanización están deshabitadas:\n",
    "\n",
    "print(urbanizacion)\n",
    "\n",
    "#Ocupemos algunas habitaciones:\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Ocupemos algunas habitaciones:\n",
    "\n",
    "urbanizacion[1][9][13] = True \n",
    "urbanizacion[1][10][13] = True\n",
    "urbanizacion[2][14][13] = True\n",
    "\n",
    "print(urbanizacion)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "19\n"
     ]
    }
   ],
   "source": [
    "#Verificar si hay disponibilidad en el piso 15 del tercer edificio:\n",
    "\n",
    "vacante = 0\n",
    "\n",
    "for numeroHabitacion in range(20):\n",
    "    if not urbanizacion[2][14][numeroHabitacion]: #: urbanizacion[2][14][numeroHabitacion] == True\n",
    "        vacante += 1\n",
    "\n",
    "print(vacante)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.4 64-bit",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.4"
  },
  "vscode": {
   "interpreter": {
    "hash": "110fe3fb9777db4ce1f884af3cc527a40b2c98427ad17781c021ef692bd3d28d"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}