Construyendo un Web Scraper de principio a fin

¿Qué es un raspador web?

Un Web Scraper es un programa que, literalmente, extrae o recopila datos de los sitios web. Tome el siguiente ejemplo hipotético, en el que podríamos construir un raspador web que iría a Twitter y recopilaría el contenido de los tweets.

En el ejemplo anterior, podríamos usar un raspador web para recopilar datos de Twitter. Podríamos limitar los datos recopilados a tweets sobre un tema específico o por un autor específico. Como puede imaginar, los datos que recopilamos de un raspador web se decidirían en gran medida por los parámetros que le damos al programa cuando lo construimos. Como mínimo, cada proyecto de raspado web necesitaría tener una URL desde la que raspar. En este caso, la URL sería twitter.com. En segundo lugar, un raspador web necesitaría saber qué etiquetas buscar para la información que queremos raspar. En el ejemplo anterior, podemos ver que es posible que tengamos mucha información que no querríamos eliminar, como el encabezado, el logotipo, los enlaces de navegación, etc. La mayoría de los tweets reales probablemente estarían en una etiqueta de párrafo, o tener una clase específica u otra característica de identificación. Saber cómo identificar dónde está la información en la página requiere un poco de investigación antes de construir el raspador.

En este punto, podríamos construir un raspador que recolectaría todos los tweets en una página. Esto podría ser útil. O bien, podríamos filtrar aún más el raspado, pero especificando que solo queremos raspar los tweets si contienen cierto contenido. Sin dejar de mirar nuestro primer ejemplo, es posible que solo nos interese recopilar tweets que mencionen una determinada palabra o tema, como "Gobernador". Podría ser más fácil recopilar un grupo más grande de tweets y analizarlos más tarde en el back-end. O bien, podríamos filtrar algunos de los resultados aquí de antemano.

¿Por qué son útiles los web scrapers?

Hemos respondido parcialmente a esta pregunta en la primera sección. El web scraping podría ser tan simple como identificar el contenido de una página grande o varias páginas de información. Sin embargo, una de las mejores cosas de raspar la web es que nos brinda la capacidad no solo de identificar información útil y relevante, sino que también nos permite almacenar esa información para su uso posterior. En el ejemplo anterior, es posible que deseemos almacenar los datos que hemos recopilado de los tweets para poder ver cuándo los tweets fueron más frecuentes, cuáles fueron los temas más comunes o qué personas se mencionaron con más frecuencia.

¿Qué requisitos previos necesitamos para construir un web scraper?

Antes de entrar en detalles sobre cómo funciona un raspador web, demos un paso atrás y hablemos sobre dónde encaja el raspado web en el ecosistema más amplio de tecnologías web. Eche un vistazo al sencillo flujo de trabajo a continuación:

La idea básica del raspado web es que estamos tomando datos HTML existentes, utilizando un raspador web para identificar los datos y convertirlos en un formato útil. La etapa final es tener estos datos almacenados como JSON o en otro formato útil. Como puede ver en el diagrama, podríamos usar cualquier tecnología que prefiramos para construir el raspador web real, como Python, PHP o incluso Node, solo por nombrar algunos. Para este ejemplo, nos centraremos en el uso de Python y la biblioteca que lo acompaña, Beautiful Soup. También es importante tener en cuenta aquí, que para construir un raspador web exitoso, necesitaremos estar al menos algo familiarizados con las estructuras HTML y formatos de datos como JSON.

Para asegurarnos de que todos estamos en la misma página, cubriremos cada uno de estos requisitos previos con cierto detalle, ya que es importante comprender cómo encaja cada tecnología en un proyecto de web scraping. Los requisitos previos de los que hablaremos a continuación son:

1. Estructuras HTML
2. Conceptos básicos de Python
3. Bibliotecas de Python
4. Almacenamiento de datos como JSON (Notación de objetos de JavaScript)

Si ya está familiarizado con alguno de estos, siéntase libre de pasar a continuación.

1. Estructuras HTML

1.a. Identificación de etiquetas HTML

Si no está familiarizado con la estructura de HTML, un excelente lugar para comenzar es abrir las herramientas para desarrolladores de Chrome. Otros navegadores como Firefox e Internet Explorer también tienen herramientas para desarrolladores, pero para este ejemplo, usaré Chrome. Si hace clic en los tres puntos verticales en la esquina superior derecha del navegador, y luego en la opción 'Más herramientas', y luego en 'Herramientas para desarrolladores', verá un panel emergente que se parece a lo siguiente:

