python网络爬虫与信息提取

课程《Python网络爬虫与信息提取-北京理工大学-嵩天》中的内容，作为笔记

Table of Contents

一、网络爬虫之规则：Requests库

1. request()方法

2. 其他方法 

3. 爬取网页的通用代码框架

4. 实例

5. 网络爬虫的“盗亦有道”

二、网络爬虫之提取

1.Beautiful Soup库

2. 信息组织与提取方法

3. 实例：中国大学排名定向爬虫

4、正则表达式入门

5.实例：当当网比价定向爬虫

实例：股票数据定向爬虫

三、Scrapy爬虫框架

Scrapy爬虫框架介绍

实例：Scrapy获取上交所和深交所所有股票的名称和交易信息

---

一、网络爬虫之规则：Requests库

爬取网页的最好的第三方库，简单简洁，更多信息可访问http://www.python-requests.org

安装方法：Anaconda中已经包含了这个库，如果要安装，使用命令：pip install requests

requests的7个主要方法：

方法	说明	HTTP协议方法
requests.request()	构造一个请求，支撑以下各方法的基础方法
requests.get()	获取html网页的主要方法，对应于http的get	GET
request.head()	获取html网页头信息的方法，对应于http的head	HEAD
request.post()	向html网页提交post请求的方法，对应于http的post	POST
request.put()	向html网页提交put请求的方法，对应于http的put	PUT
request.patch()	向html网页提交局部修改请求，对应于http的patch	PATCH
request.delete()	向html提交删除请求，对应于http的delete	DELETE

HTTP对资源的操作：

方法	说明
GET	请求获取URL位置的资源
HEAD	请求获取URL位置资源的响应消息报告，即获得该资源的头部信息
POST	请求向URL位置的资源后附加新的数据
PUT	请求向URL位置存储一个资源，覆盖原URL位置的资源
PATCH	请求局部更新URL位置的资源，覆盖原URL位置的资源
DELETE	请求删除URL位置存储的资源

1. request()方法

def request(method, url, **kwargs):
"""Constructs and sends a :class:`Request <Request>`.

    :param method: 请求方式，对应GET/HEAD/POST/PUT/PATCH/delete/OPTIONS,OPTIONS获取服务器参数，使用较少.
    :param url: 访问链接.
    :**kwargs: 控制访问的参数，均为可选项
    :param params:  字典或者字节序列，作为参数增加到url中.可以将一些键值对增加到url中，服务器根据参数返回资源.
        kv = {'key1':'value1', 'key2':'value2'}
        r = requests.request('GET', "http://www.python123.io/ws", params=kv)
        print(r.url) #https://www.python123.io/ws?key1=value1&key2=value2
    :param data: 字典，字节序列或文件对象，作为request的内容.
        r = requests.request('POST', "http://www.python123.io/ws", data=kv)
        body = '主体内容'
        r = requests.request('POST', "http://www.python123.io/ws", data=body)
    :param json: json格式的数据，作为request的内容，向服务器提交.
        r = requests.request('POST', "http://www.python123.io/ws", json=kv)
    :param headers: 字典，http定制头，模拟浏览器的访问.
        hd = {'user-agent' : 'Chrome/10'}
        r = requests.request('POST', "http://www.python123.io/ws", headers = hd)
    :param cookies: 字典或CookieJar，Request中的cookie
    :param files: 字典类型，传输文件.
        fs = {'file' : open('data.xls', 'rb')}
        r = requests.request('POST', "http://www.python123.io/ws", files=fs)
    :param auth: 元组，支持http认证功能.
    :param timeout: 设定的超时时间，秒为单位，超时后产生timeout异常
    :param allow_redirects: bool, 重定向开关，默认为True.
    :type allow_redirects: bool
    :param proxies: 字典类型，设定访问代理服务器，可以增加登录认证.
        proxy = {'http': 'http://127.0.0.1:1080',
                 'https': 'https://127.0.0.1:1080'}
        r = requests.request('POST', "http://www.python123.io/ws", proxies = proxy)
    :param verify: bool, 默认为True, 认证SSL证书开关.
    :param stream: bool, 默认为True, 获取内容立即下载开关.
    :param cert: 本地SSL证书路径.

    :return: :class:`Response <Response>` object
    :rtype: requests.Response
    """

