Análisis y ejemplos de marco de rastreo Scrapy (MOOC de la Universidad de China)

Marco scrapy

 Scrapy es un marco de aplicación escrito para rastrear datos de sitios web y extraer datos estructurados. Se puede utilizar en una serie de programas que incluyen minería de datos, procesamiento de información o almacenamiento de datos históricos. Originalmente se diseñó para el rastreo de páginas (más precisamente, rastreo web) y también se puede utilizar para recuperar datos devueltos por API (como Amazon Associates Web Services) o rastreadores web generales. Scrapy es versátil y puede usarse para minería de datos, monitoreo y pruebas automatizadas.

 Scrapy utiliza la biblioteca de red asincrónica Twisted para manejar la comunicación de red. La estructura general es aproximadamente la siguiente:

Componente

El motor Scrapy Engine
es responsable de controlar el flujo de datos entre todos los componentes del sistema y desencadenar eventos cuando ocurren las acciones correspondientes. Para obtener más información, consulte la sección Flujo de datos a continuación.

Programador (Programador) El
programador acepta solicitudes del motor y las pone en cola para que se puedan proporcionar al motor cuando el motor las solicite.

Arañas
Araña es una clase escrita por usuarios de Scrapy para analizar la respuesta y extraer el elemento (es decir, el elemento obtenido) o URL adicional para seguimiento. Cada araña es responsable de manejar un sitio web específico (o algunos).

Item Pipeline
Item Pipeline es responsable de procesar los elementos extraídos por las arañas. El procesamiento típico incluye limpieza, verificación y persistencia (por ejemplo, acceso a la base de datos).

Middlewares de descarga (middlewares de descarga)
Los middlewares de descarga son enlaces específicos entre el motor y el descargador, que procesan la respuesta del descargador al motor. Proporciona un mecanismo simple para ampliar la funcionalidad de Scrapy insertando código personalizado.

Middlewares Spider (middlewares Spider) Los middlewares
Spider son enlaces específicos entre el motor y la araña, que procesan la entrada (respuesta) y la salida (elementos y solicitudes) de la araña. Proporciona un mecanismo simple para ampliar la funcionalidad de Scrapy insertando código personalizado.

Flujo de datos

El flujo de datos en Scrapy está controlado por el motor de ejecución y el proceso es el siguiente:

1. El motor abre un sitio web (abre un dominio), encuentra a la araña que procesa el sitio web y solicita a la araña las primeras URL que se rastrearán.
2. El motor obtiene la primera URL que se rastreará desde Spider y la programa con Solicitud en el Programador.
   El motor solicita que se rastree la siguiente URL desde el programador.
3. El programador devuelve la siguiente URL que se rastreará al motor y el motor reenvía la URL al descargador a través del middleware de descarga (dirección de solicitud).
4. Una vez que se descarga la página, el descargador genera una respuesta para la página y la envía al motor a través del middleware de descarga (dirección de respuesta).
5. El motor recibe la respuesta del descargador y la envía al Spider para que la procese a través del middleware Spider (dirección de entrada).
   Spider procesa la respuesta y devuelve el elemento rastreado y (seguimiento) la nueva solicitud al motor.
6. El motor envía el elemento rastreado (devuelto por Spider) a Item Pipeline y envía la Solicitud (devuelta por Spider) al programador.
   (Desde el segundo paso) Repita hasta que no haya más solicitudes en el programador y el motor cierre el sitio web.

Instalación scrapy y generación de proyectos

Método de descarga

ventanas:

Instale pip desde https://pip.pypa.io/en/latest/installing.html

Abra una ventana de línea de comando y confirme que pip esté instalado correctamente:

pip --verison

Instalar scrapy:

pip install scrapy

Inicialización del proyecto

startproject
语法: scrapy startproject <project_name>
是否需要项目: no
在 project_name 文件夹下创建一个名为 project_name 的Scrapy项目。

Abra la ventana de la línea de comandos, cambie al directorio del proyecto que desea crear e inicialice un proyecto llamado myproject

scrapy startporject myproject

Después de la creación, ingrese el proyecto que creamos, la estructura de directorios en el interior es la siguiente:

scrapy.cfg
myproject/
    __init__.py 
    items.py	
    pipelines.py
    middlewares.py
    settings.py
    spiders/
        __init__.py
        ...

A continuación, puede usar el comando scrapy para administrar y controlar su proyecto. Por ejemplo, para crear una nueva araña, tomamos como ejemplo la red MOOC:

genspider
语法: scrapy genspider [-t template] <name> <domain>
是否需要项目: yes
在当前项目中创建spider。
这仅仅是创建spider的一种快捷方法。该方法可以使用提前定义好的模板来生成spider。您也可以自己创建spider的源码文件。

scrapy genspider course https://www.icourse163.org/

Después de la creación, se generará un archivo course.py en el directorio spider:

A continuación, veamos el archivo de configuración del proyecto. El archivo de configuración del proyecto se encuentra en el directorio setting.py

BOT_NAME：项目名称

USER_AGENT：用户代理

ROBOTSTXT_OBEY：是否遵循机器人协议，默认是true

CONCURRENT_REQUESTS：最大并发数

DOWNLOAD_DELAY：下载延迟时间，单位是秒，控制爬虫爬取的频率，根据你的项目调整，不要太快也不要太慢，默认是3秒，即爬一个停3秒，设置为1秒性价比较高，如果要爬取的文件较多，写零点几秒也行

COOKIES_ENABLED：是否保存COOKIES，默认关闭

DEFAULT_REQUEST_HEADERS：默认请求头，上面写了一个USER_AGENT，其实这个东西就是放在请求头里面的，这个东西可以根据你爬取的内容做相应设置。

ITEM_PIPELINES：项目管道，300为优先级，越低越爬取的优先度越高，默认是注释掉的

Al usar Scrapy, puede declarar la configuración que desea usar. Esto se puede hacer usando la variable de entorno: SCRAPY_SETTINGS_MODULE.

SCRAPY_SETTINGS_MODULE debe escribirse en la sintaxis de ruta de Python, como myproject.settings . Tenga en cuenta que el módulo de configuración debe estar en la ruta de búsqueda de importación de Python .

Luego, puede iniciar la tarea de rastreo, abrir la línea de comando e ingresar scrapy crawl para iniciar la tarea de rastreo.

crawl
语法: scrapy crawl <spider>
是否需要项目: yes
使用spider进行爬取。

scrapy crawl course

Módulo de registro

 Scrapy proporciona la función de registro. Puede usarlo a través del módulo scrapy.log. La implementación subyacente actual utiliza el registro Twisted, pero esto puede cambiar en el futuro.

 El servicio de registro debe iniciarse llamando explícitamente a scrapy.log.start ().

Scrapy proporciona 5 niveles de registro:

CRITICAL - 严重错误(critical)
ERROR - 一般错误(regular errors)
WARNING - 警告信息(warning messages)
INFO - 一般信息(informational messages)
DEBUG - 调试信息(debugging messages)

El nivel de registro se puede establecer mediante la opción de terminal (opción de línea de comando) -loglevel / -L o LOG_LEVEL. Establezca el nivel de registro en ADVERTENCIA, solo ERROR y CRÍTICO por debajo del nivel de ADVERTENCIA se

registrarán con ADVERTENCIA

from scrapy import log
log.msg("This is a warning", level=log.WARNING)

La forma recomendada de agregar log a spider es usar el método log () de Spider. Este método asignará automáticamente el parámetro de araña al llamar a scrapy.log.msg (). Otros parámetros se pasan directamente al método msg ().

También puede encapsular un módulo de registro usted mismo

, llame al módulo de registro en uso

from .course_logger import logger

caso real

A continuación, tome el MOOC de la Universidad China como ejemplo para rastrear información sobre cursos públicos gratuitos

Tomemos como ejemplo Matemáticas Avanzadas (3), la dirección del curso debe ser similar a los siguientes dos formatos:

https://www.icourse163.org/course/NUDT-42002
https://www.icourse163.org/course/NUDT-42002?tid=1462924451

En primer lugar, en item.py, defina el contenido que desea extraer. Por ejemplo, extraemos el nombre, ID, profesor, perfil y escuela del curso y creamos estas variables en consecuencia. El método real del método Field es crear un diccionario, agregar una compilación al diccionario, no asignar temporalmente un valor, esperar a que se extraigan los datos y luego asignar