Podemos ver rápidamente cómo está estructurado el sitio HTML actual. Todo el contenido contenido en 'etiquetas' específicas. El encabezado actual está en una etiqueta “<h3>”, mientras que la mayoría de los párrafos están en etiquetas “<p>”. Cada una de las etiquetas también tiene otros atributos como "clase" o "nombre". No necesitamos saber cómo construir un sitio HTML desde cero. Al construir un raspador web, solo necesitamos conocer la estructura básica de la web y cómo identificar elementos web específicos. Chrome y otras herramientas para desarrolladores de navegadores nos permiten ver qué etiquetas contienen la información que queremos recopilar, así como otros atributos como "clase", que pueden ayudarnos a seleccionar solo elementos específicos.

Veamos cómo se vería una estructura HTML típica:

Esto es similar a lo que acabamos de ver en las herramientas de desarrollo de Chrome. Aquí, podemos ver que todos los elementos en el HTML están contenidos dentro de las etiquetas de 'cuerpo' de apertura y cierre. Cada elemento también tiene su propia etiqueta de apertura y cierre. Los elementos anidados o sangrados en una estructura HTML indican que el elemento es un elemento secundario de su contenedor o elemento principal. Una vez que comenzamos a crear nuestro raspador web de Python, también podemos identificar los elementos que queremos raspar en función no solo del nombre de la etiqueta, sino también de si el elemento es un elemento secundario de otro elemento. Por ejemplo, podemos ver aquí que hay una etiqueta <ul> en esta estructura, lo que indica una lista desordenada. Cada elemento de la lista <li> es un elemento secundario de la etiqueta principal <ul>. Si quisiéramos seleccionar y raspar la lista completa, tal vez querríamos decirle a Python que tome todos los elementos secundarios de la etiqueta <ul>.

elementos HTML

Ahora, echemos un vistazo más de cerca a los elementos HTML. Partiendo del ejemplo anterior, aquí está nuestro <h1> o elemento de encabezado:

Saber especificar qué elementos queremos raspar puede ser muy importante. Por ejemplo, si le decimos a Python que queremos el elemento <h1>, estaría bien, a menos que haya varios elementos <h1> en la página. Si solo queremos el primer <h1> o el último, es posible que debamos ser específicos al decirle a Python exactamente lo que queremos. La mayoría de los elementos también nos dan atributos de "clase" e "id". Si quisiéramos seleccionar solo este elemento <h1>, podríamos hacerlo diciéndole a Python, en esencia, "Dame el elemento <h1> que tiene la clase "myClass". Los selectores de ID son aún más específicos, por lo que a veces, si un atributo de clase devuelve más elementos de los que queremos, seleccionar con el atributo ID puede ser la solución.

2. Conceptos básicos de Python

2.a. Configuración de un nuevo proyecto

Una ventaja de construir un web scraper en Python es que la sintaxis de Python es simple y fácil de entender. Podríamos estar en funcionamiento en cuestión de minutos con un web scraper de Python. Si aún no ha instalado Python, continúe y hágalo ahora:

Descargar Python _La sede oficial del lenguaje de programación Python_www.python.org

También tendremos que decidir sobre un editor de texto. Estoy usando ATOM, pero hay muchas otras opciones similares, que hacen relativamente lo mismo. Debido a que los raspadores web son bastante sencillos, nuestra elección de qué editor de texto usar depende completamente de nosotros. Si desea probar ATOM, no dude en descargarlo aquí:

Un editor de texto hackeable para el siglo XXI _En GitHub, estamos creando el editor de texto que siempre hemos querido: hackeable hasta la médula, pero accesible desde el primer día..._atom.io

Ahora que tenemos Python instalado y estamos usando un editor de texto de nuestra elección, creemos una nueva carpeta de proyecto de Python. Primero, navegue hasta donde queramos crear este proyecto. Prefiero tirar todo en mi escritorio ya sobrecargado. A continuación, cree una nueva carpeta y, dentro de la carpeta, cree un archivo. Llamaremos a este archivo "webscraper.py". También querremos crear un segundo archivo llamado "parsedata.py" en la misma carpeta. En este punto, deberíamos tener algo similar a esto:

