当前位置 : 主页 > 编程语言 > 其它开发 >

Python中Scrapy框架

来源:互联网 收集:自由互联 发布时间:2022-05-30
目录 Scrapy 框架 一、 简介 1、 介绍 2、 环境配置 3、 常用命令 4、 运行原理 4.1 流程图 4.2 部件简介 4.3 运行流程 二、 创建项目 1、 修改配置 2、 创建一个项目 3、 定义数据 4、 编写并

目录
  • Scrapy 框架
    • 一、 简介
      • 1、 介绍
      • 2、 环境配置
      • 3、 常用命令
      • 4、 运行原理
        • 4.1 流程图
        • 4.2 部件简介
        • 4.3 运行流程
    • 二、 创建项目
      • 1、 修改配置
      • 2、 创建一个项目
      • 3、 定义数据
      • 4、 编写并提取数据
      • 5、 存储数据
      • 6、 运行文件
    • 三、 日志打印
      • 1、 日志信息
      • 2、 logging 模块
    • 四、 全站爬取
      • 1、 使用request排序入队
      • 2、 继承crawlspider
    • 五、 二进制文件
      • 1、 图片下载
    • 六、 middlewares
      • 1、下载中间件
      • 2、 爬虫中间件
    • 七、 模拟登录
      • 1、 cookie
      • 2、 直接登录
    • 八、 分布式爬虫
      • 1、概念
      • 2、 用法

Scrapy 框架 一、 简介 1、 介绍

Scrapy 是一个基于 Twisted 实现的异步处理爬虫框架,该框架使用纯 Python 语言编写。Scrapy 框架应用广泛,常用于数据采集、网络监测,以及自动化测试等

2、 环境配置
  1. 安装 pywin32
    • pip install pywin32
  2. 安装 wheel
    • pip install wheel
  3. 安装 twisted
    • pip install twisted
  4. 安装 scrapy 框架
    • pip install scrapy
3、 常用命令 命令 格式 说明 startproject scrapy startproject <项目名> 创建一个新项目 genspider scrapy genspider <爬虫文件名> <域名> 新建爬虫文件 runspider scrapy runspider <爬虫文件> 运行一个爬虫文件,不需要创建项目 crawl scrapy crawl <spidername> 运行一个爬虫项目,必须要创建项目 list scrapy list 列出项目中所有爬虫文件 view scrapy view <url地址> 从浏览器中打开 url 地址 shell scrapy shell <url地址> 命令行交互模式 settings scrapy settings 查看当前项目的配置信息 4、 运行原理 4.1 流程图 4.2 部件简介
  1. 引擎(Engine)

    引擎负责控制系统所有组件之间的数据流,并在某些动作发生时触发事件。

  2. 调度器(Scheduler)

    用来接受引擎发过来的请求, 压入队列中, 并在引擎再次请求的时候返回. 可以想像成一个URL的优先级队列, 由它来决定下一个要抓取的网址是什么, 同时去除重复的网址

  3. 下载器(Downloader)

    用于下载网页内容, 并将网页内容返回给EGINE,下载器是建立在twisted这个高效的异步模型上的

  4. 爬虫(Spiders)

    是开发人员自定义的类,它负责处理所有Responses,从中分析提取数据,获取Item字段需要的数据,并将需要跟进的URL提交给引擎,再次进入Scheduler(调度器)

  5. 项目管道(Item Pipeline)

    在items被提取后负责处理它们,主要包括清理、验证、持久化(比如存到数据库)等操作

  6. 下载中间件(Downloader Middlerwares)

    你可以当作是一个可以自定义扩展下载功能的组件。

  7. 爬虫中间件(Spider Middlerwares)

    位于EGINE和SPIDERS之间,主要工作是处理SPIDERS的输入(即responses)和输出(即requests)

