爬虫

概念：

网络爬虫：就是模拟客户端发送请求，获取响应数据，一种按照一定的规则，自动地抓取万维网上的信息的程序或者脚本

爬虫分类:

通用爬虫：抓取系统中重要的组成部分。抓取的是一整张页面数据
聚焦爬虫：建立在通用爬虫的基础上，抓取的是页面中特定的局部内容。
增量式爬虫：检测网站中数据更新的情况，只会抓取网站中最新更新的数据

爬虫的矛与盾：

反爬机制：门户网站，通过制定相关的策略或技术手段，防止爬虫程序对网站数据的爬取
反反爬：破解门户网站具备的反爬机制，获取数据

爬虫和浏览器的区别：

浏览器：

浏览器向百度服务器发送请求 --> http 😕/www.baidu.com

百度服务器发送数据–> 获取响应数据，进行渲染 -->给用户看

爬虫：

向百度服务器发送请求–> http 😕/www.baidu.com

百度服务器发送数据–> 获取响应数据，并保存数据

URI和URL:

URI全称：Uniform Resource Identifier (统一资源标识符)

URL全程：Universe Resource Locator (统一资源定位符) , URL是URI的子集

举例说明： https：／／github .com/favicon.ico 这是GitHub网站的图标链接

访问协议https · 访问路径github.com · 资源名称favicon.ico

超文本：

hypertext–超文本网页就是超文本解析而成的，网页的源代码就是HTML代码

HTTP和HTTPS协议：

HTTP：Hyper Text Transfer Protocol (超文本传输协议)，用于从网络传输超文本数据到本地浏览器的传送协议，能保证高效而准确的传输超文本文档

HTTPS：Hyper Text Transfer Protocol over Secure Socket Layer (以安全为目标的HTTP通道)，就是HTTP的安全版

就是服务器与客户端进行数据交互的一种形式。

常用请求头信息：

User-Agent：请求载体的身份标识，可以使服务器识别操作系统的版本、浏览器等信息
Conection:请求完之后，是断开连接还是保持连接
Cookie: 为了辨别用户进行会话跟踪而储存在用户本地的数据，功能是维持当前访问会话。就是用户登陆后，服务器会保持登录状态

常用响应头信息：

Content-Type：服务器响应回客户端的媒体类型信息，例如html、json、gif

加密方式：

对称密钥加密：客户端对数据进行加密，锁和密钥一起发给服务器，服务器再用密钥打开锁，发送过程中被拦截密钥会被拿走
非对称密钥加密：服务器制定好加密方式发送给客户端，客户端用该加密方式对数据进行加密，再发送给服务器用私钥进行解密。但是加密方式传输时可能被拦截篡改。
证书密钥加密：先把公开密钥给证书认证机构，给公钥进行签名，公钥封装到证书里，发送给客户端。客户端相信认证机构，客户端通过公钥对报文进行加密发送，服务器接收后用私钥进行解密

响应：

由服务端返回给客户端，分为三部分。响应状态码（Response Status Code）,响应头（Response Headers）,响应体（Response Body）

1.状态码：

200--成功
400--错误请求
403--禁止访问
404--找不到请求的网页
502--错误网关
503--服务器目前无法使用
504--网关超时

2.响应头：响应头，Server、Cookies等信息

3.响应体:请求网页的时候，返回的使HTML代码，请求图片的时候响应的使二进制数据

网页的结构：

title标签使网页的标题 · body是正文内容

div是网页的区块标签，id=“ ” id的内容在网页中是唯一的 class=“ ” 属性标记

HTML文档是树结构，节点树

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gKtR4Fg8-1673159360178)(C:%5CUsers%5C%E9%93%B6%E6%99%97%5CAppData%5CRoaming%5CTypora%5Ctypora-user-images%5C1632450058735.png)]

为什么有时候解析不到数据？

1.beautifulsoup的标签不规范，无法识别定位

2.xpath的标签嵌套找不到，定位不到

3.js的渲染

使用HTTP请求库得到的源代码和浏览器中看到的数据不一样，是因为js会改变HTML的结点，向其添加内容，最后得到浏览器的页面

4.不要在Elements的选项卡中直接查看源码，那里的代码给渲染过了，要在network中查看

什么是会话（Session）和Cookies

HTTP的特点之一：无状态

指HTTP协议对事务处理是没有记忆能力的，也就是说服务器不知道客户端是什么

意味着如果后续需要处理前面的信息，必须重传

Session

在服务端----网站的服务器

用来保存用户的Session信息

Cookies

在客户端也就可以理解为浏览器端

辨别用户的身份、进行Session跟踪而储存再用户本地终端上的数据

浏览器在下次访问网页时会自动附带上cookies发送给服务器，服务器通过识别Cookies并鉴定出时哪个用户，然后再判断用户是否是登陆状态进而返回对应的响应

1.会话cookies:

cookies放在浏览器内存里，浏览器关闭之后该cookies失效

2.持久cookies:

浏览器关闭，cookies不会消失，cookies会保存会话ID信息到硬盘上，再次打开浏览器，仍然能够找到原来的会话ID，依旧可以处于保持登录状态。

恰恰是这样，这需要服务器为会话机制设置一个失效时间，距离客户端上一次书院会话的时间超过失效时间，服务器就会删除会话以节省空间

代理：

代理–>代理服务器，proxy server

功能：代理网络用户去取得网络信息

理解：代理服务器就是在本机和服务器之间的一个桥，本机向代理发请求，然后代理再向服务器发请求，回来的响应也是经历这样的过程，web服务器无法识别我们的真实IP，从而实现IP伪装

urllib：

有4个模块

request: HTTP请求模块

error: 异常处理模块，如果出现错误，我们可以捕获异常，然后进行重试或者其他操作，保证程序不会意外终止

parse: 工具模块，提供URL的处理方法

robotparse: 识别网站的robot.txt

requests

requests是一个优雅而简单的Python Http请求库，作用是发送请求获取响应数据

使用3步骤：

导入模块
发送get请求，获取响应

从响应中获取数据

import requests

get(url= ,param= ,headers=)
url:请求的路由
param:要访问抓取的参数，用抓包工具用网页上抓取，有些固定的参数自己可以更改，注意数	  据类型是str
headers:User-Agent，抓包工具抓一次就好了
timeout:超时时间，过了这个时间服务器没响应，就返回失败
 
post(url= ,headers= ,data= )	注意和get区分

response = requests.get('http://www.baidu.com')
response.status_code //返回请求状态
response.encoding = 'utf-8'
# print(response.text)
#content :获取响应的二进制数据，图片、图标
response.text = response.content.decode()  
# 默认utf-8 ，如果是gbk ，decode（encoding = ‘gbk’）

text(字符串)，content(二进制) ，json(对象)

#session使用
headers={
    ...
}
proxies={
    ...
}
s = request.Session()
s.header.update(headers)
r = s.get(url,params,headers,timeout,proxies)
r = s.post(url,data)

常用UA：