Una diferencia obvia es que todavía no tenemos ningún dato. Los datos serán los que hayamos recuperado de la web. Si pensamos en cuál podría ser nuestro flujo de trabajo para este proyecto, podríamos imaginarlo con este aspecto:

En primer lugar, están los datos HTML sin procesar que se encuentran en la web. Luego, usamos un programa que creamos en Python para raspar/recolectar los datos que queremos. Luego, los datos se almacenan en un formato que podemos usar. Finalmente, podemos analizar los datos para encontrar información relevante. El raspado y el análisis serán manejados por scripts de Python separados. El primero recogerá los datos. El segundo analizará los datos que hemos recopilado.

Si se siente más cómodo configurando este proyecto a través de la línea de comandos, no dude en hacerlo.

2.b. Entornos virtuales de Python

Todavía no hemos terminado de configurar el proyecto. En Python, a menudo usaremos bibliotecas como parte de nuestro proyecto. Las bibliotecas son como paquetes que contienen funcionalidades adicionales para nuestro proyecto. En nuestro caso, usaremos dos bibliotecas: Beautiful Soup y Requests. La biblioteca de solicitudes nos permite realizar solicitudes a direcciones URL y acceder a los datos en esas páginas HTML. Beautiful Soup contiene algunas maneras fáciles para que identifiquemos las etiquetas que discutimos anteriormente, directamente desde nuestro script de Python.

Si instalamos estos paquetes globalmente en nuestras máquinas, podríamos tener problemas si continuamos desarrollando otras aplicaciones. Por ejemplo, un programa podría usar la biblioteca de solicitudes, versión 1, mientras que una aplicación posterior podría usar la biblioteca de solicitudes, versión 2. Esto podría causar un conflicto, lo que dificultaría la ejecución de una o ambas aplicaciones.

Para resolver este problema, es una buena idea configurar un entorno virtual. Estos entornos virtuales son como cápsulas para la aplicación. De esta forma, podríamos ejecutar la versión 1 de una biblioteca en una aplicación y la versión 2 en otra, sin conflicto, si creamos un entorno virtual para cada aplicación.

Primero, abramos la ventana de la terminal, ya que los siguientes comandos son más fáciles de ejecutar desde la terminal. En OS X, abriremos la carpeta Aplicaciones y luego abriremos la carpeta Utilidades. Abra la aplicación Terminal. Es posible que deseemos agregar esto a nuestro muelle también.

En Windows, también podemos encontrar terminal/línea de comando abriendo nuestro Menú Inicio y buscando. Es simplemente una aplicación ubicada en C:\Windows\System32.

Ahora que tenemos la terminal abierta, debemos navegar a nuestra carpeta de proyecto y usar el siguiente comando para construir el entorno virtual:

python3 -m venv tutorial-env

Este paso crea el entorno virtual, pero ahora mismo está inactivo. Para utilizar el entorno virtual, también necesitaremos activarlo. Esto lo podemos hacer ejecutando el siguiente comando en nuestra terminal:

En Mac:

fuente tutorial-env/bin/activar

O ventanas:

tutorial-env\Scripts\activate.bat

3 bibliotecas de Python

3.a. Instalación de bibliotecas

Ahora que tenemos nuestro entorno virtual configurado y activado, querremos instalar las bibliotecas que mencionamos anteriormente. Para hacer esto, usaremos la terminal nuevamente, esta vez instalando las Bibliotecas con el instalador de pip. Ejecutemos los siguientes comandos:

Instalar sopa hermosa:

pip instalar bs4

Solicitudes de instalación:

solicitudes de instalación de pip

Y hemos terminado. Bueno, al menos tenemos nuestro entorno y bibliotecas en funcionamiento.

3.b. Importación de bibliotecas instaladas

Primero, abramos nuestro archivo webscraper.py. Aquí, configuraremos toda la lógica que realmente solicitará los datos del sitio que queremos raspar.

Lo primero que debemos hacer es informar a Python que en realidad vamos a usar las bibliotecas que acabamos de instalar. Podemos hacer esto importándolos a nuestro archivo de Python. Podría ser una buena idea estructurar nuestro archivo para que toda nuestra importación esté en la parte superior del archivo, y luego toda nuestra lógica venga después. Para importar nuestras dos bibliotecas, solo incluiremos las siguientes líneas en la parte superior de nuestro archivo:

desde bs4 importar BeautifulSoupsolicitudes de importación

