python爬虫总纲：步入爬虫殿堂

网络爬虫概述

定义

网络蜘蛛、网络机器人，抓取网络数据的程序。

其实就是用Python程序模仿人点击浏览器并访问网站，而且模仿的越逼真越好。

爬取数据目的

1、获取大量数据，用来做数据分析
2、公司项目的测试数据，公司业务所需数据

企业获取数据方式

1、公司自有数据
2、第三方数据平台购买(数据堂、贵阳大数据交易所)
3、爬虫爬取数据 : 第三方平台上没有,或者价格太高

Python做爬虫优势

1、Python ：请求模块、解析模块丰富成熟,强大的Scrapy网络爬虫框架
2、PHP ：对多线程、异步支持不太好
3、JAVA：代码笨重,代码量大
4、C/C++：虽然效率高,但是代码成型慢

爬虫分类

1、# 通用网络爬虫(搜索引擎使用,遵守robots协议)
   robots协议 ：网站通过robots协议告诉搜索引擎哪些页面可以抓取,哪些页面不能抓取，
               通用网络爬虫需要遵守robots协议（君子协议）
			  https://www.taobao.com/robots.txt
2、# 聚焦网络爬虫 ：自己写的爬虫程序

爬虫爬取数据步骤

1、1、确定需要爬取的URL地址
2、2、由请求模块向URL地址发出请求,并得到网站的响应
3、3、从响应内容中提取所需数据
     1、所需数据,保存
     2、页面中有其他需要继续跟进的URL地址,继续第2步去发请求，如此循环

爬虫请求模块一

模块名及导入urllib.request

1、模块名：urllib.request
2、导入方式：
   1、import urllib.request
   2、from urllib import request
3.使用方法：
	 req = request.Request(url,headers=headers)
	 res = request.urlopen(req)
     html = res.read().decode('utf-8')

常用方法详解

urllib.request.urlopen()方法

• 作用

向网站发起请求并获取响应对象

• 参数

1、URL：需要爬取的URL地址
2、timeout: 设置等待超时时间,指定时间内未得到响应抛出超时异常

• 响应对象（response）方法

1、bytes = response.read()
2、string = response.read().decode('utf-8')
3、url = response.geturl() # 返回实际数据的URL地址
4、code = response.getcode() # HTTP响应码
# 补充
5、string.encode() # string -> bytes
6、bytes.decode()  # bytes -> string

urllib.request.Request()

作用

创建请求对象(包装请求，重构User-Agent，使程序更像正常人类请求)

参数

1、URL：请求的URL地址
2、headers：添加请求头（爬虫和反爬虫斗争的第一步）

使用流程

1、构造请求对象(重构User-Agent)
   req = urllib.request.Request(url=url,headers={'User-Agent':'Mozilla/5.0 xxxx'})
2、发请求获取响应对象(urlopen)
   res = urllib.request.urlopen(req)
3、获取响应对象内容
   html = res.read().decode('utf-8')

示例：向测试网站发起请求，构造请求头并从响应中确认请求头信息

headers = {'User-Agent':'Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.1; WOW64; Trident/4.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; .NET4.0C; InfoPath.3)'}

URL地址编码模块

模块名

urllib.parse

作用

给URL地址中查询参数进行编码

编码前：https://www.baidu.com/s?wd=美女
编码后：https://www.baidu.com/s?wd=%E7%BE%8E%E5%A5%B3

常用方法

1、urlencode({dict})
   urlencode({'wd':'美女','pn':'20'})
   #编码后 ：'wd=%E8%D5XXX&pn=20'

2、quote(string)
   quote('织女')
   #编码后 ：'%D3%F5XXX'

3、unquote('%D3%F5XXX')
	#解码后:织女

使用方法：