4.3 运行流程
  1. 引擎:Hi!Spider, 你要处理哪一个网站?
  2. Spider:老大要我处理xxxx.com。
  3. 引擎:你把第一个需要处理的URL给我吧。
  4. Spider:给你,第一个URL是xxxxxxx.com。
  5. 引擎:Hi!调度器,我这有request请求你帮我排序入队一下。
  6. 调度器:好的,正在处理你等一下。
  7. 引擎:Hi!调度器,把你处理好的request请求给我。
  8. 调度器:给你,这是我处理好的request
  9. 引擎:Hi!下载器,你按照老大的下载中间件的设置帮我下载一下这个request请求
  10. 下载器:好的!给你,这是下载好的东西。(如果失败:sorry,这个request下载失败了。然后引擎告诉调度器,这个request下载失败了,你记录一下,我们待会儿再下载)
  11. 引擎:Hi!Spider,这是下载好的东西,并且已经按照老大的下载中间件处理过了,你自己处理一下(注意!这儿responses默认是交给def parse()这个函数处理的)
  12. Spider:(处理完毕数据之后对于需要跟进的URL),Hi!引擎,我这里有两个结果,这个是我需要跟进的URL,还有这个是我获取到的Item数据。
  13. 引擎:Hi !管道 我这儿有个item你帮我处理一下!调度器!这是需要跟进URL你帮我处理下。然后从第四步开始循环,直到获取完老大需要全部信息。
  14. 管道调度器:好的,现在就做!

注意:只有当调度器没有request需要处理时,整个程序才会停止。(对于下载失败的URL,Scrapy也会重新下载。)

二、 创建项目

本次示例是爬取豆瓣

1、 修改配置
LOG_LEVEL = "WARNING"  # 设置日志等级
from fake_useragent import UserAgent
USER_AGENT = UserAgent().random  # 设置请求头
ROBOTSTXT_OBEY = False  # 是否遵守 robots 协议,默认为 True
ITEM_PIPELINES = {  # 开启管道
    'myFirstSpider.pipelines.MyfirstspiderPipeline': 300,  # 300 为权重,
    'myFirstSpider.pipelines.DoubanPipeline': 301,  # 数字越大权重越小
}
2、 创建一个项目

在命令行输入:

(scrapy_) D:\programme\Python\scrapy_>scrapy startproject myFirstSpider

(scrapy_) D:\programme\Python\scrapy_>cd myFirstSpider

(scrapy_) D:\programme\Python\scrapy_\myFirstSpider>scrapy genspider douban "douban.com"
3、 定义数据

定义一个提取的结构化数据(Item)

  1. 打开 myFirstSpider 目录下的 items.py
  2. item 定义结构化的数据字段,用来存储爬取到的数据,有点像python里面的字典,但是提供了一些而外的保护减少错误
  3. 可以通过创建一个 scrapy.Item 类,并且定义类型为 scrapy.Field 的类属性来定义一个 Item (可以理解成类似于ORM的映射关系)
  4. 接下来,创建一个 Douban 类,和构建 item 模型
# Define here the models for your scraped items
#
# See documentation in:
# https://docs.scrapy.org/en/latest/topics/items.html

import scrapy


class MyfirstspiderItem(scrapy.Item):  # 可以自己创建一个类,但是要继承 scrapy.Item 类
    # define the fields for your item here like:
    # name = scrapy.Field()
    pass


class DoubanItem(scrapy.Item):
    title = scrapy.Field()  # 标题
    introduce = scrapy.Field()  # 介绍
4、 编写并提取数据

编写爬取网站的 Spider 并提取出结构化数据(Item)

在定义的爬虫文件中写入:

import scrapy
from ..items import DoubanItem  # 导入定义的格式化数据


class DoubanSpider(scrapy.Spider):
    name = 'douban'  # 爬虫的识别名称,唯一的
    # allowed_domains = ['douban.com']  # 允许爬取的范围
    # start_urls = ['http://douban.com/']  # 最初爬取的 url
    start_urls = ['https://movie.douban.com/top250']  # 可以自己定义要爬取的 url
	
    def parse(self, response):
        info = response.xpath('//div[@class="info"]')
        for i in info:
            # 存放电影信息合集
            item = DoubanItem()
            title = i.xpath("./div[1]/a/span[1]/text()").extract_first()  # 获取第一个内容,通过extract方法提取selector对象
            introduce = i.xpath("./div[2]/p[1]//text()").extract()  # 获取全部内容
            introduce = "".join(j.strip() for j in [i.replace("\\xa0", '') for i in introduce])  # 整理信息
            item["title"] = title
            item["introduce"] = introduce

            # 将获取的数据交给 pipeline
            yield item
5、 存储数据

编写 Item Pipelines 来存储提取到的 Item (即结构化数据)

# Define your item pipelines here
#
# Don't forget to add your pipeline to the ITEM_PIPELINES setting
# See: https://docs.scrapy.org/en/latest/topics/item-pipeline.html


