sesion6.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ed020662-5838-48aa-bb7c-69c2b8d92012",
   "metadata": {},
   "source": [
    " # Sesion 6: \n",
    "## - Lista\n",
    "## - Bucles For"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1fd786c3-63d5-4014-8ec3-af6c3adbeb76",
   "metadata": {},
   "source": [
    "### Lista\n",
    "Las listas se utilizan para almacenar varios elementos en una sola variable.\n",
    "Las listas son uno de los 4 tipos de datos integrados en Python \n",
    "que se utilizan para almacenar colecciones de datos, \n",
    "los otros 3 son **Tuplas, Set y Dictionary**, todos con diferentes calidades y usos.\n",
    "\n",
    "* Usa una lista para almacenar muchos valores juntos.\n",
    "* Contenidos entre corchetes [...].\n",
    "* Valores separados por comas ,.\n",
    "* Usa len para averiguar cuántos valores hay en una lista.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c365e966-ab76-4e65-9a06-58ff840bc101",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Crea una lista llamada \"mi_lista\" de frutas que te gustan\n",
    "mi_lista = [\"manzana\", \"platano\", \"chirimoya\"]\n",
    "print(mi_lista)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "917bb513-0595-40a1-8d95-313465d9dee0",
   "metadata": {},
   "source": [
    "* Los elementos de la lista están ordenados, se pueden modificar y permiten valores duplicados.\n",
    "* Los elementos de la lista están indexados, el primer elemento tiene índice [0], el segundo elemento tiene índice [1], etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a04f41a9-0ece-455c-ae06-7ce8cd5220d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejercicio: crea una lista llamada numeros = [3, 2, 6, 1, 7, 4]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "04992159-93eb-4904-b783-f950359af489",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Usa len para averiguar cuántos valores hay en una lista.\n",
    "pressures = [0.273, 0.275, 0.277, 0.275, 0.276]\n",
    "print('pressures:', pressures)\n",
    "print('length:', len(pressures))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8b82fbab-8225-4f05-937c-ee22e7981897",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejercicio: crea una lista llamada vocales = ['a', 'e', 'i', 'o', 'u'] y usa len para saber los valores de esa lista\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e28a5169-9b2c-410f-89ed-adfb511f9df5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Los elementos de la lista pueden ser cadena de strings, float, int y booleanos\n",
    "list1 = [\"manzana\", \"platano\", \"frutilla\", \"mango\", \"durazno\"]\n",
    "list2 = [2, 0, 4, 38,  57]\n",
    "list3 = [0.273, 0.275, 0.277, 0.275, 0.276]\n",
    "list4 = [True, False, False, False, True]\n",
    "\n",
    "print(list1)\n",
    "print(list2)\n",
    "print(list3)\n",
    "print(list4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4c7a579d-fd27-467c-bc02-0345f696a968",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejercicio: Crea una lista que se llame elementos = [3, 'a', 8, 7.2, 'hola', True]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a28cf0d6-f65c-4591-a320-2c1a661afe00",
   "metadata": {},
   "source": [
    "## Usa el índice de un elemento para buscar en una lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "592e49f7-e6d3-4298-ba26-0f5b96e71b02",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Como en las secuencias de caracteres.\n",
    "print(pressures)\n",
    "#print(pressures[0])\n",
    "#print('cuarto elemento de pressures:', pressures[4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "014f5e92-bbb9-4f77-bc0d-f27fa6f5bace",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejercicio: de la secuencia numeros encuentra el quinto elemento\n",
    "numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "114a67b3-45b9-41b6-9b49-bc56bb5d7757",
   "metadata": {},
   "source": [
    "## Los valores de las listas se pueden reemplazar asignándole un nuevo valor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "94581823-cf49-4c50-8287-1f8f7c54067a",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Usa un índice a la izquierda de la asignación para reemplazar un valor.\n",
    "pressures = [0.273, 0.275, 0.277, 0.275, 0.276]\n",
    "print('pressures:', pressures)\n",
    "pressures[0] = 0.265\n",
    "print('pressures es ahora:', pressures)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aa632792-1100-4040-978b-1e742aa4550a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reemplaza el valor tercero de la lista numeros con 30\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5db7a12-d8d4-4292-96e8-e817837090c1",
   "metadata": {},
   "source": [
    "# Agregar elementos a una lista \n",
    "* append es un método de las listas.Como una función, pero vinculada a un objeto particular.\n",
    "* extend es similar a append, pero permite combinar dos listas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fbb020de-81c0-4752-bf8b-46a237621453",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Usa list_name.append para agregar elementos al final de una lista\n",
    "primos = [2, 3, 5, 7]\n",
    "print('los numeros primos inicialmente son:', primos)\n",
    "primos.append(11)\n",
    "primos.append(13)\n",
    "print('Los numeros primos ahora son :', primos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5142fcf4-ed65-492d-b1b9-79127aea337f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejercicio \n",
    "#Crea una lista de items de tu desayuno favorito e incluye los items queso y mantequilla con los metodos append y extend.\n",
    "desayuno = ['pan', 'leche', 'huevo', 'cafe']\n",
    "print('mi desayuno favorito consta de:', desayuno)\n",
    "desayuno.append('queso')\n",
    "desayuno.append('mantequilla')\n",
    "print('mi desayuno consta de:', desayuno)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9c7c2fb2-ef71-4ee6-875a-035be7f402a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imprime los numeros primos usando extend\n",
    "print(\"Los numeros primos son:\", primos)\n",
    "numeros_primos = [17, 19, 23, 29]\n",
    "mas_numeros_primos = [31, 37, 41, 43, 47]\n",
    "primos.extend(numeros_primos)\n",
    "print('Los numeros primos ahora son:', primos)\n",
    "primos.append(mas_numeros_primos)\n",
    "print('Finalmente los numeros primos del 1 al 50 son:', primos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "32e8e70c-ce65-4059-8ef9-8b080e78774e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# También es posible utilizar el operador de concatenación + para unir dos listas en una sola. \n",
    "#El resultado es una nueva lista con los elementos de ambas:\n",
    "lista_1 = [1, 2, 3]\n",
    "lista_2 = [4, 5, 6]\n",
    "nueva_lista = lista_1 + lista_2\n",
    "print(nueva_lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76b45372-55bd-459b-8c14-39a2207b3f6f",
   "metadata": {},
   "source": [
    "## Encontraremos otros métodos de las listas a medida que avancemos.\n",
    "* puedes entrar aqui https://docs.python.org/es/3/tutorial/datastructures.html#list-comprehensions\n",
    "* Usa help(list) para ver un avance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "30f85dd4-653a-4e46-b82b-5daeeb178f72",
   "metadata": {},
   "outputs": [],
   "source": [
    "help(list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6790ab9a-c0c9-42f3-bf48-eae041fdb001",
   "metadata": {},
   "source": [
    "## Usa del para remover elementos de una lista.\n",
    "* del list_name[index] remueve un elemento de una lista y la acorta.\n",
    "* No es una función o un método, es una sentencia del lenguaje."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "05e60520-769c-49d2-897c-ddfe634864e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "primes = [2, 3, 5, 7, 9]\n",
    "print('primes antes de remover el último elemento:', primes)\n",
    "del primes[4]\n",
    "print('primes después de remover el último elemento:', primes)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abb33066-1b89-42b1-8494-9cb81623574f",
   "metadata": {},
   "source": [
    "## La lista vacía no contiene valores.\n",
    "* Usa [] para representar una lista que no contiene ningún valor.\n",
    "“El cero de las listas.”\n",
    "*Útil como punto de partida para recolectar valores. (que veremos mas adelante)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1fde21c5-fd15-4550-a399-d698203a4bf2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejemplo\n",
    "values = []\n",
    "values.append(1)\n",
    "values.append(3)\n",
    "values.append(5)\n",
    "print('primera vez:', values)\n",
    "values = values[1:]\n",
    "print('segunda vez:', values)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04eb0b15-d727-4363-afe8-ab3b932b0d78",
   "metadata": {},
   "source": [
    "## Las listas pueden contener valores de diferentes tipos.\n",
    "Una única lista puede contener números, cadenas de string y otros distintos tipos de objetos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f302a52f-b5e0-4142-8019-a8d497102d0e",
   "metadata": {},
   "outputs": [],
   "source": [
    "goals = [1, \"Create lists.\", 2, \"Extract items from lists.\", 3, \"Modify lists.\", True]\n",
    "print(goals)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4271d864-a015-4242-87a3-cb4917005374",
   "metadata": {},
   "source": [
    "## Las secuencias de caracteres pueden indexarse de la misma manera que las listas.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "06a35dc3-7b83-470f-b260-5a8a5f892a73",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Obtén caracteres individuales de una secuencia de caracteres utilizando índices entre corchetes.\n",
    "elemento = 'carbon'\n",
    "print('caracter cero:', elemento[0])\n",
    "print('tercer caracter:', elemento[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0edf5680-9dc0-4357-95bd-f584ee117b77",
   "metadata": {},
   "source": [
    "## Las secuencias de caracteres son inmutables.\n",
    "* No se pueden cambiar los caracteres de una secuencia de caracteres después de que se haya creado.\n",
    "Inmutable: no se puede cambiar luego de su creación.\n",
    "* Por el contrario, las listas son mutables: se pueden modificar.\n",
    "* Python considera la secuencia de caracteres como un único valor con partes, no una colección de valores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6b9bf042-4b13-44ca-ae9c-3b05bbdfc4a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "element[0] = 'C'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e3ca309-4ddd-47a7-9401-b00d392219b9",
   "metadata": {},
   "source": [
    "## Indexar más allá del final de una colección es un error.\n",
    "* Python reporta un IndexError si intentamos acceder a un valor que no existe.\n",
    "* Este es un tipo de error de ejecución.\n",
    "* No se puede detectar mientras se analiza el código porque el índice podría calcularse en función de los datos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "863fd415-68db-40aa-a6dd-9f223b2f15f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "print('El elemento número 99 es:', element[99])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09089207-3fd5-46e9-8afc-bf1d52015a5a",
   "metadata": {},
   "source": [
    "### ¿Qué muestran estos dos programas? \n",
    "sorted(letters) devuelve una copia ordenada de la lista letters (la lista original letters permanece sin cambios), mientras que letters.sort() ordena la lista letters en si misma y no devuelve nada."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "87afe019-1139-470a-937c-21a40548f114",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Programa A\n",
    "letters = list('gold')\n",
    "result = sorted(letters)\n",
    "print('letters es', letters, 'y result es', result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e446dc3b-1fda-450d-83a7-b7d7d5cec0e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Programa B\n",
    "letters = list('gold')\n",
    "result = letters.sort()\n",
    "print('letters es', letters, 'y result es', result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8cfeac03-8209-449d-b31b-d7172df4da0b",
   "metadata": {},
   "source": [
    "# Bucles For\n",
    "* Un bucle for ejecuta comandos una vez para cada valor en una colección.\n",
    "* Hacer cálculos sobre los valores en una lista uno por uno es tan incómodo, mas aun si la lista tiene varios valores.\n",
    "* **Un bucle for** le dice a Python que ejecute algunas instrucciones una vez por cada valor de una lista, una secuencia de caracteres,  o alguna otra colección."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8be96c18-dafe-43c4-8b2f-75d9123f9cb9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Un bucle for \n",
    "for number in [2, 3, 5]:\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2d352f6e-4f19-4a5f-b30d-0b96a90204c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Este bucle for es equivalente a:\n",
    "print(2)\n",
    "print(3)\n",
    "print(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "55254854-723c-47fd-8cd7-3f18f69f9580",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejemplo:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e36b48a-2fe7-4367-867a-dd1adf377b8a",
   "metadata": {},
   "source": [
    "## Un bucle for se compone de una colección, una variable de control y un cuerpo.\n",
    "* La colección, [2, 3, 5], es sobre lo que se está ejecutando el bucle.\n",
    "* El cuerpo, print (number), especifica qué hacer para cada valor en la colección.\n",
    "* La variable de control, number, es lo que cambia para cada iteración del bucle.\n",
    "* El “valor actual de la variable”."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0905a478-03e3-4ec4-88d1-2bb5622bf54f",
   "metadata": {},
   "outputs": [],
   "source": [
    "for number in [2, 3, 5]:\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc2d0840-f395-431c-9632-bcfe08e52731",
   "metadata": {},
   "source": [
    "## La primera línea del bucle for debe terminar con dos puntos, y el cuerpo debe estar indentado.\n",
    "* Los dos puntos al final de la primera línea indican el inicio de un bloque de instrucciones.\n",
    "* Python usa indentación.\n",
    "* Cualquier indentación consistente es legal, pero casi todos usan cuatro espacios."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c7accdd-761d-42d2-998b-66bf38f1bc7b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# La indentación es siempre importante en Python.\n",
    "for number in [2, 3, 5]:\n",
    "print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b203627c-89b9-4c3c-9dd0-577a5e40cd38",
   "metadata": {},
   "source": [
    "## Las variables de control pueden tener cualquier nombre.\n",
    "* Como todas las variables, las variables de control son:\n",
    "1. Creadas a petición.\n",
    "2. Sin significado: pueden usar cualquier nombre.\n",
    "3. Se recomienda que sea una en relacion a lo que se esta haciendo"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15d4b1df-9deb-4304-b662-fe60cb02b84e",
   "metadata": {},
   "source": [
    "## El cuerpo de un bucle puede contener muchas instrucciones.\n",
    "* Pero ningún bucle debería tener más de unas pocas líneas de longitud. Es difícil tener en mente grandes fragmentos de código."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b5a74287-0be9-43ff-8033-8ebc24b2053a",
   "metadata": {},
   "outputs": [],
   "source": [
    "primes = [2, 3, 5]\n",
    "for p in primes:\n",
    "    squared = p ** 2\n",
    "    cubed = p ** 3\n",
    "    print(p, squared, cubed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ed21fe6f-e3bb-4511-ab0c-1144f71edeab",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Se puede iterar sobre dos listas del mismo tamaño en un solo bucle con la función zip()\n",
    "A = [\"a\", \"b\", \"c\"]\n",
    "B = [\"a\", \"d\", \"e\"]\n",
    "\n",
    "for a, b in zip(A, B):\n",
    "    print(a, b, a == b)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d3d1f7d-01f0-4699-99ed-893fdd3ef60f",
   "metadata": {},
   "source": [
    "## Usa range para iterar sobre una secuencia de números.\n",
    "* La función incorporada range produce una secuencia de números.\n",
    "* No es una lista: los números se producen a pedido. para hacer que el bucle en grandes rangos sea más eficiente\n",
    "range(N) son los números 0..N-1\n",
    "* Exactamente los índices legales de una lista o secuencia de caracteres de longitud N"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "950d34a0-04a8-4c3d-bd8c-97290fa3d2de",
   "metadata": {},
   "outputs": [],
   "source": [
    "print('un range no es una lista: range(0, 5)')\n",
    "for number in range(0, 5):\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c8d014f2-75a2-4c51-904c-fab434920f87",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Ejercicio\n",
    "for i in range(5):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd1806e3-4a24-4ddf-a2b4-2d2272a35094",
   "metadata": {},
   "source": [
    "## El patrón Acumulador convierte muchos valores en uno.\n",
    "* Un patrón común en los programas es:\n",
    "* Inicializar una variable acumulador a cero, la secuencia de caracteres vacía o la lista vacía.\n",
    "* Actualizar la variable con valores de una colección."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0356b3df-4f84-468e-84e1-b9412c101e2c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Suma los primeros 10 números enteros.\n",
    "# total = 0\n",
    "for number in range(10):    \n",
    "    print(number + 1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "538ecd6b-b604-406a-b855-9f9de7b89aba",
   "metadata": {},
   "outputs": [],
   "source": [
    "total = 0\n",
    "for number in range(10):\n",
    "    total = total + (number + 1)\n",
    "print(total)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06ea8cab-b8bd-4058-a59a-e37818f80a2e",
   "metadata": {},
   "source": [
    "* Lee total = total + (number + 1) como:\n",
    "* Suma 1 al valor actual de la variable de control number.\n",
    "* Añade esto al valor actual de la variable acumuladora total.\n",
    "* Asigna esto a total, reemplazando el valor actual.\n",
    "* Tenemos que añadir number + 1 porque range produce 0..9, no 1..10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2a1a1707-61af-48c7-93be-4361cb796de8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Longitud total de las cadenas de texto en la lista: [\"red\", \"green\", \"blue\"] => 12\n",
    "total = 0\n",
    "for word in [\"red\", \"green\", \"blue\"]:\n",
    "    ____ = ____ + len(word)\n",
    "print(total)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "41efbb95-62cc-4d60-aab9-0b3f2c8561ec",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1c8b2f72-cda6-42ad-9f16-18836d33d5bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lista de longitudes de las palabras: [\"red\", \"green\", \"blue\"] => [3, 5, 4]\n",
    "lengths = ____\n",
    "for word in [\"red\", \"green\", \"blue\"]:\n",
    "    lengths.____(____)\n",
    "print(lengths)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e422fa9d-1a20-4a9a-b6bc-657efbf7dfb6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Concatena todas las palabras: [\"red\", \"green\", \"blue\"] => \"redgreenblue\"\n",
    "words = [\"red\", \"green\", \"blue\"]\n",
    "result = ____\n",
    "for ____ in ____:\n",
    "    ____\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4311c2c-e948-41c9-80ba-28ae936c97b9",
   "metadata": {},
   "source": [
    "## Puntos CLave"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c95e347-4df5-414c-a3ed-1c425b1175bc",
   "metadata": {},
   "source": [
    "### Lista\n",
    "Una lista es una estructura de datos y un tipo de dato en python con características especiales. Lo especial de las listas en Python es que nos permiten almacenar cualquier tipo de valor como enteros, cadenas y hasta otras funciones"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43c1600f-8ee3-4894-9d0e-2c36f0be6f93",
   "metadata": {},
   "source": [
    "### Bucle For\n",
    "\n",
    "Un bucle for ejecuta comandos una vez para cada valor en una colección.\n",
    "\n",
    "Un bucle for se compone de una colección, una variable de bucle y un cuerpo.\n",
    "\n",
    "La primera línea del bucle for debe terminar con dos puntos, y el cuerpo debe ser indentado.\n",
    "\n",
    "La indentación siempre es significativa en Python.\n",
    "\n",
    "Las variables de bucle se pueden llamar de cualquier forma (pero se recomienda encarecidamente tener un nombre significativo para la variable de bucle).\n",
    "\n",
    "El cuerpo de un bucle puede contener muchas instrucciones.\n",
    "\n",
    "Usa range para iterar sobre una secuencia de números.\n",
    "\n",
    "El patrón Acumulador convierte muchos valores en uno."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "016b560f-e7ed-4d8b-bfc7-8bfbd483cb96",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ff52f55b-f5de-4743-8155-81d8ea256404",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}