User_Agent = [
    "Mozilla/5.0 (iPod; U; CPU iPhone OS 4_3_2 like Mac OS X; zh-cn) AppleWebKit/533.17.9 (KHTML, like Gecko) Version/5.0.2 Mobile/8H7 Safari/6533.18.5",
    "Mozilla/5.0 (iPhone; U; CPU iPhone OS 4_3_2 like Mac OS X; zh-cn) AppleWebKit/533.17.9 (KHTML, like Gecko) Version/5.0.2 Mobile/8H7 Safari/6533.18.5",
    "MQQBrowser/25 (Linux; U; 2.3.3; zh-cn; HTC Desire S Build/GRI40;480*800)",
    "Mozilla/5.0 (Linux; U; Android 2.3.3; zh-cn; HTC_DesireS_S510e Build/GRI40) AppleWebKit/533.1 (KHTML, like Gecko) Version/4.0 Mobile Safari/533.1",
    "Mozilla/5.0 (SymbianOS/9.3; U; Series60/3.2 NokiaE75-1 /110.48.125 Profile/MIDP-2.1 Configuration/CLDC-1.1 ) AppleWebKit/413 (KHTML, like Gecko) Safari/413",
    "Mozilla/5.0 (iPad; U; CPU OS 4_3_3 like Mac OS X; zh-cn) AppleWebKit/533.17.9 (KHTML, like Gecko) Mobile/8J2",
    "Mozilla/5.0 (Windows NT 5.2) AppleWebKit/534.30 (KHTML, like Gecko) Chrome/12.0.742.122 Safari/534.30",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_2) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/14.0.835.202 Safari/535.1",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_2) AppleWebKit/534.51.22 (KHTML, like Gecko) Version/5.1.1 Safari/534.51.22",
    "Mozilla/5.0 (iPhone; CPU iPhone OS 5_0 like Mac OS X) AppleWebKit/534.46 (KHTML, like Gecko) Version/5.1 Mobile/9A5313e Safari/7534.48.3",
    "Mozilla/5.0 (iPhone; CPU iPhone OS 5_0 like Mac OS X) AppleWebKit/534.46 (KHTML, like Gecko) Version/5.1 Mobile/9A5313e Safari/7534.48.3",
    "Mozilla/5.0 (iPhone; CPU iPhone OS 5_0 like Mac OS X) AppleWebKit/534.46 (KHTML, like Gecko) Version/5.1 Mobile/9A5313e Safari/7534.48.3",
    "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/14.0.835.202 Safari/535.1",
    "Mozilla/5.0 (compatible; MSIE 9.0; Windows Phone OS 7.5; Trident/5.0; IEMobile/9.0; SAMSUNG; OMNIA7)",
    "Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0; XBLWP7; ZuneWP7)",
    "Mozilla/5.0 (Windows NT 5.2) AppleWebKit/534.30 (KHTML, like Gecko) Chrome/12.0.742.122 Safari/534.30",
    "Mozilla/5.0 (Windows NT 5.1; rv:5.0) Gecko/20100101 Firefox/5.0",
    "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.2; Trident/4.0; .NET CLR 1.1.4322; .NET CLR 2.0.50727; .NET4.0E; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729; .NET4.0C)",
    "Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.2; .NET CLR 1.1.4322; .NET CLR 2.0.50727; .NET4.0E; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729; .NET4.0C)",
    "Mozilla/4.0 (compatible; MSIE 60; Windows NT 5.1; SV1; .NET CLR 2.0.50727)",
    "Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; .NET4.0C; .NET4.0E)",
    "Opera/9.80 (Windows NT 5.1; U; zh-cn) Presto/2.9.168 Version/11.50",
    "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1)",
    "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.1; Trident/4.0; .NET CLR 2.0.50727; .NET CLR 3.0.04506.648; .NET CLR 3.5.21022; .NET4.0E; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729; .NET4.0C)",
    "Mozilla/5.0 (Windows; U; Windows NT 5.1; zh-CN) AppleWebKit/533.21.1 (KHTML, like Gecko) Version/5.0.5 Safari/533.21.1",
    "Mozilla/5.0 (Windows; U; Windows NT 5.1; ) AppleWebKit/534.12 (KHTML, like Gecko) Maxthon/3.0 Safari/534.12",
    "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 2.0.50727; TheWorld)",
    "Opera/9.80 (X11; Linux i686; Ubuntu/14.10) Presto/2.12.388 Version/12.16",
    "Opera/9.80 (Windows NT 6.0) Presto/2.12.388 Version/12.14",
    "Mozilla/5.0 (Windows NT 6.0; rv:2.0) Gecko/20100101 Firefox/4.0 Opera 12.14",
    "Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.0) Opera 12.14",
    "Opera/12.80 (Windows NT 5.1; U; en) Presto/2.10.289 Version/12.02",
    "Opera/9.80 (Windows NT 6.1; U; es-ES) Presto/2.9.181 Version/12.00",
    "Opera/9.80 (Windows NT 5.1; U; zh-sg) Presto/2.9.181 Version/12.00",
    "Opera/12.0(Windows NT 5.2;U;en)Presto/22.9.168 Version/12.00",
    "Opera/12.0(Windows NT 5.1;U;en)Presto/22.9.168 Version/12.00",
    "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:40.0) Gecko/20100101 Firefox/40.1",
    "Mozilla/5.0 (Windows NT 6.3; rv:36.0) Gecko/20100101 Firefox/36.0",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10; rv:33.0) Gecko/20100101 Firefox/33.0",
    "Mozilla/5.0 (X11; Linux i586; rv:31.0) Gecko/20100101 Firefox/31.0",
    "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:31.0) Gecko/20130401 Firefox/31.0",
    "Mozilla/5.0 (Windows NT 5.1; rv:31.0) Gecko/20100101 Firefox/31.0",
    "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:29.0) Gecko/20120101 Firefox/29.0",
    "Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:25.0) Gecko/20100101 Firefox/29.0",
    "Mozilla/5.0 (X11; OpenBSD amd64; rv:28.0) Gecko/20100101 Firefox/28.0",
    "Mozilla/5.0 (X11; Linux x86_64; rv:28.0) Gecko/20100101  Firefox/28.0",
    "Mozilla/5.0 (Windows NT 6.1; rv:27.3) Gecko/20130101 Firefox/27.3",
    "Mozilla/5.0 (Windows NT 6.2; Win64; x64; rv:27.0) Gecko/20121011 Firefox/27.0",
    "Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:25.0) Gecko/20100101 Firefox/25.0",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.6; rv:25.0) Gecko/20100101 Firefox/25.0",
    "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:24.0) Gecko/20100101 Firefox/24.0",
    "Mozilla/5.0 (Windows NT 6.0; WOW64; rv:24.0) Gecko/20100101 Firefox/24.0",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:24.0) Gecko/20100101 Firefox/24.0"
]

UA：

UA= User-Agent(请求载体的身份标识)

UA伪装：门户网站的服务器会检测对应请求的载体身份标识。如果是某一款浏览器就是一个正常的请求，如果不是就是爬虫，是不正常的请求，服务端可能会拒绝请求，是拿不到数据的。

为了避免被拒绝，爬虫需要进行UA伪装：让爬虫对应的身份标识伪装成某一个浏览器

将 User-Agent封装到一个字典中:

headers={

’ User-Agent‘ = ‘ 网站上的 User-Agent对应的字符串’

}

response.json()  //拿json数据
filename= input+'.json'
fp= open('./douban.json','w', encording='utf-8')
dump.(filename, fp= fp, ensure_ascii=False)

代理：

破解封IP这种反扒机制，突破自身IP访问的限制，隐藏自身IP不会被封。什么是代理服务器：作为一个中转服务器，我们的IP发给代理，代理再发IP给服务器，我们的IP地址不会别封。

代理相关网站：快代理、西祠代理、www.goubanjia.com

代理ip类型：
http：应用到http协议对应的url中
https：应用到https协议对应的url中


代理ip的透明度:
-透明：服务器知道该次请求使用了代理，也知道真实的ip
-匿名：知道使用了代理，不知道真实的ip
-高匿：不知道使用了代理也不知道真实的ip

例如：
proxy = '121.230.211.41'
如果要用户名： proxy = usernamme:password@'121.230.211.41'
proxies={'HTTP/HTTPS':'ip地址',
			  'HTTP':'http'+proxy}
page_text= requests.get(url=url,headers=headers,proxies=proxies).text

数据解析：

数据解析：Beautifulsoup，正则表达式，xpath

概念：解析的局部标签对应的属性中存储的数据值进行提取

进行标签的定位
标签或者标签对应的属性中储存的数据值进行提取

解析图片：

url= '...'
img_data= requests.get(url=url).content

with open('./giutu.jpg','wb') as fp:
	fp.write(img_data)

bs4数据解析：

实例化一个BeautifulSoup对象，并将页面源码数据加载到该对象中
通过BeautifulSoup对象的属性或者方法进行标签定位和数据提取

Beautiful Soup

BeautifulSoup 对象：代表要解析整个文档树，它支持遍历文档树和搜索文档树中描述的大部分的方法