函数返回Response对象，Response对象的属性如下：

属性	说明
r.status_code	http请求的返回状态，200表示连接成功，404表示失败
t.text	http响应内容的字符串形式，即url的页面内容
r.encoding	从http header中猜测的响应内容的编码方式 。 如果header中不存在charset，则认为编码为ISO-8859-1,这个编码不能解析中文
r.apparent_encoding	从内容中分析出的响应内容编码方式（备选编码方式）。 从网页内容中推断编码方式，更加准确一些，当encoding不能解析正确编码方式时，采用这个
r.content	http响应内容的二进制形式

使用流程：获取response对象->检测状态码->获取内容

2. 其他方法 

get()等方法只是对requests()方法做了封装，可以被request()方法替代

def get(url, params=None, **kwargs):
    """Sends a GET request.

    url: 拟获取页面的url链接.
    params: url中的额外参数，字典或字节流格式，可选.
    **kwargs: 12个控制访问的参数.
    """
    return request('get', url, params=params, **kwargs)

def head(url, **kwargs):
    r"""Sends a HEAD request.

    url: 拟获取页面的url链接.
    **kwargs: 13个控制访问的参数.
    """
    return request('head', url, **kwargs)

def post(url, data=None, json=None, **kwargs):
    r"""Sends a POST request.

    url/data/json，**kwargs: 11个控制访问的参数.
    """
    return request('post', url, data=data, json=json, **kwargs)

def put(url, data=None, **kwargs):
    r"""Sends a PUT request.

    url/data，**kwargs: 12个控制访问的参数.
    """
    return request('put', url, data=data, **kwargs)

def patch(url, data=None, **kwargs):
    r"""Sends a PATCH request.

    url/data，**kwargs: 12个控制访问的参数.
    """
    return request('patch', url, data=data, **kwargs)

def delete(url, **kwargs):
    r"""Sends a DELETE request.

    url，**kwargs: 13个控制访问的参数.
    """
    return request('delete', url, **kwargs)

3. 爬取网页的通用代码框架

网络连接有风险，异常处理很重要

异常	说明
requests.ConnectionError	网络连接异常，如DNS查询失败、拒绝连接等
requests.HTTPError	HTTP错误异常
requests.URLRequired	URL缺失异常
requests.TooManyRedirects	超过最大重定向次数，产生重定向异常
requests.ConnectTimeout	连接远程服务器超时异常
requests.Timeout	请求URL超时，产生异常

 通用框架：

import requests

def getHTMLText(url):
    try:
        r = requests.get(url, timeout=30)
        r.raise_for_status()      #如果状态不是200，引发异常
        r.encoding = r.apparent_encoding
        return r.text
    except:
        return "产生异常"

if __name__ == "__main__":
    url = "http://www.baidu.com"
    print(getHTMLText(url))

4. 实例

实例1：京东商品页面的爬取

import requests
url = "https://item.jd.com/6685410.html"
try:
    r = requests.get(url, timeout=30)
    r.raise_for_status()  # 如果状态不是200，引发异常
    r.encoding = r.apparent_encoding
    print(r.text[0:1000])
except:
    print("爬取失败")

 实例2：亚马逊商品页面的爬取。通过headers字段是代码模拟浏览器向http提交请求。

import requests
url = "https://www.amazon.cn/dp/B07DBZZPQL/ref=cngwdyfloorv2_recs_0?pf_rd_p=4940946c-0b2b-498c-9e03-31cf7dae70ec&pf_rd_s=desktop-2&pf_rd_t=36701&pf_rd_i=desktop&pf_rd_m=A1AJ19PSB66TGU&pf_rd_r=YENXHWZT81QNMXW27C8B&pf_rd_r=YENXHWZT81QNMXW27C8B&pf_rd_p=4940946c-0b2b-498c-9e03-31cf7dae70ec"
try:
    kv = {'user-agent' : 'Mozilla/5.0'}
    r = requests.get(url, headers=kv)
    r.raise_for_status()  # 如果状态不是200，引发异常
    r.encoding = r.apparent_encoding
    print(r.text[1000:2000])