# useful for handling different item types with a single interface
from itemadapter import ItemAdapter


class MyfirstspiderPipeline:
    def process_item(self, item, spider):
        return item


class DoubanPipeline:
    # 在爬虫文件开始时,运行此函数
    def open_spider(self, spider):
        if spider.name == "douban":  # 如果数据是从豆瓣爬虫传进来的
            print("爬虫开始运行!")
            self.fp = open("./douban.txt", "w", encoding="utf-8")

    def process_item(self, item, spider):
        if spider.name == "douban":
            self.fp.write(f"标题:{item['title']}, 信息:{item['introduce']}")  # 保存文件

    # 爬虫结束的时候运行
    def close_spider(self, spider):
        if spider.name == "douban":
            print("爬虫结束运行!")
            self.fp.close()
6、 运行文件
(scrapy_) D:\programme\Python\scrapy_\myFirstSpider>scrapy crawl douban 
三、 日志打印 1、 日志信息

日志信息等级:

  • ERROR:错误信息
  • WARNING:警告
  • INFO:一般的信息
  • DEBUG:调试信息

设置日志信息的制定输出

LOG_LEVEL = "ERROR"  # 指定日志信息种类
LOG_FILE = "log.txt"  # 表示将日志信息写到指定的文件中进行存储
2、 logging 模块
imoprt logging
logger = logging.getLogger(__name__)  # __name__ 获得项目的文件名
logger.warning(" info ")  # 打印要输出的日志信息
四、 全站爬取 1、 使用request排序入队
yield scrapy.Request(url=new_url, callback=self.parse_taoche, meta={"page": page})

参数:

  • url:传递的地址
  • callback:请求后响应数据的处理函数
  • meta:传递数据
    • 每次请求都会携带meta参数
    • 传递给响应
    • 可以通过response.meta \ response.meta["page"]获取
import scrapy, logging
from ..items import DetailItem

logger = logging.Logger(__name__)


class DoubanSpider(scrapy.Spider):
    name = 'douban'
    # allowed_domains = ['douban.com']
    start_urls = ['https://movie.douban.com/top250']

    def parse(self, response):
        print(response)
        info = response.xpath('//div[@class="info"]')
        for i in info:
            item_detail = DetailItem()  # 详情页的内容
            # 存放电影信息合集
            title = i.xpath("./div[1]/a/span[1]/text()").extract_first()  # 获取第一个内容,通过extract方法提取selector对象
            item_detail["title"] = title
            logger.warning(title)

            detail_url = i.xpath("./div[1]/a/@href").extract_first()  # 获取详情页的url
            # print(detail_url)
            yield scrapy.Request(url=detail_url, callback=self.parse_detail, meta=item_detail)  # 将请求传递给调度器,重新请求

        next_url = response.xpath("//div[@class='paginator']/span[3]/a/@href").extract_first()  # 获取下一页的url
        if next_url:
            next_url = "https://movie.douban.com/top250" + next_url
            # print(next_url)
            yield scrapy.Request(url=next_url, callback=self.parse, )  # 将请求传递给调度器,重新请求

    def parse_detail(self, resp):
        item = resp.meta  # 接收结构化数据

        introduce = resp.xpath("//div[@id='link-report']/span[1]/span//text()").extract()  # 获取介绍
        item["introduce"] = introduce
        logger.warning(introduce)

        content = resp.xpath("//div[@id='hot-comments']/div[1]//text()").extract()  # 获取评论
        item["content"] = content
        logger.warning(content)

        yield item
2、 继承crawlspider

Scrapy框架中分为两类爬虫:

  • Spider
  • CrawlSpider:
    • CrawlSpider是Spider的派生类,Spider类的设计原理是指爬取start_url列表中的网页,而CrwalSpider类定义了一些规则来提供跟进链接的方便的机制,从爬取的网页中获取链接并继续爬取的工作更合理

创建方法:

scrapy genspider -t crawl 项目名称 网站

创建后,其显示为

import scrapy
from scrapy.linkextractors import LinkExtractor
from scrapy.spiders import CrawlSpider, Rule