from urllib import parse
#-----------urlencode({dict})编码-----------------
query_string = {'wd' : '美女'}
result = parse.urlencode(query_string)
# result: 'wd=%e7%be%8e%e5%a5%b3'
#----------quote(string)编码------------------
string = '美女'
print(parse.quote(string))
# 结果: %E7%BE%8E%E5%A5%B3
#----------unquote(string)解码----------------
string = '%E7%BE%8E%E5%A5%B3'
result = parse.unquote(string)
print(result)

拼接URL地址的3种方式

1、字符串相加
  'https://www.baidu.com/s?' + urlencode({'wd':'美女','pn':'50'})
2、字符串格式化（占位符）
  'https://www.baidu.com/s?%s' % urlencode({'wd':'美女','pn':'50'})
3、format()方法
   'https://www.baidu.com/s?{}'.format(urlencode({'wd':'美女','pn':'50'}))

总结

1、urllib.request
   1、urllib.request.Request(url=url,headers=headers)
   2、urllib.request.urlopen(req)
2、urllib.parse
   1、urllib.parse.urlencode({'wd':'美女'})
   2、urllib.parse.quote('美女')

正则解析模块re

re模块使用流程

• 方法一

r_list=re.findall('正则表达式',html,re.S)

• 方法二

# 1、创建正则编译对象
pattern = re.compile('正则表达式',re.S)
r_list = pattern.findall(html)

正则表达式元字符

元字符	含义
.	任意一个字符（不包括\n）
\d	一个数字
\s	空白字符
\S	非空白字符
[]	包含[]内容
*	出现0次或多次
+	出现1次或多次

推荐使用方法一

# 匹配任意一个字符的正则表达式
import re
# 方法一
  pattern = re.compile('.',re.S)
# 方法二
  pattern = re.compile('[\s\S]')

贪婪匹配和非贪婪匹配

贪婪匹配（默认）

1、在整个表达式匹配成功的前提下,尽可能多的匹配 * + ?
2、表示方式： .*  .+  .?

非贪婪匹配

1、在整个表达式匹配成功的前提下,尽可能少的匹配 * + ?
2、表示方式： .*?  .+?  .??

正则表达式分组

作用

在完整的模式中定义子模式，将每个圆括号中子模式匹配出来的结果提取出来

示例

import re

s = 'A B C D'
p1 = re.compile('\w+\s+\w+')
print(p1.findall(s))
# ['A B','C D']

p2 = re.compile('(\w+)\s+\w+')
print(p2.findall(s))
# ['A','C']

p3 = re.compile('(\w+)\s+(\w+)')
print(p3.findall(s))
# ['A B','C D']
# [('A','B'),('C','D')]

分组总结

1、在网页中,想要什么内容,就加()
2、先按整体正则匹配,然后再提取分组()中的内容
   如果有2个及以上分组(),则结果中以元组形式显示 [(),(),()]

字符串常用方法

# 'hello world'.strip()  --> 'hello world'
# 'hello world'.split(' ')  --> ['hello','world']
# 'hello world'.replace(' ','#') -> 'hello#world'

requests模块

安装

• Windows

# 方法一
   进入cmd命令行 ：python -m pip install requests
# 方法二
   右键管理员进入cmd命令行 ：pip install requests

常用方法

requests.get()

• 作用

# 向网站发起请求,并获取响应对象
res = requests.get(url,headers=headers)

• 参数

1、url ：需要抓取的URL地址
2、headers : 请求头
3、timeout : 超时时间，超过时间会抛出异常

• 响应对象(res)属性

1、encoding ：响应字符编码
   res.encoding = 'utf-8'
2、text ：字符串
3、content ：字节流
4、status_code ：HTTP响应码
5、url ：实际数据的URL地址


# 方式一 
res = requests.get(url,headers=headers)
res.encoding = 'utf-8'
html = res.text
# 方式二
res = requests.get(url,headers=headers)
html = res.content.decode('utf-8')

• 非结构化数据保存

with open('xxx.jpg','wb') as f:
	f.write(res.content)

查询参数-params