它的作用就是从 HTML 和 BeautifulSoup 对象的创建

fp=open('.html','r',encording='utf-8')
soup= BeautifulSoup(fp,'lxml')

soup.tagName():返回的是html中第一次出现的tagName，tagName就是标签名

find（）方法：

find的作用就是找标签

步骤：

导入模块
准备文档字符串
创建BeautifulSoup标签
查找文档中的标签

find（self ,name=, attrs={}, recursive=True, text= ,**kwargs ）

find_all(name , attrs , recursive , text,**kargs)

参数：

name: 标签名
attrs：属性字典
recursive：是否递归查找
text: 根据文本内容查找

返回：查找到的第一个元素对象

soup = BeautifulSoup('<html>data</html>', 'lxml')  
# BeautifulSoup 会自动修正代码print(soup)

#要准备html的文档
html='''
		...		'''
soup= BeautifulSoup(html , 'lxml')
print(soup)

#查找title和a标签
title= soup.find('title')
a= soup,find('a')  	
#属性定位
soup.find('div',class_=' song')  两个属性定位，标签+属性（可以是id或者attr）

#查找所有的a
soup= find_all('a')
print(a+title)

soup.select('.属性名')  . 代表class_   id/
soup.select('.tang >ul>li>a')[0] 	标签层级选择器，大于号表示一个层级,[]表示第几个
soup.select('.tang >ul a')[0]		空格一次性表示多个层级

soup.select('.tang >ul a')[0].text  直接获取文本

soup.a['标签名']  直接提取文本
#根据属性进行查找
	#查找id 为link1的标签
    a= soup.find(id='link1')
    a= soup.find(attrs={'id':'link1'})		#两种方法
    print(a)
#根据文本内容进行查找
text= soup.find(text=' 要查找的内容')

#Tag对象
print('标签名',a.name)
print('标签所有的属性',a.attrs)
print('标签文本内容',a.text)
Tag可以获取标签的属性和文本

Xpath：

原理：实例化一个etree的对象，且需要将被解析的页面的源码数据加载到该对象中，调用xpath对象的xpath方法获取标签的定位和内容捕获

如何实例化etree对象：

将本地的html文档的源码数据加载到etree中：etree.parse(filepath)
可以将互联网上获取的源码数据加载到该对象中：etree.HTML(‘page_text’)
xpath(‘xpath的表达式’)

tree = etree.parse('test.html')

r= tree.xpath('./html/body/div')
r=tree.xpath('./html/html/div')

#属性定位 tag[@attrname='attrValue']:
r=tree.xpath('//div[@class='song']')

#索引定位 /p[]索引从1开始：(//[@class=标签名]小标签名[第几个])
r=tree.xpath('//div[@class='song']/p[3]')	

#精确文本定位,[0]小技巧去掉列表符
#   /text():拿直系标签的文本
#	//text():拿所有的文本内容
r= tree.xpath('//div[@class='tang']//li[5]/a/text()')[0]	
r= tree.xpath('//div//li[7]//text')[0]

#取属性值  /@attrname
r=tree.xpath('//div[@class='song']/img/@scr')

#属性是多值的匹配 contains(@属性名，标签名)
<li class "li li-first">first item>
result = html.xpath('//li[contain(@class,"li")]/text()')

PyQuery

使用的是CSS选择器

from pyquery import PyQuery as pq
doc = pq(url="...")


doc('#container .list li')

#调用items方法后，会返回一个生成器
for item in doc('#container .list li').items():
    print(item.text())

find()：item.find('css选择器')查找该节点的所有子孙节点
children(): 只拿子节点
parent() / parents()：获取节点的(单个/多个)父节点
siblings(): 获取兄弟节点

pyquery选择返回的结果都是pyquery类型的，可以进行类型转换

获取属性值：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wVJYpUAU-1673159360180)(C:%5CUsers%5C%E9%93%B6%E6%99%97%5CAppData%5CRoaming%5CTypora%5Ctypora-user-images%5C1635860179367.png)]

或者：a.attr.href

获取文本：

a.text() 返回的是该节点的所有的文本，字符串类型

a.html() 返回当前节点文本

动态更改节点属性

1.addClass 和removeClass

动态更改class属性

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-T6qQT0dQ-1673159360181)(C:%5CUsers%5C%E9%93%B6%E6%99%97%5CAppData%5CRoaming%5CTypora%5Ctypora-user-images%5C1635860890528.png)]

2.attr方法对属性进行操作

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-poL86Tnx-1673159360181)(C:%5CUsers%5C%E9%93%B6%E6%99%97%5CAppData%5CRoaming%5CTypora%5Ctypora-user-images%5C1635861027622.png)]

3.text()和html()

可以更改节点内部的内容

4.append、empty、prepend方法

Unicode乱码尝试方法：

UnicodeError是在处理字符串时出现的错误，分为两个子异常类，UnicodeEncode和UnicodeDecodeError

处理这个问题需要使用 encode() 和 decode()方法

encode和decode均可接收encoding与errors两个参数，用来指定编码、解码的错误和出现错误的时候的反应
#注意！解码和解码前后的字符串的长度可能不同，因为二者的长度意义不同。对于Unicode长度为其中字符的长度，str的长度取决于bytes的数目
encode ：将unicode字符串翻译成bytes，也就是str对象
decode ：相反，将bytes翻译为原有的Unicode字符串

unicode字符串就是str->  'hello world'
bytes字符串->	b'hello world'

Encoding Error: UnicodeDecodeError

报错原因：由于指定的编码格式不足以编码指定unicode字符串中的某些字符，说明使用的时错误的编码格式

>>>unicode_seq.encode('ascii')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
UnicodeEncodeError: 'ascii' codec can't encode character u'\xf8' in position 13: ordinal not in range(128)
#ascii无法编码u'\xf8'字符

Decoding Error:UnicodeDecodeError

报错原因：你指定的编码格式无法解码该字符串

>>> wrong_seq.decode('utf-8')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/local/Cellar/python/2.7.13/Frameworks/Python.framework/Versions/2.7/lib/python2.7/encodings/utf_8.py", line 16, in decode
    return codecs.utf_8_decode(input, errors, True)
UnicodeDecodeError: 'utf8' codec can't decode byte 0x89 in position 1: invalid start byte
#utf-8无法解码byte流

解决报错的思路：

思路一：Unicode编码解码的顺序
程序的内部是Unicode字符串，程序外部是bytes字符串，所以在程序的入口解码读取到的数据，在程序的出口编码数据

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ucquxuNt-1673159360182)(C:%5CUsers%5C%E9%93%B6%E6%99%97%5CPictures%5CSaved%20Pictures%5C70)]

思路二：了解被处理的数据是那种类型
两个方法：1.type()方法查看这个数据的类型  2.repr()方法查看它的Unicode字符串到底是什么

#乱码尝试方法1
 中文转Unicode编码：
 	text = '中国'
 	result = text.encode('unicode_escape')
 Unicode转中文：
 	result = u_str.decode('unicode_escape')

# 乱码尝试方法2
 1.图片：img_name = img_name.encode('iso-8859-1').decode('gbk')
 2.响应数据：response.encoding = 'utf-8'

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NQN8S858-1673159360183)(C:%5CUsers%5C%E9%93%B6%E6%99%97%5CAppData%5CRoaming%5CTypora%5Ctypora-user-images%5C1632404127737.png)]

Excel：

读取excel，保存为了excel：

 df = pd.DataFrame()

    for i in data:
        df = df.append([[
        i['rank'],
        i['score'],
        i['types'],
        i['regions'],
        i["release_date"],
        i['title'],
        i['actors']]]
        )
    df.columns = ['排名','豆瓣评分','电影类型','国家','上映日期','电影名称','演员']
    df = df.reset_index(drop=True)
    # print(df)

#写入pandas的同时直接保存到excel
#列表符号那些，可以用excel中自带功能进行删除替换处理，快捷键Ctrl+H
    df.to_excel('D:/360Downloads/豆瓣喜剧TOP100.xlsx',sheet_name='Top100',index=False)