class FuhaoSpider(CrawlSpider):
    name = 'fuhao'
    # allowed_domains = ['fuhao.com']
    start_urls = ['https://www.phb123.com/renwu/fuhao/shishi_1.html']

    rules = (
        Rule(
            LinkExtractor(allow=r'shishi_\d+.html'),  # 链接提取器,根据正则规则提取url
            callback='parse_item',  # 指定回调函数
            follow=True  # 获取的响应页面是否再次经过rules来进行提取url地址
        ),
    )
    

    def parse_item(self, response):
        print(response.request.url)

Rule(LinkExtractor(allow=r'Items/'), callback='parse_item', follow=True)

  • LinkExtractor:链接提取器,根据正则规则提取url地址
  • callback:提取出来的url地址发送请求获取响应,会把响应对象给callback指定的函数进行处理
  • follow:获取的响应页面是否再次经过rules来进行提取url地址
# 匹配豆瓣
start_urls = ['https://movie.douban.com/top250?start=0&filter=']
rules = (
    Rule(LinkExtractor(allow=r'?start=\d+&filter='), callback='parse_item', follow=True),
)
五、 二进制文件 1、 图片下载

ImagesPipeLine:图片下载的模块

pipeline中,编写代码(已知,item里面传输的是图片的下载地址)

import logging
import scrapy
from itemadapter import ItemAdapter
from scrapy.pipelines.images import ImagesPipeline


# 继承ImagesPipeLine
class PicPipeLine(ImagesPipeline):
    # 根据图片地址,发起请求
    def get_media_requests(self, item, info):
        src = item["src"]  # item["src] 里面存储的是图片的地址
        logging.warning("正在访问图片:", src)
        yield scrapy.Request(url = src,meta={'item':item})  # 对图片发起请求

    # 指定图片的名字
    def file_path(self, request, response=None, info=None, *, item=None):
        item = request.meta['item']  # 接收meta参数
        return request.url.split("/")[-1]  # 设置文件名字
        # 在settings中设置 IMAGES_STORE = "./imags"  # 设置图片保存的文件夹

    # 返回数据给下一个即将被执行的管道类
    def item_completed(self, results, item, info):
        return item  
六、 middlewares 1、下载中间件

更换代理IP,更换Cookies,更换User-Agent,自动重试

在settings.py 中添加

# 建立ip池
PROXY_LIST = []

在middlewares.py中添加

from fake_useragent import UserAgent
import random
class Spider4DownloaderMiddleware:
    # 拦截所有请求
    def process_request(self, request, spider):
        # UA 伪装
        request.headers["User-Agent"] = UserAgent().random
        return None

    # 处理请求,可以篡改响应信息,spider是实例化的爬虫对象
    def process_response(self, request, response, spider):
        bro = spider.bro  # 在爬虫对象中创建了的selenium对象
        if request.url in spider.model_urls:
            # print(request.url)
            # 要篡改request请求的响应对象, response

            bro.get(request.url)

            # 执行js代码
            bro.execute_script('window.scrollTo(0,document.body.scrollHeight)')
            # 一拉到底,发现我们滚动条还是在中间位置

            bottom = []  # 空列表,表示没有到底部
            while not bottom:  # bool([]) ==> false not false
                bro.execute_script('window.scrollTo(0,document.body.scrollHeight)')

                page_text = bro.page_source  # 获取页面内容
                # 如果到底,循环结束
                bottom = re.findall(r'<div class="load_more_tip" style="display: block;">:-\)已经到最后啦~</div>', page_text)
                time.sleep(1)

                if not bottom:
                    try:
                        bro.find_element(By.CSS_SELECTOR, '.load_more_btn').click()  # 找到加载更多进行点击
                    except:
                        bro.execute_script('window.scrollTo(0,document.body.scrollHeight)')
                        
            return HtmlResponse(url=request.url, body=page_text, encoding='utf-8', request=request)  # body 是要返回的数据
        return response

    # 处理异常,当网络请求失败时,执行此函数
    def process_exception(self, request, exception, spider):
        # 添加代理ip
        type_ = request.url.split(":")[0]
        request.meta['proxy'] = f"{type_}://{random.choice(spider.settings.get('PROXY_LIST'))}"
        return request  # 如果ip被封了,就使用代理ip,重新发送请求
	
    # 开始爬虫时执行
    def spider_opened(self, spider):
        spider.logger.info('Spider opened: %s' % spider.name)

设置完下载中间件后,要在settings配置文件中开启

2、 爬虫中间件