• 参数类型

字典,字典中键值对作为查询参数

• 使用方法

1、res = requests.get(url,params=params,headers=headers)
2、特点: 
   * url为基准的url地址，不包含查询参数
   * 该方法会自动对params字典编码,然后和url拼接

• 示例

import requests

baseurl = 'http://tieba.baidu.com/f?'
params = {
  'kw' : '赵丽颖吧',
  'pn' : '50'
}
headers = {'User-Agent' : 'Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.1; WOW64; Trident/4.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; .NET4.0C; InfoPath.3)'}
# 自动对params进行编码,然后自动和url进行拼接,去发请求
res = requests.get(baseurl,params=params,headers=headers)
res.encoding = 'utf-8'
print(res.text)

requests模块参数总结

1、url 
2、params : {}
3、proxies: {}
4、auth:   ()
5、verify:  True/False
6、timeout

requests.post()

• 适用场景

Post类型请求的网站

• 参数-data

response = requests.post(url,data=data,headers=headers)
# data ：post数据（Form表单数据-字典格式）

• 请求方式的特点

# 一般
GET请求 : 参数在URL地址中有显示
POST请求: Form表单提交数据

xpath解析

• 定义

XPath即为XML路径语言，它是一种用来确定XML文档中某部分位置的语言，同样适用于HTML文档的检索

• 示例HTML代码

<ul class="book_list">
    <li>
        <title class="book_001">Harry Potter</title>
        <author>J K. Rowling</author>
        <year>2005</year>
        <price>69.99</price>
    </li>

    <li>
        <title class="book_002">Spider</title>
        <author>Forever</author>
        <year>2019</year>
        <price>49.99</price>
    </li>
</ul>

• 匹配演示

1、查找所有的li节点
   //li
2、查找li节点下的title子节点中,class属性值为'book_001'的节点
   //li/title[@class="book_001"]
3、查找li节点下所有title节点的,class属性的值
   //li//title/@class

# 只要涉及到条件,加 []
# 只要获取属性值,加 @

• 选取节点

1、// ：从所有节点中查找（包括子节点和后代节点）
2、@  ：获取属性值
   # 使用场景1（属性值作为条件）
     //div[@class="movie"]
   # 使用场景2（直接获取属性值）
     //div/a/@src

• 匹配多路径（或）

xpath表达式1 | xpath表达式2 | xpath表达式3

• 常用函数

1、contains() ：匹配属性值中包含某些字符串节点
   # 查找class属性值中包含"book_"的title节点
     //title[contains(@class,"book_")]
   # 匹配所有段子的 div 节点
     //div[contains(@id,"qiushi_tag_")]
    
     <div class="article block untagged mb15   typs_long" id="qiushi_tag_122044339">
     </div>

     <div class="article block untagged mb15 typs_long" id="qiushi_tag_122044339">
     </div>
2、text() ：获取节点的文本内容
   # 查找所有书籍的名称
     //ul[@class="book_list"]/li/title 
        #结果:<element title at xxxx>
     //ul[@class="book_list"]/li/title/text()
        #结果:'Harry Potter'

1、获取猫眼电影中电影信息的 dd 节点
   //dl[@class="board-wrapper"]/dd
2、获取电影名称的xpath://dl[@class="board-wrapper"]/dd//p[@class="name"]/a/text()
  获取电影主演的xpath://dl[@class="board-wrapper"]/dd//p[@class="star"]/text()
  获取上映商检的xpath://dl[@class="board-wrapper"]/dd//p[@class="releasetime"]/text()

• 匹配规则

1、节点对象列表
   # xpath示例: //div、//div[@class="student"]、//div/a[@title="stu"]/span
2、字符串列表
   # xpath表达式中末尾为: @src、@href、text()

• xpath高级

1、基准xpath表达式: 得到节点对象列表
2、for r in [节点对象列表]:
       username = r.xpath('./xxxxxx')  
       # 此处注意遍历后继续xpath一定要以: . 开头，代表当前节点