wb = xlwt.Workbook(encording='utf-8',style_compression=0)
sh=wb.add_sheet('moviesTop250',cell_overwrite_ok=True)
col = ('表格的表头名')
for i in range(0,8):
	sh.write(0,i,col[i])
#通过for循环将列表中的数据逐一填写到Excel单元格内
for i in range(0,len(dataList)):
    print('%d'%(i+1))
    data= dataList[i]
    for j in range(0,8):
		sh.write(i+1,j,data[j])
sFile = 'D:/360DownLoad:\doubanmovies.xls'
wb.save(sFile)

文件处理：

from openpyxl import Workbook

wb= Workbook()	#创建表
ws= wb.active	#获取当前sheet表
sheet.title = '表名'	#改sheet名

wb2 = load_workbook('文件名字'.xlsx)


#写数据
#method1：直接分配到单元格
sheet["C5"] = 'text'
#method2：附加行
sheet.append([1,2,3])
#method3：自动类型转换
sheet['A3']=''

正则表达式

常用匹配操作：

1.^符和&符的使用，不要单独使用，结合文本例如：^He(\d+)Demo$

2.省略的部分书写(非贪婪模式)：(.*?)

3.遇到不规则的字符：加一个反斜杠例如：\（百度）www… 避免开始匹配不到

修饰符

re.I：使匹配对大小写不敏感
re.L：做本地化识别
re.M：多行匹配，影响^和&
re.S：使 . 符匹配包括换行符在内的所有字符
re.U：根据Unicode字符集解析字符，这个标志影响\w,\W,\b和\B
re.X：给予你更灵活的格式以便于你将正则表达式写得更容易理解

模式

match():从字符串起始的位置匹配正则表达式，如果匹配就返回，没有匹配就返回None
	用.group(索引)来获取匹配到的内容
search():match方法在开头不匹配可能会终止，search可以避免这个问题，sreach可以搜索整个			字符串
sub():不多说，替换
compile():规定一个同一个的正则表达式，可以重复的使用

爬虫中匹配

匹配标签中的内容：
	re.compile(<li .*?active.*?singer="(.*?)"> (.*?)</a>,html.re.S)
处理字符串：
	s = re.sub('<a.*?>|</a>','',re.S)  去除标签
	s.strip()

字符匹配：

\d:代表任意数字 \D：代表不是数字的（大写的字母一般是和小写的唱反调）
\w：代表字母，数字，下划线，也就是a-z，A-Z，0-9，—。 \W：不是字母数字下划线的
\n：代表一个换行
\r：代表一个回车 \f：代表一个换页 \t：代表一个tab
\s：代表所有的空白字符（包括换行回车换页tab) \S：不是空白的字符
\A:代表字符串的开始 \Z：代表字符串的结束
^:匹配字符串的开始位置 &：匹配字符串的结束位置
\b:匹配一个单词的边界 \B：匹配非单词边界
|：匹配两边的表达式 +（） 要想匹配的不多不少刚刚好，就必须用^和&来规定开始结束
星号：匹配前面的字符串零次或多次例如：zo* 能匹配z、zo、zoo
+：匹配前面的字符串一次或多次例如：zo+能匹配zo、zoo但不能匹配z
？：匹配前面的字符串零次或一次例如：do（es）？可以匹配do或者does
[n]：n是一个非负整数，匹配确定的n次例如o[2]必须匹配到2个o，bob就不能匹配到
[n，]：就是至少匹配n次，可以多不能少 [n,m]：最少匹配n次，最多匹配m次
. : 匹配 \r \n 之外的任何的单个字符
[…]：表示一个范围内的字符例如[a-z]就是a-z间任意一个字符 [^]唱反调
{n}：匹配在{n}前面的东西 n次
()括号可以作为一个分组，括号括起来的内容可以作为中间变量记录下来，要想记录下来并使用把后面的那一部分也括起来然后写（\1）数字就是第几个括号

括号一多容易混，所以用信息加以定义 (？p=< 定义名字>) 例子：(？p=< key1>)

首先导入模块re

校验数字：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mmrJ6avx-1673159360184)(C:\Users\银晗\AppData\Roaming\Typora\typora-user-images\1611386525311.png)]

校验字符的表达式：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-z1rOmeqR-1673159360184)(C:\Users\银晗\AppData\Roaming\Typora\typora-user-images\1611386578655.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RYEO8mCp-1673159360185)(C:\Users\银晗\AppData\Roaming\Typora\typora-user-images\1611386615056.png)]

re模块的方法：
1. 循环所有匹配：re.findall()
  
  re.findall(pattern, string , flags=0)
  
  pattern=正则表达式 string=匹配的字符串
  
  res=re.findall(r‘ r[ua]n’, ‘run ran ren’ ) print(res) 输出run 和ran
  
  注意如果要找单独的单词，请在要匹配的单词首尾各空一个空格
2. re.match(正则表达式，要匹配的字符串) result=re.match() 从左到右匹配字符串，只返回匹配到的
  
  如果match匹配到数据用result.group() 返回数据
