爬虫
第一章：网络请求
一、urllib库
urllib库是Python中一个最基本的网络请求库。可以模拟浏览器的行为，向指定的服务器发送一个请求，并可以保存服务器返回的数据。
urlopen函数
在Python3的urllib库中，所有和网络请求相关的方法，都被集到urllib.request模块下面了，以先来看下urlopen函数基本的使用：
from urllib import request
resp = request.urlopen('http://www.baidu.com') #文件句柄
print(resp.read())
实际上，使用浏览器访问百度，右键查看源代码。你会发现，跟我们刚才打印出来的数据是一模一样的。也就是说，上面的三行代码就已经帮我们把百度的首页的全部代码爬下来了。一个基本的url请求对应的python代码真的非常简单。 以下对urlopen函数的进行详细讲解：
urlopen (参数)
url：请求的url。data：请求的data，如果设置了这个值，那么将变成post请求。- 返回值：返回值是一个
http.client.HTTPResponse对象，这个对象是一个类文件句柄对象。有read(size)、readline、readlines(列表显示)以及getcode等方法。
request.urlretrieve函数
下载url内容到本地request.urlretrieve(url, 路径)
urlencode函数 (parse 模块)
用浏览器发送请求的时候，如果url中包含了中文或者其他特殊字符，那么浏览器会自动的给我们进行编码。而如果使用代码发送请求，那么就必须手动的进行编码，这时候就应该使用urlencode函数来实现。urlencode可以把字典数据转换为URL编码的数据。示例代码如下：
from urllib import parse
data = {'name':'爬虫基础','greet':'hello world','age':100}
qs = parse.urlencode(data)
print(qs)
输出：
name=%E7%88%AC%E8%99%AB%E5%9F%BA%E7%A1%80&greet=hello+world&age=100
parse_qs函数
可以将经过编码后的url参数进行解码。示例代码如下：
from urllib import parse
qs = "name=%E7%88%AC%E8%99%AB%E5%9F%BA%E7%A1%80&greet=hello+world&age=100"
print(parse.parse_qs(qs))
输出：
{'name': ['爬虫基础'], 'greet': ['hello world'], 'age': ['100']}
urlparse和urlsplit
有时候拿到一个url，想要对这个url中的各个组成部分进行分割，那么这时候就可以使用urlparse或者是urlsplit来进行分割。示例代码如下：
from urllib import request,parse
url = 'http://www.baidu.com/s?username=zhiliao'
result = parse.urlsplit(url)
# result = parse.urlparse(url)
print('scheme:',result.scheme)
# http
print('netloc:',result.netloc)
# www.baidu.com
print('path:',result.path)
# /s
print('query:',result.query)
# username=zhiliao
urlparse和urlsplit基本上是一模一样的。唯一不一样的地方是，urlparse里面多了一个params属性，而urlsplit没有这个params属性。比如有一个url为：url = 'http://www.baidu.com/s;hello?wd=python&username=abc#1'， 那么urlparse可以获取到params=hello，而urlsplit不可以获取到。url中的params也用得比较少。
所以，可以得出一个标准的链接格式，具体如下:
scheme://netloc/path;params?query#fragment
request.Request类
如果想要在请求的时候增加一些请求头，那么就必须使用request.Request类来实现。比如要增加一个User-Agent，示例代码如下：
from urllib import request
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.94 Safari/537.36',
'Referer': 'https://www.lagou.com/'
}
req = request.Request("http://www.baidu.com/",headers=headers)
resp = request.urlopen(req)
print(resp.read())
mac报错：
urllib.error.URLError: <urlopen error [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed (_s
pip install certifi
/Applications/Python\ 3.6/Install\ Certificates.command
ProxyHandler处理器(代理)
-
代理的原理：在请求目的网站之前，先请求代理服务器，然后让代理服务器去请求目的网站，代理服务器拿到目的网站的数据后，再转发给我们的代码。
-
在代码中使用代理：
- 使用
urllib.request.ProxyHandler，传入一个代理 ，这个代理 是一个字典，字典的key依赖于代理服务器能够接收的类型，一般是是http或者https，值是ip:port. - 使用上一步创建的
handler以及request.build_opener创建一个opener对象。 - 使用上一步创建的
opener，调用open函数，发起请求。
示例代码如下：
from urllib import request url = 'http://httpbin.org' # 1、使用proxyHandler传入代理构建一个handler handler = request.ProxyHandler({'http':'223.241.78.43:8010'}) # 2、使用上面创建的handler构建一个opener opener = request.build_opener(handler) # 3、使用opener去发送一个请求 resp = opener.open(url) print(resp.read()) - 使用
常用的代理有：
- 西刺免费代理IP：http://www.xicidaili.com/
- 快代理：http://www.kuaidaili.com/
- 代理云：http://www.dailiyun.com/
什么是cookie
在网站中，http请求是无状态的。也就是说即使第一次和服务器连接后并且登录成功后，第二次请求服务器依然不能知道当前请求是哪个用户。cookie的出现就是为了解决这个问题，第一次登录后服务器返回一些数据（cookie）给浏览器，然后浏览器保存在本地，当该用户发送第二次请求的时候，就会自动的把上次请求存储的cookie数据自动的携带给服务器，服务器通过浏览器携带的数据就能判断当前用户是哪个了。cookie存储的数据量有限，不同的浏览器有不同的存储大小，但一般不超过4KB。因此使用cookie只能存储一些小量的数据。
cookie的格式：
Set-Cookie: NAME=VALUE；Expires/Max-age=DATE；Path=PATH；Domain=DOMAIN_NAME；SECURE
参数意义：
- NAME：cookie的名字。
- VALUE：cookie的值。
- Expires：cookie的过期时间。
- Path：cookie作用的路径。
- Domain：cookie作用的域名。
- SECURE：是否只在https协议下起作用。
使用cookielib库和HTTPCookieProcessor模拟登录
Cookie 是指网站服务器为了辨别用户身份和进行Session跟踪，而储存在用户浏览器上的文本文件，Cookie可以保持登录信息到用户下次与服务器的会话。 这里以人人网为例。人人网中，要访问某个人的主页，必须先登录才能访问，登录说白了就是要有cookie信息。那么如果我们想要用代码的方式访问，就必须要有正确的cookie信息才能访问。解决方案有两种，第一种是使用浏览器访问，然后将cookie信息复制下来，放到headers中。示例代码如下：
from urllib import request,parse
# import ssl 用于解决urllib.error.URLError: <urlopen error [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed (_s 报错的问题
# import ssl
# ssl._create_default_https_context = ssl._create_unverified_context
url = 'https://www.zhipin.com/job_detail/?query=python&city=101010100&industry=&position='
headers = {
'User-Agent':'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.121 Safari/537.36',
'Referer':'https://www.zhipin.com/',
'Cookie':'_uab_collina=154235904858163773539703; lastCity=101010100; JSESSIONID=""; __c=1552973675; sid=sem_pz_bdpc_dasou_title; __g=sem_pz_bdpc_dasou_title; __l=l=%2Fwww.zhipin.com%2Fgeek%2Fattresume%2Fparser.html&r=https%3A%2F%2Fwww.zhipin.com%2F&g=%2Fwww.zhipin.com%2F%3Fsid%3Dsem_pz_bdpc_dasou_title; t=Yh3Nxvw52htct2Mh; wt=Yh3Nxvw52htct2Mh; Hm_lvt_194df3105ad7148dcf2b98a91b5e727a=1552997174,1552997195,1553135236,1553157868; __a=67768901.1538943368.1552191625.1552973675.551.8.392.377; Hm_lpvt_194df3105ad7148dcf2b98a91b5e727a=1553223056'
}
req = request.Request(url, headers=headers)
resq = request.urlopen(req)
print(resq.read().decode('utf8'))
但是每次在访问需要cookie的页面都要从浏览器中复制cookie比较麻烦。在Python处理Cookie，一般是通过http.cookiejar模块和urllib模块的HTTPCookieProcessor处理器类一起使用。http.cookiejar模块主要作用是提供用于存储cookie的对象。而HTTPCookieProcessor处理器主要作用是处理这些cookie对象，并构建handler对象。
http.cookiejar模块：
该模块主要的类有CookieJar、FileCookieJar、MozillaCookieJar、LWPCookieJar。这四个类的作用分别如下：
- CookieJar：管理HTTP cookie值、存储HTTP请求生成的cookie、向传出的HTTP请求添加cookie的对象。整个cookie都存储在内存中，对CookieJar实例进行垃圾回收后cookie也将丢失。
- FileCookieJar (filename,delayload=None,policy=None)：从CookieJar派生而来，用来创建FileCookieJar实例，检索cookie信息并将cookie存储到文件中。filename是存储cookie的文件名。delayload为True时支持延迟访问访问文件，即只有在需要时才读取文件或在文件中存储数据。
- MozillaCookieJar (filename,delayload=None,policy=None)：从FileCookieJar派生而来，创建与Mozilla浏览器 cookies.txt兼容的FileCookieJar实例。
- LWPCookieJar (filename,delayload=None,policy=None)：从FileCookieJar派生而来，创建与libwww-perl标准的 Set-Cookie3 文件格式兼容的FileCookieJar实例。
登录人人网：
利用http.cookiejar和request.HTTPCookieProcessor登录人人网。相关示例代码如下：
第一版：
from urllib import request
from urllib import parse
from http.cookiejar import CookieJar
# 1、登陆
# 1.1 创建一个Cookiejar的对象
cookiejar = CookieJar()
# 1.2 使用request.HTTPCookieProcessor创建一个cookiejar属性的对象
handler = request.HTTPCookieProcessor(cookiejar)
# 1.3 使用上一步创建的handler创建一个opener
opener = request.build_opener(handler)
# 1.4 使用opener发送登陆的请求（网站的用户名和邮箱）
headers = {
'User-Agent':'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.121 Safari/537.36'
}
data = {
'username':'18993381498',
'password':'gdpw,69213'
}
login_url = 'https://passport.lagou.com/login/login.html?signature=BDD02F0A026E28A46D5739F3BE5C4CB2&service=https%253A%252F%252Faccount.lagou.com%252Fv2%252Faccount%252FmodifyPwd.html&action=login&serviceId=account&ts=1553236371589'
req = request.Request(login_url,data=parse.urlencode(data).encode('utf8'),headers=headers)
opener.open(req)
# 访问个人主页
# 获取个人主页的时候，不要新建一个opener
# 而应该使用之前的那个opener,因为之前的那个opener已经包含了登录所需要的cookie信息
dapeng_url = "https://account.lagou.com/v2/account/userinfo.html"
req = request.Request(dapeng_url, headers=headers)
resp = opener.open(req)
print(resp.read().decode('utf8'))
with open('text.html', 'w', encoding='utf8') as fp:
fp.write(resp.read().decode('utf8'))
第二版
from urllib import request,parse
from http.cookiejar import CookieJar
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.94 Safari/537.36'
}
def get_opener():
cookiejar = CookieJar()
handler = request.HTTPCookieProcessor(cookiejar)
opener = request.build_opener(handler)
return opener
def login_renren(opener):
data = {"email": "970138074@qq.com", "password": "pythonspider"}
data = parse.urlencode(data).encode('utf-8')
login_url = "http://www.renren.com/PLogin.do"
req = request.Request(login_url, headers=headers, data=data)
opener.open(req)
def visit_profile(opener):
url = 'http://www.renren.com/880151247/profile'
req = request.Request(url,headers=headers)
resp = opener.open(req)
with open('renren.html','w') as fp:
fp.write(resp.read().decode("utf-8"))
if __name__ == '__main__':
opener = get_opener()
login_renren(opener)
visit_profile(opener)
保存cookie到本地：
保存cookie到本地，可以使用cookiejar的save方法，并且需要指定一个文件名：
from urllib import request
from http.cookiejar import MozillaCookieJar
cookiejar = MozillaCookieJar("cookie.txt")
handler = request.HTTPCookieProcessor(cookiejar)
opener = request.build_opener(handler)
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.94 Safari/537.36'
}
req = request.Request('http://httpbin.org/cookies',headers=headers)
resp = opener.open(req)
print(resp.read())
cookiejar.save(ignore_discard=True,ignore_expires=True)
# ignore_discard=True 保存过期的cookie信息
从本地加载cookie
从本地加载cookie，需要使用cookiejar的load方法，并且也需要指定方法：
from urllib import request
from http.cookiejar import MozillaCookieJar
cookiejar = MozillaCookieJar("cookie.txt")
cookiejar.load(ignore_expires=True,ignore_discard=True)
handler = request.HTTPCookieProcessor(cookiejar)
opener = request.build_opener(handler)
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.94 Safari/537.36'
}
req = request.Request('http://httpbin.org/cookies',headers=headers)
resp = opener.open(req)
print(resp.read())
二、requests 库
发送get请求
发送get请求，直接调用requests.get就可以了，想要 发送什么类型的请求，就调用什么方法。返回的是requests.models.Response对象。
response = requests.get("http://www.baidu.com/")
response 的一样属性
import requests
kw = {'wd':'中国'}
headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.99 Safari/537.36"}
# params 接收一个字典或者字符串的查询参数，字典类型自动转换为url编码，不需要urlencode()
response = requests.get("http://www.baidu.com/s", params = kw, headers = headers)
# 查看响应内容，response.text 返回的是Unicode格式的数据
print(response.text)
# 查看响应内容，response.content返回的字节流数据
print(response.content)
# 查看完整url地址
print(response.url)
# 查看响应头部字符编码
print(response.encoding)
# 查看响应码
print(response.status_code)
response.text 和 response.content的区别
- response.content： 这个是直接从网络上面抓取的数据，没有经过任何解码，所以是一个bytes类型，其实在硬盘上和网络上传输的字符串都是bytes类型
- response.text:这个是requests,将response.content进行解码的字符串，解码需要指定一个编码方式，requests会根据自己的猜测来判断编码的方式，所有有时候可能会猜测错误，就会乱码，这时候应该使用
response.contect.decode('utf8')进行手动解码。
发送post请求
最基本的POST请求可以使用post方法：
response = requests.post("http://www.baidu.com/",data=data)
传入data数据： 这时候就不要再使用urlencode进行编码了，直接传入一个字典进去就可以了。比如请求拉勾网的数据的代码：
import requests
url = "https://www.lagou.com/jobs/positionAjax.json?city=%E6%B7%B1%E5%9C%B3&needAddtionalResult=false&isSchoolJob=0"
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.94 Safari/537.36',
'Referer': 'https://www.lagou.com/jobs/list_python?labelWords=&fromSearch=true&suginput='
}
data = {
'first': 'true',
'pn': 1,
'kd': 'python'
}
resp = requests.post(url,headers=headers,data=data)
# 如果是json数据，直接可以调用json方法将json字符串转化为字典或列表
print(resp.json())
使用代理
使用requests添加代理也非常简单，只要在请求的方法中（比如get或者post）传递proxies参数就可以了。示例代码如下：
import requests
url = "http://httpbin.org/get"
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.94 Safari/537.36',
}
proxy = {
'http': '171.14.209.180:27829'
}
resp = requests.get(url,headers=headers,proxies=proxy)
with open('xx.html','w',encoding='utf-8') as fp:
fp.write(resp.text)
cookie
如果在一个响应中包含了cookie，那么可以利用cookies属性拿到这个返回的cookie值：
url = "http://www.renren.com/PLogin.do"
resp = requests.get('http://www.baidu.com/')
print(resp.cookies)
print(resp.cookies.get_dict())
session
之前使用urllib库，是可以使 用opener发送多个请求，多个请求之间是可以共享cookie的。那么如果使用requests，也要达到共享cookie的目的，那么可以使用requests库给我们提供的session对象。注意，这里的session不是web开发中的那个session，这个地方只是一个会话的对象而已。还是以登录人人网为例，使用requests来实现。示例代码如下：
import requests
url = "http://www.renren.com/PLogin.do"
data = {"email":"970138074@qq.com",'password':"pythonspider"}
headers = {
'User-Agent': "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.94 Safari/537.36"
}
# 登录
session = requests.session()
session.post(url,data=data,headers=headers)
# 访问大鹏个人中心
resp = session.get('http://www.renren.com/880151247/profile')
print(resp.text)
处理不信任的SSL证书
对于那些已经被信任的SSL整数的网站，比如https://www.baidu.com/，那么使用requests直接就可以正常的返回响应。取消证书验证就行了verify=False示例代码如下：
resp = requests.get('http://www.12306.cn/mormhweb/',verify=False)
print(resp.content.decode('utf-8'))
aiohttp库
Requests库是一个阻塞式HTTP请求库，当我们发出一个请求后，程序会一直等待服务器响应，直到得到响应后，程序才会进行下一步处理。其实，这个过程比较耗费资源。如果程序可以在这个等待过程中做一些其他的事情，如进行请求的调度、响应的处理等，那么爬取效率一定会大大提高。
aiohttp就是这样一个提供异步Web服务的库，从Python 3.5版本开始，Python中加入了async/await关键字，使得回调的写法更加直观和人性化。aiohttp的异步操作借助于async/await关键字的写法变得更加简洁，架构更加清晰。使用异步请求库进行数据抓取时，会大大提高效率，下面我们来看一下这个库的安装方法。
后面的实例中用到这个库，比如维护一个代理池时，利用异步方式检测大量代理的运行状况，会极大地提升效率。
相关链接
- 官方文档：http://aiohttp.readthedocs.io/en/stable
- GitHub：https://github.com/aio-libs/aiohttp
- PyPI：https://pypi.python.org/pypi/aiohttp
pip安装
这里推荐使用pip安装，命令如下：
pip3 install aiohttp
另外，官方还推荐安装如下两个库：一个是字符编码检测库cchardet，另一个是加速DNS的解析库aiodns。安装命令如下：
pip3 install cchardet aiodns
第二章：数据提取
一、xpath语法与lxml库
XPath语法和lxml模块
什么是XPath？
xpath（XML Path Language）是一门在XML和HTML文档中查找信息的语言，可用来在XML和HTML文档中对元素和属性进行遍历。
XPath开发工具
- Chrome插件XPath Helper。
- Firefox插件Try XPath。
XPath语法
选取节点：
XPath 使用路径表达式来选取 XML 文档中的节点或者节点集。这些路径表达式和我们在常规的电脑文件系统中看到的表达式非常相似
| bookstore | 选取 bookstore 元素的所有子节点。 |
|---|---|
| /bookstore | 选取根元素 bookstore。注释：假如路径起始于正斜杠( / )，则此路径始终代表到某元素的绝对路径！ |
| bookstore/book | 选取属于 bookstore 的子元素的所有 book 元素。 |
| //book | 选取所有 book 子元素，而不管它们在文档中的位置。 |
| bookstore//book | 选择属于 bookstore 元素的后代的所有 book 元素，而不管它们位于 bookstore 之下的什么位置。 |
| //@lang | 选取名为 lang 的所有属性。 |
| .. 或者parent:: | 获取父节点 |
谓语：
谓语用来查找某个特定的节点或者包含某个指定的值的节点，被嵌在方括号中。 在下面的表格中，我们列出了带有谓语的一些路径表达式，以及表达式的结果：
| 路径表达式 | 结果 |
|---|---|
| /bookstore/book[1] | 选取属于 bookstore 子元素的第一个 book 元素。 |
| /bookstore/book[last()] | 选取属于 bookstore 子元素的最后一个 book 元素。 |
| /bookstore/book[last()-1] | 选取属于 bookstore 子元素的倒数第二个 book 元素。 |
| /bookstore/book[position()<3] | 选取最前面的两个属于 bookstore 元素的子元素的 book 元素。 |
| //title[@lang] | 选取所有拥有名为 lang 的属性的 title 元素。 |
| //title[@lang='eng'] | 选取所有 title 元素，且这些元素拥有值为 eng 的 lang 属性。 |
| /bookstore/book[price>35.00] | 选取 bookstore 元素的所有 book 元素，且其中的 price 元素的值须大于 35.00。 |
| /bookstore/book[price>35.00]/title | 选取 bookstore 元素中的 book 元素的所有 title 元素，且其中的 price 元素的值须大于 35.00。 |
| //li[contains(@class, 'li')] | class有两个属性值，li,li-fist，只要此属性值包含所传入的属性值li就可以匹配成功了 |
通配符
| 通配符 | 描述 | 示例 | 结果 |
|---|---|---|---|
| * | 匹配任意节点 | /bookstore/* | 选取bookstore下的所有子元素。 |
| @* | 匹配节点中的任何属性 | //book[@*] | 选取所有带有属性的book元素。 |
| node() | 匹配任何类型的节点。 | //title[@*] | 选取所有带有属性的 title 元素。 |
选取多个路径
通过在路径表达式中使用“|”运算符，可以选取若干个路径。 示例如下：
| 路径表达式 | 结果 |
|---|---|
| //book/title | //book/price | 选取 book 元素的所有 title 和 price 元素。 |
| //title | //price | 选取文档中的所有 title 和 price 元素。 |
| /bookstore/book/title | //price | 选取属于 bookstore 元素的 book 元素的所有 title 元素，以及文档中所有的 price 元素。 |
运算符
| 运算符 | 描述 | 实例 | 返回值 |
|---|---|---|---|
| | | 计算两个节点集 | //book | //cd | 返回所有拥有 book 和 cd 元素的节点集 |
| + | 加法 | 6 + 4 | 10 |
| - | 减法 | 6 - 4 | 2 |
| * | 乘法 | 6 * 4 | 24 |
| div | 除法 | 8 div 4 | 2 |
| = | 等于 | price=9.80 | 如果 price 是 9.80，则返回 true。如果 price 是 9.90，则返回 false。 |
| != | 不等于 | price!=9.80 | 如果 price 是 9.90，则返回 true。如果 price 是 9.80，则返回 false。 |
| < | 小于 | price<9.80 | 如果 price 是 9.00，则返回 true。如果 price 是 9.90，则返回 false。 |
| <= | 小于或等于 | price<=9.80 | 如果 price 是 9.00，则返回 true。如果 price 是 9.90，则返回 false。 |
| > | 大于 | price>9.80 | 如果 price 是 9.90，则返回 true。如果 price 是 9.80，则返回 false。 |
| >= | 大于或等于 | price>=9.80 | 如果 price 是 9.90，则返回 true。如果 price 是 9.70，则返回 false。 |
| or | 或 | price=9.80 or price=9.70 | 如果 price 是 9.80，则返回 true。如果 price 是 9.50，则返回 false。 |
| and | 与 | price>9.00 and price<9.90 | 如果 price 是 9.80，则返回 true。如果 price 是 8.50，则返回 false。 |
| mod | 计算除法的余数 | 5 mod 2 | 1 |
使用方式
使用//获取整个页面当中的元素，然后写标签名，然后再写谓词进行提取比如
//div[@class='abc']
需要注意的点
- /和//区别：/代表只获取直接子节点。 // 获取子孙节点。一般//用的比较多。当然也要视情况而定
- Contains：有时候某个属性中包含了多个值，那么可以使用
contains函数，示例如下：
//div[contains(@class,'job_detail')]
- 谓词中的下调是从1开始的，不是从0开始的。
- 获取标签属性的值
//a/@href 获取所有a标签的href属性的值
- 获取标签中的文本
//a/text()
lxml库
lxml 是 一个HTML/XML的解析器，主要的功能是如何解析和提取 HTML/XML 数据。
lxml和正则一样，也是用 C 实现的，是一款高性能的 Python HTML/XML 解析器，我们可以利用之前学习的XPath语法，来快速的定位特定元素以及节点信息。
lxml python 官方文档：http://lxml.de/index.html
需要安装C语言库，可使用 pip 安装：pip install lxml
安装中出现 的问题
在Linux平台下安装问题不大，同样可以先尝试pip安装，如果报错，可以尝试下面的解决方案。CentOS、Red Hat对于此类系统，报错主要是因为缺少必要的库。执行如下命令安装所需的库即可：
sudo yum groupinstall -y development tools
sudo yum install -y epel-release libxslt-devel libxml2-devel openssl-devel
主要是libxslt-devel和libxml2-devel这两个库，lxml依赖它们。安装好之后，重新尝试pip安装即可。
Ubuntu、Debian和Deepin在这些系统下，报错的原因同样可能是缺少了必要的类库，执行如下命令安装：
sudo apt-get install -y python3-dev build-essential libssl-dev libffi-dev libxml2 libxml2-dev libxslt1-dev zlib1g-dev
Macos 如果产生错误，可以执行如下命令将必要的类库安装
xcode-select --install
之后再重新尝试pip安装，就没有问题了。
lxml是一个非常重要的库，后面的Beautiful Soup、Scrapy框架都需要用到此库，所以请一定安装成功。
基本使用：
我们可以利用他来解析HTML代码，并且在解析HTML代码的时候，如果HTML代码不规范，他会自动的进行补全。示例代码如下：
解析HTML字符串
# 使用 lxml 的 etree 库
from lxml import etree
text = '''
<div>
<ul>
<li class="item-0"><a href="link1.html">first item</a></li>
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-inactive"><a href="link3.html">third item</a></li>
<li class="item-1"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a> # 注意，此处缺少一个 </li> 闭合标签
</ul>
</div>
'''
#利用etree.HTML，将字符串解析为HTML文档
html = etree.HTML(text)
# 按字符串序列化HTML文档
result = etree.tostring(html, encoding='utf-8').decode('utf-8')
print(result)
输出结果如下：
<html><body>
<div>
<ul>
<li class="item-0"><a href="link1.html">first item</a></li>
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-inactive"><a href="link3.html">third item</a></li>
<li class="item-1"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a></li>
</ul>
</div>
</body></html>
可以看到。lxml会自动修改HTML代码。例子中不仅补全了li标签，还添加了body，html标签。
从文件中读取html代码：
除了直接使用字符串进行解析，lxml还支持从文件中读取内容。我们新建一个hello.html文件：
<!-- hello.html -->
<div>
<ul>
<li class="item-0"><a href="link1.html">first item</a></li>
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-inactive"><a href="link3.html"><span class="bold">third item</span></a></li>
<li class="item-1"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a></li>
</ul>
</div>
然后利用etree.parse()方法来读取文件。示例代码如下：
from lxml import etree
# 读取外部文件 hello.html
html = etree.parse('hello.html')
result = etree.tostring(html, pretty_print=True)
print(result)
输出的结果和之前是相同的。这里需要注意的是，如果html代码中如果有没有闭合的标签，会报错，需要指定解析器。如果是从字符串中读取的话，etree.HTML()的话就不需要指定解析器了
from lxml import etree
# 指定解析器
parser = etree.HTMLParser(encoding='utf-8')
# 读取外部文件 hello.html,指定解析器
html = etree.parse('hello.html', parser=parser)
result = etree.tostring(html, pretty_print=True).decode('utf-8')
print(result)
在lxml中使用XPath语法
-
获取所有li标签：
from lxml import etree html = etree.parse('hello.html') print type(html) # 显示etree.parse() 返回类型 result = html.xpath('//li') print(result) # 打印<li>标签的元素集合 -
获取所有li元素下的所有class属性的值：
from lxml import etree html = etree.parse('hello.html') result = html.xpath('//li/@class') print(result) -
获取li标签下href为
www.baidu.com的a标签：from lxml import etree html = etree.parse('hello.html') result = html.xpath('//li/a[@href="www.baidu.com"]') print(result) -
获取li标签下所有span标签：
from lxml import etree html = etree.parse('hello.html') #result = html.xpath('//li/span') #注意这么写是不对的： #因为 / 是用来获取子元素的，而 <span> 并不是 <li> 的子元素，所以，要用双斜杠 result = html.xpath('//li//span') print(result) -
获取li标签下的a标签里的所有class：
from lxml import etree html = etree.parse('hello.html') result = html.xpath('//li/a//@class') print(result) -
获取最后一个li的a的href属性对应的值：
from lxml import etree html = etree.parse('hello.html') result = html.xpath('//li[last()]/a/@href') # 谓语 [last()] 可以找到最后一个元素 print(result) -
获取倒数第二个li元素的内容：
from lxml import etree html = etree.parse('hello.html') result = html.xpath('//li[last()-1]/a') # text 方法可以获取元素内容 print(result[0].text) -
获取倒数第二个li元素的内容的第二种方式：
from lxml import etree html = etree.parse('hello.html') result = html.xpath('//li[last()-1]/a/text()') print(result)
注意事项：
- 使用
xpath语法，应该使用Element.xpath方法，来执行xpath的选择，示例如下：
trs = html.xpath("//tr[position()>1]")
xpath函数返回的永远是一个列表
- 获取某个标签的属性：
html.xpath("//a/@href") # 获取a标签的href属性对应的值
- 获取文本， 是通过
xpath中的text()函数
address = tr.xpath("./td[4]/text()")[0]
- 在某标签下，再执行xpath函数，获取这个标签下的子孙元素，那么应该在//之前加一个点，代表是在当前元素下获取，示例见上
二、BeautifulSoup4库
和 lxml 一样，Beautiful Soup 也是一个HTML/XML的解析器，主要的功能也是如何解析和提取 HTML/XML 数据。同时还有pyquery同样是一个强大的网页解析工具，它提供了和jQuery类似的语法来解析HTML文档，支持CSS选择器，使用非常方便。 lxml 只会局部遍历，而Beautiful Soup 是基于HTML DOM（Document Object Model）的，会载入整个文档，解析整个DOM树，因此时间和内存开销都会大很多，所以性能要低于lxml。 BeautifulSoup 用来解析 HTML 比较简单，API非常人性化，支持CSS选择器、Python标准库中的HTML解析器，也支持 lxml 的 XML解析器。 Beautiful Soup 3 目前已经停止开发，推荐现在的项目使用Beautiful Soup 4。
安装和文档
- 安装：
pip install bs4。 - 中文文档：https://www.crummy.com/software/BeautifulSoup/bs4/doc/index.zh.html
几大解析工具对比
| 解析工具 | 解析速度 | 使用难度 |
|---|---|---|
| BeautifulSoup | 最慢 | 最简单 |
| lxml | 快 | 简单 |
| 正则 | 最快 | 最难 |
简单使用
from bs4 import BeautifulSoup
html = """
<html><head><title>The Dormouse's story</title></head>
<body>
<p class="title" name="dromouse"><b>The Dormouse's story</b></p>
<p class="story">Once upon a time there were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1"><!-- Elsie --></a>,
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
and they lived at the bottom of a well.</p>
<p class="story">...</p>
"""
#创建 Beautiful Soup 对象
# 使用lxml来进行解析
soup = BeautifulSoup(html,"lxml")
# soup = BeautifulSoup(markup, "html5lib") # 使容错性更好的解析器,解析速度慢
print(soup.prettify())
四个常用的对象：
Beautiful Soup将复杂HTML文档转换成一个复杂的树形结构,每个节点都是Python对象,所有对象可以归纳为4种:
- Tag
- NavigatableString
- BeautifulSoup
- Comment
1. Tag：
Tag 通俗点讲就是 HTML 中的一个个标签。BeautifuSoup中所有的标签都是Tag类型的对象，并且BeautifulSoup的对象其实本质上也是一个Tag类型，是继承了Tag的类，一些方法比如find、find_all并不是BeautifulSoup的，而是Tag的。
示例代码如下：
from bs4 import BeautifulSoup
html = """
<html><head><title>The Dormouse's story</title></head>
<body>
<p class="title" name="dromouse"><b>The Dormouse's story</b></p>
<p class="story">Once upon a time there were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1"><!-- Elsie --></a>,
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
and they lived at the bottom of a well.</p>
<p class="story">...</p>
"""
#创建 Beautiful Soup 对象
soup = BeautifulSoup(html,'lxml')
print soup.title
# <title>The Dormouse's story</title>
print soup.head
# <head><title>The Dormouse's story</title></head>
print soup.a
# <a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>
print soup.p
# <p class="title" name="dromouse"><b>The Dormouse's story</b></p>
print type(soup.p)
# <class 'bs4.element.Tag'>
我们可以利用 soup 加标签名轻松地获取这些标签的内容，这些对象的类型是bs4.element.Tag。但是注意，它查找的是在所有内容中的第一个符合要求的标签。如果要查询所有的标签，后面会进行介绍。 对于Tag，它有两个重要的属性，分别是name和attrs。示例代码如下：
print soup.name
# [document] #soup 对象本身比较特殊，它的 name 即为 [document]
print soup.head.name
# head #对于其他内部标签，输出的值便为标签本身的名称
print soup.p.attrs
# {'class': ['title'], 'name': 'dromouse'}
# 在这里，我们把 p 标签的所有属性打印输出了出来，得到的类型是一个字典。
print soup.p['class'] # soup.p.get('class')
# ['title'] #还可以利用get方法，传入属性的名称，二者是等价的
soup.p['class'] = "newClass"
print soup.p # 可以对这些属性和内容等等进行修改
# <p class="newClass" name="dromouse"><b>The Dormouse's story</b></p>
2. NavigableString：
如果拿到标签后，还想获取标签中的内容。那么可以通过tag.string获取标签中的文字。继承自python中的str，用起来跟使用python的str是一样的。
示例代码如下：
print soup.p.string
# The Dormouse's story
print type(soup.p.string)
# <class 'bs4.element.NavigableString'>thon
3. BeautifulSoup：
BeautifulSoup 对象表示的是一个文档的全部内容.大部分时候,可以把它当作 Tag 对象,它支持 遍历文档树 和 搜索文档树 中描述的大部分的方法，通俗讲，继承自Tag。 因为 BeautifulSoup 对象并不是真正的HTML或XML的tag,所以它没有name和attribute属性.但有时查看它的 .name 属性是很方便的,所以 BeautifulSoup 对象包含了一个值为 “[document]” 的特殊属性 .name
soup.name
# '[document]'
4. Comment：
Tag , NavigableString , BeautifulSoup 几乎覆盖了html和xml中的所有内容,但是还有一些特殊对象.容易让人担心的内容是文档的注释部分:
markup = "<b><!--Hey, buddy. Want to buy a used parser?--></b>"
soup = BeautifulSoup(markup)
comment = soup.b.string
type(comment)
# <class 'bs4.element.Comment'>
Comment 对象是一个特殊类型的 NavigableString 对象，继承 自NavigableString
comment
# 'Hey, buddy. Want to buy a used parser'
遍历文档树：
1. contents和children：
contents返回的是列表
children返回的是一个生成器
html_doc = """
<html><head><title>The Dormouse's story</title></head>
<p class="title"><b>The Dormouse's story</b></p>
<p class="story">Once upon a time there were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1">Elsie</a>,
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
and they lived at the bottom of a well.</p>
<p class="story">...</p>
"""
from bs4 import BeautifulSoup
soup = BeautifulSoup(html_doc,'lxml')
head_tag = soup.head
# 返回所有子节点的列表
print(head_tag.contents)
# 返回所有子节点的迭代器
for child in head_tag.children:
print(child)
2. strings 和 stripped_strings
- string：获取某个标签下的非标签字符串, 返回的是一个字符串
- strings：获取某个标签下的子孙非标签字符串，返回的是一个生成器，会有空的字符串元素。
- stripped_strings：获取某个标签下的子孙非标签字符串，返回一个生成器，会去掉空白字符，生成器内不会有空字符串元素。
- get_text(): 获取某个标签下的子孙非标签字符串，不是以生成器返回，是以普通字符串返回。
搜索文档树：
1. find和find_all方法：
搜索文档树，一般用得比较多的就是两个方法，一个是find，一个是find_all。find方法是找到第一个满足条件的标签后就立即返回，只返回一个元素。find_all方法是把所有满足条件的标签都选到，然后返回一个列表。使用这两个方法，最常用的用法是出入name以及attr参数找出符合要求的标签。
soup.find_all("a",attrs={"id":"link2"})
或者是直接传入属性的的名字作为关键字参数：
soup.find_all("a",id='link2')
有些时候，在提取标签的时候，不想提取那么多，可以使用limit参数限制提取多少个
soup.find_all('a', limit=2, class_="link")
过滤条件：
- 关键字参数 ：将属性的名字作为关键字参数的名子，以及属性的值作为关键字参数的值进行过滤
- attrs参数 ：将属性的条件放到一个字典中传给attrs参数 。
获取标签的属性：
- 通过下标获取：
href = a['href']
- 通过attrs属性获取：
href = a.attrs['href']
2. select方法：
使用以上方法可以方便的找出元素。但有时候使用css选择器的方式可以更加的方便。使用css选择器的语法，应该使用select方法。返回的是一个列表，以下列出几种常用的css选择器方法：
#####（1）通过标签名查找：
print(soup.select('a'))
（2）通过类名查找：
通过类名，则应该在类的前面加一个.。比如要查找class=sister的标签。示例代码如下：
print(soup.select('.sister'))
（3）通过id查找：
通过id查找，应该在id的名字前面加一个＃号。示例代码如下：
print(soup.select("#link1"))
（4）组合查找：
组合查找即和写 class 文件时，标签名与类名、id名进行的组合原理是一样的，例如查找 p 标签中，id 等于 link1的内容，二者需要用空格分开：
print(soup.select("p #link1"))
直接子标签查找，则使用 > 分隔：
print(soup.select("head > title"))
（5）通过属性查找：
查找时还可以加入属性元素，属性需要用中括号括起来，注意属性和标签属于同一节点，所以中间不能加空格，否则会无法匹配到。示例代码如下：
print(soup.select('a[href="http://example.com/elsie"]'))
（6）获取内容
以上的 select 方法返回的结果都是列表形式，可以遍历形式输出，然后用 get_text() 方法来获取它的内容。
soup = BeautifulSoup(html, 'lxml')
print type(soup.select('title'))
print soup.select('title')[0].get_text()
for title in soup.select('title'):
print title.get_text()
三、正则表达式和re模块：
什么是正则表达式：
通俗理解：按照一定的规则，从某个字符串中匹配出想要的数据。这个规则就是正则表达式。 标准答案：https://baike.baidu.com/item/正则表达式/1700215?fr=aladdin
正则表达式常用匹配规则：
匹配某个字符串：
text = 'hello'
ret = re.match('he',text)
print(ret.group())
>> he
以上便可以在hello中，匹配出he。
点（.）匹配任意的字符：
text = "ab"
ret = re.match('.',text)
print(ret.group())
>> a
但是点（.）不能匹配不到换行符。示例代码如下：
text = "ab"
ret = re.match('.',text)
print(ret.group())
>> AttributeError: 'NoneType' object has no attribute 'group'
\d匹配任意的数字：
text = "123"
ret = re.match('\d',text)
print(ret.group())
>> 1
\D匹配任意的非数字：
text = "a"
ret = re.match('\D',text)
print(ret.group())
>> a
而如果text是等于一个数字，那么就匹配不成功了。示例代码如下：
text = "1"
ret = re.match('\D',text)
print(ret.group())
>> AttributeError: 'NoneType' object has no attribute 'group'
\s匹配的是空白字符（包括：\n，\t，\r和空格）：
text = "\t"
ret = re.match('\s',text)
print(ret.group())
>> 空白
\w匹配的是a-z和A-Z以及数字和下划线：
text = "_"
ret = re.match('\w',text)
print(ret.group())
>> _
而如果要匹配一个其他的字符，那么就匹配不到。示例代码如下：
text = "+"
ret = re.match('\w',text)
print(ret.group())
>> AttributeError: 'NoneType' object has no attribute
\W匹配的是和\w相反的：
text = "+"
ret = re.match('\W',text)
print(ret.group())
>> +
而如果你的text是一个下划线或者英文字符，那么就匹配不到了。示例代码如下：
text = "_"
ret = re.match('\W',text)
print(ret.group())
>> AttributeError: 'NoneType' object has no attribute
[]组合的方式，只要满足中括号中的某一项都算匹配成功：
text = "0731-88888888"
ret = re.match('[\d\-]+',text)
print(ret.group())
>> 0731-88888888
之前讲到的几种匹配规则，其实可以使用中括号的形式来进行替代：
- \d：[0-9]
- \D：
[^0-9] - \w：[0-9a-zA-Z_]
- \W：
[^0-9a-zA-Z]
匹配多个字符：
-
*：可以匹配0或者任意多个字符。示例代码如下：text = "0731" ret = re.match('\d*',text) print(ret.group()) >> 0731以上因为匹配的要求是
\d，那么就要求是数字，后面跟了一个星号，就可以匹配到0731这四个字符。 -
+：可以匹配1个或者多个字符。最少一个。示例代码如下：text = "abc" ret = re.match('\w+',text) print(ret.group()) >> abc因为匹配的是
\w，那么就要求是英文字符，后面跟了一个加号，意味着最少要有一个满足\w的字符才能够匹配到。如果text是一个空白字符或者是一个不满足\w的字符，那么就会报错。示例代码如下：text = "" ret = re.match('\w+',text) print(ret.group()) >> AttributeError: 'NoneType' object has no attribute -
?：匹配的字符可以出现一次或者不出现（0或者1）。示例代码如下：text = "123" ret = re.match('\d?',text) print(ret.group()) >> 1 -
{m}：匹配m个字符。示例代码如下：text = "123" ret = re.match('\d{2}',text) print(ret.group()) >> 12 -
{m,n}：匹配m-n个字符。在这中间的字符都可以匹配到。示例代码如下：text = "123" ret = re.match('\d{1,2}',text) prit(ret.group()) >> 12如果text只有一个字符，那么也可以匹配出来。示例代码如下：
text = "1" ret = re.match('\d{1,2}',text) prit(ret.group()) >> 1
小案例：
-
验证手机号码：手机号码的规则是以
1开头，第二位可以是34587，后面那9位就可以随意了。示例代码如下：text = "18570631587" ret = re.match('1[34587]\d{9}',text) print(ret.group()) >> 18570631587而如果是个不满足条件的手机号码。那么就匹配不到了。示例代码如下：
text = "1857063158" ret = re.match('1[34587]\d{9}',text) print(ret.group()) >> AttributeError: 'NoneType' object has no attribute -
验证邮箱：邮箱的规则是邮箱名称是用
数字、数字、下划线组成的，然后是@符号，后面就是域名了。示例代码如下：text = "hynever@163.com" ret = re.match('\w+@\w+\.[a-zA-Z\.]+',text) print(ret.group()) -
验证URL：URL的规则是前面是
http或者https或者是ftp然后再加上一个冒号，再加上一个斜杠，再后面就是可以出现任意非空白字符了。示例代码如下：text = "http://www.baidu.com/" ret = re.match('(http|https|ftp)://[^\s]+',text) print(ret.group()) -
验证身份证：身份证的规则是，总共有18位，前面17位都是数字，后面一位可以是数字，也可以是小写的x，也可以是大写的X。示例代码如下：
text = "3113111890812323X" ret = re.match('\d{17}[\dxX]',text) print(ret.group())
^（脱字号）：表示以...开始：
text = "hello"
ret = re.match('^h',text)
print(ret.group())
如果是在中括号中，那么代表的是取反操作.
$：表示以...结束：
# 匹配163.com的邮箱
text = "xxx@163.com"
ret = re.search('\w+@163\.com$',text)
print(ret.group())
>> xxx@163.com
|：匹配多个表达式或者字符串：
text = "hello|world"
ret = re.search('hello',text)
print(ret.group())
>> hello
贪婪模式和非贪婪模式：
贪婪模式：正则表达式会匹配尽量多的字符。默认是贪婪模式。 非贪婪模式：正则表达式会尽量少的匹配字符。 示例代码如下：
text = "0123456"
ret = re.match('\d+',text)
print(ret.group())
# 因为默认采用贪婪模式，所以会输出0123456
>> 0123456
可以改成非贪婪模式，那么就只会匹配到0。示例代码如下：
text = "0123456"
ret = re.match('\d+?',text)
print(ret.group())
案例：匹配0-100之间的数字：
text = '99'
ret = re.match('[1-9]?\d$|100$',text)
print(ret.group())
>> 99
而如果text=101，那么就会抛出一个异常。示例代码如下：
text = '101'
ret = re.match('[1-9]?\d$|100$',text)
print(ret.group())
>> AttributeError: 'NoneType' object has no attribute 'group'
转义字符和原生字符串：
在正则表达式中，有些字符是有特殊意义的字符。因此如果想要匹配这些字符，那么就必须使用反斜杠进行转义。比如$代表的是以...结尾，如果想要匹配$，那么就必须使用\$。示例代码如下：
text = "apple price is \$99,orange paice is $88"
ret = re.search('\$(\d+)',text)
print(ret.group())
>> $99
原生字符串： 在正则表达式中，\是专门用来做转义的。在Python中\也是用来做转义的。因此如果想要在普通的字符串中匹配出\，那么要给出四个\。示例代码如下：
text = "apple \c"
ret = re.search('\\\\c',text)
print(ret.group())
因此要使用原生字符串就可以解决这个问题：
text = "apple \c"
ret = re.search(r'\\c',text)
print(ret.group())
re模块中常用函数：
match：
从开始的位置进行匹配。如果开始的位置没有匹配到。就直接失败了。示例代码如下：
text = 'hello'
ret = re.match('h',text)
print(ret.group())
>> h
如果第一个字母不是h，那么就会失败。示例代码如下：
text = 'ahello'
ret = re.match('h',text)
print(ret.group())
>> AttributeError: 'NoneType' object has no attribute 'group'
如果想要匹配换行的数据，那么就要传入一个flag=re.DOTALL，就可以匹配换行符了。示例代码如下：
text = "abc\nabc"
ret = re.match('abc.*abc',text,re.DOTALL)
print(ret.group())
search：
在字符串中找满足条件的字符。如果找到，就返回。说白了，就是只会找到第一个满足条件的。
text = 'apple price $99 orange price $88'
ret = re.search('\d+',text)
print(ret.group())
>> 99
分组：
在正则表达式中，可以对过滤到的字符串进行分组。分组使用圆括号的方式。
group：和group(0)是等价的，返回的是整个满足条件的字符串。groups：返回的是里面的子组。索引从1开始。group(1)：返回的是第一个子组，可以传入多个。 示例代码如下：
text = "apple price is $99,orange price is $10"
ret = re.search(r".*(\$\d+).*(\$\d+)",text)
print(ret.group())
print(ret.group(0))
print(ret.group(1))
print(ret.group(2))
print(ret.groups())
findall：
找出所有满足条件的，返回的是一个列表。
text = 'apple price $99 orange price $88'
ret = re.findall('\d+',text)
print(ret)
>> ['99', '88']
sub：
用来替换字符串。将匹配到的字符串替换为其他字符串。
text = 'apple price $99 orange price $88'
ret = re.sub('\d+','0',text)
print(ret)
>> apple price $0 orange price $0
sub函数的案例，获取拉勾网中的数据：
html = """
<div>
<p>基本要求：</p>
<p>1、精通HTML5、CSS3、 JavaScript等Web前端开发技术，对html5页面适配充分了解，熟悉不同浏览器间的差异，熟练写出兼容各种浏览器的代码；</p>
<p>2、熟悉运用常见JS开发框架，如JQuery、vue、angular，能快速高效实现各种交互效果；</p>
<p>3、熟悉编写能够自动适应HTML5界面，能让网页格式自动适应各款各大小的手机；</p>
<p>4、利用HTML5相关技术开发移动平台、PC终端的前端页面，实现HTML5模板化；</p>
<p>5、熟悉手机端和PC端web实现的差异，有移动平台web前端开发经验，了解移动互联网产品和行业，有在Android,iOS等平台下HTML5+CSS+JavaScript（或移动JS框架）开发经验者优先考虑；6、良好的沟通能力和团队协作精神，对移动互联网行业有浓厚兴趣，有较强的研究能力和学习能力；</p>
<p>7、能够承担公司前端培训工作，对公司各业务线的前端（HTML5\CSS3）工作进行支撑和指导。</p>
<p><br></p>
<p>岗位职责：</p>
<p>1、利用html5及相关技术开发移动平台、微信、APP等前端页面，各类交互的实现；</p>
<p>2、持续的优化前端体验和页面响应速度，并保证兼容性和执行效率；</p>
<p>3、根据产品需求，分析并给出最优的页面前端结构解决方案；</p>
<p>4、协助后台及客户端开发人员完成功能开发和调试；</p>
<p>5、移动端主流浏览器的适配、移动端界面自适应研发。</p>
</div>
"""
ret = re.sub('</?[a-zA-Z0-9]+>',"",html)
print(ret)
split：
使用正则表达式来分割字符串。
text = "hello world ni hao"
ret = re.split('\W',text)
print(ret)
>> ["hello","world","ni","hao"]
compile：
对于一些经常要用到的正则表达式，可以使用compile进行编译，后期再使用的时候可以直接拿过来用，执行效率会更快。而且compile还可以指定flag=re.VERBOSE，在写正则表达式的时候可以做好注释。示例代码如下：
text = "the number is 20.50"
r = re.compile(r"""
\d+ # 小数点前面的数字
\.? # 小数点
\d* # 小数点后面的数字
""",re.VERBOSE)
ret = re.search(r,text)
print(ret.group())
第三章 数据存储
一、json文件处理：
什么是json：
JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式。它基于 ECMAScript (w3c制定的js规范)的一个子集，采用完全独立于编程语言的文本格式来存储和表示数据。简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。 易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。更多解释请见：https://baike.baidu.com/item/JSON/2462549?fr=aladdin
JSON支持数据格式：
- 对象（字典）。使用花括号。
- 数组（列表）。使用方括号。
- 整形、浮点型、布尔类型还有null类型。
- 字符串类型（字符串必须要用双引号，不能用单引号）。
多个数据之间使用逗号分开。 注意：json本质上就是一个字符串。
字典和列表转JSON：
import json
books = [
{
'title': '钢铁是怎样练成的',
'price': 9.8
},
{
'title': '红楼梦',
'price': 9.9
}
]
json_str = json.dumps(books,ensure_ascii=False)
print(json_str)
因为json在dump的时候，只能存放ascii的字符，因此会将中文进行转义，这时候我们可以使用ensure_ascii=False关闭这个特性。 在Python中。只有基本数据类型才能转换成JSON格式的字符串。也即：int、float、str、list、dict、tuple。
将json数据直接dump到文件中：
json模块中除了dumps函数，还有一个dump函数，这个函数可以传入一个文件指针，直接将字符串dump到文件中。示例代码如下：
books = [
{
'title': '钢铁是怎样练成的',
'price': 9.8
},
{
'title': '红楼梦',
'price': 9.9
}
]
with open('a.json','w') as fp:
json.dump(books,fp)
将一个json字符串load成Python对象：
json_str = '[{"title": "钢铁是怎样练成的", "price": 9.8}, {"title": "红楼梦", "price": 9.9}]'
books = json.loads(json_str,encoding='utf-8')
print(type(books))
print(books)
直接从文件中读取json：
import json
with open('a.json','r',encoding='utf-8') as fp:
json_str = json.load(fp)
print(json_str)
csv文件处理
读取csv文件：
import csv
with open('stock.csv','r') as fp:
reader = csv.reader(fp) # reader 是一个迭代器，返回的是一个列表
titles = next(reader)
for x in reader:
print(x)
这样操作，以后获取数据的时候，就要通过下表来获取数据。如果想要在获取数据的时候通过标题来获取。那么可以使用DictReader。示例代码如下：
import csv
with open('stock.csv','r') as fp:
reader = csv.DictReader(fp) # reader是一个迭代器，遍历这个迭代器，返回的是一个字典
for x in reader:
print(x['turnoverVol'])
写入数据到csv文件：
写入数据到csv文件，需要创建一个writer对象，主要用到两个方法。一个是writerow，这个是写入一行。一个是writerows，这个是写入多行。示例代码如下：
import csv
headers = ['name','age','classroom']
values = [
('zhiliao',18,'111'),
('wena',20,'222'),
('bbc',21,'111')
]
with open('test.csv','w',newline='', encoding='utf-8') as fp:
writer = csv.writer(fp)
writer.writerow(headers)
writer.writerows(values)
也可以使用字典的方式把数据写入进去。这时候就需要使用DictWriter了。示例代码如下：
import csv
headers = ['name','age','classroom']
values = [
{"name":'wenn',"age":20,"classroom":'222'},
{"name":'abc',"age":30,"classroom":'333'}
]
with open('test.csv','w',newline='', encoding='utf-8') as fp:
writer = csv.DictWriter(fp,headers)
writer = csv.writeheader() # 需要手动的写入表头信息
# writer.writerow({'name':'zhiliao',"age":18,"classroom":'111'}) # 一交性写入一个字典
writer.writerows(values)
MySQL数据库操作
安装mysql：
- 在官网：https://dev.mysql.com/downloads/windows/installer/5.7.html
- 如果提示没有
.NET Framework框架。那么就在提示框中找到下载链接，下载一个就可以了。 - 如果提示没有
Microsoft Virtual C++ x64(x86)，那么百度或者谷歌这个软件安装即可。 - 如果没有找到。那么私聊我。
navicat：
navicat是一个操作mysql数据库非常方便的软件。使用他操作数据库，就跟使用excel操作数据是一样的。
安装驱动程序：
Python要想操作MySQL。必须要有一个中间件，或者叫做驱动程序。驱动程序有很多。比如有mysqldb、mysqlclient、pymysql等。在这里，我们选择用pymysql。安装方式也是非常简单，通过命令pip install pymysql即可安装。
数据库连接：
数据库连接之前。首先先确认以下工作完成，这里我们以一个pymysql_test数据库.以下将介绍连接mysql的示例代码：
import pymysql
db = pymysql.connect(
host="127.0.0.1",
user='root',
password='root',
database='pymysql_test',
port=3306
)
cursor = db.cursor()
cursor.execute("select 1")
data = cursor.fetchone()
print(data)
db.close()
插入数据：
import pymysql
db = pymysql.connect(
host="127.0.0.1",
user='root',
password='root',
database='pymysql_test',
port=3306
)
cursor = db.cursor()
sql = """
insert into user(
id,username,gender,age,password
)
values(null,'abc',1,18,'111111');
"""
cursor.execute(sql)
db.commit()
db.close()
如果在数据还不能保证的情况下，可以使用以下方式来插入数据：
sql = """
insert into user(
id,username,gender,age,password
)
values(null,%s,%s,%s,%s);
"""
cursor.execute(sql,('spider',1,20,'222222'))
查找数据：
使用pymysql查询数据。可以使用fetch*方法。
fetchone()：这个方法每次之获取一条数据。fetchall()：这个方法接收全部的返回结果。fetchmany(size)：可以获取指定条数的数据。 示例代码如下：
cursor = db.cursor()
sql = """
select * from user
"""
cursor.execute(sql)
while True:
result = cursor.fetchone()
if not result:
break
print(result)
db.close()
或者是直接使用fetchall，一次性可以把所有满足条件的数据都取出来：
cursor = db.cursor()
sql = """
select * from user
"""
cursor.execute(sql)
results = cursor.fetchall()
for result in results:
print(result)
db.close()
或者是使用fetchmany，指定获取多少条数据：
cursor = db.cursor()
sql = """
select * from user
"""
cursor.execute(sql)
results = cursor.fetchmany(1)
for result in results:
print(result)
db.close()
删除数据：
cursor = db.cursor()
sql = """
delete from user where id=1
"""
cursor.execute(sql)
db.commit()
db.close()
更新数据：
conn = pymysql.connect(host='localhost',user='root',password='root',database='pymysql_demo',port=3306)
cursor = conn.cursor()
sql = """
update user set username='aaa' where id=1
"""
cursor.execute(sql)
conn.commit()
conn.close()
mongodb 数据库操作
第四章 爬虫进阶
一、多线程爬虫
有些时候，比如下载图片，因为下载图片是一个耗时的操作。如果采用之前那种同步的方式下载。那效率肯会特别慢。这时候我们就可以考虑使用多线程的方式来下载图片。
多线程介绍：
多线程是为了同步完成多项任务，通过提高资源使用效率来提高系统的效率。线程是在同一时间需要完成多项任务的时候实现的。 最简单的比喻多线程就像火车的每一节车厢，而进程则是火车。车厢离开火车是无法跑动的，同理火车也可以有多节车厢。多线程的出现就是为了提高效率。同时它的出现也带来了一些问题。更多介绍请参考：https://baike.baidu.com/item/多线程/1190404?fr=aladdin
threading模块介绍：
threading模块是python中专门提供用来做多线程编程的模块。threading模块中最常用的类是Thread。以下看一个简单的多线程程序：
import threading
import time
def coding():
for x in range(3):
print('%s正在写代码' % x)
time.sleep(1)
def drawing():
for x in range(3):
print('%s正在画图' % x)
time.sleep(1)
def single_thread():
coding()
drawing()
def multi_thread():
t1 = threading.Thread(target=coding)
t2 = threading.Thread(target=drawing)
t1.start()
t2.start()
if __name__ == '__main__':
multi_thread()
查看线程数：
使用threading.enumerate()函数便可以看到当前线程的数量。
查看当前线程的名字：
使用threading.current_thread()可以看到当前线程的信息。
继承自threading.Thread类：
为了让线程代码更好的封装。可以使用threading模块下的Thread类，继承自这个类，然后实现run方法，线程就会自动运行run方法中的代码。示例代码如下：
import threading
import time
class CodingThread(threading.Thread):
def run(self):
for x in range(3):
print('%s正在写代码' % threading.current_thread())
time.sleep(1)
class DrawingThread(threading.Thread):
def run(self):
for x in range(3):
print('%s正在画图' % threading.current_thread())
time.sleep(1)
def multi_thread():
t1 = CodingThread()
t2 = DrawingThread()
t1.start()
t2.start()
if __name__ == '__main__':
multi_thread()
多线程共享全局变量的问题：
多线程都是在同一个进程中运行的。因此在进程中的全局变量所有线程都是可共享的。这就造成了一个问题，因为线程执行的顺序是无序的。有可能会造成数据错误。比如以下代码：
import threading
tickets = 0
def get_ticket():
global tickets
for x in range(1000000):
tickets += 1
print('tickets:%d'%tickets)
def main():
for x in range(2):
t = threading.Thread(target=get_ticket)
t.start()
if __name__ == '__main__':
main()
以上结果正常来讲应该是6，但是因为多线程运行的不确定性。因此最后的结果可能是随机的。
锁机制：
为了解决以上使用共享全局变量的问题。threading提供了一个Lock类，这个类可以在某个线程访问某个变量的时候加锁，其他线程此时就不能进来，直到当前线程处理完后，把锁释放了，其他线程才能进来处理。示例代码如下：
import threading
VALUE = 0
gLock = threading.Lock()
def add_value():
global VALUE
gLock.acquire()
for x in range(1000000):
VALUE += 1
gLock.release()
print('value：%d'%VALUE)
def main():
for x in range(2):
t = threading.Thread(target=add_value)
t.start()
if __name__ == '__main__':
main()
Lock版本生产者和消费者模式：
生产者和消费者模式是多线程开发中经常见到的一种模式。生产者的线程专门用来生产一些数据，然后存放到一个中间的变量中。消费者再从这个中间的变量中取出数据进行消费。但是因为要使用中间变量，中间变量经常是一些全局变量，因此需要使用锁来保证数据完整性。以下是使用threading.Lock锁实现的“生产者与消费者模式”的一个例子：
import threading
import random
import time
gMoney = 1000
gLock = threading.Lock()
# 记录生产者生产的次数，达到10次就不再生产
gTimes = 0
class Producer(threading.Thread):
def run(self):
global gMoney
global gLock
global gTimes
while True:
money = random.randint(100, 1000)
gLock.acquire()
# 如果已经达到10次了，就不再生产了
if gTimes >= 10:
gLock.release()
break
gMoney += money
print('%s当前存入%s元钱，剩余%s元钱' % (threading.current_thread(), money, gMoney))
gTimes += 1
time.sleep(0.5)
gLock.release()
class Consumer(threading.Thread):
def run(self):
global gMoney
global gLock
global gTimes
while True:
money = random.randint(100, 500)
gLock.acquire()
if gMoney > money:
gMoney -= money
print('%s当前取出%s元钱，剩余%s元钱' % (threading.current_thread(), money, gMoney))
time.sleep(0.5)
else:
# 如果钱不够了，有可能是已经超过了次数，这时候就判断一下
if gTimes >= 10:
gLock.release()
break
print("%s当前想取%s元钱，剩余%s元钱，不足！" % (threading.current_thread(),money,gMoney))
gLock