except:
    print("爬取失败")

实例3：百度360搜索关键字提交

百度关键词接口：http://www.baidu.com/s?wd=keyword 

360关键词接口：http://www.so.com/s?q=keywork

import requests
keyword = 'python'
url = "http://www.baidu.com/s"
try:
    kv = {'wd' : keyword}
    r = requests.get(url, params=kv)
    r.raise_for_status()
    print(r.request.url)
    print(len(r.text))
except:
    print("爬取失败")

实例4：网络图片的爬取和存储

网络图片的连接格式：http://www.example.com/picture.jpg ,获取的图片为二进制格式

import requests
import os
url = "http://image.ngchina.com.cn/2018/1127/20181127013714400.jpg"
root = "D://pics//"
path = root + url.split('/')[-1]
try:
    if not os.path.exists(root):
        os.mkdir(root)
    if not os.path.exists(path):
        r = requests.get(url)
        with open(path, 'wb') as f:
            f.write(r.content)
            f.close()
            print("文件保存成功")
    else:
        print("文件已经存在")
except:
    print("爬取失败")

实例5：IP地址的归属地自动查询

查询IP的链接格式：http://www.ip138.com/ips138.asp?ip=ipaddress

import requests
url = "http://www.ip138.com/ips138.asp?ip="
try:
    r = requests.get(url + '202.204.80.112')
    r.raise_for_status()
    r.encoding = r.apparent_encoding
    print(r.text[-2500:-1500])
except:
    print("爬取失败")

 

5. 网络爬虫的“盗亦有道”

1. 网络爬虫引发的问题

网络爬虫的尺寸

小规模，数据量小，爬取速度不敏感，Requests库	中规模，数据规模较大，爬取速度敏感，Scrapy库	大规模，搜索引擎，爬取速度关键，定制开发
爬取网页，玩转网页	爬取网站，爬取系列网站	爬取全网

（1）骚扰问题：受限于编程水平和目的，网络爬虫将会为web服务器带来巨大的资源开销。

（2）法律风险：服务器上的数据有产权归属，网络爬虫获取数据后牟利将会带来法律风险

（3）隐私泄露：网络爬虫可能具备突破简单访问控制的能力，获得被保护数据从而泄露个人隐私

2. 网络爬虫的限制

（1）来源审查：判断User-Agent进行限制

检查来访HTTP协议头的User-Agent域，只响应浏览器或友好爬虫的访问。

（2）发布公告：Robots

Robots协议： Robots Exclusion Standard 网络爬虫排除标准 作用：告知所有爬虫网站的爬取策略，要求爬虫遵守。 形式：在网站的根目录下的robots.txt文件 使用：自动或人工识别robots.txt，再进行内容爬取，协议可以不遵守，但可能存在法律风险 类人类行为可不遵守，如写小程序一天访问几次服务器

 

二、网络爬虫之提取

1.Beautiful Soup库

Beautiful Soup库是解析、遍历、维护“标签树”的功能库。

解析器有：html.parser, lxml, xml, html5lib

格式化显示：soup.prettify()，自动为标签间添加换行符。bs4将读入的文件或者字符串转换为"utf-8"。

BeautifulSoup类的基本元素

基本元素	说明
Tag	标签，最基本的信息组织单元，分别用<>和</>表明开头和结尾
Name	标签的名字，<p></p>的名字是'p'，格式:<tag>.name
Attributes	标签的属性，字典的组织形式，格式：<tag>.attrs
NavigableString	标签内非属性字符串，<>...</>中的字符串，格式：<tag>.string
Comment	标签内字符串的注释部分，一种特殊的Comment类型

标签树的遍历

	属性	说明
下行	.contents	子节点列表，将<tag>所有儿子节点存入列表
	.children	子节点的迭代类型，与.contents类似，用于循环遍历儿子节点
	.descendants	子孙节点的迭代类型，包含所有子孙节点，用于循环遍历