3. 替换匹配内容：re.sub()
  
  re.sub( 待替换的字符串,要替换上的字符串，原来整个字符串)
  
  过滤掉网页中那些不需要的符号：re.sub( r‘<.+?>’, ,s)或者(r’</? \w+ >‘ )
  
  实例操作：re.sub(r “ http://.+?/)”,lambda x: x.group(1),s) 用匿名函数输出来替换
4. re.search(r’‘ 搜索内容’, ‘匹配内容 ’) :与match不同终端无法继续
5. 分裂内容：re.split()
  
  res=re.split(r ‘ ,;.\ \（分裂标志）’ , ‘a,b;c.d\e’) 就是把，；. \之间的值全部分裂开输出a,b,c,d,e
  
  返回的是列表
6. 包装正则表达式：re.compile()
  
  compile_re=re.complie(r’ r[ua]n ’) 就相当于等效了一下
  
  res=compile_re.findall(‘ run ran ren’)
7. 贪婪模式：只有不设置限制，系统默认一直往后找
  
  用括号括起要关闭贪婪模式的表达式加上一个？

JSon

json模块是Python自带的模块，用于json与python数据之间的相互转换

json.load()方法：

把json字符串，转换为python数据

json_str=‘’‘ … str …’‘’

rs = json.loads(json_str)
读取文件：

with open(‘data.json’) as fp:

python_list = json.load(fp)

python 数据转换为json数据：

json.dumps(obj) 转换为json字符串

json_str = json.dumps(rs, ensure_ascii=Flase) #有中文就要指定ensure_ascii=Flase

python 数据转换为json数据写入文件：

with open('data.json', 'w') as fp:
    json.dump(rs, fp, ensure_ascii=Flase)

文件存储：

1.json文件存储

with open(file = 'result.txt',mode='a',encording='utf-8') as f:
	f.write(json.dumps(content,ensure_ascii=False)+'\n',indent=2)
    #indent表示缩进2个空格

2.csv文件存储

import csv
with open('data.csv','w') as csvfile:
	writer.writerow(['','',''])  //写入每行的数据

不过我还是建议用pandas中转保存！

3.连接MySql数据库：

import pymysql
db = pymqsql.connect(host='localhost',user='root',password='20020520zyh,port=3306')
cursor = db.cursor() //获得mysql的操作游标
// 用execute执行sql语句
cursor.execute('SELECT VERSION()')//获取版本
data = cursor.fetchone()
print('DATABASE version:',data)
cursor.execute("Create database spiders default character set utf-8")
db.close()

高性能异步爬虫：

目的：在爬虫中使用异步实现高性能的数据的爬取

#同步爬虫，单线程，get()很慢，是一个阻塞的方法
response=requests.get(url=url,headers=headers)
if response.status_code == 200:				#判断是否有响应
	return response.content

异步爬虫方式：

多线程，多进程：可以为相关阻塞的操作单独开启线程或者进程，不会等。但是不能无限制的开启多线程

线程池、进程池：可以降低系统对进程或者线程创建和销毁的一个频率，提升效率。但是池中线程数量有上限

from multiprocessing.dummy import Pool

name_list=['aa','bb','cc','dd']
def get_page(str):
{
    print(str)
}
#实例化线程对象
pool=Pool(4)	#四个对象
pool.map(get_page,name_list)	#map(阻塞的方法，对象列表)

单线程+异步协程：
1. event_loop:事件循环，相当于无限循环，把函数注册到事件循环上，当满足某些条件时，函数就会被循环执行
2. coroutine:协程对象，把协程的对象注册到事件循环中，它会被事件循环调用。我们可以使用async关键字来定义一个方法，这个方法在调用时不会立即执行，而是返回一个协程对象。
3. task:任务，它是对协程对象的封装，包含了任务的各个状态。
4. future:代表将来执行或者还没执行的任务，和task没有本质区别
5. async:定义一个协程
6. await:用来挂起阻塞的方法

import asyncio


async def request(url):
    # 用async修饰的函数，调用后返回是一个协程对象
    print('请求的对象是', url)


c = request('www.baidu.com')

# #创建事件循环对象
# loop = asyncio.get_event_loop()
# #将协程对象注册到loop中，然后启动loop
# loop.run_until_complete(c)

# task的使用
loop = asyncio.get_event_loop()
# 基于loop创建一个task对象
task= loop.create_task(c)
print(task)
loop.run_until_complete(task)
print(task)
#future的使用
loop = asyncio.get_event_loop()
task= asyncio.ensure_future(c)
loop.run_until_complete(task)

# 多任务异步协程实现
urls = {
    'www.baidu.com',
    'www.sougou.com',
    'www.goubanjia.com',
}
stasks = []  # 存放任务列表
for url in urls:
    c = request(url)
    task = asyncio.ensure_future(c)
    stasks.append(task)
    # 需要将任务列表封装到wait中
    loop.run_until_complete(asyncio.wait(stasks))
    # 但是在异步协程中出现同步模块的代码，那么无法实现异步

async def requests(url):
    print('正在下载',url)
    # 改一下time.sleep(2)
    await asyncio.sleep(2)

数据分析：

jupyter notebook：

基本操作快捷键：

添加cell：a或者b
删除cell：x
修改成markdown模式：m
修改成code模式：y
执行cell：shift+enter
自动补全：tab
打开帮助文档：shift+tab

Selenium

之前动态加载数据，需要用抓包工具，抓XHR中的参数，用param参数列表进行爬取，selenium更方便

selenium是基于自动化的一个模块

基本使用：

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.support import expected_condition as EC
from selenium.webdriver.support.wait import WebDriverWait

browser = webdriver.Chrome()
try:
    browser.get('https://www.baidu.com') #访问页面
    input = broswer.find_element_by_id('kw') #找到输入框
    input.send_keys('Python') #输入
    input.send_keys(Keys.ENTER) #按回车
    wait = WebdriverWait(broswer,10)  #等待10s
    wait.until(EC.presence_of_element_located((By.ID),'content_left'))
    
    print(broswer.current_url,
         broswer.get_cookies(),
         broswe.page_source())
expect Expection as e:
    print(e)
Fianlly:
    broswer.close()

自动化代码：

发起请求：get（）
broswer= webdriver.Edge()
标签定位：find_element_by_选择器(）
标签交互：send_keys()
执行js程序：excute_script（‘jsCode’）
前进、后退：back()、forward（）
关闭：quit()
点击：click()
清空：clear()
获取cookies:

#选项卡管理
bro.get(...)
bro.execute_script('window.open()')
bro.switch_to_window(bro.window_handles[1])
bro.get(...)
bro.switch_to_window(bro.window_handles[0])

window.open()是JS语句，开启一个选项卡
bro.window_handles :获取当前开启的所有选项卡
switch_to_window(选项卡代号)：切换选项卡

异常处理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-icAPXOl9-1673159360185)(C:%5CUsers%5C%E9%93%B6%E6%99%97%5CAppData%5CRoaming%5CTypora%5Ctypora-user-images%5C1632557905053.png)]

标签选择器：

单个标签：find_element_by_选择器（）

选择器：id name xpath link_text tag_name class_name css_selector

多个标签：find_elements_by_选择器()

结点交互：

输入：send_keys(‘内容’)

前进、后退：back()、forward（）

关闭：quit()

点击：click()

清空：clear()

获取结点信息：

通过page_source可以获取网页的源代码，接着可以用解析库解析了，但是selenium提供了选择节点的方法

例：

bro = webdriver.Chrome()
url = 'https://zhihu.com'
bro.get(url)
input = bro.find_element_by_class_name('zu-top-add-question')
print(input.text)

获取结点的信息主要通过属性：

input.id
input.location
input.tag_name
input.size

切换frame：

网页中有一种节点叫做iframe , 也就是子Frame,相当于页面的子页面，它的结构和外部页面一致，但是selenium打开页面之后默认在父级Frame里面操作，不能获取子Frame里面的节点，这时候需要swith_to.frame()来切换Frame

browser.get(url) 
browser.switch_to.frame('iframresult ’) 
browser.switch_to.parent_frame()

等待：

隐式等待：Selenium没有找到节点，就等着直到超出设定时间，则抛出异常

browser=webdriver.Edge()
browser=implicitly_wait(10) 等待10s

显式等待：指定最长等待时间，如果在规定时间内加载出来就返回，超时则抛出异常

wait = WebDriverWait(browser,10)
input = wait.until(EC.presence_of_element_located(By.ID,'q'))

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QZJn26uG-1673159360186)(C:%5CUsers%5C%E9%93%B6%E6%99%97%5CAppData%5CRoaming%5CTypora%5Ctypora-user-images%5C1632556633791.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cDgiFWOM-1673159360187)(C:%5CUsers%5C%E9%93%B6%E6%99%97%5CAppData%5CRoaming%5CTypora%5Ctypora-user-images%5C1632556869868.png)]

cookies:

.get_cookies()   

.add_cookies({‘name’:  ,‘domain’:  ,‘values’:  }) 

 delete_all_cookies()

选项卡管理：

bro.get(...)
bro.execute_script('window.open()')
bro.switch_to_window(bro.window_handles[1])
bro.get(...)
bro.switch_to_window(bro.window_handles[0])

window.open()是JS语句，开启一个选项卡
bro.window_handles :获取当前开启的所有选项卡（列表）
switch_to_window(选项卡代号)：切换选项卡

无头浏览器设置：

rom selenium import webdriver
from selenium.webdriver.edge.options import Options
from time import sleep

#创建无头浏览器对象
edge_options = Options()
path = "MicrosoftWebDriver.exe"
EDGE = {
    "browserName": "MicrosoftEdge",
    "version": "",
    "platform": "WINDOWS",
    "ms:edgeOptions": {
        'extensions': [],
        'args': [
            '--headless',
            '--disable-gpu'
        ]}
}
bro = webdriver.Edge(executable_path=path,capabilities=EDGE)

iframe:

#切换浏览器的标签作用域：
bro.switch_to.frame(‘iframeResult’)//切换到子页面
bro.switch_to.parent_frame()

div=bro.find_element_by_id('id')

#动作链
action= ActionChains(bro)
#点击长按指定标签
action.click_and_hold(div)

for i in range(5):
    action.move_by_offset(17).perform()	#perform执行动作链，移动操纵
    sleep(0.3)
action.release()	#释放动作链

隐式等待：
browser=webdriver.Edge()
browser=implicitly_wait(10) 等待10s

显式等待：指定最长等待时间，如果在规定时间内加载出来就返回，超时则抛出异常
wait = WebDriverWait(browser,10)
input = wait.until(EC.presence_of_element_located(By.ID,'q'))

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lJ8SCOOf-1673159360187)(C:%5CUsers%5C%E9%93%B6%E6%99%97%5CAppData%5CRoaming%5CTypora%5Ctypora-user-images%5C1632556633791.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Wbvz4nGt-1673159360188)(C:%5CUsers%5C%E9%93%B6%E6%99%97%5CAppData%5CRoaming%5CTypora%5Ctypora-user-images%5C1632556869868.png)]