lxml解析库

• 使用流程

1、导模块
   from lxml import etree
2、创建解析对象
   parse_html = etree.HTML(html)
3、解析对象调用xpath
   r_list = parse_html.xpath('xpath表达式')
   # 只要调用xpath，结果一定为列表

• 练习

from lxml import etree

html = '''<div class="wrapper">
	<i class="iconfont icon-back" id="back"></i>
	<a href="/" id="channel">新浪社会</a>
	<ul id="nav">
		<li><a href="http://domestic.firefox.sina.com/" title="国内">国内</a></li>
		<li><a href="http://world.firefox.sina.com/" title="国际">国际</a></li>
		<li><a href="http://mil.firefox.sina.com/" title="军事">军事</a></li>
		<li><a href="http://photo.firefox.sina.com/" title="图片">图片</a></li>
		<li><a href="http://society.firefox.sina.com/" title="社会">社会</a></li>
		<li><a href="http://ent.firefox.sina.com/" title="娱乐">娱乐</a></li>
		<li><a href="http://tech.firefox.sina.com/" title="科技">科技</a></li>
		<li><a href="http://sports.firefox.sina.com/" title="体育">体育</a></li>
		<li><a href="http://finance.firefox.sina.com/" title="财经">财经</a></li>
		<li><a href="http://auto.firefox.sina.com/" title="汽车">汽车</a></li>
	</ul>
	<i class="iconfont icon-liebiao" id="menu"></i>
</div>'''

# 获取所有 a 节点的文本内容
//ul//li/a/text()
# 获取所有 a 节点的 href 的属性值
//ul//li/a/@href
# 获取 图片、军事、...,不包括新浪社会  
//ul//li/a/title[not(contains(@title,"社会"))]/text()

常见的反爬机制及处理方式

1、Headers反爬虫 ：Cookie、Referer、User-Agent
   解决方案: 通过F12获取headers,传给requests.get()方法
        
2、IP限制 ：网站根据IP地址访问频率进行反爬,短时间内进制IP访问
   解决方案: 
        1、构造自己IP代理池,每次访问随机选择代理,经常更新代理池
        2、购买开放代理或私密代理IP
        3、降低爬取的速度
        
3、User-Agent限制 ：类似于IP限制
   解决方案: 构造自己的User-Agent池,每次访问随机选择
        
4、Ajax动态加载 ：从url加载网页的源代码后,会在浏览器执行JavaScript程序,这些程序会加载更多内容
   解决方案: F12或抓包工具抓包处理

5、对查询参数加密
   解决方案: 找到JS文件,分析加密算法,用Python实现加密执行JS文件中的代码,返回加密数据
        
6、对响应内容做处理
   解决方案: 打印并查看响应内容,用xpath或正则做处理

cookie模拟登录

• 适用网站及场景

抓取需要登录才能访问的页面
http://www.renren.com/970294164/profile

• 方法一

1、先登录成功1次,获取到携带登陆信息的Cookie
   F12打开控制台,在页面输入用户名、密码,登录成功,找到/home(一般在抓到地址的上面)
2、携带着cookie发请求
   ** Cookie
   ** Referer(源,代表你从哪里转过来的)
   ** User-Agent

• 方法二

1. 知识点

利用requests模块中的session会话保持功能

2. session会话使用流程

1、实例化session对象
   session = requests.session()
2、让session对象发送get或者post请求
   res = session.get(url,headers=headers)

3. 具体步骤

1、寻找登录时POST的地址
   查看网页源码,查看form,找action对应的地址: http://www.renren.com/PLogin.do

2、发送用户名和密码信息到POST的地址
   * 用户名和密码信息以什么方式发送？ -- 字典
     键 ：<input>标签中name的值(email,password)
     值 ：真实的用户名和密码
     post_data = {'email':'','password':''}