上行	.parent	节点的父亲标签
	.parents	节点先辈标签的迭代类型，用于循环 遍历先辈节点
平行	.next_sibling	返回按照HTML文本顺序的下一个平行节点标签
	.previous_sibling	返回按照HTML文本顺序的上一个平行节点标签
	.next_siblings	迭代类型，返回按照HTML文本顺序的后续所有平行节点标签
	.previous_siblings	迭代类型，返回按照HTML文本顺序的前续所有平行节点标签

2. 信息组织与提取方法

信息标记的形式：

   

           

实例：

  

比较：

XML	最早的通用信息标记语言，可扩展性好，但是繁琐	Internet上的信息交互与传递
JSON	信息有类型，适合程序处理，较XML简洁	移动应用云端和节点的信息通信，无注释
YAML	信息无类型，文本信息比例最高，可读性好	各类系统配置文件有注释易读

信息提取的一般方法：

（1）完整解析信息的标记形式，再提取关键信息。XML,JSON,YAML

需要标记解析器，如bs4库的标签树遍历，优点是信息解析准确，缺点是提取过程繁琐

（2）无视标记信息，直接搜索关键信息。搜索

使用对信息的文本查找函数即可。优点是提取过程简洁，速度快，缺点是提取信息的准确性与信息内容直接相关。

融合方法：完整形式解析+搜索，提取关键信息，需要标记解析器及文本查找函数。

实例：提取HTML所有URL链接

思路 ：1）搜索到所有<a>标签，

            2）解析<a>标签格式，提取href后的链接内容

url = "http://python123.io/ws/demo.html"
r = requests.get(url)
demo = r.text
soup = BeautifulSoup(demo, "html.parser")
for link in soup.find_all('a'):
    print(link.get('href'))
--------------out---------------
http://www.icourse163.org/course/BIT-268001
http://www.icourse163.org/course/BIT-1001870001

bs4库中HTML内容的查找方法：

<>.find_all(self, name=None, attrs={}, recursive=True, text=None, limit=None, **kwargs)
#返回一个列表类型，存储查找的结果
name:对标签名称的检索字符串
attrs:对标签属性值的检索字符串，可标注属性检索
recursive：是否对子孙全部搜索，默认为True
string: <>...</>中字符串区域的检索字符串

soup.find_all('a')
soup.find_all(['a','b'])
soup.find_all(True)            #返回所有标签
soup.find_all('p', 'course')   #所有属性是course的p标签
soup.find_all(id='link1')      #查找包含属性id='link1'的标签
简写形式：
<tag>(..) 等价于 <tag>.find_all(..)

3. 实例：中国大学排名定向爬虫

功能：爬取http://www.zuihaodaxue.cn/zuihaodaxuepaiming2016.html网站上的大学排名信息，输出排名，学校及总分

步骤：1）从网络上获取大学排名网页信息：getHTMLText()

           2）提取网页内容中信息到合适的数据结构（关键，二维结构）:fillUnivList()

           3）利用数据结构展示并输出结果:printUnivList

import requests
import bs4
from bs4 import BeautifulSoup

def getHTMLText(url):
    try:
        r = requests.get(url, timeout = 30)
        r.raise_for_status()
        r.encoding = r.apparent_encoding
        return r.text
    except:
        return ""

def fillUnivList(ulist, html):
    soup = BeautifulSoup(html, 'html.parser')
    for tr in soup.find('tbody').children:
        if isinstance(tr, bs4.element.Tag):
            tds = tr.find_all('td')
            ulist.append([tds[0].string,tds[1].string,tds[3].string])

def printUnivList(ulist, num):
    tplt = "{0:^10}\t{1:{3}^10}\t{2:^10}"
    print(tplt.format("排名", "学校名称", "总分", chr(12288)))
    for i in range(num):
        u = ulist[i]
        print(tplt.format(u[0], u[1], u[2], chr(12288)))

def main():
    uinfo = []
    url = 'http://www.zuihaodaxue.cn/zuihaodaxuepaiming2016.html'
    html = getHTMLText(url)
    fillUnivList(uinfo, html)
    printUnivList(uinfo, 3)