scrapy：

创建工程：scrapy startproject 文件名

cd 文件名

在spiders子目录中创建一个爬虫文件：scrapy genspider first www.xxx.com

执行工程：scrapy crawl 文件名

进入setting：

进行UA伪装，USER_AGENT='...'
把ROBOTSTXT_OBEY = True 改成Flase 
添加LOG_LEVEL='ERROR'

import scrapy


class FirstSpider(scrapy.Spider):
    name = 'first'  # 爬虫文件的名称
    # allowed_domains = ['www.xxx.com']   允许的域名，start_urls中哪些url可以进行请求，不过一般不用这种机制
    start_urls = ['https://www.baidu.com/', 'https://www.sogou.com/']  # 起始的url列表,可以有多个url

    # 用于数据解析，response参数表示就是start_urls列表的url请求成功后对应响应的对象
    def parse(self, response):
        pass

持久化存储：

#基于终端指令：只可以将parse方法的返回值存储到本地的文本文件中
scrapy crawl 爬虫名 -o ./文件名.csv
#基于管道：在items.py中添加文本对象
文本对象名= scrapy.Field()
#再在pipelines.py中process_item接收持久化储存对象
class QiubaiproPipeline:
    fp= None
    def open_spider(self,spider):
        self.fp= open('./qiubai.txt','w',encoding='utf-8')
		
    def process_item(self, item, spider):
        author= item['author']				#定义属性
        page_text= item['page_text']		#定义属性	
        self.fp.write(author+':'+page_text+'\n')

        return item	#传递下一个管道类，养成习惯
    
    def close_spider(self,spider):
        self.fp.close()
#一个管道类存储一份数据

        
        
        
        
        
        
#再去setting第65-68行开启管道

#爬虫主程序

from qiubaiPro.items import QiubaiproItem
#把工程中items.py文件中 类名导入
item= QiubaiproItem()			
item['author'] = author			#item回倒主程序
item['page_text'] = page_text	#item回倒主程序
yield item



#直接写到mysql数据库:

#重写一个管道类

import pymysql

class mysqlPileLine(object):
    conn= None
    cursor= None
    def open_spider(self,spider):
        #链接对象
        self.conn= pymysql.Connect(host='127.0.0.1',port=3306,user='root',password='20020520zyh',db=qubai,charset='utf8')

    def process_item(self,item,spider):
        #创建游标对象
        self.cursor = self.conn.cursor()

        try:
            self.cursor.execute('insert into qubai values ("%s","%s")'%(item["author"],item["page_text"]))
            self.conn.commit()  #提交
        except Exception as e:
            print('e')
            self.conn.rollback()
		return item
    def close_spider(self,spider):
        self.cursor.close()
        self.conn.close()

#去setting里添加管道
TEM_PIPELINES = {
   'qiubaiPro.pipelines.QiubaiproPipeline': 300,
   'qiubaiPro.pipelines.mysqlPileLine': 301,
}

循环爬取网站多页数据：

class HanSpider(scrapy.Spider):
    name = 'han'
    # allowed_domains = ['www.xxx.com']
    start_urls = ['http://www.xxx.com/']
    # 通用url模板
    url = '...%d...'
    page_num = 2

    def parse(self, response):
        li_list = response.xpath(' ')
        for li in li_list:
            page_text = li.xpath('... | ... ').extract_first()  # 出现数据为空，直接去找空的情况对应的xpath路径，用或连接
            print(page_text)
            if self.page_num <=11:
                new_url = format(self.url % self.page_num)
                self.page_num+=1
                yield scrapy.Request(url=new_url, callback=self.parse())    #手动发送请求，callback回调函数专门用于数据解析

深度爬取：

#第二层网页的爬取
    def parse_detail(self, response):
        # 接收参数
        item = response.meta['item']

        job_detail = response.xpath('//*[@id="main"]/div[3]/div/div[2]/div[2]/div[1]/div//text()').extract_first()
        job_detail = ''.join(job_detail)
        print(job_detail)
        item['job_detail'] = job_detail
        yield item  # 提交管道

def parse(self, response):
        li_list = response.xpath(' ')
        for li in li_list:
            page_text = li.xpath('... | ... ').extract_first() 
            # 出现数据为空，直接去找空的情况对应的xpath路径，用或连接
            item['job'] = job
            item['job_area'] = job_area
            
            # 请求传参
            yield scrapy.Request(detail_url, callback=self.parse_detail, meta={'item': item}, dont_filter=True)

图片爬取：

字符串数据：只需要基于xpath进行解析，且提交管道进行持久化存储
图片：xpath解析出图片的src的属性值，单独的对图片地址发起请求获取图片二进制类型的数据

ImagesPipeline:只需要将img的src的属性值解析进行解析，提交到管道，管道就会对src进行请求发送获取图片的二进制数据
    
    
1.xpath解析图片地址
2.将存储图片地址的item存储到制定管道类
 src = li.xpath('./div/a/img/@src2').extract_first()
            src = 'https:'+src
            # print(src)
            item = ImgsproItem()
            item['src'] = src
            yield item
3.重写管道类

from scrapy.pipelines.images import ImagesPipeline
import scrapy
class imagesPileLine(ImagesPipeline):

    #对图片进行请求操作
    def get_media_requests(self, item, info):


        yield scrapy.Request(item['src'])

    #指定图片的存储路径
    def file_path(self, request, response=None, info=None):
        imgName = request.url.split('/')[-1]
        return imgName

    def item_completed(self, results, item, info):
        return item  #返回给下一个即将被执行的管道类，养成习惯
    
4.进入setting更改配置：

开启管道类，并修改类名，改为自定义的管道类名

末尾增加一行存储路径
IMAGES_STORE = './imgs_han'

中间件：

middlewares.py文件中
# import random

	网上找一些ip复制进来
    # user_agent_list=[
    #     '...'
    # ]
    # PROXY_http = [
    #     '...'
    # ]
    #
    # PROXY_https = [
    #     '...'
    # ]
    def process_request(self, request, spider):
        # request.headers['User-Agent'] = random.choice(self.user_agent_list)
        return None

    def process_response(self, request, response, spider):

        return response

    def process_exception(self, request, exception, spider):

        # if request.url.split(':')[0] == 'http':
        #     request.meta['proxy'] = 'http://'+random.choice(self.PROXY_http)
        #
        # else:
        # #代理
        # request.meta['proxy'] = 'https://'+random.choice(self.PROXY_http)
        #
        # return request
       

    
    setting文件中：第55行开启中间件
#DOWNLOADER_MIDDLEWARES = {
#    'imgsPro.middlewares.ImgsproDownloaderMiddleware': 543,
#}

CrawlSpider：

全站数据爬取的方式：基于spider：手动请求；基于CrawlSpider

使用：创建爬虫文件，scrapy genspider -t crawl 文件名 www.xxx.com

 #链接提取器
    link = LinkExtractor(allow=r'type=4&page=\d+')#匹配到了当前页面的链接
#去起始url中，根据指定规则，提取链接  allow="正则表达式"
    rules = (
        #规则解析器对象
        Rule(LinkExtractor(allow=r'Items/'), callback='parse_item', follow=True),
    )

全站数据爬取过程：

可以使用链接提取器提取所有的页码链接
让链接提取器提取所有的新闻详情页链接

道类，养成习惯

4.进入setting更改配置：

开启管道类，并修改类名，改为自定义的管道类名

末尾增加一行存储路径
IMAGES_STORE = ‘./imgs_han’




#### 中间件：