Si quisiéramos instalar otras bibliotecas en este proyecto, podríamos hacerlo a través del instalador de pip y luego importarlas en la parte superior de nuestro archivo. Una cosa a tener en cuenta es que algunas bibliotecas son bastante grandes y pueden ocupar mucho espacio. Puede ser difícil implementar un sitio en el que hemos trabajado si está sobrecargado con demasiados paquetes grandes.

3.c. Biblioteca de solicitudes de Python

Las solicitudes con Python y Beautiful Soup básicamente tendrán tres partes:

La URL, RESPUESTA Y CONTENIDO.

La URL es simplemente una cadena que contiene la dirección de la página HTML que pretendemos raspar.

La RESPUESTA es el resultado de una solicitud GET. De hecho, usaremos la variable URL en la solicitud GET aquí. Si observamos cuál es la respuesta, en realidad es un código de estado HTTP. Si la solicitud fue exitosa, obtendremos un código de estado exitoso como 200. Si hubo un problema con la solicitud o el servidor no responde a la solicitud que hicimos, el código de estado podría fallar. Si no obtenemos lo que queremos, podemos buscar el código de estado para solucionar cuál podría ser el error. Aquí hay un recurso útil para descubrir qué significan los códigos, en caso de que necesitemos solucionarlos:

www.restapitutorial.com

Finalmente, el CONTENIDO es el contenido de la respuesta. Si imprimimos todo el contenido de la respuesta, obtendremos todo el contenido de la página completa de la URL que hemos solicitado.

4. Almacenamiento de datos como JSON

Si no quiere perder el tiempo raspando y quiere pasar directamente a la manipulación de datos, aquí hay varios de los conjuntos de datos que usé para este ejercicio:

https://www.dropbox.com/s/v6vjffuakehjpic/stopwords.json?dl=0 https://www.dropbox.com/s/2wqibsa5fro6gpx/tweetsjson.json?dl=0 https://www.dropbox. com/s/1zwynoyjg15l4gv/twitterData.json?dl=0

4.a. Visualización de datos extraídos

Ahora que sabemos más o menos cómo se configurará nuestro raspador, es hora de encontrar un sitio que realmente podamos raspar. Anteriormente, vimos algunos ejemplos de cómo podría verse un raspador de Twitter y algunos de los casos de uso de dicho raspador. Sin embargo, probablemente no rasparemos Twitter aquí por un par de razones. En primer lugar, cada vez que se trata de contenido generado dinámicamente, como sería el caso de Twitter, es un poco más difícil de raspar, lo que significa que el contenido no es fácilmente visible. Para hacer esto, necesitaríamos usar algo como Selenium, que no trataremos aquí. En segundo lugar, Twitter proporciona varias API que probablemente serían más útiles en estos casos.

En su lugar, aquí hay un sitio de "Twitter falso" que se ha configurado solo para este ejercicio.

http://ethans_fake_twitter_site.surge.sh/

En el sitio de "Twitter falso" anterior, podemos ver una selección de tweets reales de Jimmy Fallon entre 2013 y 2017. Si seguimos el enlace anterior, deberíamos ver algo como esto:

Aquí, si quisiéramos raspar todos los Tweets, hay varias cosas asociadas con cada Tweet que también podríamos raspar:

1. El tuit
2. El autor (Jimmy Fallon)
3. La fecha y la hora
4. El número de Me gusta
5. El número de acciones

La primera pregunta que debemos hacernos antes de comenzar a raspar es qué queremos lograr. Por ejemplo, si todo lo que quisiéramos hacer fuera saber cuándo ocurrieron la mayoría de los tweets, los únicos datos que realmente necesitamos recopilar serían la fecha. Sin embargo, para mayor facilidad, seguiremos adelante y rasparemos todo el Tweet. Abramos las Herramientas para desarrolladores nuevamente en Chrome para ver cómo está estructurado y ver si hay algún selector que sea útil para recopilar estos datos:

Debajo del capó, parece que cada elemento aquí está en su propia clase. El autor está en una etiqueta <h2> con la clase denominada "autor". El Tweet está en una etiqueta <p> con una clase llamada "contenido". Los "Me gusta" y "Compartir" también se encuentran en las etiquetas <p> con clases denominadas "me gusta" y "compartir". Finalmente, nuestra Fecha/Hora está en una etiqueta <h5> con una clase “dateTime”.

Si usamos el mismo formato que usamos anteriormente para extraer este sitio e imprimir los resultados, probablemente veremos algo similar a esto:

Lo que hemos hecho aquí es simplemente seguir los pasos descritos anteriormente. Comenzamos importando bs4 y solicitudes, y luego configuramos URL, RESPUESTA y CONTENIDO como variables, e imprimimos la variable de contenido. Ahora, los datos que hemos impreso aquí no son muy útiles. Simplemente hemos impreso toda la estructura HTML sin procesar. Lo que preferiríamos es obtener los datos raspados en un formato utilizable.

4.b Selectores en Beautiful Soup

Para obtener un tweet, necesitaremos usar los selectores que proporciona beautiful soup. Intentemos esto:

tweet = content.findAll('p', attrs={"class": "content"}).textprint tweet

En lugar de imprimir todo el contenido, intentaremos obtener los tweets. Echemos otro vistazo a nuestro ejemplo html anterior y veamos cómo se relaciona con el fragmento de código anterior:

El fragmento de código anterior utiliza el atributo de clase "contenido" como selector. Básicamente, la 'p', attrs={“class”: “content”} dice: “queremos seleccionar todas las etiquetas de párrafo <p>, pero solo las que tienen la clase denominada “contenido”.

Ahora, si nos detuviéramos allí e imprimiéramos los resultados, obtendríamos la etiqueta completa, la ID, la clase y el contenido. El resultado se vería así:

<p class="content> Esta noche: @MichaelKeaton, @ninadobrev, música de @The_xx y más. #FallonTonight</p>

Pero, todo lo que realmente queremos es el contenido o el texto de la etiqueta:

Esta noche: @MichaelKeaton, @ninadobrev, música de @The_xx y más. #FallonTonight

Entonces, el .text le dice a Python que si encontramos una etiqueta <p>, con la clase "contenido", solo seleccionaremos el contenido de texto de esta etiqueta.

Sin embargo, cuando ejecutamos esta línea de código, solo obtenemos el primer tweet, y no todos los tweets. Parece un poco contrario a la intuición, ya que usamos el método findAll() . Para obtener todos los tweets, y no solo el primero, necesitaremos recorrer el contenido y seleccionarlo en un bucle, así:

para tweet en content.findAll('p', attrs={"class": "content"}):print tweet.text.encode('utf-8')

Ahora, cuando repasemos el contenido, podremos ver todos los tweets. ¡Impresionante!

4.c Conversión de datos raspados a JSON

El siguiente paso en este proceso, antes de almacenar los datos, es convertirlos a JSON. JSON significa Notación de objetos de JavaScript. En Python, la terminología es Dicts. En cualquier caso, estos datos estarán en forma de pares clave/valor. En nuestro caso, estos datos podrían ser similares a los siguientes:

tweetObject = {"autor": "JimmyFallon","fecha": "28/02/2018","tweet": "¡No te pierdas el programa de esta noche!", "me gusta": "250","compartir": " 1000"}

Cada Tweet tendría este formato y podría almacenarse en una matriz. Esto nos permitiría analizar más fácilmente los datos más adelante. Podríamos pedirle rápidamente a Python todas las fechas, o todos los Me gusta, o contar la cantidad de veces que se usa "mostrar" en todos los "tweets". Almacenar los datos de una manera utilizable como esta será la clave para hacer algo divertido con los datos más adelante. Si nos desplazamos hacia arriba y miramos nuevamente la estructura HTML, podemos notar que cada tweet está en un elemento <div> con el nombre de clase "tweetcontainer". Cada autor, tuit, fecha, etc, estará dentro de uno de estos contenedores. Previamente repasamos todos los datos y seleccionamos los tweets de cada elemento. ¿Por qué no hacemos lo mismo, sino que recorremos cada contenedor para poder seleccionar la fecha, el autor y el tweet individuales de cada uno? Nuestro código podría ser algo como esto:

para tweet en content.findAll('div', attrs={"class": "tweetcontainer"}):tweetObject = {"autor": "JimmyFallon","fecha": "28/02/2018","tweet" : "¡No te pierdas el programa de esta noche!", "me gusta": "250", "comparte": "1000"}

Sin embargo, en lugar de estos datos, queremos seleccionar los datos individuales de cada tweet para construir nuestro objeto. En cambio, el resultado final sería:

desde bs4 importar BeautifulSoupsolicitudes de importación