爬虫中间件的用法与下载器中间件非常相似,只是它们的作用对象不同。下载器中间件的作用对象是请求request和返回response;爬虫中间件的作用对象是爬虫,更具体地来说,就是写在spiders文件夹下面的各个文件

  1. 当运行到yield scrapy.Request()或者yield item的时候,爬虫中间件的process_spider_output()方法被调用
  2. 当爬虫本身的代码出现了Exception的时候,爬虫中间件的process_spider_exception()方法被调用
  3. 当爬虫里面的某一个回调函数parse_xxx()被调用之前,爬虫中间件的process_spider_input()方法被调用
  4. 当运行到start_requests()的时候,爬虫中间件的process_start_requests()方法被调用
import scrapy


class Spider5SpiderMiddleware:
    # 在下载器中间件处理完成后,马上要进入某个回调函数parse_xxx()前调用
    def process_spider_input(self, response, spider):
        return None

    # 在爬虫运行yield item或者yield scrapy.Request()的时候调用
    def process_spider_output(self, response, result, spider):
        for item in result:
            print(result)
            if isinstance(item, scrapy.Item):
                # 这里可以对即将被提交给pipeline的item进行各种操作
                print(f'item将会被提交给pipeline')
            yield item  # 也可以 yield request,当为yield request时,可以修改请求信息,如meta等

    # 当在爬虫程序运行过程中报错时调用
    def process_spider_exception(self, response, exception, spider):
        """
        爬虫里面如果发现了参数错误,就使用raise这个关键字人工抛出一个自定义的异常。在实际爬虫开发中,可以在某些地方故意不使用try ...
        except捕获异常,而是让异常直接抛出。例如XPath匹配处理的结果,直接读里面的值,不用先判断列表是否为空。这样如果列表为空,就会被抛出一个IndexError,
        于是就能让爬虫的流程进入到爬虫中间件的process_spider_exception()中
        """
        print("第%s页出现错误,错误信息:%s" % response.meta["page"], exception)  # 这里可以捕获异常信息,也可以有返回值

    # 当爬虫运行到start_request时被调用
    def process_start_requests(self, start_requests, spider):
        for r in start_requests:
            print(r.text)
            yield r

    # 当爬虫开始时调用
    def spider_opened(self, spider):
        spider.logger.info('Spider opened: %s' % spider.name)

注意:要在settings配置文件中开启爬虫中间件

七、 模拟登录 1、 cookie

在整个框架运作前,需要一个启动条件,这个启动条件就是start_urls,首先从start_urls的网页发起requests请求,才会有后面的调度器、下载器、爬虫、管道的运转。所以,这里我们可以针对start_urls进行网络请求的start_requests方法进行重写,把我们的cookie给携带进去

注意:必须要使用yield返回,不然没办法运行

import scrapy


class ExampleSpider(scrapy.Spider):
    name = 'example'
    # allowed_domains = ['example.com']
    start_urls = ['https://www.baidu.com']

    # 重写start_request方法,scrapy从这里开始
    def start_requests(self):
        # 添加cookie的第一种方法,直接添加
        cookie = " "
        cookie_dic = {}
        for i in cookie.split(";"):
            cookie_dic[i.split("=")[0]] = i.split("=")[1]

        # 添加cookie的第二种方法:添加头部
        headers = {
            "cookie": "cookie_info",
            # 使用headers传入cookie时,要在settings中加入COOKIES_ENABLE = True
        }
        for url in self.start_urls:
            yield scrapy.Request(url=url, callback=self.parse, headers=headers)  # 添加cookies

    def parse(self, response):
        print(response.text)
2、 直接登录

通过传递参数,访问接口,来实现模拟登录:

第一种方法的使用方法:

import scrapy


class ExampleSpider(scrapy.Spider):
    name = 'example'
    # allowed_domains = ['example.com']
    start_urls = ['https://github.com']

    def parse(self, response):
        # 这里面填写大量的登录参数
        post_data = {
            "username": "lzk",
            "password": "123456",
            "time": "123",
            "sad": "asdsad12",
        }
        # 把登录参数传入服务器,验证登录
        # 方法一
        yield scrapy.FormRequest(
            url='https://github.com/session',
            formdata=post_data,
            callback=self.parse_login,
        )  

    def parse_login(self, response):
        print(response.text)

第二种方法的使用方法

# -*- coding: utf-8 -*-
import scrapy
from scrapy import FormRequest, Request