```python
middlewares.py文件中
# import random

	网上找一些ip复制进来
    # user_agent_list=[
    #     '...'
    # ]
    # PROXY_http = [
    #     '...'
    # ]
    #
    # PROXY_https = [
    #     '...'
    # ]
    def process_request(self, request, spider):
        # request.headers['User-Agent'] = random.choice(self.user_agent_list)
        return None

    def process_response(self, request, response, spider):

        return response

    def process_exception(self, request, exception, spider):

        # if request.url.split(':')[0] == 'http':
        #     request.meta['proxy'] = 'http://'+random.choice(self.PROXY_http)
        #
        # else:
        # #代理
        # request.meta['proxy'] = 'https://'+random.choice(self.PROXY_http)
        #
        # return request
       

    
    setting文件中：第55行开启中间件
#DOWNLOADER_MIDDLEWARES = {
#    'imgsPro.middlewares.ImgsproDownloaderMiddleware': 543,
#}

CrawlSpider：

全站数据爬取的方式：基于spider：手动请求；基于CrawlSpider

使用：创建爬虫文件，scrapy genspider -t crawl 文件名 www.xxx.com

 #链接提取器
    link = LinkExtractor(allow=r'type=4&page=\d+')#匹配到了当前页面的链接
#去起始url中，根据指定规则，提取链接  allow="正则表达式"
    rules = (
        #规则解析器对象
        Rule(LinkExtractor(allow=r'Items/'), callback='parse_item', follow=True),
    )

全站数据爬取过程：

可以使用链接提取器提取所有的页码链接
让链接提取器提取所有的新闻详情页链接

异步爬虫：

目的：在爬虫中使用异步实现高性能的数据的爬取

#同步爬虫，单线程，get()很慢，是一个阻塞的方法
response=requests.get(url=url,headers=headers)
if response.status_code == 200:				#判断是否有响应
	return response.content

异步爬虫方式：

多线程，多进程：可以为相关阻塞的操作单独开启线程或者进程，不会等。但是不能无限制的开启多线程

线程池、进程池：可以降低系统对进程或者线程创建和销毁的一个频率，提升效率。但是池中线程数量有上限

from multiprocessing.dummy import Pool

name_list=['aa','bb','cc','dd']
def get_page(str):
{
    print(str)
}
#实例化线程对象
pool=Pool(4)	#四个对象
pool.map(get_page,name_list)	#map(阻塞的方法，对象列表)

单线程+异步协程：
1. event_loop:事件循环，相当于无限循环，把函数注册到事件循环上，当满足某些条件时，函数就会被循环执行
2. coroutine:协程对象，把协程的对象注册到事件循环中，它会被事件循环调用。我们可以使用async关键字来定义一个方法，这个方法在调用时不会立即执行，而是返回一个协程对象。
3. task:任务，它是对协程对象的封装，包含了任务的各个状态。
4. future:代表将来执行或者还没执行的任务，和task没有本质区别
5. async:定义一个协程
6. await:用来挂起阻塞的方法

import asyncio


async def request(url):
    # 用async修饰的函数，调用后返回是一个协程对象
    print('请求的对象是', url)


c = request('www.baidu.com')

# #创建事件循环对象
# loop = asyncio.get_event_loop()
# #将协程对象注册到loop中，然后启动loop
# loop.run_until_complete(c)

# task的使用
loop = asyncio.get_event_loop()
# 基于loop创建一个task对象
task= loop.create_task(c)
print(task)
loop.run_until_complete(task)
print(task)
#future的使用
loop = asyncio.get_event_loop()
task= asyncio.ensure_future(c)
loop.run_until_complete(task)

# 多任务异步协程实现
urls = {
    'www.baidu.com',
    'www.sougou.com',
    'www.goubanjia.com',
}
stasks = []  # 存放任务列表
for url in urls:
    c = request(url)
    task = asyncio.ensure_future(c)
    stasks.append(task)
    # 需要将任务列表封装到wait中
    loop.run_until_complete(asyncio.wait(stasks))
    # 但是在异步协程中出现同步模块的代码，那么无法实现异步

async def requests(url):
    print('正在下载',url)
    # 改一下time.sleep(2)
    await asyncio.sleep(2)

模拟登录

验证码的识别：

对网页发起request请求，拿到验证码的图片链接
拿到链接之后，再对这个图片的链接发起request请求，拿到content二进制数据
然后打开一个文件，将二进制数据write到这个文件里面
第三方平台进行解码（传入图片文件路径，验证码类型）
登录之后，找到login的数据包，拿到param参数列表，更改icode ，改为验证码识别的内容
再次发送post请求，拿到page_text
利用状态码，看是否是200，是200就成功了

登录成功之后，重新发起详情页的请求后，页面会重新回到登录页面，因为cookies的原因

自动处理cookies：

1.cookies值的来源来自哪里？来源上一次对网页发起请求后生成的

2.使用session对象：

1.可以进行请求的发送

2.如果请求过程中产生了cookie，则该cookie会被自动储存，即携带在session对象中

创建session对象

#自动携带cookie，不用手动写cookies了
session = requests.Session()
response = session.get(url,headers,data)

失败常见原因

1.url错误

2.登陆后的参数列表错误，参数列表除了icode其余都要写成键值对的形式，因为icode每次都会变化

如何保存图片和HTML文件：

#图片数据
with open('./code.jpg','wb') as fp:
	fp.write(img_data)
#HTML文件    
with open('./return.html','w',encoding = 'utf-8') as fp:
	fp.write(login_page_text)

代理使用：

#构建代理池
proxie = { 
        'http' : 'http://xx.xxx.xxx.xxx:xxxx',
        'http' : 'http://xxx.xx.xx.xxx:xxx',
        ....
    }  

response = request.get(url,headers,proxies={'http/https':'代理号'})

异步

协程

协程不是计算机提供，程序员是认为创造。

也叫微线程，是一种用户态内的上下文切换技术，简而言之，其实就是通过，一个线程实现代码块相互切换。

协程的意义

在一个协程中如果遇到IO等待时间，线程不会等待，利用空闲的时候再去干的别的事。

实现协程的方法：

greenlet :早期模块
yield ：生成器
asyncio装饰器
async，await关键字

greenlet

def func1():
	print(1)     #第1步：输出1
	gr2.switch() #第2步：切换到func2
	print(2)   #第5步 输出2
	gr2.switch() #第6步 切换func2
	
def func2():
	print(3)  #第3步 输出3
	gr1.switch() #第4步 切换func1
	print(4) #第7步 输出4
    
gr1 = greenlet(func1)
gr2 = greenlet(func2)

gr1.switch(func1)

yield

def func1():
    yield 1
    yield from func2() #跳到func2
    yield 2
    
def func2():
    yield 3
    yield from func1()
    yield 4
    
f1 = func1()
from item in f1:
    print(item)

asyncio

遇到IO阻塞就自动切换代码块执行，遇到耗时的操作要等待的时候，就立即切换下一个代码块，加快速度

协程函数：asyncio def 函数名

协程对象: 执行协程函数产生的协程对象
asyncio def func():
    print(...)
    
result = func()
asyncio.run(result)

asyncio	描述
get_event_loop()	开启事件循环
run_until_complete(task列表)	执行任务
await()	等待事件结束，返回结果
run()	运行
ensure_future()	创建future对象

理解性代码：

import asyncio

async def func1(): #必须带上关键字async
    print(3)
    await asyncio.sleep()  #模拟耗时操作，自动切换
    print(2)
    
    
async def func2(): 
    print(3)
    await asyncio.sleep()
    print(4)
    
 tasks = [
     asyncio.ensure_future(func1())
     asyncio.ensure_future(func2())
 ]

loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))

事件循环：

理解为一个死循环

1.去检测任务列表，

2.如果任务可执行，就去执行，

3.如果不可执行，就忽略跳过，

4.如果有任务执行完成，就从任务列表中移除

代码操作：

import asyncio

#生成一个事件循环
loop = asyncio.get_event_loop()

#将任务循环放到任务列表
loop.run_until_complete(任务)

await

await + 可等待对象（协程对象、Future对象、Task对象）

#单个协程对象
async def func():
	print('..')
	result = await asyncio.sleep(2)  #等待这个io结束,并返回结果
	print(result)
	
asyncio.run(func())

#多个协程对象
async def others():
    print('start')
    await asyncio.sleep(2)
    print('end')
	return 2
    
    
async def func1():
	print('..')
	result1 = await others() #接收返回的2
	print(result1)
    
async def func2():
	print('..')
    result1 = await others() #遇到IO阻塞，会切换到其他的协程但是不会执行result2
	print(result1)
	result2 = await others() #接收返回的2
	print(result2)	

asyncio.run(func())

Task对象

在事件循环中添加多个任务

Task用于并发调度协程，通过asyncio.create_task(协程对象)的方式创建Task对象，这样可以让协程加入事件循环中等待被调度执行。除此之外，太可以用低级一点的loop.create_task ()或者 ensure_future() 函数，本质上是一样的。

示例代码1：

async def others():
    print('start')
    await asyncio.sleep(2)
    print('end')
	return 2

async def main():
    print('main开始')
    
    task1 = asyncio.create_task(func())
    
    #这里特别解释一下，task1中在执行others函数中 await的sleep的操作时遇到阻塞会自动切换到task2去执行，所以输出第一个start然后接着输出第二个start
    
    task2 = asyncio.create_task(func())
    
    ret1 = await task1
    ret2 = await task2
    
    
asyncio.run(main())

实例代码2：

async def others():
    print('start')
    await asyncio.sleep(2)
    print('end')
	return 2

async def main():
    print('main开始')
    
    task_list =[
        asyncio.create_task(func(),name = '设置task的名字'),
        asyncio.create_task(func())
    ]
    print('main结束')
    
    done,pending = await asyncio.wait(task_list，timeout=2)  
    
    #等待任务列表中的任务全部结束
    #done是已完成的任务的返回值的列表
    #pending是超过timeout时间问完成的任务列表
    
asyncio.run(main())

#另一种写法：
task_list =[
        func(),
        func()，
    ]
#这里会内部自动创建任务，所以列表中就不用创建任务
asyncio.run(asyncio.wait(task_list))

asyncio.Future对象

基于协程，Task继承Future，Task对象内部await结果处理基于Future对象

async def main():
    #创建当前时间循环
	loop = asyncio.get_running_loop()
    
    #创建future对象的任务
    fut = loop.create_future()
    
    #等待任务循环（Future对象），没有结果则会一直等下去
    await fut
    
    
asyncio.run(main())

实例代码：

async def func(fut):
    await asyncio.sleep(2)
    fut.func('666')

async def main():
    #创建当前时间循环
	loop = asyncio.get_running_loop()
	fut = loop.create_future()
	
    #创建任务，绑定func任务
	await loop.create_task( func(fut) )
    
    data = awiat fut
    print(data)

concurrent.futures.Future对象：

使用线程池、进程池实现异步操作时用到的对象

from concurrent.futures import Future
from concurrent.futures.thread import ThreadPoolExcutor
from concurrent.futures.process import ProcessExecutor

def func(values):
    time.sleep(1)
    print(values)
    
#创建线程池
pool = ThreadPoolExecutor(max_workers = 5)
#创建线程池
pool = ProcessPoolExecutor(max_workers = 5)

for i in range(10):
    fut = pool.submit(func , i )
    #创建10个线程，但线程池容量为5
    print(fut)

import time
import asyncio
import concurrent.futures

def func1():
    time.sleep(2)
    return "bb"

async def main():
    loop = asyncio.get_running_loop()
    
    #首先，内部调用THreadPoolExecute方法去线程池中执行func函数，并返回一个concurrent.futures.Future对象
    #然后，调用asyncio.wrap_future对象将concurrent.futures.Future对象包装成asyncio.Future对象，因为concurrent.futures.Future对象不支持await方法，所以需要包装
    fut = loop.run_in_executor(None, func1)
    result = await fut
    print('default thread pool' ,result)
    
    #使用线程池
    with concurrent.futures.ThreadPoolExecutor() as pool:
        result = await loop.run_in_execute(pool,func1)
    #使用进程池   
    with concurrent.futures.ProcessPoolExecute() as pool:
        result = await loop.run_in_execute(pool,func1)
        
 asyncio.run(main())

实战案例：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Hx7C5Yol-1673159330044)(C:%5CUsers%5C%E9%93%B6%E6%99%97%5CAppData%5CRoaming%5CTypora%5Ctypora-user-images%5C1636385289648.png)]

爬虫内部有三个线程，下载一个图片的同时会执行其他的线程，即下载另一张图片

异步上下文管理器

自动打开和关闭协程函数

定义_ aenyer ()和 _ aexit _ _()方法对async with 语句中的环境进行控制

class AsyncManager:
    def __init__(self):
        self.conn = conn
        
    #第2步：执行函数
    async def do_something(self):
        return 666
    
    #第1步：先执行这里
    async def __aenter__(self):
        #异步连接数据库
        self.conn = await asyncio.sleep(1)
        return self
    
    async def __aexit__(self,exc_type,exc,tb):
        await asyncio.sleep(1)

 	async def func():        
        asynci with AsyncManager() as f:
            result = await f.do_something()
            print(result)
 asyncio.run(func())

异步连接Mysql

pip install aiomysql

import asyncio
import aiomysql

async def execute():
    #连接数据库,先连接'47.93.41.197',遇到阻塞就连接'23.23.67.346'
    conn = await 		    aiomysql.connect(host=host,port=3306,user='root',password=' '，db="mysql")
    
    #网络IO操作，遇到阻塞会自动切换任务
    cur = await conn.cursor()
    
    #网络IO操作，遇到阻塞会自动切换任务
    await cur.execute("SELECT HOST ,USER FROM user")
    await cur.execute('select* from exp ...')
    #网络IO操作，遇到阻塞会自动切换任务
    result = await cur.fetchall()
    print(result)
    
    #网络IO操作，遇到阻塞会自动切换任务
    await cur.close()
    conn.close()
    print("结束")
task_list = [
    execute('47.93.41.197',"root12345"),
    execute('23.23.67.346',"root12345")
]

异步爬虫

pip install aiohttp

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ytlugbKF-1673159330045)(C:%5CUsers%5C%E9%93%B6%E6%99%97%5CAppData%5CRoaming%5CTypora%5Ctypora-user-images%5C1636416125977.png)]

#网络IO操作，遇到阻塞会自动切换任务
cur = await conn.cursor()

#网络IO操作，遇到阻塞会自动切换任务
await cur.execute("SELECT HOST ,USER FROM user")
await cur.execute('select* from exp ...')
#网络IO操作，遇到阻塞会自动切换任务
result = await cur.fetchall()
print(result)

#网络IO操作，遇到阻塞会自动切换任务
await cur.close()
conn.close()
print("结束")

task_list = [
execute(‘47.93.41.197’,“root12345”),
execute(‘23.23.67.346’,“root12345”)
]


#### 异步爬虫

```python
pip install aiohttp