4. 程序实现

整体思路
1、先POST: 把用户名和密码信息POST到某个地址中
2、再GET:  正常请求去获取页面信息

json解析模块

json.loads(json格式字符串)

• 作用

把json格式的字符串转为Python数据类型

• 示例

html_json = json.loads(res.text)

json.dump(python,f,ensure_ascii=False)

• 作用

把python数据类型 转为 json格式的字符串
# 一般让你把抓取的数据保存为json文件时使用

• 参数说明

第1个参数: python类型的数据(字典，列表等)
第2个参数: 文件对象
第3个参数: ensure_ascii=False # 序列化时编码

• 示例

import json

app_dict = {
    '应用名称' : 'QQ',
    '应用链接' : 'http://qq.com'
}
with open('小米.json','a') as f:
	json.dump(app_dict,f,ensure_ascii=False)

• json转python

变量名 = json.loads(res.text)

• python转json（保存为json文件）

# 保存所抓取数据为json数据
with open(filename,'a') as f:
	json.dump(字典/列表/元组,f,ensure_ascii=False)

scrapy框架

• 定义

异步处理框架,可配置和可扩展程度非常高,Python中使用最广泛的爬虫框架

• 安装

# Windows安装
cmd命令行(管理员): python -m pip install Scrapy
# Visual C++ 14.0 xxx is required

• Scrapy框架五大组件

1、引擎(Engine)      ：整个框架核心
2、调度器(Scheduler) ：维护请求队列
3、下载器(Downloader)：获取响应对象
4、爬虫文件(Spider)  ：数据解析提取
5、项目管道(Pipeline)：数据入库处理
**********************************
# 下载器中间件(Downloader Middlewares) : 引擎->下载器,包装请求(随机代理等)
# 蜘蛛中间件(Spider Middlewares) : 引擎->爬虫文件,可修改响应对象属性

• scrapy爬虫工作流程

# 爬虫项目启动
1、由引擎向爬虫程序索要第一个要爬取的URL,交给调度器去入队列
2、调度器处理请求后出队列,通过下载器中间件交给下载器去下载
3、下载器得到响应对象后,通过蜘蛛中间件交给爬虫程序
4、爬虫程序进行数据提取：
   1、数据交给管道文件去入库处理
   2、对于需要继续跟进的URL,再次交给调度器入队列，依次循环

• scrapy常用命令

# 1、创建爬虫项目
scrapy startproject 项目名
# 2、创建爬虫文件
scrapy genspider 爬虫名 域名
# 3、运行爬虫
scrapy crawl 爬虫名

• scrapy项目目录结构

Baidu                   # 项目文件夹
├── Baidu               # 项目目录
│   ├── items.py        # 定义数据结构
│   ├── middlewares.py  # 中间件
│   ├── pipelines.py    # 数据处理
│   ├── settings.py     # 全局配置
│   └── spiders
│       ├── baidu.py    # 爬虫文件
└── scrapy.cfg          # 项目基本配置文件

• 全局配置文件settings.py详解

# 1、定义User-Agent
USER_AGENT = 'Mozilla/5.0'
# 2、是否遵循robots协议，一般设置为False
ROBOTSTXT_OBEY = False
# 3、最大并发量，默认为16
CONCURRENT_REQUESTS = 32
# 4、下载延迟时间
DOWNLOAD_DELAY = 1
# 5、请求头，此处也可以添加User-Agent
DEFAULT_REQUEST_HEADERS={}
# 6、项目管道
ITEM_PIPELINES={
	'项目目录名.pipelines.类名':300
}

• 创建爬虫项目步骤

1、新建项目 ：scrapy startproject 项目名
2、cd 项目文件夹
3、新建爬虫文件 ：scrapy genspider 文件名 域名
4、明确目标(items.py)
5、写爬虫程序(文件名.py)
6、管道文件(pipelines.py)
7、全局配置(settings.py)
8、运行爬虫 ：scrapy crawl 爬虫名