if __name__ == "__main__":
    main()
'''out
    排名    	　　　学校名称　　　	    总分    
    1     	　　　清华大学　　　	   95.9   
    2     	　　　北京大学　　　	   82.6   
    3     	　　　浙江大学　　　	    80 
'''

4、正则表达式入门

regular expression :用来简洁表达一组字符串的表达式。

编译：将符合正则表达式语法的字符串转换成正则表达式特征：p = re.compile( regex ), 特征可以表达一组字符串

常用操作符

操作符	说明	实例
.	表示任何单个字符
[ ]	字符集，对单个字符给出取值范围	[abc]，表示a,b,c，[a-z]表示a到z的单个字符
[^ ]	非字符集，对单个字符给出排除范围	[^abc]表示非a或b或c的单个字符
*	前一个字符0次或无限次扩展	abc*表示ab,abc,abccccc等
+	表示前一个字符一次或无限次扩展	abc+表示abc,abcc,abccc等
?	前一个字符0次或1次扩展	abc?表示ab,abc
|	左右表达式任取其一	abc|def表示abc、def
{m}	扩展前一个字符m次	ab{2}c表示abbc
{m,n}	扩展前一个字符m至n次（含n）	ab{1,2}c表示abc,abbc
^	匹配字符串开头	^abc表示abc且在一个字符串的开头
$	匹配字符串结尾	abc$表示abc且在一个字符串结尾
()	分组标记，内部只能使用|操作符	(abc)表示abc,(abc|def)表示abc,def
\d	数字，等价于[0-9]
\w	单词字符，等价于[A-Za-z0-9_]

经典正则表达式实例：

正则表达式	内容
^[A-Za-z]+$	由26个字母组成的字符串
^[A-Za-z0-9]+$	由26个字母和数字组成的字符串
^-?\d+$	整数形式字符串
^[0-9]*[1-9][0-9]*$	正整数形式字符串
[1-9]\d{5}	中国境内邮政编码
[\u4e00-\u9fa5]	匹配中文字符
\d{3}-\d{8}|\d{4}-\d{7}	国内电话号码：010-68913536
(([1-9]?\d|1\d{2}|2[0-4]\d|25[0-5]).){3}([1-9]?\d|1\d{2}|2[0-4]\d|25[0-5])	IP地址

 

正则表达式的类型

• raw string类型（原生字符串类型,不包含转义符的类型）：r'text'， 如r'\d{3}-\d{8}|\d{4}-\d{7}'
• string类型，将\理解为转义符，使用更繁琐：如'\\d{3}-\\d{8}|\\d{4}-\\d{7}'
• 当正则表达式包含转义字符，使用raw string类型 

Re库主要功能函数： 

函数	说明
re.search(pattern,string,flags=0)	在一个字符串中搜索匹配正则表达式的第一个位置，返回match对象
re.match(pattern,string,flags=0)	从一个字符串的的开始位置起匹配正则表达式，返回match对象
re.findall(pattern,string,flags=0)	搜索字符串，以列表类型返回全部能匹配的字符串
re.split(pattern,string,maxsplit=0,flags=0)	将一个字符串按照正则表达式匹配结果进行分割，返回列表类型
re.finditer(pattern,string,flags=0)	搜索字符串，返回一个匹配结果的迭代类型，每个迭代元素是match对象
re.sub(pattern,repl,string,count=0,flags=0)	在一个字符串中替换所有匹配正则表达式的字串，返回替换后的字符串

Re库的另一种等价用法

# 函数式用法：一次性操作
rst = re.search(r'[1-9]\d{5}', 'BIT 100081')
# 面向对象用法：编译后的多次操作
pat = re.compile(r'[1-9]\d{5}')
rst = pat.search('BIT 100081')

# 真正的正则表达式
regex = re.compile(pattern, flags = 0)

Re库的match对象

属性	说明	方法	说明
.string	待匹配文本	.group(0)	获得匹配后的字符串
.re	匹配时使用的pattern对象（正则表达式）	.start()	匹配字符串在原始字符串的开始位置
.pos	正则表达式搜索文本的开始位置	.end()	匹配字符串在原始字符串的结束位置
.endpos	正则表达式搜索文本的结束位置	.span()	返回(.start(), .end())