[外链图片转存中…(img-ytlugbKF-1673159330045)]

爬虫学习+实战

爬虫

概念：

URI和URL:

超文本：

HTTP和HTTPS协议：

响应：

网页的结构：

为什么有时候解析不到数据？

什么是会话（Session）和Cookies

Session

Cookies

代理：

urllib：

requests

常用UA：

UA：

代理：

数据解析：

Beautiful Soup

find（）方法：

Xpath：

PyQuery

获取属性值：

获取文本：

动态更改节点属性

Unicode乱码尝试方法：

Excel：

读取excel，保存为了excel：

文件处理：

正则表达式

常用匹配操作：

修饰符

模式

爬虫中匹配

JSon

文件存储：

高性能异步爬虫：

数据分析：

jupyter notebook：

Selenium

标签选择器：

结点交互：

获取结点信息：

切换frame：

等待：

cookies:

选项卡管理：

无头浏览器设置：

iframe:

scrapy：

持久化存储：

循环爬取网站多页数据：

深度爬取：

图片爬取：

中间件：

CrawlSpider：

CrawlSpider：

异步爬虫：

模拟登录

验证码的识别：

自动处理cookies：

创建session对象

失败常见原因

如何保存图片和HTML文件：

代理使用：

异步

协程

协程的意义

greenlet

yield

asyncio

理解性代码：

事件循环：

await

Task对象

asyncio.Future对象

concurrent.futures.Future对象：

异步上下文管理器

异步连接Mysql