class ExampleLoginSpider(scrapy.Spider):
    name = "login_"
    # allowed_domains = ["example.webscraping.com"]
    start_urls = ['http://example.webscraping.com/user/profile']
    login_url = 'http://example.webscraping.com/places/default/user/login'

        def start_requests(self):
        # 重写start_requests方法,用来登录
        yield scrapy.Request(
            self.login_url,
            callback=self.login
        )

    def login(self,response):
        formdata = {
      	 	'email': 'liushuo@webscraping.com',
            'password': '12345678'
        	}
        yield FormRequest.from_response(
            response, 
            formdata=formdata, 
            callback=self.parse_login
        )
        
    def parse_login(self, response):
        if 'Welcome Liu' in response.text:
            yield from super().start_requests()  # 继承start_requests 的作用,访问要访问的页面
            
    def parse(self, response):
        print(response.text)

使用from_response方法发送请求,等同于selenium里面的查找表单直接将数据填入表单中,不用考虑加密

八、 分布式爬虫 1、概念

概念:

  • 多台机器对一个项目进行分布联合爬取

作用:

  • 增加工作单位,提升爬取效率

实现:

  • 多台机器共用一个调度器
    • 实现一个公有调度器
      • 首先要保证每台机器都可以进行连接,其次的话要能够进行存储,也就是存储我们爬取的url,就是数据库的存储功能,使用redis
        • 可以把url由爬虫交给引擎,引擎给redis
        • 也可以把url由调度器交给redis
        • 同样也可以在持久化存储中,也由管道把item数据交给redis进行存储
      • 安装
        • pip install scrapy-redis -i https://pypi.com/simple
2、 用法

在settings配置文件中添加

# 使用scrapy_redis的管道,其为定义好的管道,直接调用就可以
ITEM_PIPELINES = {
   'scrapy_redis.pipelines.RedisPipeline': 300,
}
# 指定redis地址
REDIS_HOST = '192.168.45.132'  # redis服务器地址,我们使用的虚拟机
REDIS_PORT = 6379  # redis端口

# 使用scrapy_redis 的调度器
SCHEDULER = 'scrapy_redis.scheduler.Scheduler'

# 去重容器类配置,作用:redis的set集合,来存储请求的指纹数据,从而实现去重的持久化
DUPEFILTER_CLASS = 'scrapy_redis.dupefilter.RFPDupeFilter'

# 配置调度器是否需要持久化,爬虫结束的时候要不要清空Redis中请求队列和指纹的set集合,要持久化设置为True
SCHEDULER_PERSIST = True

在爬虫文件中添加

import scrapy
from ..items import TaoCheItem
from scrapy_redis.spiders import RedisCrawlSpider
from scrapy.linkextractors import LinkExtractor
from scrapy.spiders import CrawlSpider, Rule


# 注意 如果使用的是scrapy.Spider 那么使用redis分布式的时候,就继承 RedisSpider
# 如果是CrawlSpider 就继承 RedisCrawlSpider
class TaocheSpider(RedisCrawlSpider):
    name = 'taoche'
    # allowed_domains = ['taoche.com']
    # start_urls = ['https://changsha.taoche.com/bmw/?page=1']  # 起始的url应该去redis(公共调度器)里面获取

    redis_key = 'taoche'  # 回去redis里面获取key值为taoche的数据
    rules = (
        Rule(LinkExtractor(allow=r'/\?page=\d+'), callback='parse_item', follow=True),
    )

    def parse_item(self, response):
        car_list = response.xpath('//div[@id="container_base"]/ul/li')
        for car in car_list:
            lazyimg = car.xpath('./div[1]/div/a/img/@src').extract_first()
            lazyimg = 'https:' + lazyimg
            title = car.xpath('./div[2]/a/span/text()').extract_first()
            resisted_date = car.xpath('./div[2]/p/i[1]/text()').extract_first()
            mileage = car.xpath('./div[2]/p/i[2]/text()').extract_first()
            city = car.xpath('./div[2]/p/i[3]/text()').extract_first().replace('\n', '').strip()
            price = car.xpath('./div[2]/div[1]/i[1]//text()').extract()
            price = ''.join(price)
            sail_price = car.xpath('./div[2]/div[1]/i[2]/text()').extract_first()
            print(lazyimg, title, resisted_date, mileage, city, price, sail_price)

【文章转自bgp服务器 http://www.558idc.com/yz.html提供,感恩】

网友评论