贪婪匹配和最小匹配：

Re库默认采用贪婪匹配，即输出匹配最长的字串。

# 贪婪匹配 
match = re.search(r'PY.*N', 'PYANBNCNDN')

# 最小匹配 
match = re.search(r'PY.*?N', 'PYANBNCNDN')

最小匹配操作符

操作符	说明
*?	前一个字符0次或无限次扩展，最小匹配
+?	前一个字符1次或无限次扩展，最小匹配
??	前一个字符0次或1次扩展，最小匹配
{m,n}?	扩展一个字符m至n次(含n)，最小匹配

5.实例：当当网比价定向爬虫

目的：获取淘宝搜索页面信息，提取其中的商品名称和价格

难点：淘宝的搜索接口

技术路线：request - BeautifulSoup

程序结构设计： 1）提交商品搜索请求，循环获取页面

                          2）对于每个页面，提取商品名称和价格信息

                          3）将信息输出到屏幕上

import requests
from bs4 import BeautifulSoup
import csv

def getHTMLText(url):
    try:
        r = requests.get(url, timeout = 30)
        r.raise_for_status()
        r.encoding = r.apparent_encoding
        return r.text
    except:
        return("")

def parsePage(ilt, html):
    try:
        soup = BeautifulSoup(html, 'html.parser')
        div_tag = soup.find(name='div', attrs={'dd_name':"普通商品区域"})
        li_tag = div_tag.find_all(name='li')
        for each_goods_li in li_tag:
            price = each_goods_li.find(name = 'span', attrs={'class':"price_n"}).string[1:]
            name = each_goods_li.find(name='a', attrs={'dd_name': r"单品标题"}).attrs['title']
            ilt.append([price,name])
    except:
        print("")

def printGoodsList(ilt):
    tplt = "{:4}\t{:8}\t{:16}"
    print(tplt.format("序号","价格", "商品名称"))
    count = 0
    for g in ilt:
        count += 1
        print(tplt.format(count, g[0], g[1]))

def saveGoods(ilt):
    if(len(ilt) != 0):
        headers = ["序号","价格", "商品名称"]
        with open('goods.csv','w',encoding='utf-8') as f:
            f_csv = csv.writer(f)
            f_csv.writerow(headers)
            for i in range(len(ilt)):
                row = [i+1,ilt[i][0],ilt[i][1]]
                f_csv.writerow(row)

def main():
    goods = '书包'
    depth = 3
    start_url = 'http://search.dangdang.com/?key=' + goods + '&page_index='
    infoList = []
    for i in range(depth):
        try:
            url = start_url + str(i+1)
            html = getHTMLText(url)
            parsePage(infoList, html)
        except:
            continue
    printGoodsList(infoList)
    saveGoods(infoList)

if __name__ == "__main__":
    main()

实例：股票数据定向爬虫

目标：获取上交所和深交所所有股票的名称和交易信息

输出：保存到文件中

候选网站: 1)新浪股票：http://finance.sina.com.cn/stock/ (可能js生成，不太合适)

                 2)百度股票：https://gupiao.baidu.com/stock/

选取原则：股票信息存在于HTML页面中，非js代码生成，没有Robots协议限制。

程序设计结构：1）从东方财富网获取股票列表

                         2）根据股票列表逐个到百度股票获取个股信息

                         3）将结果存储到文件

import  requests
from bs4 import BeautifulSoup
import traceback
import re

def getHTMLText(url, code='utf-8'):
    try:
        r = requests.get(url, timeout = 30)
        r.raise_for_status()
        r.encoding = code
        return r.text
    except:
        return("")

def getStockList(lst, stockURL):
    html = getHTMLText(stockURL, 'GB2312')
    soup = BeautifulSoup(html, 'html.parser')
    a = soup.find_all('a')
    for i in a:
        try:
            href = i.attrs['href']
            lst.append(re.findall(r'[s][hz]\d{6}', href)[0])
        except:
            continue