url = ' http://ethans_fake_twitter_site.surge.sh/' respuesta = request.get(url, timeout=5)content = BeautifulSoup(response.content, "html.parser")

tweetArr = []for tweet in content.findAll('div', attrs={"class": "tweetcontainer"}):tweetObject = {"author": tweet.find('h2', attrs={"class": "autor"}).text.encode('utf-8'),"fecha": tweet.find('h5', attrs={"class": "dateTime"}).text.encode('utf-8 '),"tweet": tweet.find('p', attrs={"class": "contenido"}).text.encode('utf-8'),"me gusta": tweet.find('p' , attrs={"clase": "me gusta"}).text.encode('utf-8'),"shares": tweet.find('p', attrs={"class": "shares"}). text.encode('utf-8')}imprimir tweetObject

¡Impresionante! Todos nuestros datos están en un formato agradable y fácil de usar. Aunque, hasta este punto, todo lo que hemos hecho es imprimir los resultados. Agreguemos un paso final y guardemos los datos como un archivo JSON.

4.d Guardar los datos

Para hacer esto, agregaremos una importación más a nuestro código en la parte superior e importaremos json. Esta es una biblioteca central, por lo que no necesitamos instalarla a través de pip como hicimos con los otros paquetes. Luego, después de recorrer nuestros datos y construir el tweetobject a partir de cada elemento, agregaremos ese objeto o dictaremos a nuestro tweetArr, que será una matriz de tweets. Finalmente, aprovecharemos la biblioteca json y escribiremos un archivo json, utilizando nuestra matriz de tweets como datos para escribir. El código final podría verse así:

desde bs4 importar BeautifulSoupsolicitud de importaciónimportar json

url = ' http://ethans_fake_twitter_site.surge.sh/' respuesta = request.get(url, timeout=5)content = BeautifulSoup(response.content, "html.parser")

tweetArr = []for tweet in content.findAll('div', attrs={"class": "tweetcontainer"}):tweetObject = {"author": tweet.find('h2', attrs={"class": "autor"}).text.encode('utf-8'),"fecha": tweet.find('h5', attrs={"class": "dateTime"}).text.encode('utf-8 '),"tweet": tweet.find('p', attrs={"class": "contenido"}).text.encode('utf-8'),"me gusta": tweet.find('p' , attrs={"clase": "me gusta"}).text.encode('utf-8'),"shares": tweet.find('p', attrs={"class": "shares"}). text.encode('utf-8')}tweetArr.append(tweetObject)with open('twitterData.json', 'w') as outfile:json.dump(tweetArr, outfile)

Al ejecutar esto, Python debería haber generado y escrito un nuevo archivo llamado twitterData. ¡Ahora intentemos analizar esos datos!

5. Análisis de datos JSON

Volvamos a nuestro árbol de archivos y abramos nuestro archivo de análisis (parsedata.py), que debería estar en blanco.

Al igual que llamamos a json y abrimos un archivo json en el paso anterior, haremos lo mismo en este paso. Sin embargo, ahora en lugar de escribir en un archivo json, querremos leer del archivo json que acabamos de crear.

importar json

con open('twitterData.json') como json_data:jsonData = json.load(json_data)

Ahora, podemos usar la variable jsonData. Esto debería contener toda la información que recopilamos, pero en formato JSON. Comencemos con algo simple, imprimiendo todas las fechas de todos los tweets:

para i en jsonData: imprime i ['fecha']

Al ejecutar este comando, deberíamos ver una lista generada de todas las fechas de todos los tweets.

Otra cosa divertida de hacer sería ver con qué frecuencia aparecen ciertas palabras en los tweets. Por ejemplo, podríamos ejecutar una consulta que viera con qué frecuencia aparece "Obama" en los tweets:

para i en jsonData:si "obama" en i['tweet'].lower():print i

Hacer esto nos mostrará el objeto de tweet completo para cada tweet donde se menciona "obama". Bastante genial, ¿verdad? Obviamente, las posibilidades son infinitas. Ahora debería quedar claro lo fácil que es extraer datos de la web de manera eficiente y luego convertirlos a un formato utilizable para analizarlos. ¡Fantástico!

Si tiene algún comentario o pregunta, ¡no dude en comunicarse!

Ethan Jarrell - Desarrollador - AT&T | LinkedIn _Vea el perfil de Ethan Jarrell en LinkedIn, la red profesional más grande del mundo. Ethan tiene 5 trabajos listados en su…_www.linkedin.com