Python-scrapy爬虫

scrapy框架爬虫简介

安装scrapy

windows系统在命令行模式下输入pip install scrapy命令即可。

建立scrapy项目

1. 进入命令行窗体，在D盘中建立一个文件夹，例如example，进入d:\example然后执行命令：scrapy startproject demo，该命令建立一个名称为demo的scrapy项目。
2. scrapy项目建立后会在d:\demo中建立demo文件夹，同时下面还有另外一个demo子文件夹，有一些必要的项目文件。
3. 为了测试这个scrapy项目，先建立一个web网站，可以在d:\example中建立一个server.py程序，如下：

import flask

app=flask.Flask(__name__)
@app.route("/")
def index():
	return "测试scrapy"
if __name__ == "__main__":
	app.run()

4. 在d:\example\demo\demo\spider文件夹中建立一个自己的python文件，例如MySpider.py，程序如下：

import scrapy

class MySpider(scrapy.Spider):
	name="mySpider"
	
	def start_request(self):
		url = "http://127.0.0.1:5000"
		yield scrapy.Request(url=url,callback=self.parse)
	def parse(self,response):
		print(response.url)
		data=response.body.decode()
		print(data)

5. 在d:\example\demo\demo文件夹中建立一个执行程序如run.py，程序如下：

from scrapy import cmdline
cmdline.execute("scrapy crawl mySpider -s LOG_ENABLED=False".split())

6. 保存这些程序并运行run.py，可以看到结果:

http://127.0.0.1:5000
测试scrapy

由此可见程序MySpider.py是访问了我们自己的Web网站并爬取了网站的网页。下面来分析这个程序：
(1). import scrapy 引入scrapy程序包，这个包中有一个请求对象Request与一个响应对象Response类。
(2).

class MySpider(scrapy.Spider): 
	name = "mySpider"

任何一个爬虫程序类都继承与scrapy.Spider类，任何一个爬虫程序都有一个名字，这个名字在整个爬虫项目是唯一的，此项目中的爬虫名字为“mySpider”。
(3)

def start_request(self):
	url = "http://127.0.0.1:5000"
	yield scrapy.Request(url=url,callback=self.parse)

这个地址url是爬虫程序的入口地址，这个start_request函数是程序的入口函数。程序开始时确定要爬取的网站地址，然后建立一个scrapy.Request请求类，向这个类提供url参数，指明要爬取的网页地址。爬取网页完成后就执行默认的回调函数parse。
scrapy的执行过程是异步进行的，即指定一个url网址开始爬取数据时，程序不用一直等待这个网站的响应，如果网站迟迟不响应，那么整个程序就卡死了。但是scrapy提供一个回调函数，网站什么时候响应就什么时候调用这个回调函数，这样有利于对响应时间很长的网站的爬取。
(4)

def parse(self,response):
	print(response.url)
	data=response.body.decode()
	print(data)

回调函数parse包含一个scrapy.Request类的对象response，它是网站响应的一切信息，其中response.url就是网站的网址，response.body是网站响应的二进制数据，即网页的内容。通过decode()解码后变成字符串，就可以用print输出了。
(5) run.py的作用
程序MySpider.py只是一个类，不能单独执行，要执行这个爬虫程序就必须使用scrapy中专门的命令scrapy crawl。可以在命令窗口，在d:\example\demo\demo中执行命令：scrapy crawl mySpider -s LOG_ENABLED=False，那么就可以看到执行后的结果。注：其中mySpider指爬虫程序的名称，后面的参数是不现实调试信息。但是由于窗口的切换比较繁琐，因此设计一个python的run.py，专门用来执行MySpider.py程序。

入口函数与入口地址

在程序中使用了入口函数：

def start_request(self):
	url = "http://127.0.0.1:5000"
	yield scrapy.Request(url=url,callback=self.parse)

实际上这个函数可以用start_urls的入口地址来代替：

start_urls = "http://127.0.0.1:5000"

入口地址可有多个，因此start_urls是一个列表。入口函数与入口地址的作用是一样的。

Python的yield语句

• 在入口函数，有一条yield语句，主要作用是返回一个值等待被取走。
• 实例：

def fun():
	s = ['a','b','c']
	for x in s:
		yield x
		print("fun End")
f = fun()
print(f)
for e in f:
	print(e)

程序结果：

a
b
c
fun End

