Python中Scrapy框架

目录

• 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)