def getStockInfo(lst, stockURL, fpath):
    count = 0
    for stock in lst:
        url = stockURL + stock + '.html'
        html = getHTMLText(url)
        try:
            if html == "":
                continue
            infoDict = {}
            soup = BeautifulSoup(html, 'html.parser')
            stockInfo = soup.find('div', attrs={ 'class':"stock-bets"})
            name = stockInfo.find_all(attrs={ 'class':"bets-name"})[0]
            infoDict.update({'股票名称':name.text.split()[0]})
            keyList = stockInfo.find_all('dt')
            valueList = stockInfo.find_all('dd')
            for i in range(len(keyList)):
                key = keyList[i].text
                value = valueList[i].text
                infoDict[key] = value
            with open(fpath, 'a', encoding='utf-8') as f:
                f.write(str(infoDict) + '\n')
                count += 1
                print('\r当前速度：{:.2f}%'.format(count*100/len(lst)), end='')
        except:
            #traceback.print_exc()
            count += 1
            print('\r当前速度：{:.2f}%'.format(count * 100 / len(lst)), end='')
            continue

def main():
    stock_list_url = 'http://quote.eastmoney.com/stocklist.html'
    stock_info_url = 'https://gupiao.baidu.com/stock/'
    output_file = 'D://BaiduStockInfo.txt'
    slist = []
    getStockList(slist,stock_list_url)
    getStockInfo(slist,stock_info_url,output_file)
if __name__ == '__main__':
    main()

三、Scrapy爬虫框架

Scrapy爬虫框架介绍

scrapy不是一个简单的函数功能库，而是一个爬虫框架: 5+2结构

框架解析：

使用	模块	功能
不需要用户修改	Engine	框架核心，控制所有模块之间的数据流；根据条件触发事件。
	Downloader	根据请求下载网页
	Scheduler	对所有爬取请求进行调度管理
需要用户修改	Downloader Middleware	实施Engine、Scheduer和Downloader之间进行用户可配置的控制 修改、丢弃、新增请求或响应
	Spider	解析Downloader返回的响应（Response） 产生爬取项，产生额外的爬取请求
	Item Piplines	以流水线方式处理Spider产生的爬取项 操作包括：清理，检验，查重，存储数据
	Spider Middleware	对请求和爬取项再处理

Requests VS Scrapy

相同点	不同点		选择
1)页面请求和爬取两个重要技术路线； 2)可用性好，文档丰富，入门简单； 3)都没有处理js、提交表单、应对验证码等功能（可扩展）。	Requests	Scrapy	1)非常小的需求：requests库 2)不太小：Scrapy,持续，周期爬取信息，积累形成库 3)定制程度很高：自搭框架，requests>Scrapy
	页面级爬虫	网站级爬虫
	功能库	框架
	并发性考虑不足，性能较差	并发性好，性能较高
	重点在于页面下载	重点在于爬虫结构
	定制灵活	一般定制灵活，深度定制困难
	上手十分简单	入门稍难

常用命令：

命令	说明	格式
startproject	创建一个新工程	scrapy startproject<name>[dir]
genspider	创建一个爬虫	scrapy genspider [options] <name><domain>
settings	获得爬虫配置信息	scrapy settings [options]
crawl	运行一个爬虫	scrapy crawl<spider>
list	列出工程中所有爬虫	scrapy list
shell	启动URL调试命令行	scrapy shell [url]

步骤：

1）建立一个Scrapy爬虫工程：scrapy startproject python123demo

2）在工程中产生一个Scrapy爬虫：scrapy genspider demo python123.io

3）配置产生的spider爬虫demp.py

简化版

import scrapy

class DemoSpider(scrapy.Spider):
    name = 'demo'
    #allowed_domains = ['python123.io']
    start_urls = ['http://python123.io/ws/demo.html']

    def parse(self, response):
        fname = response.url.split('/')[-1]
        with open(fname, 'wb') as f:
            f.write(response.body)
        self.log("Save file %s." % fname)

完整版：

import scrapy