由此可见，fun返回一个generator的对象，这种对象包含一系列的元素，可以使用for循环提取，执行循环的过程如下：

for e in f:
	print(e)

• 第一次 for e in f 循环，f执行到yield语句，就返回一个值’a’，for循环从f抽取的元素是’a’，然后e=‘a’，打印a。fun中执行到yield时会等待yield返回的值被抽走，同时fun停留在yield语句，一旦被抽走，再次循环，yield返回’b’。
• 第二次循环 for e in f 循环，抽取f函数的’b’元素，打印出’b’，然后f中循环继续yield返回’c’元素。
• 第三次循环 for e in f 循环，抽取f函数的’c元素，打印出’c’，然后f中循环就结束了，显示fun End，随后for e in f循环中f也没有元素可以继续抽走了，也结束，随后程序结束。
• 只要包含yield语句的函数都返回一个generator的可循环对象，执行到yield语句时只是返回一个值，等待调用循环抽取，一旦调用循环抽取后，函数又继续进行。这个过程非常类似两个线程的协助过程，当提供数据的一方准备好数据把yield提交数据时，就等待另外一方把数据抽取走，如果不抽走yield就一直等待，一旦抽走后数据提供方继续它的程序，一直等到出现下一次yield或者程序结束。scrapy的框架使用的是异步执行的过程，因此大量使用yield语句。

Scrapy中查找HTML元素

Scrapy中查找HTML元素(1)

• 在scrapy中有强大的查找HTML元素的功能，那就是使用xpath方法。xpath方法使用xPath语法，比BeautifulSoup的select要灵活而且速度快。
• 使用xpath查找HTML中的元素

#从scrapy中引入Selector类，这个类就是选择查找类
from scrapy.selector import Selector
htmlText='''



	
	29.99


	
	39.99



'''
selector=Selector(text=htmlText)  
#查看selector的类型
print(type(selector))
print(selector)
#在文档中查找所有的'>, Learning XML'>]

(1).selector=Selector(text=htmlText) 使用htmlText的文字建立Selector类，就是装载HTML文档，文档装载后就形成一个Selector对象，就可以使用xpath查找元素。
(2). selector.xpath("//tagName")表示在文档中搜索的tags，形成一个Selector的列表。

• 由此可见一般selector搜索一个的HTML元素的方法是：

  selector.xpath("//tagName")

• 在装载HTML文档后selector=Selector(text=htmlText)得到的selector是对应全文档顶层的元素的，其中"//"表示全文档搜索，结果是一个Selector的列表，哪怕只有一个元素也成一个列表。

• selector.xpath("//body")搜索到元素，结果是一个Selector的列表，包含一个Selector元素；

