web_scraping_freeCodeCamp.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/GEJ1/web_scraping_freecodecamp/blob/main/web_scraping_freeCodeCamp.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HFbPvfyu3yaS"
      },
      "source": [
        "<center>\n",
        "<img src=\"https://d33wubrfki0l68.cloudfront.net/774b60156d8f103170dc66f3ad10310941114653/da262/img/fcc_secondary_large.svg\" width=\"600\" height=\"auto\"/>\n",
        "\n",
        "# **Web scraping con Python**\n",
        "\n",
        "## *Material complementario del curso dictado por [Gustavo Juantorena](https://github.com/GEJ1) para **freeCodecamp** en español.*\n",
        "\n",
        "### **Link a la web de práctica: https://scrapepark.org/courses/spanish/**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2T6lp5_w9Gi0"
      },
      "source": [
        "<center>\n",
        "\n",
        "### **Importante**: Los cambios que hagan en este cuaderno de Colab no se guardarán, lo ideal sería que hagan una copia del mismo en sus respectivas cuentas de Google Drive de la siguiente manera:\n",
        "\n",
        "### *Archivo > Guardar una copia en drive*\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UE_kUe2dlbbF"
      },
      "source": [
        "# **Hoja de ruta**\n",
        "\n",
        "## 1. Pedidos HTTP con **Requests**\n",
        "## 2. Uso basico de **APIs**\n",
        "## 3. Web Scraping con **Beautiful Soup**\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5UQcVg3CKSi1"
      },
      "source": [
        "# **Pedidos HTTP con requests**\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "32ZIp-taK6PE"
      },
      "outputs": [],
      "source": [
        "import requests\n",
        "import json"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "bc1hU64tLv-v"
      },
      "outputs": [],
      "source": [
        "# Hacemos un pedido a la página de wikipedia\n",
        "URL = 'https://es.wikipedia.org/'\n",
        "\n",
        "# Guardamos el objeto que nos devuelve\n",
        "respuesta = requests.get(URL)\n",
        "\n",
        "# print(f'Tipo de Objeto: {type(respuesta)} \\n')\n",
        "# print(f'Código de estado: {respuesta.status_code} \\n')\n",
        "print(f'Data: {respuesta.text} \\n')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z1AgS5HxPIPg"
      },
      "source": [
        "## **Headers**\n",
        "\n",
        "Una serie de datos que acompañan al pedido. Para saber más: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers\n",
        "\n",
        "\n",
        "El objeto `Response` de `requests` tiene los siguientes elementos principales:\n",
        "\n",
        "* `.text`\n",
        "* `.content`\n",
        "* `.json()`\n",
        "* `.status_code`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "HBifgfShPKlV"
      },
      "outputs": [],
      "source": [
        "URL = 'https://scrapepark.org/courses/spanish/'\n",
        "\n",
        "headers = {\n",
        "    'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:52.0) Gecko/20100101 Firefox/52.0'\n",
        "}\n",
        "respuesta = requests.get(URL, headers=headers)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "sbA4w5LXhb-F"
      },
      "outputs": [],
      "source": [
        "respuesta.text"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6yF0A4Nl6K2d"
      },
      "source": [
        "Veamoslo en la práctica utilizando la siguiente web: http://httpbin.org/headers (útil para testear pedidos HTTP).\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yGvs4upI6KLv"
      },
      "outputs": [],
      "source": [
        "URL = 'http://httpbin.org/headers'\n",
        "resp = requests.get(URL)\n",
        "\n",
        "print('Respuesta sin headers:')\n",
        "print(resp.text)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "X94bg5Lfh1Uw"
      },
      "outputs": [],
      "source": [
        "print('Respuesta con headers:')\n",
        "nuestros_headers = {\n",
        "    'user-agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.105 Safari/537.36'\n",
        "    }\n",
        "resp_con_headers = requests.get(URL, headers = nuestros_headers)\n",
        "print(resp_con_headers.text)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NFVDnesOKZ7N"
      },
      "source": [
        "# **Uso basico de APIs**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Dd60DCLFhhvP"
      },
      "source": [
        "### Uso de API de manera directa"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i3rq7-cOLHuV"
      },
      "source": [
        "[Sunset and sunrise times API](https://sunrise-sunset.org/api)\n",
        "\n",
        "**Sirve para obtener la hora del amanecer y el ocaso de un determinado día**\n",
        "\n",
        "*Parámetros:*\n",
        "\n",
        "\n",
        "*  **lat** (float): Latitud en grados decimales(Obligatorio)\n",
        "*  **lng** (float): Longitud en grados decimales (obligatorio)\n",
        "*  **date** (string): Fecha en formato AAAA-MM-DD (opcional, por defecto usa el día actual)\n",
        "\n",
        "*Estructura de la query:*\n",
        "\n",
        "`https://api.sunrise-sunset.org/json?`\n",
        "\n",
        "`lat=36.7201600`\n",
        "\n",
        "`&`\n",
        "\n",
        "`lng=-4.4203400`\n",
        "\n",
        "`&`\n",
        "\n",
        "`date=2021-07-26`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "EIFWdHPVJsEi"
      },
      "outputs": [],
      "source": [
        "# Definimos los parametros de nuestra query\n",
        "latitud = -34.6\n",
        "longitud = -58.4\n",
        "fecha = '1816-07-09' # AAAA-MM-DD"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "oe0bMEQBJubx"
      },
      "outputs": [],
      "source": [
        "# Hacemos el pedido y guardamos la respuesta en una nueva variable\n",
        "respuesta_sunset = requests.get(f'https://api.sunrise-sunset.org/json?lat={latitud}&lng={longitud}&date={fecha}')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1KBTJWoYllvx"
      },
      "outputs": [],
      "source": [
        "type(respuesta_sunset)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "dZkY8OHKJxFN"
      },
      "outputs": [],
      "source": [
        "# Para des-serializar el objeto (que era tipo 'HTTPResponse') y cargarlo como json\n",
        "datos_sunset = respuesta_sunset.json()\n",
        "print(datos_sunset)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7kr6nPiQl1gK"
      },
      "outputs": [],
      "source": [
        "type(datos_sunset)\n",
        "datos_sunset.keys()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Z8lcUaepJ2IJ"
      },
      "outputs": [],
      "source": [
        "# Evaluamos el status del pedido\n",
        "sunset_status = datos_sunset['status']\n",
        "print(f'Status: {sunset_status}')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "AVf-wnSKmAKg"
      },
      "outputs": [],
      "source": [
        "datos_sunset['results']['sunset']"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vDCpwey_J6J1"
      },
      "outputs": [],
      "source": [
        "# Podemos ver su contenido ya que es son diccionarios anidados:\n",
        "sunset = datos_sunset['results']['sunset']\n",
        "print(f'El {fecha} el sol se ocultó a las {sunset} (UTC)')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_1N7IJIiKIIC"
      },
      "outputs": [],
      "source": [
        "# tambien podriamos iterar sobre sus claves\n",
        "print(\"Iterando data_sunset['results']:\")\n",
        "for elemento in datos_sunset['results']:\n",
        "  print(elemento)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KcHglp06hnfy"
      },
      "source": [
        "### **Uso de API por medio de una librería: Wikipedia**\n",
        "\n",
        "Wikipedia-API es un *wrapper* de Python fácil de usar para la API de Wikipedia. Admite la extracción de textos, secciones, enlaces, categorías, traducciones, etc.\n",
        "\n",
        "Repositorio: https://github.com/martin-majlis/Wikipedia-API\n",
        "\n",
        "Documentación: https://wikipedia-api.readthedocs.io/en/latest/README.html\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "EqWcjExWiihS"
      },
      "outputs": [],
      "source": [
        "# Instalamos el paquete porque no viene con Colab\n",
        "!pip3 install --force-reinstall -v  \"wikipedia-api==0.5.8\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9WTgRAA3sjdG"
      },
      "outputs": [],
      "source": [
        "# Ahora si podemos importarlo\n",
        "import wikipediaapi\n",
        "\n",
        "# Chequear versión\n",
        "print(wikipediaapi.__version__)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "id": "VLY7a8imigip",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6e7e4d43-9c13-4eec-fb46-3c2db4f6af2a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "wikipedia_programacion es un objeto de tipo: \n",
            " \n",
            "<class 'wikipediaapi.WikipediaPage'>\n"
          ]
        }
      ],
      "source": [
        "# Instanciamos la clase wikipediaapi y utilizamos el metodo Wikipedia con el parametro de idioma\n",
        "IDIOMA = 'es'\n",
        "wiki_wiki = wikipediaapi.Wikipedia(IDIOMA)\n",
        "\n",
        "# Usamos el metodo page para y hacemos un pedido con una palabra clave\n",
        "PALABRA_CLAVE = 'programación'\n",
        "wikipedia_programacion = wiki_wiki.page(PALABRA_CLAVE)\n",
        "\n",
        "print(f'wikipedia_programacion es un objeto de tipo: \\n \\n{type(wikipedia_programacion)}')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "dK5pdTsYivt8"
      },
      "outputs": [],
      "source": [
        "# Resumen\n",
        "print(wikipedia_programacion.title)\n",
        "print(' ')\n",
        "print(wikipedia_programacion.summary)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UhukUmpni1Au"
      },
      "outputs": [],
      "source": [
        "# Url completa\n",
        "print(wikipedia_programacion.fullurl)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g-ZRRKjv8b4e"
      },
      "source": [
        "# **BeautifulSoup**\n",
        "Documentación oficial: https://beautiful-soup-4.readthedocs.io/en/latest/"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BGXRo8BWtIDc"
      },
      "source": [
        "## **Generalidades**\n",
        "\n",
        "Vamos a practicar con https://scrapepark.org/spanish/\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "id": "DemLUNc7d_W7"
      },
      "outputs": [],
      "source": [
        "from bs4 import BeautifulSoup\n",
        "import requests"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "T5XplMATeVXQ"
      },
      "outputs": [],
      "source": [
        "# Versiones\n",
        "import bs4 # Solo para el chequeo\n",
        "print(\"Versión de BeautifulSoup:\",bs4.__version__)\n",
        "print(\"Versión de requests:\", requests.__version__)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "OOJxCTeb2Sys"
      },
      "outputs": [],
      "source": [
        "# En caso de no tener la versión que se usa en este curso\n",
        "!pip3 install beautifulsoup4==4.11.2\n",
        "!pip3 install requests==2.27.1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "id": "YLnDRuoftSDX"
      },
      "outputs": [],
      "source": [
        "# Empezamos el scraping\n",
        "\n",
        "# 1. Obtener el HTML\n",
        "URL_BASE = 'https://scrapepark.org/courses/spanish/'\n",
        "pedido_obtenido = requests.get(URL_BASE)\n",
        "html_obtenido = pedido_obtenido.text\n",
        "\n",
        "# 2. \"Parsear\" ese HTML\n",
        "soup = BeautifulSoup(html_obtenido, \"html.parser\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "O1lXQ39Ao64s"
      },
      "outputs": [],
      "source": [
        "type(soup)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AS5-q5L-eLZ_"
      },
      "source": [
        "## **El método `find()`**\n",
        "\n",
        "Nos permite quedarnos con la información asociada a una etiqueta de HTML"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Jo7AkWAhh23W"
      },
      "outputs": [],
      "source": [
        "primer_h2 = soup.find('h2')\n",
        "print(primer_h2)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jP47spPBiYfB"
      },
      "outputs": [],
      "source": [
        "# Solo el texto\n",
        "print(primer_h2.text)\n",
        "\n",
        "# equivalente a:\n",
        "# print(soup.h2.text)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MFO_d99OeavG"
      },
      "source": [
        "## **El método `find_all()`**\n",
        "\n",
        "Busca **TODOS** los elementos de la página con esa etiqueta y devuelve una \"lista\" que los contiene (en realidad devuelve un objeto de la clase *bs4.element.ResultSet*)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6YlYosUFmc66"
      },
      "outputs": [],
      "source": [
        "h2_todos = soup.find_all('h2')\n",
        "print(h2_todos)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Az5VWD8qh5XP"
      },
      "outputs": [],
      "source": [
        "# ARGUMENTOS\n",
        "# Si usamos el parametro limit = 1, emulamos al metodo find\n",
        "h2_uno_solo = soup.find_all('h2',limit=1)\n",
        "print(h2_uno_solo)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "g_pjutuZh9wz"
      },
      "outputs": [],
      "source": [
        "# Podemos iterar sobre el objeto\n",
        "for seccion in h2_todos:\n",
        "  print(seccion.text)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Vm5TjiHV4lCR"
      },
      "outputs": [],
      "source": [
        "# get_text() para más funcionalidades\n",
        "for seccion in h2_todos:\n",
        "  print(seccion.get_text(strip=True))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H936ZYAerBXJ"
      },
      "source": [
        "## **Utilizando atributos de las etiquetas**\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GyPbqaejp4is"
      },
      "outputs": [],
      "source": [
        "# Clase\n",
        "divs = soup.find_all('div', class_ = \"heading-container heading-center\")\n",
        "\n",
        "for div in divs:\n",
        "  print(div)\n",
        "  print(\" \")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fVxip8F0iEYA"
      },
      "outputs": [],
      "source": [
        "# Todas las etiquetas que tengan el atributo \"src\"\n",
        "src_todos = soup.find_all(src=True)\n",
        "\n",
        "for elemento in src_todos:\n",
        "  if elemento['src'].endswith(\".jpg\"):\n",
        "    print(elemento)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pm4eVZCW6jjD"
      },
      "outputs": [],
      "source": [
        "#@title Ejercicio: Bajar todas las imagenes!\n",
        "\n",
        "url_imagenes = []\n",
        "\n",
        "for i, imagen in enumerate(src_todos):\n",
        "\n",
        "  if imagen['src'].endswith('png'):\n",
        "\n",
        "    print(imagen['src'])\n",
        "    r = requests.get(f\"https://scrapepark.org/courses/spanish/{imagen['src']}\")\n",
        "\n",
        "    with open(f'imagen_{i}.png', 'wb') as f:\n",
        "      f.write(r.content)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nxurw0jxiwm0"
      },
      "source": [
        "## **Tablas**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YyqtIpXMw9sx"
      },
      "outputs": [],
      "source": [
        "soup.find_all('iframe')[0]['src']"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qvrCha4Qwz1P"
      },
      "outputs": [],
      "source": [
        "# Información de tablas\n",
        "\n",
        "URL_BASE = 'https://scrapepark.org/courses/spanish'\n",
        "URL_TABLA = soup.find_all('iframe')[0]['src']\n",
        "\n",
        "request_tabla = requests.get(f'{URL_BASE}/{URL_TABLA}')\n",
        "\n",
        "html_tabla = request_tabla.text\n",
        "soup_tabla = BeautifulSoup(html_tabla, \"html.parser\")\n",
        "soup_tabla.find('table')\n",
        "\n",
        "productos_faltantes = soup_tabla.find_all(['th', 'td'], attrs={'style':'color: red;'})\n",
        "productos_faltantes = [talle.text for talle in productos_faltantes]\n",
        "\n",
        "print(productos_faltantes)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "OWDrRpN14mkR"
      },
      "outputs": [],
      "source": [
        "divs = soup.find_all('div', class_='detail-box')\n",
        "productos = []\n",
        "precios = []\n",
        "\n",
        "for div in divs:\n",
        "  if (div.h6 is not None) and ('Patineta' in div.h5.text):\n",
        "    producto = div.h5.get_text(strip=True)\n",
        "    precio = div.h6.get_text(strip=True).replace('$', '')\n",
        "    # Se puede agregar filtros\n",
        "    print(f'producto: {producto:<16} | precio: {precio}')\n",
        "    productos.append(producto)\n",
        "    precios.append(precio)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 38,
      "metadata": {
        "id": "fFOxFOsRretL",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5021ae88-400c-4cf0-e231-3a58c107eee9"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['75', '80', '68', '70', '75', '58', '80', '35', '165', '54', '99', '110']"
            ]
          },
          "metadata": {},
          "execution_count": 38
        }
      ],
      "source": [
        "precios"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "guSnGHLIrcp_"
      },
      "outputs": [],
      "source": [
        "productos"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2QphGTciOnZS"
      },
      "source": [
        "## **Cambios que dependen de la URL**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zW_XZj6TOqar"
      },
      "outputs": [],
      "source": [
        "URL_BASE = \"https://scrapepark.org/courses/spanish/contact\"\n",
        "\n",
        "for i in range(1,3):\n",
        "  URL_FINAL = f\"{URL_BASE}{i}\"\n",
        "  print(URL_FINAL)\n",
        "  r = requests.get(URL_FINAL)\n",
        "  soup = BeautifulSoup(r.text, \"html.parser\")\n",
        "  print(soup.h5.text)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mRw2htzlj9Wr"
      },
      "source": [
        "## **Datos que no sabemos en que parte de la página se encuentran**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "SClwgT23kDb_"
      },
      "outputs": [],
      "source": [
        "# Expresiones regulares\n",
        "import re\n",
        "\n",
        "# 1. Obtener el HTML\n",
        "URL_BASE = 'https://scrapepark.org/courses/spanish'\n",
        "pedido_obtenido = requests.get(URL_BASE)\n",
        "html_obtenido = pedido_obtenido.text\n",
        "\n",
        "# 2. \"Parsear\" ese HTML\n",
        "soup = BeautifulSoup(html_obtenido, \"html.parser\")\n",
        "\n",
        "telefonos = soup.find_all(string=re.compile(\"\\d+-\\d+-\\d+\"))\n",
        "telefonos"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1Sq_ZX03oPQ8"
      },
      "source": [
        "## **Moviéndonos por el árbol**\n",
        "\n",
        "Para saber más: https://www.crummy.com/software/BeautifulSoup/bs4/doc/#searching-the-tree"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QqzYlp0jnxAA"
      },
      "outputs": [],
      "source": [
        "copyrights = soup.find_all(string=re.compile(\"©\"))\n",
        "copyrights[0]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BYaiCi_tuSek"
      },
      "outputs": [],
      "source": [
        "primer_copyright = copyrights[0]\n",
        "primer_copyright.parent"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GDlAB53SuDf6"
      },
      "outputs": [],
      "source": [
        "# # Otro ejemplo con elementos al mismo nivel\n",
        "menu = soup.find(string=re.compile(\"MENÚ\"))\n",
        "# menu.parent\n",
        "menu.parent.find_next_siblings()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IrUz6btarWj6"
      },
      "source": [
        "## **Comentario sobre excepciones**\n",
        "https://docs.python.org/es/3/tutorial/errors.html"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "iSgBLoDFrs3I"
      },
      "outputs": [],
      "source": [
        "strings_a_buscar = [\"MENÚ\", \"©\", \"carpincho\", \"Patineta\"]\n",
        "\n",
        "for string in strings_a_buscar:\n",
        "  try:\n",
        "    resultado = soup.find(string=re.compile(string))\n",
        "    print(resultado.text)\n",
        "  except AttributeError:\n",
        "    print(f\"El string '{string}' no fue encontrado\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rnyPln5D4dsg"
      },
      "source": [
        "## **Almacenamiento de los datos**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 46,
      "metadata": {
        "id": "MizBsJA3gCQt"
      },
      "outputs": [],
      "source": [
        "productos.insert(0, \"productos\")\n",
        "precios.insert(0, \"precios\")\n",
        "# datos = dict(zip(productos, precios))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 47,
      "metadata": {
        "id": "qXUvdB2Mx5WD"
      },
      "outputs": [],
      "source": [
        "datos = dict(zip(productos, precios))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tsss7E0Ny4mU"
      },
      "outputs": [],
      "source": [
        "datos.items()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 49,
      "metadata": {
        "id": "YcIts8u56tA7"
      },
      "outputs": [],
      "source": [
        "import csv\n",
        "\n",
        "with open('datos.csv','w') as f:\n",
        "    w = csv.writer(f)\n",
        "    w.writerows(datos.items())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oEHvwn9Xw0sf"
      },
      "source": [
        "**BONUS!**\n",
        "Algunos ejercicios para seguir practicando:\n",
        "\n",
        "1. Las patinetas que salgan menos que $68\n",
        "2. Las patinetas que en su nombre tengan un numero mayor a 3\n",
        "3. Traer cualquier texto de la pagina que tenga la palabra descuento u oferta.\n",
        "5. Generar un archivo .csv con dos columnas: Una conteniendo el nombre del cliente y otra su testimonio."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 49,
      "metadata": {
        "id": "eCpy9QPW8Dwd"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}