class DemoSpider(scrapy.Spider):
    name = 'demo'

    def start_requests(self):
        urls = [
            'http://python123.io/ws/demo.html'
        ]
        for url in urls:
            yield scrapy.Request(url=url, callback=self.parse)

    def parse(self, response):
        fname = response.url.split('/')[-1]
        with open(fname, 'wb') as f:
            f.write(response.body)
        self.log("Save file %s." % fname)

4）运行爬虫，获取网页：scrapy crawl demo

使用步骤:

1) 创建一个工程和Spider模板	数据类型： Request类 Response类 Item类
2) 编写Spider
3) 编写Item Pipleline
4）优化配置策略

1）Request类

class scrapy.http.Request(): 表示一个http请求，由Spider生成，由Downloader执行

属性或方法	说明
.url	Request对应的请求的URL地址
.method	对应的请求方法，'Get'，‘POST’等
.headers	字典类型请求风格头
.body	请求内容主体，字符串风格
.meta	用户添加的扩展信息，在Scrapy内部模块间传递信息使用
.copy()	复制该请求

2）Response类

class. scrapy.http.Response():表示一个http响应。由Downloader生成，由Spider处理

属性或方法	说明
.url	Response对应的URL地址
.status	HTTP状态码，默认是200
.headers	Response对应的头信息
.body	Response 对应的内容信息，字符串类型
.flags	一组标记
.request	产生Response类型对应的Request对象
.copy()	复制该响应

3）Item类

class scrapy.item.Item(): Item对象表示一个从HTML中提取的信息内容，由Spider生成，由Item Pipeline处理。类似字典类型，可以按照字典类型操作

Scrapy爬虫支持多种HTML信息提取方法：Beautiful Soup, lxml, re, XPath Selector, CSS Selector

实例：Scrapy获取上交所和深交所所有股票的名称和交易信息

百度股票：https://gupiao.baidu.com/stock/

单个股票：https://gupiao.baidu.com/stock/sz002439

东方财富网：http://quote.eastmoney.com/stocklist.html

1）建立工程和spider模板
>scrapy startproject BaiduStocks
>cd BaiduStocks
>scrapy genspider stocks baidu.com
>修改spiders/stocks.py文件
2）编写spider
>配置stocks.py文件
>修改对返回页面的处理
>修改对新增URL爬取请求的处理
3）编写Pipelines
>配置pipelines.py文件
>d定义对爬取项的处理类
>配置ITEM_PIPLINES选项

stocks.py

# -*- coding: utf-8 -*-
import scrapy
import re

class StocksSpider(scrapy.Spider):
    name = 'stocks'
    start_urls = ['http://quote.eastmoney.com/stocklist.html']

    def parse(self, response):
        for href in response.css('a::attr(href)').extract():
            try:
                stock = re.findall(r"[s][hz]\d{6}", href)[0]
                url = "https://gupiao.baidu.com/stock/"+ stock + '.html'
                yield scrapy.Request(url, callback=self.parse_stock)
            except:
                continue

    def parse_stock(self, response):
        infoDict = {}
        stockInfo = response.css('.stock-bets')
        name = stockInfo.css('.bets-name').extract()[0]
        keyList = stockInfo.css('dt').extract()
        valueList = stockInfo.css('dd').extract()
        for i in range(len(keyList)):
            key = re.findall(r'>.*</dt', keyList[i])[0][1:-5]
            try:
                val = re.findall(r'\d+\.?.*</dd', valueList[i])[0][0:-5]
            except:
                val = '--'
            infoDict[key] = val
        infoDict.update({'股票名称': re.findall('\s.*\(',name)[0].split()[0] +
                         re.findall('\>.*\<',name)[0][1:-1]})
        yield infoDict

pipelines.py, 修改settings.py中的内容，关联BaidustocksInfoPipline

class BaidustocksInfoPipline(object):
    def open_spider(self, spider):
        self.f = open('BaiduStockInfo.txt', 'w')

    def close_spide(self, spider):
        self.f.close()

    def process_item(self, item, spider):
        try:
            line = str(dict(item)) + '\n'
            self.f.write(line)
        except:
            pass
        return item