sesion7.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "1b35bc86-22e7-4bc1-8a98-e5cb17197748",
   "metadata": {},
   "source": [
    "# Sesion 7: \n",
    "### - Datos Integrados: Listas, tuplas, set y diccionarios\n",
    "### - Condicionales\n",
    "### - Iterando sobre Datos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "62b5718c-b39e-4232-822d-f4a122360833",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "275014a2-3aea-445e-940a-8225c299620a",
   "metadata": {},
   "source": [
    "############"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7178a040-bac0-4314-88a8-9a19a492eb90",
   "metadata": {},
   "source": [
    "## Datos integrados\n",
    "Python dispone de diferentes estructuras de datos integrados: Listas, Tuplas, Diccionarios, Conjuntos, todos con diferentes calidades y usos.\n",
    "Las listas son uno de los 4 tipos de datos integrados en Python que se utilizan para almacenar colecciones de datos. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e806d8e7-b232-4086-9681-3561b20e9e07",
   "metadata": {},
   "source": [
    "### Tuplas\n",
    "* Una tupla es un conjunto ordenado e **inmutable**, no modificado de elementos del mismo o diferentes tipos.\n",
    "* Son muy similares a las listas (caso de listas son mutables) y comparten varias de sus funciones y métodos integrados.\n",
    "* Las tuplas se representan escribiendo los elementos entre paréntesis y separados por comas.\n",
    "* Se usa tupals si se tiene un control total sobre diferentes tipos de datos, y estos datos sean constantes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "81c9b804-e628-4251-8639-9db3c0a3942b",
   "metadata": {},
   "outputs": [],
   "source": [
    "elementos = (1, \"a\", 3.14)\n",
    "print(elementos)\n",
    "print(elementos[1])\n",
    "print(elementos[0:2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4883a61e-75e1-406f-933d-3333e11ed49d",
   "metadata": {},
   "outputs": [],
   "source": [
    "valores = (\"Python\", True, \"a\", 5)\n",
    "print(valores.index(\"a\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "10664aa5-6855-4c6d-82fe-a5529db8850d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Se puede usar los elementos de la tupla utilizando un bucle for.\n",
    "mitupla = (\"manzana\", \"banana\", \"durazno\")\n",
    "for x in mitupla:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7eac89cd-ffb3-4587-841c-fde6a79d05e7",
   "metadata": {},
   "source": [
    "### Conjuntos(Sets)\n",
    "* Un set es una colección que no posee órden, y por tanto, tampoco números de índex. \n",
    "* Esto quiere decir que no podemos decidir el orden en el cual aparecerán sus elementos.\n",
    "* Los conjuntos se utilizan para almacenar varios elementos en una sola variable.\n",
    "* Los conjuntos se escriben con llaves.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "08529832-bc9c-403b-82ec-05dd05d3062f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Se ignoran los valores duplicados:\n",
    "mi_conjunto = {\"manzana\", \"platano\", \"ciruela\", \"manzana\", \"manzana\"}\n",
    "print(mi_conjunto)\n",
    "# Para determinar cuántos elementos tiene un conjunto, use el método len ().\n",
    "print(len(mi_conjunto))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "10193a4f-5c73-4a92-abe0-29675ff71611",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Los elementos del conjunto pueden ser de cualquier tipo de datos:\n",
    "set1 = {\"apple\", \"banana\", \"cherry\"}\n",
    "set2 = {1, 5, 7, 9, 3}\n",
    "set3 = {True, False, False}\n",
    "\n",
    "print(set1)\n",
    "print(set2)\n",
    "print(set3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3207c023-1a09-4779-9076-218da62fbf38",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Un conjunto puede contener diferentes tipos de datos:\n",
    "set1 = {\"abc\", 34, True, 40, \"male\"}\n",
    "print(set1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "50a84ea7-93da-46c5-aa4e-39f38ddbefca",
   "metadata": {},
   "outputs": [],
   "source": [
    "thisset = {\"apple\", \"banana\", \"cherry\"}\n",
    "\n",
    "for x in thisset:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "98cfed3b-904c-4c53-a833-ef563a1e3e97",
   "metadata": {},
   "outputs": [],
   "source": [
    "# se puede anadir elementos a un set\n",
    "frutas = {\"manzana\", \"platano\", \"ciruela\"}\n",
    "frutas.add(\"naranja\")\n",
    "print(frutas)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e7bfa547-ccd0-4c38-8b88-1b76159dbb57",
   "metadata": {},
   "outputs": [],
   "source": [
    "# El objeto en el método update () no tiene que ser un conjunto, \n",
    "# puede ser cualquier objeto iterable (tuplas, listas, diccionarios, etc.).\n",
    "thisset = {\"apple\", \"banana\", \"cherry\"}\n",
    "mylist = [\"kiwi\", \"orange\"]\n",
    "thisset.update(mylist)\n",
    "print(thisset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "624aa7d2-2a77-4dde-a7f4-5af7cf3a37e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Elimina \"banana\" usando el método remove ():\n",
    "thisset = {\"apple\", \"banana\", \"cherry\"}\n",
    "\n",
    "thisset.remove(\"banana\")\n",
    "\n",
    "print(thisset)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7fa56ef8-0f9a-4b98-b1f7-44a8fc5ce406",
   "metadata": {},
   "source": [
    "### Diccionario\n",
    "* Son un tipo de estructuras de datos que permite guardar un conjunto no ordenado de pares clave-valor, siendo las claves únicas dentro de un mismo diccionario \n",
    "* Un diccionario es una colección ordenada *, modificable y que no admite duplicados.\n",
    "* Los diccionarios se escriben con llaves y tienen claves y valores:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8d288f64-9530-4db6-9753-3140f84b97cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# se encierra el listado de valores entre llaves. \n",
    "# Las parejas de clave y valor se separan con comas, \n",
    "# y la clave y el valor se separan con dos puntos.\n",
    "diccionario = {'nombre' : 'Ana', 'edad' : 28, 'cursos': ['Python','R','stata'] }\n",
    "print(diccionario)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d1397c65-0764-4277-8e42-f93bab3d6064",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Podemos acceder al elemento de un Diccionario mediante la clave de este elemento, como veremos a continuación:\n",
    "print(diccionario['nombre']) #Ana\n",
    "print(diccionario['edad'])#28\n",
    "print(diccionario['cursos']) #['Python','R','stata']\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f0f9ec3b-e5e5-4ae9-af23-a4ca07f5f95b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# También es posible insertar una lista dentro de un diccionario. \n",
    "# Para acceder a cada uno de los cursos usamos los índices:\n",
    "print(diccionario['cursos'][0])#Python\n",
    "print(diccionario['cursos'][1])#R\n",
    "print(diccionario['cursos'][2])#stata"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6a244fa4-733a-4c4a-9984-f11d11767225",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Para recorrer todo el Diccionario, podemos hacer uso de la estructura for:\n",
    "for i in diccionario:\n",
    "    print(i, \":\", diccionario[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3378b559-8d95-41a9-8e74-aec41c4d3a06",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejercicio\n",
    "diccionario = {\"clave1\":234, \"clave2\":True, \"clave3\":\"Valor 1\", \"clave4\":[1,2,3,4]}\n",
    "print(diccionario)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1396796-a0bf-4f44-a247-07eff418ef8f",
   "metadata": {},
   "source": [
    "### Hay cuatro tipos de datos de recopilación en el lenguaje de programación Python:\n",
    "* Las listas son una colección ordenada y modificable. Permite miembros duplicados.\n",
    "* Las Tuplas son una colección ordenada e inmutable. Permite miembros duplicados.\n",
    "* Los conjuntos es una colección que no está ordenada ni indexada. No hay miembros duplicados.\n",
    "* El diccionario es una colección ordenada * y modificable. No hay miembros duplicados."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37ab50a6-243d-4a5f-9c6b-211bdc291aa5",
   "metadata": {},
   "source": [
    "# Condicionales\n",
    "Utiliza las declaraciones if para controlar si se ejecuta o no un bloque de código.\n",
    "\n",
    "Una declaración if (más propiamente llamada declaración condicional) controla si algún bloque de código se ejecuta o no."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27fefc34-7d60-41d1-8a72-8f68b4a6a3fe",
   "metadata": {},
   "source": [
    "### Python admite las condiciones lógicas habituales de las matemáticas:\n",
    "\n",
    "* Es igual a: a == b\n",
    "* No es igual a: a! = B\n",
    "* Menor que: a < b\n",
    "* Menor o igual a: a <= b\n",
    "* Mayor que: a > b\n",
    "* Mayor o igual a: a > = b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "216a9190-48f0-4853-879a-129b486c39c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "9 <= 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0d21a90d-649d-4be9-aa1e-600cf0c417b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "'hola' != 'Hola'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9c12b049-37aa-4d56-bd03-3dcba9d2110a",
   "metadata": {},
   "outputs": [],
   "source": [
    "2 + 2 == \"4\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90c9c790-5b80-4d2c-9b17-5890f6d280d8",
   "metadata": {},
   "source": [
    "* Estas condiciones se pueden utilizar de varias formas, más comúnmente en \"sentencias if\" y bucles.\n",
    "\n",
    "* Una \"instrucción if\" se escribe utilizando la palabra clave if.\n",
    "* La estructura es similar a una declaración for:\n",
    "\n",
    "* La primera línea se abre con if y termina con dos puntos\n",
    "\n",
    "* El cuerpo que contiene una o más declaraciones es indentado (generalmente por 4 espacios)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d78cecb-8bc0-4bd2-9388-79856b0d68fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejemplo declaracion condicional;\n",
    "name = 'Maisha'\n",
    "if name == 'Maisha':\n",
    "    print('Hi, Maisha!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "21e456b6-2025-4bee-b78e-639fde417ee7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejemplo declaracion condicional;\n",
    "mass = 3.54\n",
    "if mass > 3.0:\n",
    "    print(mass, 'is large')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d217deb3-f94f-4615-92d5-6c4aad5ee2fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# no se ejecuta\n",
    "mass = 2.07\n",
    "if mass > 3.0:\n",
    "    print (mass, 'is large')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aeb72eed-99bd-4432-a141-867bcdb309c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejercicio \n",
    "# En este ejemplo usamos dos variables, a y b, que se usan como parte de la instrucción \n",
    "# if para probar si b es mayor que a. Como a es 33 y b es 200, \n",
    "# sabemos que 200 es mayor que 33, por lo que imprimimos en la pantalla que \"b es mayor que a\n",
    "a = 33\n",
    "b = 200\n",
    "if b > a:\n",
    "    print(\"b mayor que a\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "837de8c2-26f1-42b9-a1fb-ec83afb9f073",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejercicio\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40e5d024-0f2c-4754-860e-f720e87eeab5",
   "metadata": {},
   "source": [
    "### Las sentencias condicionales a menudo se usan dentro de bucles.\n",
    "* No tiene mucho sentido usar una sentencia condicional cuando conocemos el valor (como arriba).\n",
    "* Pero es útil cuando tenemos una colección de datos para procesar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "967ee776-868b-4656-8489-f73c4400d20b",
   "metadata": {},
   "outputs": [],
   "source": [
    "masses = [3.54, 2.07, 9.22, 1.86, 1.71]\n",
    "for m in masses:\n",
    "    if m > 3.0:\n",
    "        print(m, 'is large')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d4b0592-1542-4f04-91bc-9bd320c2389d",
   "metadata": {},
   "source": [
    "## Utiliza else para ejecutar un bloque de código cuando una condición if no es verdadera.\n",
    "* La palabra clave **else** captura cualquier cosa que no sea detectada por las condiciones anteriores.\n",
    "* else se puede usar después de un if.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "714ac183-95d6-497c-bbd3-ef78de2bf025",
   "metadata": {},
   "outputs": [],
   "source": [
    "mi_gato = 'tiene hambre'\n",
    "\n",
    "if mi_gato == 'tiene hambre':\n",
    "    print('tu gato tiene hambre. Por favor aliméntalo.')\n",
    "else:\n",
    "    print('tu gato no tiene hambre ahora')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f5254bb4-cd27-4f28-93ad-eb862c527e7d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejercicio\n",
    "velocity = 10.0\n",
    "if velocity > 20.0:\n",
    "    print('moving too fast')\n",
    "else:\n",
    "    print('adjusting velocity')\n",
    "    velocity = 50.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "17eff2e2-28e3-4e0c-9896-557bda6f2d74",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Else nos permite especificar una alternativa para ejecutar cuando no se entra en la rama if\n",
    "masas = [3.54, 2.07, 9.22, 1.86, 1.71]\n",
    "for m in masas:\n",
    "    if m > 3.0:\n",
    "        print(m, 'es largo')\n",
    "    else:\n",
    "        print(m, 'es pequeño')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53cd79ec-b024-4c3f-8416-406794feb394",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejercicio\n",
    "x = 41\n",
    "\n",
    "if x > 10:\n",
    "    print(\"Above ten,\")\n",
    "if x > 20:\n",
    "    print(\"and also above 20!\")\n",
    "else:\n",
    "    print(\"but not above 20.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c936b1b0-80c2-4690-bb1a-8bbad772bc87",
   "metadata": {},
   "source": [
    "## Usa elif para especificar verificaciones adicionales.\n",
    "* Tal vez desees proporcionar varias opciones alternativas, cada una con su propia verificación.\n",
    "* Usa elif (abreviatura de” else if “) y una condición para especificarlos. (sino si)\n",
    "* Siempre asociado con un if.\n",
    "* Debe venir antes de else (que “trata todo lo demás”).\n",
    "\n",
    "\n",
    "Usar la condición elif se usa para incluir múltiples expresiones condicionales después de la condición if o entre las condiciones if y else"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b9b2be41-80a6-4dd4-8bf0-9d9e7bebe9f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "pressure = 71.9\n",
    "\n",
    "if pressure > 50.0:\n",
    "    pressure = 25.0\n",
    "elif pressure <= 50.0:\n",
    "    pressure = 0.0\n",
    "# endif\n",
    "print(pressure)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ef4f761a-bd47-4fed-bf7c-1d6356712148",
   "metadata": {},
   "outputs": [],
   "source": [
    "masses = [3.54, 2.07, 9.22, 1.86, 1.71]\n",
    "for m in masses:\n",
    "    if m > 9.0:\n",
    "        print(m, 'is HUGE')\n",
    "    elif m > 3.0:\n",
    "        print(m, 'is large')\n",
    "    else:\n",
    "        print(m, 'is small')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c892084-5741-4df5-8bc8-92767cbeb39f",
   "metadata": {},
   "source": [
    "## Las condiciones se verifican una vez, en orden.\n",
    "* Python recorre las ramas de las sentencias condicionales en orden, verificando cada una por turno.\n",
    "* Por lo que el orden es importante."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9c1985c7-4a86-47e4-8058-d7479b3859c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "grade = 75\n",
    "if grade >= 90:\n",
    "    print('grade is A')\n",
    "elif grade >= 80:\n",
    "    print('grade is B')\n",
    "elif grade >= 70:\n",
    "    print('grade is C')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e53e8aca-5e22-4f56-a5b2-02edb724ed22",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejercicio\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8dd13f3b-31cb-4f26-b1ab-59813d814557",
   "metadata": {},
   "outputs": [],
   "source": [
    "list(range(5))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "51818008-baf0-48c0-acf8-7ba7726e7f96",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A menudo se usa condicionales en un bucle para “evolucionar” los valores de las variables.\n",
    "velocity = 10.0\n",
    "\n",
    "for i in range(5): # execute the loop 5 times\n",
    "    print(i, ':', velocity)\n",
    "    if velocity > 20.0:\n",
    "        print('moving too fast')\n",
    "        velocity = velocity - 5.0\n",
    "    else:\n",
    "        print('moving too slow')\n",
    "        velocity = velocity + 10.0\n",
    "        \n",
    "print('final velocity:', velocity)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b945ae82-0846-46dd-b2c6-5aeed40ab6ec",
   "metadata": {},
   "source": [
    "#### Al igual que con la aritmética, debes usar paréntesis siempre que se presente una posible ambigüedad. Una buena regla general es siempre usar paréntesis al mezclar and y or en la misma condición. Es decir, en lugar de:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "935e7610-f7f1-48e8-9b2f-553108fa0427",
   "metadata": {},
   "source": [
    "# Iterando Sobre Datos\n",
    "* Usa un bucle for para procesar archivos dando una lista de sus nombres.\n",
    "* Un nombre de archivo es una cadena de caracteres.\n",
    "* Y las listas pueden contener cadenas de caracteres."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a3ced1c-51ac-475d-8ea1-4a773a605335",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "for filename in ['data/gapminder_gdp_africa.csv', 'data/gapminder_gdp_asia.csv']:\n",
    "    data = pd.read_csv(filename, index_col='country') #abrir el csv\n",
    "    print(filename, data.min())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b24a0cfe-9a21-4d6b-a89e-4ae84c71d3aa",
   "metadata": {},
   "source": [
    "## Usa glob.glob para encontrar conjuntos de archivos cuyos nombres coinciden con un patrón.\n",
    "En Unix, el término “globbing” significa “coincidir un conjunto de archivos con un patrón”.\n",
    "Los patrones más comunes son:\n",
    "* significa “coincide con cero o más caracteres”\n",
    "? significa “coincide exactamente con un carácter”\n",
    "Python contiene la biblioteca [glob] (https://docs.python.org/3/library/glob.html) para proporcionar la funcionalidad de los patrones de coincidencia\n",
    "La biblioteca [glob] (https://docs.python.org/3/library/glob.html) contiene una función también llamada glob para encontrar coincidencias con patrones de archivo\n",
    "Por ejemplo, glob.glob('*.txt') coincide con todos los archivos en el directorio actual cuyos nombres terminan con .txt.\n",
    "El resultado es una lista (posiblemente vacía) de cadenas de caracteres."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "189ddf1b-2296-46c7-98d2-07fd3908916b",
   "metadata": {},
   "outputs": [],
   "source": [
    "import glob\n",
    "print('all csv files in data directory:', glob.glob('data/*.csv'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0b6d4c70-1d79-4689-848d-12c1ccdc1d41",
   "metadata": {},
   "outputs": [],
   "source": [
    "print('all PDB files:', glob.glob('*.pdb'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26eaf501-94d8-4202-b9eb-1b265e9a94bd",
   "metadata": {},
   "source": [
    "### Usa glob y for para procesar grupos de archivos.\n",
    "Ayuda mucho si los archivos se nombran y almacenan de manera sistemática y consistente de forma que patrones simples encuentren los datos correctos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d5856cff-5542-47d6-be94-36b8f0c278c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "for filename in glob.glob('data/gapminder_*.csv'):\n",
    "    data = pd.read_csv(filename)\n",
    "    print(filename, data['gdpPercap_1952'].min())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b132d87e-0789-4408-91fd-fed498857297",
   "metadata": {},
   "source": [
    "* Esto incluye todos los datos, así como datos por región.\n",
    "* Usa un patrón más específico en los ejercicios para excluir todo el conjunto de datos.\n",
    "* Pero nota que el mínimo de todo el conjunto de datos también es el mínimo de uno de los conjuntos de datos, lo cual es un buen control sobre la corrección."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e7413bd-d2bd-4aec-878c-dc1e4d104588",
   "metadata": {},
   "source": [
    "## Puntos Clave\n",
    "* Utiliza las declaraciones if para controlar si se ejecuta o no un bloque de código.\n",
    "\n",
    "* Las sentencias condicionales a menudo se usan dentro de bucles.\n",
    "\n",
    "* Usa else para ejecutar un bloque de código cuando una condición if no es verdadera.\n",
    "\n",
    "* Usa elif para especificar verificaciones adicionales.\n",
    "\n",
    "* Las condiciones se verifican una vez, en orden.\n",
    "\n",
    "* Crea una tabla que muestre los valores de las variables para rastrear la ejecución de un programa"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a8729b1-4525-43ce-9a8e-b799482f776c",
   "metadata": {},
   "source": [
    "* Usar un bucle for para procesar el archivos dando una lista de sus nombres.\n",
    "\n",
    "* Usar glob.glob para encontrar conjuntos de archivos cuyos nombres coinciden con un patrón.\n",
    "\n",
    "* Usar glob y for para procesar un grupo de archivos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "add5621b-167e-4f26-a227-3375a6a2a480",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}