import scrapy


class MoocItem(scrapy.Item):
    term_id = scrapy.Field()
    title = scrapy.Field()
    description = scrapy.Field()
    college = scrapy.Field()
    lector = scrapy.Field()

Ideas

Lo que necesitamos rastrear es solo una página, principalmente analizando elementos HTML, usando xpath para escribir expresiones de ruta para obtener nodos / conjuntos de nodos, similar a la ruta de archivos de computadora normales.

re - Operación de expresión regular El
módulo re es un módulo de coincidencia de cadenas de Python único. Muchas funciones proporcionadas en este módulo se implementan en función de expresiones regulares, y las expresiones regulares se utilizan para realizar coincidencias difusas en cadenas para extraer lo que necesita La parte de la cadena, es es común a todos los idiomas

El
marco de scrapy de rendimiento realizará diferentes operaciones según el tipo de instancia devuelto por yield:
a. Si es un objeto scrapy.Request, el marco de scrapy obtendrá el enlace al que apunta el objeto y llamará a la función de devolución de llamada del objeto después de la la solicitud se ha completado
b. Si es un objeto scrapy.Item, el marco scrapy pasará este objeto a pipelines.py para su posterior procesamiento

def parse(self, response):
    item = {
    
    'term_id': re.search(r'termId : "(\d+)"', response.text).group(1),
            'title': response.xpath("//meta[@name= 'description']/@content").extract_first().split(',')[0],
            'description': response.xpath("//meta[@name= 'description']/@content").extract_first().split(',')[1][
                           10:],
            'college': response.xpath("//meta[@name= 'keywords']/@content").extract_first().split(',')[1],
            }
        lectors = []
        script = response.css('script:contains("window.staffLectors")::text').get()
        chiefLector_str = ''.join(re.findall('chiefLector = \\{([^}]*)\\}', script))
        chiefLector_list = re.sub('\s+', '', ' '.join(chiefLector_str.split())).strip()
        chiefLector = demjson.decode("{" + chiefLector_list + "}")
        lectors.append(chiefLector)
        staffLectors_str = ''.join(re.findall('staffLectors = \[([^\[\]]+)\]', script))
        staffLectors_list = re.sub('\s+', '', ' '.join(staffLectors_str.split())).strip()
        staffLector = demjson.decode("[" + staffLectors_list + "]")
        if staffLector:
            for staff in staffLector:
                lectors.append(staff)
        item['lector'] = lectors
        yield item

Hay un pequeño problema al extraer el contenido del conferenciante. El contenido del conferenciante es

usar expresiones regulares en la etiqueta de secuencia de comandos para que coincida con el nombre de la variable, y luego hacer coincidir el contenido entre paréntesis o llaves, y debe use demjson para procesar JSON

El
procesamiento json de Demjson python requiere el soporte de una biblioteca json de terceros. Cuando se trata de datos json durante el trabajo, no hay una biblioteca json de terceros instalada. El módulo demjson proporciona clases y funciones para codificar o decodificar datos representados en formato JSON neutro en el lenguaje (esto se usa a menudo como un simple reemplazo de XML en aplicaciones web ajax). Esta implementación intenta cumplir con la especificación JSON (RFC 4627) tanto como sea posible, al mismo tiempo que proporciona muchas extensiones opcionales para permitir una sintaxis de JavaScript menos restrictiva. Incluye compatibilidad completa con Unicode, incluido UTF-32, BOM y procesamiento de pares sustitutos.

La canalización pipline.py puede procesar los datos extraídos, como almacenarlos en la base de datos de Mongo. No olvide abrir la canalización en la configuración después de escribir el código.

from pymongo import MongoClient

class MyprojectPipeline:
    MONGO_URL = "mongodb://localhost:27017"
    MONGO_DB = "mooc"
    MONGO_TABLE = "course"

    client = MongoClient(MONGO_URL)
    db = client[MONGO_DB]

    def process_item(self, item, spider):
        self.save_to_mongo(item)

        return item

    def save_to_mongo(self, data):
        if self.db[self.MONGO_TABLE].insert(data):
            print("SAVE SUCCESS", data)
            return True
        return False

Almacenado exitosamente