• pycharm运行爬虫项目

1、创建begin.py(和scrapy.cfg文件同目录)
2、begin.py中内容：
	from scrapy import cmdline
	cmdline.execute('scrapy crawl maoyan'.split())

猫眼电影案例

• 目标

URL: 百度搜索 -> 猫眼电影 -> 榜单 -> top100榜
内容:电影名称、电影主演、上映时间

• 实现步骤

1. 创建项目和爬虫文件

# 创建爬虫项目
scrapy startproject Maoyan
# 创建爬虫文件
cd Maoyan
scrapy genspider maoyan maoyan.com
# Maoyan/Maoyan/spiders/maoyan.py

2. 定义要爬取的数据结构（items.py）

name = scrapy.Field()
star = scrapy.Field()
time = scrapy.Field()

3. 编写爬虫文件（maoyan.py）

1、基准xpath,匹配每个电影信息节点对象列表
	dd_list = response.xpath('//dl[@class="board-wrapper"]/dd')
2、for dd in dd_list:
	电影名称 = dd.xpath('./a/@title')
	电影主演 = dd.xpath('.//p[@class="star"]/text()')
	上映时间 = dd.xpath('.//p[@class="releasetime"]/text()')

思路梳理

1、items.py : 定义爬取的数据结构
2、maoyan.py: 提取数据
   from ..items import MaoyanItem
   item = MaoyanItem()
   item['name'] = xpathxxxxxx
   yield item # 把item对象（数据）交给管道文件处理
3、pipelines.py: 处理数据
  class MaoyanPipeline(object):
    def process_item(self,item,spider):
        # 处理item数据（从爬虫文件传过来的item对象）
        return item 
4、settings.py: 开启管道
   ITEM_PIPELINES = {
       # 优先级1-1000，数字越小优先级越高
       'Maoyan.pipelines.MaoyanPipeline':200
   }

代码实现

class MaoyanSpider(scrapy.Spider):
    name = 'maoyan3'
    allowed_domains = ['maoyan.com']

    # 重写start_requests()方法,把所有URL地址都交给调度器
    def start_requests(self):
        for offset in range(0,91,10):
            url = 'https://maoyan.com/board/4?offset={}'.format(offset)
            # 交给调度器
            yield scrapy.Request(
                url = url,
                callback = self.parse_html
            )

3. 定义管道文件（pipelines.py）

class MaoyanPipeline(object):
    def process_item(self,item,spider):
        # 处理item数据（从爬虫文件传过来的item对象）
        return item 

5. 全局配置文件（settings.py）

USER_AGENT = 'Mozilla/5.0'
ROBOTSTXT_OBEY = False
DEFAULT_REQUEST_HEADERS = {
	'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
	'Accept-Language': 'en',
}
ITEM_PIPELINES = {
   'Maoyan.pipelines.MaoyanPipeline': 300,
}

6. 创建并运行文件（run.py）

from scrapy import cmdline
cmdline.execute('scrapy crawl maoyan'.split())

总结

• 节点对象.xpath(’’)

1、列表,元素为选择器 [<selector xpath='' data='A'>,]
2、列表.extract() ：序列化列表中所有选择器为Unicode字符串 ['A','B','C']
3、列表.extract_first() 或者 get() :获取列表中第1个序列化的元素(字符串)

• pipelines.py中必须由1个函数叫process_item

def process_item(self,item,spider):
	return item ( * 此处必须返回 item )

• 管道处理数据流程

1、在爬虫文件中 为 items.py中类做实例化，用爬下来的数据给对象赋值
	from ..items import MaoyanItem
	item = MaoyanItem()
    item['name'] = xxx
2、管道文件（pipelines.py）
3、开启管道（settings.py）
	ITEM_PIPELINES = { '项目目录名.pipelines.类名':优先级 }# 优先级1-1000，数字越小优先级越高