• selector.xpath("//title")搜索到两个 29.99 39.99 ''' selector=Selector(text=htmlText) s=selector.xpath("//book").xpath("./title") for e in s: print(e)

  程序结果：

  Novel'>
  Harry Potter'>
  TextBook'>
  Learning XML'>
  

  • selector.xpath("//book")首先搜索到文档中所有元素，总共有2个，然后再次调用xpath("./title")，就是从当前元素开始往下一级搜索 29.99 39.98 ''' selector=Selector(text=htmlText) s=selector.xpath("//book/price") print(type(s),s) s=selector.xpath("//book/price").extract() print(type(s),s) s=selector.xpath("//book/price").extract_first() print(type(s),s)

    程序结果：

     [, ]
     ['29.99', '39.98']
     29.99
    

    由此可见：s=selector.xpath("//book/price")得到的是SelectorList列表；
    s=selector.xpath("//book/price").extract()得到的是元素的Selector对象对应的元素的文本组成的列表，即[29.99', u'39.98]；s=selector.xpath("//book/price").extract_first()得到的是元素的文本组成的列表的第一个元素，是一个文本，即29.99。

    • xpath使用"/@attrName"得到一个Selector元素的attrName属性节点对象，属性节点对象也是一个Selector对象，通过extract()函数获取其属性值。
    • 对上述的doc文档获取元素属性值：

    selector=Selector(text=htmlText)
    s=selector.xpath("//book/@id")
    print(s)
    print(s.extract())
    for e in s:
    	print(e.extract())
    

    程序结果：

    [, ]
    ['b1', 'b2']
    b1
    b2
    

    由此可见：s=selector.xpath("//book/@id")结果是2个的id属性组成的SelectorList列表，即属性也是一个Selector对象；print(s.extract())结果是的id属性的两个Selector对象的属性文本值的列表，即['b1','b2']；e.extract()获取对象e的属性值。

    • xpath使用"/text()"得到一个Selector元素包含的文本值，文本值节点对象也是一个Selector对象，通过extract()获取文本值。
    • 获取上述doc文档的节点文本值

    selector=Selector(text=htmlText)
    s=selector.xpath("//book/title/text()")
    print(s)
    print(s.extract())
    for e in s:
    	print(e.extract())
    

    程序结果：

    [,]
    ['Harry Potter','Learning-XML']
    Harry Potter
    Learning-XML
    

    由此可见：s=selector.xpath("//book/title/text()")结果也是SelectorList列表，即文本也是一个节点；print(s.extract())结果是文本节点的字符串值的列表，即['Harry Potter','Learning-XML']；最后的for语句，每个e是一个Selector对象，因此extract()获取对象的属性值。值得注意的是如果一个element的元素包含的文本不是单一的文本，那么可能会产生多个文本值。

    • xpath使用"tag[condition]"来限定一个tag元素，其中condition是由这个tag的属性、文本等计算出的一个逻辑值。如果有多个条件，可以写成："tag[condition1][condition2]...[conditionN]"或者"tag[condition1] and [condition2] and ... and [conditionN]"。
    • xpath可以使用position()来确定其中一个元素的限制，这个选择序号是从1开始的，不是从0开始编号的，还可以通过and、or等构造复杂表达式。
    • xpath使用星号"*"代表任何Element节点，不包括Text、Comment的节点。
    • xpath使用"@*"代表任何属性。
    • xpath使用"element/parent::*"选择element的父节点，这个节点只有一个。如果写成"element/parent::tag"，就是指定element的tag父节点，除非element的父节点正好是tag节点，不然就为None。
    • xpath使用"element/following-sibling::*"搜索element后面的同级的所有兄弟节点，使用"element/following-sibling::*[position()=1]"搜索element后面的同级的第一个兄弟节点。
    • xpath使用"element/preceding-sibling::*"搜索element前面的同级的所有兄弟节点，使用"element/preceding-sibling::*[position()=1]"搜索element前面的同级的第一个兄弟节点。

    Scrapy爬取与存储数据

    建立Web网站

    使用scrapy startproject demo语句创建一个demo的scrapy项目，在项目中创建一个server.py文件，用来编写网站内容，这个网站有一个网页，返回基本计算机教材，flask程序如下：

    import flask
    app = flask.Flask(__name__)
    
    @app.route("/")
    def index():
        html="""
        
        
            
            James
            人民邮电出版社
        
        
            
            Robert
            人民邮电出版社
        
        
            
            Steven
            高等教育出版社
        
        
            """
        return html
    
    if __name__=="__main__":
        app.run()
    
    

    编写数据项目类

    程序爬取的数据是多本教材，每本教材有名称与作者，因此要建立一个教材的类，类中包括教材名称title，作者author与出版社publisher。在demo\demo目录下有一个items.py文件就是用来设计数据项目类的，打开文件，并改成如下形式：

    import scrapy
    
    class BookItem(scrapy.Item):
        # define the fields for your item here like:
        # name = scrapy.Field()
        title = scrapy.Field()
        author = scrapy.Field()
        publisher = scrapy.Field()
    

    其中BookItem是我们设计的教材项目类，这个类必须从scrapy.Itrm类继承，在类中定义教材的字段项目，每个字段项目都是一个scrapy.Field对象，定义了3个字段项目，分别用来存储title、author以及publisher。注：可以通过item[“title”]、item[“author”]、item[“publisher”]来获取或设置各个字段的值。

    编写爬虫程序myspider

    在demo\demo\spider目录下新建myspider.py文件，编写程序如下：

    import scrapy
    from scrapy import Selector
    #从demo文件夹的items.py文件中引入BookItem类的定义
    from demo.items import BookItem
    
    class MySpider(scrapy.Spider):
        name = "mySpider"
        start_urls = ["http://127.0.0.1:5000"]
    
        def parse(self, response):
            try:
                #得到网站数据并建立Selector对象，搜索到所有的节点的元素
                data = response.body.decode()
                selector = Selector(text=data)
                books = selector.xpath("//book")
                for book in books:
                    item = BookItem()
                    #对于每个节点，在它的下面搜索