0%

Python

前面讲解了代理池的维护和付费代理的相关使用方法,接下来我们进行一下实战演练,利用代理来爬取微信公众号的文章。

1. 本节目标

我们的主要目标是利用代理爬取微信公众号的文章,提取正文、发表日期、公众号等内容,爬取来源是搜狗微信,其链接为 http://weixin.sogou.com/,然后把爬取结果保存到 MySQL 数据库。

2. 准备工作

首先需要准备并正常运行前文中所介绍的代理池。这里需要用的 Python 库有 aiohttp、requests、redis-py、pyquery、Flask、PyMySQL,如这些库没有安装可以参考第 1 章的安装说明。

3. 爬取分析

搜狗对微信公众平台的公众号和文章做了整合。我们可以通过上面的链接搜索到相关的公众号和文章,例如搜索 NBA,可以搜索到最新的文章,如图 9-21 所示。 图 9-21 搜索结果 点击搜索后,搜索结果的 URL 中其实有很多无关 GET 请求参数,将无关的参数去掉,只保留 type 和 query 参数,例如 http://weixin.sogou.com/weixin?type=2&query=NBA,搜索关键词为 NBA,类型为 2,2 代表搜索微信文章。 下拉网页,点击下一页即可翻页,如图 9-22 所示。 图 9-22 翻页列表 注意,如果没有输入账号登录,那只能看到 10 页的内容,登录之后可以看到 100 页内容,如图 9-23 和图 9-24 所示。 图 9-23 不登录的结果 图 9-24 登录后的结果 如果需要爬取更多内容,就需要登录并使用 Cookies 来爬取。 搜狗微信站点的反爬虫能力很强,如连续刷新,站点就会弹出类似如图 9-25 所示的验证。 图 9-25 验证码页面 网络请求出现了 302 跳转,返回状态码为 302,跳转的链接开头为 http://weixin.sogou.com/antispider/,这很明显就是一个反爬虫的验证页面。所以我们得出结论,如果服务器返回状态码为 302 而非 200,则 IP 访问次数太高,IP 被封禁,此请求就是失败了。 如果遇到这种情况,我们可以选择识别验证码并解封,也可以使用代理直接切换 IP。在这里我们采用第二种方法,使用代理直接跳过这个验证。代理使用上一节所讲的代理池,还需要更改检测的 URL 为搜狗微信的站点。 对于这种反爬能力很强的网站来说,如果我们遇到此种返回状态就需要重试。所以我们采用另一种爬取方式,借助数据库构造一个爬取队列,待爬取的请求都放到队列里,如果请求失败了重新放回队列,就会被重新调度爬取。 在这里我们可以采用 Redis 的队列数据结构,新的请求就加入队列,或者有需要重试的请求也放回队列。调度的时候如果队列不为空,那就把一个个请求取出来执行,得到响应后再进行解析,提取出我们想要的结果。 这次我们采用 MySQL 存储,借助 PyMySQL 库,将爬取结果构造为一个字典,实现动态存储。 综上所述,我们本节实现的功能有如下几点。

  • 修改代理池检测链接为搜狗微信站点
  • 构造 Redis 爬取队列,用队列实现请求的存取
  • 实现异常处理,失败的请求重新加入队列
  • 实现翻页和提取文章列表并把对应请求加入队列
  • 实现微信文章的信息的提取
  • 将提取到的信息保存到 MySQL

好,那么接下来我们就用代码来实现一下。

4. 构造 Request

既然我们要用队列来存储请求,那么肯定要实现一个请求 Request 的数据结构,这个请求需要包含一些必要信息,如请求链接、请求头、请求方式、超时时间。另外对于某个请求,我们需要实现对应的方法来处理它的响应,所以需要再加一个 Callback 回调函数。每次翻页请求需要代理来实现,所以还需要一个参数 NeedProxy。如果一个请求失败次数太多,那就不再重新请求了,所以还需要加失败次数的记录。 这些字段都需要作为 Request 的一部分,组成一个完整的 Request 对象放入队列去调度,这样从队列获取出来的时候直接执行这个 Request 对象就好了。 我们可以采用继承 reqeusts 库中的 Request 对象的方式来实现这个数据结构。requests 库中已经有了 Request 对象,它将请求 Request 作为一个整体对象去执行,得到响应后再返回。其实 requests 库的 get()、post() 等方法都是通过执行 Request 对象实现的。 我们首先看看 Request 对象的源码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class Request(RequestHooksMixin):
def __init__(self,
method=None, url=None, headers=None, files=None, data=None,
params=None, auth=None, cookies=None, hooks=None, json=None):

# Default empty dicts for dict params.
data = [] if data is None else data
files = [] if files is None else files
headers = {} if headers is None else headers
params = {} if params is None else params
hooks = {} if hooks is None else hooks

self.hooks = default_hooks()
for (k, v) in list(hooks.items()):
self.register_hook(event=k, hook=v)

self.method = method
self.url = url
self.headers = headers
self.files = files
self.data = data
self.json = json
self.params = params
self.auth = auth
self.cookies = cookies

这是 requests 库中 Request 对象的构造方法。这个 Request 已经包含了请求方式、请求链接、请求头这几个属性,但是相比我们需要的还差了几个。我们需要实现一个特定的数据结构,在原先基础上加入上文所提到的额外几个属性。这里我们需要继承 Request 对象重新实现一个请求,将它定义为 WeixinRequest,实现如下:

1
2
3
4
5
6
7
8
9
10
TIMEOUT = 10
from requests import Request

class WeixinRequest(Request):
def __init__(self, url, callback, method='GET', headers=None, need_proxy=False, fail_time=0, timeout=TIMEOUT):
Request.__init__(self, method, url, headers)
self.callback = callback
self.need_proxy = need_proxy
self.fail_time = fail_time
self.timeout = timeout

在这里我们实现了 WeixinRequest 数据结构。init() 方法先调用了 Request 的init() 方法,然后加入额外的几个参数,定义为 callback、need_proxy、fail_time、timeout,分别代表回调函数、是否需要代理爬取、失败次数、超时时间。 我们就可以将 WeixinRequest 作为一个整体来执行,一个个 WeixinRequest 对象都是独立的,每个请求都有自己的属性。例如,我们可以调用它的 callback,就可以知道这个请求的响应应该用什么方法来处理,调用 fail_time 就可以知道这个请求失败了多少次,判断失败次数是不是到了阈值,该不该丢弃这个请求。这里我们采用了面向对象的一些思想。

5. 实现请求队列

接下来我们就需要构造请求队列,实现请求的存取。存取无非就是两个操作,一个是放,一个是取,所以这里利用 Redis 的 rpush() 和 lpop() 方法即可。 另外还需要注意,存取不能直接存 Request 对象,Redis 里面存的是字符串。所以在存 Request 对象之前我们先把它序列化,取出来的时候再将其反序列化,这个过程可以利用 pickle 模块实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
from pickle import dumps, loads
from request import WeixinRequest

class RedisQueue():
def __init__(self):
"""初始化 Redis"""
self.db = StrictRedis(host=REDIS_HOST, port=REDIS_PORT, password=REDIS_PASSWORD)

def add(self, request):
"""
向队列添加序列化后的 Request
:param request: 请求对象
:param fail_time: 失败次数
:return: 添加结果
"""
if isinstance(request, WeixinRequest):
return self.db.rpush(REDIS_KEY, dumps(request))
return False

def pop(self):
"""
取出下一个 Request 并反序列化
:return: Request or None
"""
if self.db.llen(REDIS_KEY):
return loads(self.db.lpop(REDIS_KEY))
else:
return False

def empty(self):
return self.db.llen(REDIS_KEY) == 0

这里实现了一个 RedisQueue,它的 init() 构造方法里面初始化了一个 StrictRedis 对象。随后实现了 add() 方法,首先判断 Request 的类型,如果是 WeixinRequest,那么就把程序就会用 pickle 的 dumps() 方法序列化,然后再调用 rpush() 方法加入队列。pop() 方法则相反,调用 lpop() 方法将请求从队列取出,然后再用 pickle 的 loads() 方法将其转为 WeixinRequest 对象。另外,empty() 方法返回队列是否为空,只需要判断队列长度是否为 0 即可。 在调度的时候,我们只需要新建一个 RedisQueue 对象,然后调用 add() 方法,传入 WeixinRequest 对象,即可将 WeixinRequest 加入队列,调用 pop() 方法,即可取出下一个 WeixinRequest 对象,非常简单易用。

6. 修改代理池

接下来我们要生成请求并开始爬取。在此之前还需要做一件事,那就是先找一些可用代理。 之前代理池检测的 URL 并不是搜狗微信站点,所以我们需要将代理池检测的 URL 修改成搜狗微信站点,以便于把被搜狗微信站点封禁的代理剔除掉,留下可用代理。 现在将代理池的设置文件中的 TEST_URL 修改一下,如 http://weixin.sogou.com/weixin?type=2& query=nba,被本站点封的代理就会减分,正常请求的代理就会赋值为 100,最后留下的就是可用代理。 修改之后将获取模块、检测模块、接口模块的开关都设置为 True,让代理池运行一会,如图 9-26 所示。 图 9-26 代理池运行结果 这样,数据库中留下的 100 分的代理就是针对搜狗微信的可用代理了,如图 9-27 所示。 图 9-27 可用代理列表 同时访问代理接口,接口设置为 5555,访问 http://127.0.0.1:5555/random,即可获取到随机可用代理,如图 9-28 所示。 图 9-28 代理接口 再定义一个函数来获取随机代理:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
PROXY_POOL_URL = 'http://127.0.0.1:5555/random'

def get_proxy(self):
"""
从代理池获取代理
:return:
"""
try:
response = requests.get(PROXY_POOL_URL)
if response.status_code == 200:
print('Get Proxy', response.text)
return response.text
return None
except requests.ConnectionError:
return None

7. 第一个请求

一切准备工作都做好,下面我们就可以构造第一个请求放到队列里以供调度了。定义一个 Spider 类,实现 start() 方法的代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
from requests import Session
from db import RedisQueue
from request import WeixinRequest
from urllib.parse import urlencode

class Spider():
base_url = 'http://weixin.sogou.com/weixin'
keyword = 'NBA'
headers = {
'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8',
'Accept-Encoding': 'gzip, deflate',
'Accept-Language': 'zh-CN,zh;q=0.8,en;q=0.6,ja;q=0.4,zh-TW;q=0.2,mt;q=0.2',
'Cache-Control': 'max-age=0',
'Connection': 'keep-alive',
'Cookie': 'IPLOC=CN1100; SUID=6FEDCF3C541C940A000000005968CF55; SUV=1500041046435211; ABTEST=0|1500041048|v1; SNUID=CEA85AE02A2F7E6EAFF9C1FE2ABEBE6F; weixinIndexVisited=1; JSESSIONID=aaar_m7LEIW-jg_gikPZv; ld=Wkllllllll2BzGMVlllllVOo8cUlllll5G@HbZllll9lllllRklll5@@@@@@@@@@',
'Host': 'weixin.sogou.com',
'Upgrade-Insecure-Requests': '1',
'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.115 Safari/537.36'
}
session = Session()
queue = RedisQueue()

def start(self):
"""初始化工作"""
# 全局更新 Headers
self.session.headers.update(self.headers)
start_url = self.base_url + '?' + urlencode({'query': self.keyword, 'type': 2})
weixin_request = WeixinRequest(url=start_url, callback=self.parse_index, need_proxy=True)
# 调度第一个请求
self.queue.add(weixin_request)

这里定义了 Spider 类,设置了很多全局变量,比如 keyword 设置为 NBA,headers 就是请求头。在浏览器里登录账号,然后在开发者工具里将请求头复制出来,记得带上 Cookie 字段,这样才能爬取 100 页的内容。然后初始化了 Session 和 RedisQueue 对象,它们分别用来执行请求和存储请求。 首先,start() 方法全局更新了 headers,使得所有请求都能应用 Cookies。然后构造了一个起始 URL:http://weixin.sogou.com/weixin?type=2&query=NBA,随后用改 URL 构造了一个 WeixinRequest 对象。回调函数是 Spider 类的 parse_index() 方法,也就是当这个请求成功之后就用 parse_index() 来处理和解析。need_proxy 参数设置为 True,代表执行这个请求需要用到代理。随后我们调用了 RedisQueue 的 add() 方法,将这个请求加入队列,等待调度。

8. 调度请求

加入第一个请求之后,调度开始了。我们首先从队列中取出这个请求,将它的结果解析出来,生成新的请求加入队列,然后拿出新的请求,将结果解析,再生成新的请求加入队列,这样循环往复执行,直到队列中没有请求,则代表爬取结束。我们用代码实现如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
VALID_STATUSES = [200]

def schedule(self):
"""
调度请求
:return:
"""
while not self.queue.empty():
weixin_request = self.queue.pop()
callback = weixin_request.callback
print('Schedule', weixin_request.url)
response = self.request(weixin_request)
if response and response.status_code in VALID_STATUSES:
results = list(callback(response))
if results:
for result in results:
print('New Result', result)
if isinstance(result, WeixinRequest):
self.queue.add(result)
if isinstance(result, dict):
self.mysql.insert('articles', result)
else:
self.error(weixin_request)
else:
self.error(weixin_request)

在这里实现了一个 schedule() 方法,其内部是一个循环,循环的判断是队列不为空。 当队列不为空时,调用 pop() 方法取出下一个请求,调用 request() 方法执行这个请求,request() 方法的实现如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
from requests import ReadTimeout, ConnectionError

def request(self, weixin_request):
"""
执行请求
:param weixin_request: 请求
:return: 响应
"""
try:
if weixin_request.need_proxy:
proxy = get_proxy()
if proxy:
proxies = {
'http': 'http://' + proxy,
'https': 'https://' + proxy
}
return self.session.send(weixin_request.prepare(),
timeout=weixin_request.timeout, allow_redirects=False, proxies=proxies)
return self.session.send(weixin_request.prepare(), timeout=weixin_request.timeout, allow_redirects=False)
except (ConnectionError, ReadTimeout) as e:
print(e.args)
return False

这里首先判断这个请求是否需要代理,如果需要代理,则调用 get_proxy() 方法获取代理,然后调用 Session 的 send() 方法执行这个请求。这里的请求调用了 prepare() 方法转化为 Prepared Request,具体的用法可以参考 http://docs.python-requests.org/en/master/user/advanced/#prepared-requests,同时设置 allow_redirects 为 False,timeout 是该请求的超时时间,最后响应返回。 执行 request() 方法之后会得到两种结果:一种是 False,即请求失败,连接错误;另一种是 Response 对象,还需要判断状态码,如果状态码合法,那么就进行解析,否则重新将请求加回队列。 如果状态码合法,解析的时候就会调用 WeixinRequest 的回调函数进行解析。比如这里的回调函数是 parse_index(),其实现如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
from pyquery import PyQuery as pq

def parse_index(self, response):
"""
解析索引页
:param response: 响应
:return: 新的响应
"""
doc = pq(response.text)
items = doc('.news-box .news-list li .txt-box h3 a').items()
for item in items:
url = item.attr('href')
weixin_request = WeixinRequest(url=url, callback=self.parse_detail)
yield weixin_request
next = doc('#sogou_next').attr('href')
if next:
url = self.base_url + str(next)
weixin_request = WeixinRequest(url=url, callback=self.parse_index, need_proxy=True)
yield weixin_request

此方法做了两件事:一件事就是获取本页的所有微信文章链接,另一件事就是获取下一页的链接,再构造成 WeixinRequest 之后 yield 返回。 然后,schedule() 方法将返回的结果进行遍历,利用 isinstance() 方法判断返回结果,如果返回结果是 WeixinRequest,就将其重新加入队列。 至此,第一次循环结束。 这时 while 循环会继续执行。队列已经包含第一页内容的文章详情页请求和下一页的请求,所以第二次循环得到的下一个请求就是文章详情页的请求,程序重新调用 request() 方法获取其响应,然后调用其对应的回调函数解析。这时详情页请求的回调方法就不同了,这次是 parse_detail() 方法,此方法实现如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
def parse_detail(self, response):
"""
解析详情页
:param response: 响应
:return: 微信公众号文章
"""
doc = pq(response.text)
data = {'title': doc('.rich_media_title').text(),
'content': doc('.rich_media_content').text(),
'date': doc('#post-date').text(),
'nickname': doc('#js_profile_qrcode> div > strong').text(),
'wechat': doc('#js_profile_qrcode> div > p:nth-child(3) > span').text()}
yield data

这个方法解析了微信文章详情页的内容,提取出它的标题、正文文本、发布日期、发布人昵称、微信公众号名称,将这些信息组合成一个字典返回。 结果返回之后还需要判断类型,如是字典类型,程序就调用 mysql 对象的 insert() 方法将数据存入数据库。 这样,第二次循环执行完毕。 第三次循环、第四次循环,循环往复,每个请求都有各自的回调函数,索引页解析完毕之后会继续生成后续请求,详情页解析完毕之后会返回结果以便存储,直到爬取完毕。 现在,整个调度就完成了。 我们完善一下整个 Spider 代码,实现如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
from requests import Session
from config import *
from db import RedisQueue
from mysql import MySQL
from request import WeixinRequest
from urllib.parse import urlencode
import requests
from pyquery import PyQuery as pq
from requests import ReadTimeout, ConnectionError

class Spider():
base_url = 'http://weixin.sogou.com/weixin'
keyword = 'NBA'
headers = {
'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8',
'Accept-Encoding': 'gzip, deflate',
'Accept-Language': 'zh-CN,zh;q=0.8,en;q=0.6,ja;q=0.4,zh-TW;q=0.2,mt;q=0.2',
'Cache-Control': 'max-age=0',
'Connection': 'keep-alive',
'Cookie': 'IPLOC=CN1100; SUID=6FEDCF3C541C940A000000005968CF55; SUV=1500041046435211; ABTEST=0|1500041048|v1; SNUID=CEA85AE02A2F7E6EAFF9C1FE2ABEBE6F; weixinIndexVisited=1; JSESSIONID=aaar_m7LEIW-jg_gikPZv; ld=Wkllllllll2BzGMVlllllVOo8cUlllll5G@HbZllll9lllllRklll5@@@@@@@@@@',
'Host': 'weixin.sogou.com',
'Upgrade-Insecure-Requests': '1',
'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.115 Safari/537.36'
}
session = Session()
queue = RedisQueue()
mysql = MySQL()

def get_proxy(self):
"""
从代理池获取代理
:return:
"""
try:
response = requests.get(PROXY_POOL_URL)
if response.status_code == 200:
print('Get Proxy', response.text)
return response.text
return None
except requests.ConnectionError:
return None

def start(self):
"""初始化工作"""
# 全局更新 Headers
self.session.headers.update(self.headers)
start_url = self.base_url + '?' + urlencode({'query': self.keyword, 'type': 2})
weixin_request = WeixinRequest(url=start_url, callback=self.parse_index, need_proxy=True)
# 调度第一个请求
self.queue.add(weixin_request)

def parse_index(self, response):
"""
解析索引页
:param response: 响应
:return: 新的响应
"""
doc = pq(response.text)
items = doc('.news-box .news-list li .txt-box h3 a').items()
for item in items:
url = item.attr('href')
weixin_request = WeixinRequest(url=url, callback=self.parse_detail)
yield weixin_request
next = doc('#sogou_next').attr('href')
if next:
url = self.base_url + str(next)
weixin_request = WeixinRequest(url=url, callback=self.parse_index, need_proxy=True)
yield weixin_request

def parse_detail(self, response):
"""
解析详情页
:param response: 响应
:return: 微信公众号文章
"""
doc = pq(response.text)
data = {'title': doc('.rich_media_title').text(),
'content': doc('.rich_media_content').text(),
'date': doc('#post-date').text(),
'nickname': doc('#js_profile_qrcode> div > strong').text(),
'wechat': doc('#js_profile_qrcode> div > p:nth-child(3) > span').text()}
yield data

def request(self, weixin_request):
"""
执行请求
:param weixin_request: 请求
:return: 响应
"""
try:
if weixin_request.need_proxy:
proxy = self.get_proxy()
if proxy:
proxies = {
'http': 'http://' + proxy,
'https': 'https://' + proxy
}
return self.session.send(weixin_request.prepare(),
timeout=weixin_request.timeout, allow_redirects=False, proxies=proxies)
return self.session.send(weixin_request.prepare(), timeout=weixin_request.timeout, allow_redirects=False)
except (ConnectionError, ReadTimeout) as e:
print(e.args)
return False

def error(self, weixin_request):
"""
错误处理
:param weixin_request: 请求
:return:
"""
weixin_request.fail_time = weixin_request.fail_time + 1
print('Request Failed', weixin_request.fail_time, 'Times', weixin_request.url)
if weixin_request.fail_time < MAX_FAILED_TIME:
self.queue.add(weixin_request)

def schedule(self):
"""
调度请求
:return:
"""
while not self.queue.empty():
weixin_request = self.queue.pop()
callback = weixin_request.callback
print('Schedule', weixin_request.url)
response = self.request(weixin_request)
if response and response.status_code in VALID_STATUSES:
results = list(callback(response))
if results:
for result in results:
print('New Result', result)
if isinstance(result, WeixinRequest):
self.queue.add(result)
if isinstance(result, dict):
self.mysql.insert('articles', result)
else:
self.error(weixin_request)
else:
self.error(weixin_request)

def run(self):
"""
入口
:return:
"""
self.start()
self.schedule()

if __name__ == '__main__':
spider = Spider()
spider.run()

最后,我们加了一个 run() 方法作为入口,启动的时候只需要执行 Spider 的 run() 方法即可。

9. MySQL 存储

整个调度模块完成了,上面还没提及到的就是存储模块,在这里还需要定义一个 MySQL 类供存储数据,实现如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
REDIS_HOST = 'localhost'
REDIS_PORT = 6379
REDIS_PASSWORD = 'foobared'
REDIS_KEY = 'weixin'

import pymysql
from config import *

class MySQL():
def __init__(self, host=MYSQL_HOST, username=MYSQL_USER, password=MYSQL_PASSWORD, port=MYSQL_PORT,
database=MYSQL_DATABASE):
"""
MySQL 初始化
:param host:
:param username:
:param password:
:param port:
:param database:
"""
try:
self.db = pymysql.connect(host, username, password, database, charset='utf8', port=port)
self.cursor = self.db.cursor()
except pymysql.MySQLError as e:
print(e.args)

def insert(self, table, data):
"""
插入数据
:param table:
:param data:
:return:
"""
keys = ', '.join(data.keys())
values = ', '.join(['% s'] * len(data))
sql_query = 'insert into % s (% s) values (% s)' % (table, keys, values)
try:
self.cursor.execute(sql_query, tuple(data.values()))
self.db.commit()
except pymysql.MySQLError as e:
print(e.args)
self.db.rollback()

init() 方法初始化了 MySQL 连接,需要 MySQL 的用户、密码、端口、数据库名等信息。数据库名为 weixin,需要自己创建。 insert() 方法传入表名和字典即可动态构造 SQL,在 5.2 节中也有讲到,SQL 构造之后执行即可插入数据。 我们还需要提前建立一个数据表,表名为 articles,建表的 SQL 语句如下:

1
2
3
4
5
6
7
8
CREATE TABLE `articles` (`id` int(11) NOT NULL,
`title` varchar(255) NOT NULL,
`content` text NOT NULL,
`date` varchar(255) NOT NULL,
`wechat` varchar(255) NOT NULL,
`nickname` varchar(255) NOT NULL
) DEFAULT CHARSET=utf8;
ALTER TABLE `articles` ADD PRIMARY KEY (`id`);

现在,我们的整个爬虫就算完成了。

10. 运行

示例运行结果如图 9-29 所示: 图 9-29 运行结果 程序首先调度了第一页结果对应的请求,获取了代理执行此请求,随后得到了 11 个新请求,请求都是 WeixinRequest 类型,将其再加入队列。随后继续调度新加入的请求,也就是文章详情页对应的请求,再执行,得到的就是文章详情对应的提取结果,提取结果是字典类型。 程序循环往复,不断爬取,直至所有结果爬取完毕,程序终止,爬取完成。 爬取结果如图 9-30 所示。 图 9-30 爬取结果 我们可以看到,相关微信文章都已被存储到数据库里了。

11. 本节代码

本节代码地址为:https://github.com/Python3WebSpider/Weixin,运行之前请先配置好代理池。

12. 结语

以上内容便是使用代理爬取微信公众号文章的方法,涉及的新知识点不少,希望大家可以好好消化。

技术杂谈

我们尝试维护过一个代理池。代理池可以挑选出许多可用代理,但是常常其稳定性不高、响应速度慢,而且这些代理通常是公共代理,可能不止一人同时使用,其 IP 被封的概率很大。另外,这些代理可能有效时间比较短,虽然代理池一直在筛选,但如果没有及时更新状态,也有可能获取到不可用的代理。 如果要追求更加稳定的代理,就需要购买专有代理或者自己搭建代理服务器。但是服务器一般都是固定的 IP,我们总不能搭建 100 个代理就用 100 台服务器吧,这显然是不现实的。 所以,ADSL 动态拨号主机就派上用场了。下面我们来了解一下 ADSL 拨号代理服务器的相关设置。

1. 什么是 ADSL

ADSL(Asymmetric Digital Subscriber Line,非对称数字用户环路),它的上行和下行带宽不对称,它采用频分复用技术把普通的电话线分成了电话、上行和下行 3 个相对独立的信道,从而避免了相互之间的干扰。 ADSL 通过拨号的方式上网,需要输入 ADSL 账号和密码,每次拨号就更换一个 IP。IP 分布在多个 A 段,如果 IP 都能使用,则意味着 IP 量级可达千万。如果我们将 ADSL 主机作为代理,每隔一段时间主机拨号就换一个 IP,这样可以有效防止 IP 被封禁。另外,主机的稳定性很好,代理响应速度很快。

2. 准备工作

首先需要成功安装 Redis 数据库并启动服务,另外还需要安装 requests、redis-py、Tornado 库。如果没有安装,读者可以参考第一章的安装说明。

3. 购买主机

我们先购买一台动态拨号 VPS 主机,这样的主机服务商相当多。在这里使用了云立方,官方网站:http://www.yunlifang.cn/dynamicvps.asp。 建议选择电信线路。可以自行选择主机配置,主要考虑带宽是否满足需求。 然后进入拨号主机的后台,预装一个操作系统,如图 9-10 所示。 图 9-10 预装操作系统 推荐安装 CentOS 7 系统。 然后找到远程管理面板远程连接的用户名和密码,也就是 SSH 远程连接服务器的信息。比如我使用的 IP 和端口是 153.36.65.214:20063,用户名是 root。命令行下输入如下内容:

1
ssh root@153.36.65.214 -p 20063

输入管理密码,就可以连接上远程服务器了。 进入之后,我们发现一个可用的脚本文件 ppp.sh,这是拨号初始化的脚本。运行此脚本会提示输入拨号的用户名和密码,然后它就开始各种拨号配置。一次配置成功,后面拨号就不需要重复输入用户名和密码。 运行 ppp.sh 脚本,输入用户名、密码等待它的配置完成,如图 9-11 所示。 图 9-11 配置页面 提示成功之后就可以进行拨号了。注意,在拨号之前测试 ping 任何网站都是不通的,因为当前网络还没联通。输入如下拨号命令:

1
adsl-start

拨号命令成功运行,没有报错信息,耗时约几秒。接下来再去 ping 外网就可以通了。 如果要停止拨号,可以输入如下命令:

1
adsl-stop

之后,可以发现又连不通网络了,如图 9-12 所示。 图 9-12 拨号建立连接 断线重播的命令就是二者组合起来,先执行 adsl-stop,再执行 adsl-start。每次拨号,ifconfig 命令观察主机的 IP,发现主机的 IP 一直在变化,网卡名称叫作 ppp0,如图 9-13 所示。 图 9-13 网络设备信息 接下来,我们要做两件事:一是怎样将主机设置为代理服务器,二是怎样实时获取拨号主机的 IP。

4. 设置代理服务器

在 Linux 下搭建 HTTP 代理服务器,推荐 TinyProxy 和 Squid,配置都非常简单。在这里我们以 TinyProxy 为例来讲解一下怎样搭建代理服务器。

安装 TinyProxy

第一步就是安装 TinyProxy 软件。在这里我使用的系统是 CentOS,所以使用 yum 来安装。如果是其他系统,如 Ubuntu,可以选择 apt-get 等命令安装。 命令行执行 yum 安装指令:

1
2
3
yum install -y epel-release
yum update -y
yum install -y tinyproxy

运行完成之后就可以完成 tinyproxy 的安装了。

配置 TinyProxy

TinyProxy 安装完成之后还要配置一下才可以用作代理服务器。我们需要编辑配置文件,此文件一般的路径是 /etc/tinyproxy/tinyproxy.conf。 可以看到有一行

1
Port 8888

在这里可以设置代理的端口,默认是 8888。 继续向下找到如下代码:

1
Allow 127.0.0.1

这行代码表示被允许连接的主机 IP。如果希望连接任何主机,那就直接将这行代码注释即可。在这里我们选择直接注释,也就是任何主机都可以使用这台主机作为代理服务器。 修改为如下代码:

1
# Allow 127.0.0.1

设置完成之后重启 TinyProxy 即可:

1
2
systemctl enable tinyproxy.service
systemctl restart tinyproxy.service

防火墙开放该端口:

1
iptables -I INPUT -p tcp --dport 8888 -j ACCEPT

当然如果想直接关闭防火墙也可以:

1
systemctl stop firewalld.service

这样我们就完成了 TinyProxy 的配置了。

验证 TinyProxy

首先,用 ifconfig 查看当前主机的 IP。比如,当前我的主机拨号 IP 为 112.84.118.216,在其他的主机运行测试一下。 用 curl 命令设置代理请求 httpbin,检测代理是否生效。

1
curl -x 112.84.118.216:8888 httpbin.org/get

运行结果如图 9-14 所示: 图 9-14 运行结果 如果有正常的结果输出,并且 origin 的值为代理 IP 的地址,就证明 TinyProxy 配置成功了。

5. 动态获取 IP

现在可以执行命令让主机动态切换 IP,也在主机上搭建了代理服务器。我们只需要知道拨号后的 IP 就可以使用代理。 我们考虑到,在一台主机拨号切换 IP 的间隙代理是不可用的,在这拨号的几秒时间内如果有第二台主机顶替第一台主机,那就可以解决拨号间隙代理无法使用的问题了。所以我们要设计的架构必须要考虑支持多主机的问题。 假如有 10 台拨号主机同时需要维护,而爬虫需要使用这 10 台主机的代理,那么在爬虫端维护的开销是非常大的。如果爬虫在不同的机器上运行,那么每个爬虫必须要获得这 10 台拨号主机的配置,这显然是不理想的。 为了更加方便地使用代理,我们可以像上文的代理池一样定义一个统一的代理接口,爬虫端只需要配置代理接口即可获取可用代理。要搭建一个接口,就势必需要一台服务器,而接口的数据从哪里获得呢,当然最理想的还是选择数据库。 比如我们需要同时维护 10 台拨号主机,每台拨号主机都会定时拨号,那这样每台主机在某个时刻可用的代理只有一个,所以我们没有必要存储之前的拨号代理,因为重新拨号之后之前的代理已经不能用了,所以只需要将之前的代理更新其内容就好了。数据库要做的就是定时对每台主机的代理进行更新,而更新时又需要拨号主机的唯一标识,根据主机标识查出这条数据,然后将这条数据对应的代理更新。 所以数据库端就需要存储一个主机标识到代理的映射关系。那么很自然地我们就会想到关系型数据库,如 MySQL 或者 Redis 的 Hash 存储,只需存储一个映射关系,不需要很多字段,而且 Redis 比 MySQL 效率更高、使用更方便,所以最终选定的存储方式就是 Redis 的 Hash。

6. 存储模块

那么接下来我们要做可被远程访问的 Redis 数据库,各个拨号机器只需要将各自的主机标识和当前 IP 和端口(也就是代理)发送给数据库就好了。 先定义一个操作 Redis 数据库的类,示例如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import redis
import random

# Redis 数据库 IP
REDIS_HOST = 'remoteaddress'
# Redis 数据库密码,如无则填 None
REDIS_PASSWORD = 'foobared'
# Redis 数据库端口
REDIS_PORT = 6379
# 代理池键名
PROXY_KEY = 'adsl'

class RedisClient(object):
def __init__(self, host=REDIS_HOST, port=REDIS_PORT, password=REDIS_PASSWORD, proxy_key=PROXY_KEY):
"""
初始化 Redis 连接
:param host: Redis 地址
:param port: Redis 端口
:param password: Redis 密码
:param proxy_key: Redis 哈希表名
"""
self.db = redis.StrictRedis(host=host, port=port, password=password, decode_responses=True)
self.proxy_key = proxy_key

def set(self, name, proxy):
"""
设置代理
:param name: 主机名称
:param proxy: 代理
:return: 设置结果
"""
return self.db.hset(self.proxy_key, name, proxy)

def get(self, name):
"""
获取代理
:param name: 主机名称
:return: 代理
"""
return self.db.hget(self.proxy_key, name)

def count(self):
"""
获取代理总数
:return: 代理总数
"""
return self.db.hlen(self.proxy_key)

def remove(self, name):
"""
删除代理
:param name: 主机名称
:return: 删除结果
"""
return self.db.hdel(self.proxy_key, name)

def names(self):
"""
获取主机名称列表
:return: 获取主机名称列表
"""
return self.db.hkeys(self.proxy_key)

def proxies(self):
"""
获取代理列表
:return: 代理列表
"""
return self.db.hvals(self.proxy_key)

def random(self):
"""
随机获取代理
:return:
"""
proxies = self.proxies()
return random.choice(proxies)

def all(self):
"""
获取字典
:return:
"""return self.db.hgetall(self.proxy_key)

这里定义了一个 RedisClient 类,在init() 方法中初始化了 Redis 连接,其中 REDIS_HOST 就是远程 Redis 的地址,REDIS_PASSWORD 是密码,REDIS_PORT 是端口,PROXY_KEY 是存储代理的散列表的键名。 接下来定义了一个 set() 方法,这个方法用来向散列表添加映射关系。映射是从主机标识到代理的映射,比如一台主机的标识为 adsl1,当前的代理为 118.119.111.172:8888,那么散列表中就会存储一个 key 为 adsl1、value 为 118.119.111.172:8888 的映射,Hash 结构如图 9-15 所示。 图 9-15 Hash 结构 如果有多台主机,只需要向 Hash 中添加映射即可。 另外,get() 方法就是从散列表中取出某台主机对应的代理。remove() 方法则是从散列表中移除对应的主机的代理。还有 names()、proxies()、all() 方法则是分别获取散列表中的主机列表、代理列表及所有主机代理映射。count() 方法则是返回当前散列表的大小,也就是可用代理的数目。 最后还有一个比较重要的方法 random(),它随机从散列表中取出一个可用代理,类似前面代理池的思想,确保每个代理都能被取到。 如果要对数据库进行操作,只需要初始化 RedisClient 对象,然后调用它的 set() 或者 remove() 方法,即可对散列表进行设置和删除。

7. 拨号模块

接下来要做的就是拨号,并把新的 IP 保存到 Redis 散列表里。 首先是拨号定时,它分为定时拨号和非定时拨号两种选择。 非定时拨号:最好的方法就是向该主机发送一个信号,然后主机就启动拨号,但这样做的话,我们首先要搭建一个重新拨号的接口,如搭建一个 Web 接口,请求该接口即进行拨号,但开始拨号之后,此时主机的状态就从在线转为离线,而此时的 Web 接口也就相应失效了,拨号过程无法再连接,拨号之后接口的 IP 也变了,所以我们无法通过接口来方便地控制拨号过程和获取拨号结果,下次拨号还得改变拨号请求接口,所以非定时拨号的开销还是比较大的。 定时拨号:我们只需要在拨号主机上运行定时脚本即可,每隔一段时间拨号一次,更新 IP,然后将 IP 在 Redis 散列表中更新即可,非常简单易用,另外可以适当将拨号频率调高一点,减少短时间内 IP 被封的可能性。 在这里选择定时拨号。 接下来就是获取 IP。获取拨号后的 IP 非常简单,只需要调用 ifconfig 命令,然后解析出对应网卡的 IP 即可。 获取了 IP 之后,我们还需要进行有效性检测。拨号主机可以自己检测,比如可以利用 requests 设置自身的代理请求外网,如果成功,那么证明代理可用,然后再修改 Redis 散列表,更新代理。 需要注意,由于在拨号的间隙拨号主机是离线状态,而此时 Redis 散列表中还存留了上次的代理,一旦这个代理被取用了,该代理是无法使用的。为了避免这个情况,每台主机在拨号之前还需要将自身的代理从 Redis 散列表中移除。 这样基本的流程就理顺了,我们用如下代码实现:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
import re
import time
import requests
from requests.exceptions import ConnectionError, ReadTimeout
from db import RedisClient

# 拨号网卡
ADSL_IFNAME = 'ppp0'
# 测试 URL
TEST_URL = 'http://www.baidu.com'
# 测试超时时间
TEST_TIMEOUT = 20
# 拨号间隔
ADSL_CYCLE = 100
# 拨号出错重试间隔
ADSL_ERROR_CYCLE = 5
# ADSL 命令
ADSL_BASH = 'adsl-stop;adsl-start'
# 代理运行端口
PROXY_PORT = 8888
# 客户端唯一标识
CLIENT_NAME = 'adsl1'

class Sender():
def get_ip(self, ifname=ADSL_IFNAME):
"""
获取本机 IP
:param ifname: 网卡名称
:return:
"""
(status, output) = subprocess.getstatusoutput('ifconfig')
if status == 0:
pattern = re.compile(ifname + '.*?inet.*?(d+.d+.d+.d+).*?netmask', re.S)
result = re.search(pattern, output)
if result:
ip = result.group(1)
return ip

def test_proxy(self, proxy):
"""
测试代理
:param proxy: 代理
:return: 测试结果
"""
try:
response = requests.get(TEST_URL, proxies={
'http': 'http://' + proxy,
'https': 'https://' + proxy
}, timeout=TEST_TIMEOUT)
if response.status_code == 200:
return True
except (ConnectionError, ReadTimeout):
return False

def remove_proxy(self):
"""
移除代理
:return: None
"""
self.redis = RedisClient()
self.redis.remove(CLIENT_NAME)
print('Successfully Removed Proxy')

def set_proxy(self, proxy):
"""
设置代理
:param proxy: 代理
:return: None
"""
self.redis = RedisClient()
if self.redis.set(CLIENT_NAME, proxy):
print('Successfully Set Proxy', proxy)

def adsl(self):
"""
拨号主进程
:return: None
"""
while True:
print('ADSL Start, Remove Proxy, Please wait')
self.remove_proxy()
(status, output) = subprocess.getstatusoutput(ADSL_BASH)
if status == 0:
print('ADSL Successfully')
ip = self.get_ip()
if ip:
print('Now IP', ip)
print('Testing Proxy, Please Wait')
proxy = '{ip}:{port}'.format(ip=ip, port=PROXY_PORT)
if self.test_proxy(proxy):
print('Valid Proxy')
self.set_proxy(proxy)
print('Sleeping')
time.sleep(ADSL_CYCLE)
else:
print('Invalid Proxy')
else:
print('Get IP Failed, Re Dialing')
time.sleep(ADSL_ERROR_CYCLE)
else:
print('ADSL Failed, Please Check')
time.sleep(ADSL_ERROR_CYCLE)
def run():
sender = Sender()
sender.adsl()

在这里定义了一个 Sender 类,它的主要作用是执行定时拨号,并将新的 IP 测试通过之后更新到远程 Redis 散列表里。 主方法是 adsl() 方法,它首先是一个无限循环,循环体内就是拨号的逻辑。 adsl() 方法首先调用了 remove_proxy() 方法,将远程 Redis 散列表中本机对应的代理移除,避免拨号时本主机的残留代理被取到。 接下来利用 subprocess 模块来执行拨号脚本,拨号脚本很简单,就是 stop 之后再 start,这里将拨号的命令直接定义成了 ADSL_BASH。 随后程序又调用 get_ip() 方法,通过 subprocess 模块执行获取 IP 的命令 ifconfig,然后根据网卡名称获取了当前拨号网卡的 IP 地址,即拨号后的 IP。 再接下来就需要测试代理有效性了。程序首先调用了 test_proxy() 方法,将自身的代理设置好,使用 requests 库来用代理连接 TEST_URL。在此 TEST_URL 设置为百度,如果请求成功,则证明代理有效。 如果代理有效,再调用 set_proxy() 方法将 Redis 散列表中本机对应的代理更新,设置时需要指定本机唯一标识和本机当前代理。本机唯一标识可随意配置,其对应的变量为 CLIENT_NAME,保证各台拨号主机不冲突即可。本机当前代理则由拨号后的新 IP 加端口组合而成。通过调用 RedisClient 的 set() 方法,参数 name 为本机唯一标识,proxy 为拨号后的新代理,执行之后便可以更新散列表中的本机代理了。 建议至少配置两台主机,这样在一台主机的拨号间隙还有另一台主机的代理可用。拨号主机的数量不限,越多越好。 在拨号主机上执行拨号脚本,示例输出如图 9-16 所示。 图 9-16 示例输出 首先移除了代理,再进行拨号,拨号完成之后获取新的 IP,代理检测成功之后就设置到 Redis 散列表中,然后等待一段时间再重新进行拨号。 我们添加了多台拨号主机,这样就有多个稳定的定时更新的代理可用了。Redis 散列表会实时更新各台拨号主机的代理,如图 9-17 所示。 图 9-17 Hash 结构 图中所示是四台 ADSL 拨号主机配置并运行后的散列表的内容,表中的代理都是可用的。

8. 接口模块

目前为止,我们已经成功实时更新拨号主机的代理。不过还缺少一个模块,那就是接口模块。像之前的代理池一样,我们也定义一些接口来获取代理,如 random 获取随机代理、count 获取代理个数等。 我们选用 Tornado 来实现,利用 Tornado 的 Server 模块搭建 Web 接口服务,示例如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
import json
import tornado.ioloop
import tornado.web
from tornado.web import RequestHandler, Application

# API 端口
API_PORT = 8000

class MainHandler(RequestHandler):
def initialize(self, redis):
self.redis = redis

def get(self, api=''):
if not api:
links = ['random', 'proxies', 'names', 'all', 'count']
self.write('<h4>Welcome to ADSL Proxy API</h4>')
for link in links:
self.write('<a href=' + link + '>' + link + '</a><br>')

if api == 'random':
result = self.redis.random()
if result:
self.write(result)

if api == 'names':
result = self.redis.names()
if result:
self.write(json.dumps(result))

if api == 'proxies':
result = self.redis.proxies()
if result:
self.write(json.dumps(result))

if api == 'all':
result = self.redis.all()
if result:
self.write(json.dumps(result))

if api == 'count':
self.write(str(self.redis.count()))

def server(redis, port=API_PORT, address=''):
application = Application([(r'/', MainHandler, dict(redis=redis)),
(r'/(.*)', MainHandler, dict(redis=redis)),
])
application.listen(port, address=address)
print('ADSL API Listening on', port)
tornado.ioloop.IOLoop.instance().start()

这里定义了 5 个接口,random 获取随机代理,names 获取主机列表,proxies 获取代理列表,all 获取代理映射,count 获取代理数量。 程序启动之后便会在 API_PORT 端口上运行 Web 服务,主页面如图 9-18 所示。 图 9-18 主页面 访问 proxies 接口可以获得所有代理列表,如图 9-19 所示。 图 9-19 代理列表 访问 random 接口可以获取随机可用代理,如图 9-20 所示。 图 9-20 随机代理 我们只需将接口部署到服务器上,即可通过 Web 接口获取可用代理,获取方式和代理池类似。

9. 本节代码

本节代码地址为:https://github.com/Python3WebSpider/AdslProxy

10. 结语

本节介绍了 ADSL 拨号代理的搭建过程。通过这种代理,我们可以无限次更换 IP,而且线路非常稳定,抓取效果好很多。

技术杂谈

爬虫是大数据时代不可或缺的数据获取手段,它是综合技术的应用体现。

​有取就有失,有攻就有防。开发者为了保护数据,不得已想出了很多办法来限制爬虫对数据的获取。WEB 网站的构成使得 JavaScript 成为了开发者阻挡爬虫的最佳选择。

作为一名爬虫工程师,解决目标网站设置的反爬虫手段是职责所在。大家遇到的问题都很相似:

1、遇到加密的内容就无从下手,一片迷茫……!

2、会一点 JS 语法,能解一些简单的,但复杂的就不行了!

3、抠代码太繁杂了,根本不知道怎么办,一早上都定位不到函数入口!

4、混淆过后的代码,看得头都痛!

5、咦,这串加密的字符串怎么搞?

需求又如何呢?

爬虫工程师真的需要学习逆向吗?

在此之前我们在多个爬虫工程师群做了调查,投票结果如下:

在招聘方面

很多岗位都要求有逆向或者解决反爬虫的能力 甚至作为优先选择的条件

显然,拥有逆向能力的爬虫工程师的职业等级会变得更高、团队地位更高,薪资自然也更高。

本课程将主要从原理和技巧两个角度来为大家讲解 JavaScript 反爬虫绕过的相关知识。课程从反爬虫原理、工具介绍和使用、JavaScript 基础语法入手,结合常见的反爬虫现象及其绕过实战操作,帮助你掌握中级爬虫工程师必备的 JavaScript 逆向知识,向更高的职级迈进!

你将从本课程中收获什么?

序号

内容

重要程度

1

深入理解 JavaScript 反爬虫的根本原因

A+

2

了解工作中常用的 JavaScript 语法和知识

B

3

掌握各种逆向神器的基本使用和骚操作

A

4

深入理解 JavaScript 代码混淆的原理

A+

5

掌握 JavaScript 中常见的编码和加密方法

A

6

拥有快速定位加密代码位置的能力

A

7

轻松面对各种各样的加密字符串

A

学习案例的制作思路均来自实际网站在用的反爬虫手段,当你学习完整套课程后就可以独立面对前端反爬虫问题,平时的苦恼也将迎刃而解。

课程大纲设计

序号

标签

课程标题

1

追根究底

探寻 JavaScript 反爬虫的根本原因

2

浮沙之上

课程中用到的 JavaScript 语法和知识

3

奇门遁甲

使用 Python 执行 JavaScript

4

蓄势待发

浏览器开发者工具的介绍和使用技巧

5

磨刀霍霍

抓包和拦截工具的介绍和使用技巧

6

初窥门径

阻挠爬虫工程师的无限 debug

7

火眼金睛

定位加密参数对应代码位置的方法

8

拨开云雾

代码混淆的原理

9

一击即中

处理代码混淆的方法

10

知己知彼

掌握常见的编码和加密

11

长枪直入

轻松解决反人类的混淆代码

12

一叶障目

服务端返回的神秘字符串

13

螳臂当车

解密!AES 并不是每次都奏效

14

插翅难逃

纵然 CSS 加身也难逃命运的安排

15

真假猴王

Base64 竟有如此威力

16

过眼云烟

历练半生 归来仍是少年

备注:具体开课时的目录有可能与现在的大纲存在差异,但改动不大。 这课程大纲预售放出来,我们都不怕别的机构抄,随便它们模仿。

课程特色和内容制作团队介绍

自研练习平台,不触碰法律红线、练习案例不会过期。

我们没有xx顶级讲师,也没有国外xx计算机硕士博士,不存在的。

我们只有一线爬虫工程师,讲最实用的内容,做最有效的练习。团队成员包括:崔庆才、韦世东、陈祥安、张冶青、唐轶飞、蔡晋、冯威、戴煌金、周子淇。

不像在线课平台,加群后讲师根本没空回答问题。我们会持续跟进与交流,制作良心内容,恶心营销狗?干的事我们才不会干。

团队成员有图书出版经历,例如崔庆才的 IT 畅销书《Python3 网络爬虫开发实战》、韦世东即将出版的《Python3 反爬虫原理与绕过实战》。

团队水平如何请大家自行斟酌,这里我就不吹嘘什么了。

预售活动

课程在准备当中,现在开放预售。完整课程售价 399,预售 50 元抵正式课程 100 元,且可提前进入视频教程的微信交流群,甚至可以提出想看的内容,团队会酌情考虑加课。

预售目标为 1000 人,不足 1000 人预售取消,逐个退款。

预售成功后,开课之前可以申请退课退款,支持全额退款。

参与预售的朋友还可以参与开课前的营销活动。

未参与预售的朋友,只能在开课时按原价或活动价购买课程。

预售活动截止日期为 2019年10月31日。

开课时间

课程在准备当中,预计 2 个月左右可看,最迟 2020年01月20日 你就能看到了!

不过可以肯定的是,报名人数越多,内容制作越快。

如何报名

添加微信号:Domfreez,或者扫描下方二维码,与夜幕韦世东聊一聊。 我为粉丝争取到了额外的 50 元优惠,预售期间内主动出示优惠码:GERMEY01 即可在活动基础上再减 50 元! 相信我没错的,现在你只需要花 50 元预订,399 元的课程就抵扣了 150,正式开售的时候只需要再付 249 即可学习,从此前端反爬虫不再是烦恼! 声明: 本次活动最终解释权归内容制作方夜幕团队所有。

技术杂谈

本文为转载文章,旨在记录一些有用的知识点。

  • 作者: JSON-RPC 工作组< json-rpc@googlegroups.com >
  • 原文链接: http://www.jsonrpc.org/specification
  • 翻译: leozvc < xxfs91@gmail.com >

1. 概述

JSON-RPC 是一个无状态且轻量级的远程过程调用 (RPC) 协议。 本规范主要定义了一些数据结构及其相关的处理规则。它允许运行在基于 socket, http 等诸多不同消息传输环境的同一进程中。其使用 JSONRFC 4627)作为数据格式。 它为简单而生!

2. 约定

文档中关键字 “MUST”、”MUST NOT”、”REQUIRED”、”SHALL”、”SHALL NOT”、”SHOULD”、”SHOULD NOT”、”RECOMMENDED”、”MAY” 和 “OPTIONAL” 将在 RFC 2119 中得到详细的解释及描述。 由于 JSON-RPC 使用 JSON,它具有与其相同的类型系统 (见 http://www.json.orgRFC 4627)。JSON 可以表示四个基本类型 (String、Numbers、Booleans 和 Null) 和两个结构化类型 (Objects 和 Arrays)。 规范中,术语 “Primitive” 标记那 4 种原始类型,“Structured” 标记两种结构化类型。任何时候文档涉及 JSON 数据类型,第一个字母都必须大写:Object,Array,String,Number,Boolean,Null。包括 True 和 False 也要大写。 在客户端与任何被匹配到的服务端之间交换的所有成员名字应是区分大小写的。 函数、方法、过程都可以认为是可以互换的。 客户端被定义为请求对象的来源及响应对象的处理程序。 服务端被定义为响应对象的起源和请求对象的处理程序。 该规范的一种实现为可以轻而易举的填补这两个角色,即使是在同一时间,同一客户端或其他不相同的客户端。 该规范不涉及复杂层。

3. 兼容性

JSON-RPC 2.0 的请求对象和响应对象可能无法在现用的 JSON-RPC 1.0 客户端或服务端工作,然而我们可以很容易在两个版本间区分出 2.0,总会包含一个成员命名为 “jsonrpc” 且值为 “2.0”, 而 1.0 版本是不包含的。大部分的 2.0 实现应该考虑尝试处理 1.0 的对象,即使不是对等的也应给其相关提示。

4. 请求对象

发送一个请求对象至服务端代表一个 rpc 调用, 一个请求对象包含下列成员: jsonrpc

指定 JSON-RPC 协议版本的字符串,必须准确写为 “2.0”

method

包含所要调用方法名称的字符串,以 rpc 开头的方法名,用英文句号(U+002E or ASCII 46)连接的为预留给 rpc 内部的方法名及扩展名,且不能在其他地方使用。

params

调用方法所需要的结构化参数值,该成员参数可以被省略。

id

已建立客户端的唯一标识 id,值必须包含一个字符串、数值或 NULL 空值。如果不包含该成员则被认定为是一个通知。该值一般不为 NULL [1],若为数值则不应该包含小数 [2]

服务端必须回答相同的值如果包含在响应对象。 这个成员用来两个对象之间的关联上下文。 [1] 在请求对象中不建议使用 NULL 作为 id 值,因为该规范将使用空值认定为未知 id 的请求。另外,由于 JSON-RPC 1.0 的通知使用了空值,这可能引起处理上的混淆。 [2] 使用小数是不确定性的,因为许多十进制小数不能精准的表达为二进制小数。

4.1 通知

没有包含 “id” 成员的请求对象为通知, 作为通知的请求对象表明客户端对相应的响应对象并不感兴趣,本身也没有响应对象需要返回给客户端。服务端必须不回复一个通知,包含那些批量请求中的。 由于通知没有返回的响应对象,所以通知不确定是否被定义。同样,客户端不会意识到任何错误(例如参数缺省,内部错误)。

4.2 参数结构

rpc 调用如果存在参数则必须为基本类型或结构化类型的参数值,要么为索引数组,要么为关联数组对象。

  • 索引:参数必须为数组,并包含与服务端预期顺序一致的参数值。
  • 关联名称:参数必须为对象,并包含与服务端相匹配的参数成员名称。没有在预期中的成员名称可能会引起错误。名称必须完全匹配,包括方法的预期参数名以及大小写。

5. 响应对象

当发起一个 rpc 调用时,除通知之外,服务端都必须回复响应。响应表示为一个 JSON 对象,使用以下成员: jsonrpc

指定 JSON-RPC 协议版本的字符串,必须准确写为 “2.0”

result

该成员在成功时必须包含。 当调用方法引起错误时必须不包含该成员。 服务端中的被调用方法决定了该成员的值。

error

该成员在失败是必须包含。 当没有引起错误的时必须不包含该成员。 该成员参数值必须为 5.1 中定义的对象。

id

该成员必须包含。 该成员值必须于请求对象中的 id 成员值一致。 若在检查请求对象 id 时错误(例如参数错误或无效请求),则该值必须为空值。

响应对象必须包含 result 或 error 成员,但两个成员必须不能同时包含。

5.1 错误对象

当一个 rpc 调用遇到错误时,返回的响应对象必须包含错误成员参数,并且为带有下列成员参数的对象: code

使用数值表示该异常的错误类型。 必须为整数。

message

对该错误的简单描述字符串。 该描述应尽量限定在简短的一句话。

data

包含关于错误附加信息的基本类型或结构化类型。该成员可忽略。 该成员值由服务端定义(例如详细的错误信息,嵌套的错误等)。

-32768 至 - 32000 为保留的预定义错误代码。在该范围内的错误代码不能被明确定义,保留下列以供将来使用。错误代码基本与 XML-RPC 建议的一样,url: http://xmlrpc-epi.sourceforge.net/specs/rfc.fault_codes.php

code

message

meaning

-32700

Parse error 语法解析错误

服务端接收到无效的 json。该错误发送于服务器尝试解析 json 文本

-32600

Invalid Request 无效请求

发送的 json 不是一个有效的请求对象。

-32601

Method not found 找不到方法

该方法不存在或无效

-32602

Invalid params 无效的参数

无效的方法参数。

-32603

Internal error 内部错误

JSON-RPC 内部错误。

-32000 to -32099

Server error 服务端错误

预留用于自定义的服务器错误。

除此之外剩余的错误类型代码可供应用程序作为自定义错误。

6. 批量调用

当需要同时发送多个请求对象时,客户端可以发送一个包含所有请求对象的数组。 当批量调用的所有请求对象处理完成时,服务端则需要返回一个包含相对应的响应对象数组。每个响应对象都应对应每个请求对象,除非是通知的请求对象。服务端可以并发的,以任意顺序和任意宽度的并行性来处理这些批量调用。 这些相应的响应对象可以任意顺序的包含在返回的数组中,而客户端应该是基于各个响应对象中的 id 成员来匹配对应的请求对象。 若批量调用的 rpc 操作本身非一个有效 json 或一个至少包含一个值的数组,则服务端返回的将单单是一个响应对象而非数组。若批量调用没有需要返回的响应对象,则服务端不需要返回任何结果且必须不能返回一个空数组给客户端。

7. 示例

语法:

--> data sent to Server data sent to Client

带索引数组参数的rpc调用:

1
2
3
4
5
\--> {"jsonrpc": "2.0", "method": "subtract", "params": [42, 23], "id": 1}
{"jsonrpc": "2.0", "result": 19, "id": 1}

--> {"jsonrpc": "2.0", "method": "subtract", "params": [23, 42], "id": 2}
{"jsonrpc": "2.0", "result": -19, "id": 2}

带关联数组参数的rpc调用:

1
2
3
4
5
\--> {"jsonrpc": "2.0", "method": "subtract", "params": {"subtrahend": 23, "minuend": 42}, "id": 3}
{"jsonrpc": "2.0", "result": 19, "id": 3}

--> {"jsonrpc": "2.0", "method": "subtract", "params": {"minuend": 42, "subtrahend": 23}, "id": 4}
{"jsonrpc": "2.0", "result": 19, "id": 4}

通知:

1
2
\--> {"jsonrpc": "2.0", "method": "update", "params": [1,2,3,4,5]}
--> {"jsonrpc": "2.0", "method": "foobar"}

不包含调用方法的rpc调用:

1
2
\--> {"jsonrpc": "2.0", "method": "foobar", "id": "1"}
{"jsonrpc": "2.0", "error": {"code": -32601, "message": "Method not found"}, "id": "1"}

包含无效json的rpc调用:

1
2
\--> {"jsonrpc": "2.0", "method": "foobar, "params": "bar", "baz]
{"jsonrpc": "2.0", "error": {"code": -32700, "message": "Parse error"}, "id": null}

包含无效请求对象的rpc调用:

1
2
\--> {"jsonrpc": "2.0", "method": 1, "params": "bar"}
{"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request"}, "id": null}

包含无效json的rpc批量调用:

1
2
3
4
5
\--> [
{"jsonrpc": "2.0", "method": "sum", "params": [1,2,4], "id": "1"},
{"jsonrpc": "2.0", "method"
]
{"jsonrpc": "2.0", "error": {"code": -32700, "message": "Parse error"}, "id": null}

包含空数组的rpc调用:

1
2
\--> []
{"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request"}, "id": null}

非空且无效的rpc批量调用:

1
2
3
4
\--> [1]
[
{"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request"}, "id": null}
]

无效的rpc批量调用:

1
2
3
4
5
6
\--> [1,2,3]
[
{"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request"}, "id": null},
{"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request"}, "id": null},
{"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request"}, "id": null}
]

rpc批量调用:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
\--> [
{"jsonrpc": "2.0", "method": "sum", "params": [1,2,4], "id": "1"},
{"jsonrpc": "2.0", "method": "notify_hello", "params": [7]},
{"jsonrpc": "2.0", "method": "subtract", "params": [42,23], "id": "2"},
{"foo": "boo"},
{"jsonrpc": "2.0", "method": "foo.get", "params": {"name": "myself"}, "id": "5"},
{"jsonrpc": "2.0", "method": "get_data", "id": "9"}
]
[
{"jsonrpc": "2.0", "result": 7, "id": "1"},
{"jsonrpc": "2.0", "result": 19, "id": "2"},
{"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request"}, "id": null},
{"jsonrpc": "2.0", "error": {"code": -32601, "message": "Method not found"}, "id": "5"},
{"jsonrpc": "2.0", "result": ["hello", 5], "id": "9"}
]

所有都为通知的rpc批量调用:

1
2
3
4
5
6
\--> [
{"jsonrpc": "2.0", "method": "notify_sum", "params": [1,2,4]},
{"jsonrpc": "2.0", "method": "notify_hello", "params": [7]}
]

//Nothing is returned for all notification batches

8. 扩展

以 rpc 开头的方法名预留作为系统扩展,且必须不能用于其他地方。每个系统扩展都应该有相关规范文档,所有系统扩展都应是可选的。

技术杂谈

在 Python 中,一般情况下我们可能直接用自带的 logging 模块来记录日志,包括我之前的时候也是一样。在使用时我们需要配置一些 Handler、Formatter 来进行一些处理,比如把日志输出到不同的位置,或者设置一个不同的输出格式,或者设置日志分块和备份。但其实个人感觉 logging 用起来其实并不是那么好用,其实主要还是配置较为繁琐。

常见使用

首先看看 logging 常见的解决方案吧,我一般会配置输出到文件、控制台和 Elasticsearch。输出到控制台就仅仅是方便直接查看的;输出到文件是方便直接存储,保留所有历史记录的备份;输出到 Elasticsearch,直接将 Elasticsearch 作为存储和分析的中心,使用 Kibana 可以非常方便地分析和查看运行情况。 所以在这里我基本会对 logging 做如下的封装写法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
import logging
import sys
from os import makedirs
from os.path import dirname, exists

from cmreslogging.handlers import CMRESHandler

loggers = {}

LOG_ENABLED = True # 是否开启日志
LOG_TO_CONSOLE = True # 是否输出到控制台
LOG_TO_FILE = True # 是否输出到文件
LOG_TO_ES = True # 是否输出到 Elasticsearch

LOG_PATH = './runtime.log' # 日志文件路径
LOG_LEVEL = 'DEBUG' # 日志级别
LOG_FORMAT = '%(levelname)s - %(asctime)s - process: %(process)d - %(filename)s - %(name)s - %(lineno)d - %(module)s - %(message)s' # 每条日志输出格式
ELASTIC_SEARCH_HOST = 'eshost' # Elasticsearch Host
ELASTIC_SEARCH_PORT = 9200 # Elasticsearch Port
ELASTIC_SEARCH_INDEX = 'runtime' # Elasticsearch Index Name
APP_ENVIRONMENT = 'dev' # 运行环境,如测试环境还是生产环境

def get_logger(name=None):
"""
get logger by name
:param name: name of logger
:return: logger
"""
global loggers

if not name: name = __name__

if loggers.get(name):
return loggers.get(name)

logger = logging.getLogger(name)
logger.setLevel(LOG_LEVEL)

# 输出到控制台
if LOG_ENABLED and LOG_TO_CONSOLE:
stream_handler = logging.StreamHandler(sys.stdout)
stream_handler.setLevel(level=LOG_LEVEL)
formatter = logging.Formatter(LOG_FORMAT)
stream_handler.setFormatter(formatter)
logger.addHandler(stream_handler)

# 输出到文件
if LOG_ENABLED and LOG_TO_FILE:
# 如果路径不存在,创建日志文件文件夹
log_dir = dirname(log_path)
if not exists(log_dir): makedirs(log_dir)
# 添加 FileHandler
file_handler = logging.FileHandler(log_path, encoding='utf-8')
file_handler.setLevel(level=LOG_LEVEL)
formatter = logging.Formatter(LOG_FORMAT)
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)

# 输出到 Elasticsearch
if LOG_ENABLED and LOG_TO_ES:
# 添加 CMRESHandler
es_handler = CMRESHandler(hosts=[{'host': ELASTIC_SEARCH_HOST, 'port': ELASTIC_SEARCH_PORT}],
# 可以配置对应的认证权限
auth_type=CMRESHandler.AuthType.NO_AUTH,
es_index_name=ELASTIC_SEARCH_INDEX,
# 一个月分一个 Index
index_name_frequency=CMRESHandler.IndexNameFrequency.MONTHLY,
# 额外增加环境标识
es_additional_fields={'environment': APP_ENVIRONMENT}
)
es_handler.setLevel(level=LOG_LEVEL)
formatter = logging.Formatter(LOG_FORMAT)
es_handler.setFormatter(formatter)
logger.addHandler(es_handler)

# 保存到全局 loggers
loggers[name] = logger
return logger

定义完了怎么使用呢?只需要使用定义的方法获取一个 logger,然后 log 对应的内容即可:

1
2
logger = get_logger()
logger.debug('this is a message')

运行结果如下:

1
DEBUG - 2019-10-11 22:27:35,923 - process: 99490 - logger.py - __main__ - 81 - logger - this is a message

我们看看这个定义的基本实现吧。首先这里一些常量是用来定义 logging 模块的一些基本属性的,比如 LOG_ENABLED 代表是否开启日志功能,LOG_TO_ES 代表是否将日志输出到 Elasticsearch,另外还有很多其他的日志基本配置,如 LOG_FORMAT 配置了日志每个条目输出的基本格式,另外还有一些连接的必要信息。这些变量可以和运行时的命令行或环境变量对接起来,可以方便地实现一些开关和配置的更换。 然后定义了这么一个 get_logger 方法,接收一个参数 name。首先该方法拿到 name 之后,会到全局的 loggers 变量里面查找,loggers 变量是一个全局字典,如果有已经声明过的 logger,直接将其获取返回即可,不用再将其二次初始化。如果 loggers 里面没有找到 name 对应的 logger,那就进行创建即可。创建 logger 之后,可以为其添加各种对应的 Handler,如输出到控制台就用 StreamHandler,输出到文件就用 FileHandler 或 RotatingFileHandler,输出到 Elasticsearch 就用 CMRESHandler,分别配置好对应的信息即可。 最后呢,将新建的 logger 保存到全局的 loggers 里面并返回即可,这样如果有同名的 logger 便可以直接查找 loggers 直接返回了。 在这里依赖了额外的输出到 Elasticsearch 的包,叫做 CMRESHandler,它可以支持将日志输出到 Elasticsearch 里面,如果要使用的话可以安装一下:

1
pip install CMRESHandler

其 GitHub 地址是:https://github.com/cmanaha/python-elasticsearch-logger,具体的使用方式可以看看它的官方说明,如配置认证信息,配置 Index 分隔信息等等。 好,上面就是我之前常用的 logging 配置,通过如上的配置,我就可以实现将 logging 输出到三个位置,并可以实现对应的效果。比如输出到 Elasticsearch 之后,我就可以非常方便地使用 Kibana 来查看当前运行情况,ERROR Log 的比例等等,如图所示: 也可以在它的基础上做更进一步的统计分析。

loguru

上面的实现方式已经是一个较为可行的配置方案了。然而,我还是会感觉到有些 Handler 配起来麻烦,尤其是新建一个项目的很多时候懒得去写一些配置。即使是不用上文的配置,用最基本的几行 logging 配置,像如下的通用配置:

1
2
3
import logging
logging.basicConfig(level = logging.INFO,format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

我也懒得去写,感觉并不是一个优雅的实现方式。 有需求就有动力啊,这不,就有人实现了这么一个库,叫做 loguru,可以将 log 的配置和使用更加简单和方便。 下面我们来看看它到底是怎么用的吧。

安装

首先,这个库的安装方式很简单,就用基本的 pip 安装即可,Python 3 版本的安装如下:

1
pip3 install loguru

安装完毕之后,我们就可以在项目里使用这个 loguru 库了。

基本使用

那么这个库怎么来用呢?我们先用一个实例感受下:

1
2
3
from loguru import logger

logger.debug('this is a debug message')

看到了吧,不需要配置什么东西,直接引入一个 logger,然后调用其 debug 方法即可。 在 loguru 里面有且仅有一个主要对象,那就是 logger,loguru 里面有且仅有一个 logger,而且它已经被提前配置了一些基础信息,比如比较友好的格式化、文本颜色信息等等。 上面的代码运行结果如下:

1
2019-10-13 22:46:12.367 | DEBUG    | __main__:<module>:4 - this is a debug message

可以看到其默认的输出格式是上面的内容,有时间、级别、模块名、行号以及日志信息,不需要手动创建 logger,直接使用即可,另外其输出还是彩色的,看起来会更加友好。 以上的日志信息是直接输出到控制台的,并没有输出到其他的地方,如果想要输出到其他的位置,比如存为文件,我们只需要使用一行代码声明即可。 例如将结果同时输出到一个 runtime.log 文件里面,可以这么写:

1
2
3
4
from loguru import logger

logger.add('runtime.log')
logger.debug('this is a debug')

很简单吧,我们也不需要再声明一个 FileHandler 了,就一行 add 语句搞定,运行之后会发现目录下 runtime.log 里面同样出现了刚刚控制台输出的 DEBUG 信息。 上面就是一些基本的使用,但这还远远不够,下面我们来详细了解下它的一些功能模块。

详细使用

既然是日志,那么最常见的就是输出到文件了。loguru 对输出到文件的配置有非常强大的支持,比如支持输出到多个文件,分级别分别输出,过大创建新文件,过久自动删除等等。 下面我们分别看看这些怎样来实现,这里基本上就是 add 方法的使用介绍。因为这个 add 方法就相当于给 logger 添加了一个 Handler,它给我们暴露了许多参数来实现 Handler 的配置,下面我们来详细介绍下。 首先看看它的方法定义吧:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def add(
self,
sink,
*,
level=_defaults.LOGURU_LEVEL,
format=_defaults.LOGURU_FORMAT,
filter=_defaults.LOGURU_FILTER,
colorize=_defaults.LOGURU_COLORIZE,
serialize=_defaults.LOGURU_SERIALIZE,
backtrace=_defaults.LOGURU_BACKTRACE,
diagnose=_defaults.LOGURU_DIAGNOSE,
enqueue=_defaults.LOGURU_ENQUEUE,
catch=_defaults.LOGURU_CATCH,
**kwargs
):
pass

看看它的源代码,它支持这么多的参数,如 level、format、filter、color 等等,另外我们还注意到它有个非常重要的参数 sink,我们看看官方文档:https://loguru.readthedocs.io/en/stable/api/logger.html#sink,可以了解到通过 sink 我们可以传入多种不同的数据结构,汇总如下:

  • sink 可以传入一个 file 对象,例如 sys.stderr 或者 open('file.log', 'w') 都可以。
  • sink 可以直接传入一个 str 字符串或者 pathlib.Path 对象,其实就是代表文件路径的,如果识别到是这种类型,它会自动创建对应路径的日志文件并将日志输出进去。
  • sink 可以是一个方法,可以自行定义输出实现。
  • sink 可以是一个 logging 模块的 Handler,比如 FileHandler、StreamHandler 等等,或者上文中我们提到的 CMRESHandler 照样也是可以的,这样就可以实现自定义 Handler 的配置。
  • sink 还可以是一个自定义的类,具体的实现规范可以参见官方文档。

所以说,刚才我们所演示的输出到文件,仅仅给它传了一个 str 字符串路径,他就给我们创建了一个日志文件,就是这个原理。

基本参数

下面我们再了解下它的其他参数,例如 format、filter、level 等等。 其实它们的概念和格式和 logging 模块都是基本一样的了,例如这里使用 format、filter、level 来规定输出的格式:

1
logger.add('runtime.log', format="{time} {level} {message}", filter="my_module", level="INFO")

删除 sink

另外添加 sink 之后我们也可以对其进行删除,相当于重新刷新并写入新的内容。 删除的时候根据刚刚 add 方法返回的 id 进行删除即可,看下面的例子:

1
2
3
4
5
6
from loguru import logger

trace = logger.add('runtime.log')
logger.debug('this is a debug message')
logger.remove(trace)
logger.debug('this is another debug message')

看这里,我们首先 add 了一个 sink,然后获取它的返回值,赋值为 trace。随后输出了一条日志,然后将 trace 变量传给 remove 方法,再次输出一条日志,看看结果是怎样的。 控制台输出如下:

1
2
2019-10-13 23:18:26.469 | DEBUG    | __main__:<module>:4 - this is a debug message
2019-10-13 23:18:26.469 | DEBUG | __main__:<module>:6 - this is another debug message

日志文件 runtime.log 内容如下:

1
2019-10-13 23:18:26.469 | DEBUG    | __main__:<module>:4 - this is a debug message

可以发现,在调用 remove 方法之后,确实将历史 log 删除了。但实际上这并不是删除,只不过是将 sink 对象移除之后,在这之前的内容不会再输出到日志中。 这样我们就可以实现日志的刷新重新写入操作。

rotation 配置

用了 loguru 我们还可以非常方便地使用 rotation 配置,比如我们想一天输出一个日志文件,或者文件太大了自动分隔日志文件,我们可以直接使用 add 方法的 rotation 参数进行配置。 我们看看下面的例子:

1
logger.add('runtime_{time}.log', rotation="500 MB")

通过这样的配置我们就可以实现每 500MB 存储一个文件,每个 log 文件过大就会新创建一个 log 文件。我们在配置 log 名字时加上了一个 time 占位符,这样在生成时可以自动将时间替换进去,生成一个文件名包含时间的 log 文件。 另外我们也可以使用 rotation 参数实现定时创建 log 文件,例如:

1
logger.add('runtime_{time}.log', rotation='00:00')

这样就可以实现每天 0 点新创建一个 log 文件输出了。 另外我们也可以配置 log 文件的循环时间,比如每隔一周创建一个 log 文件,写法如下:

1
logger.add('runtime_{time}.log', rotation='1 week')

这样我们就可以实现一周创建一个 log 文件了。

retention 配置

很多情况下,一些非常久远的 log 对我们来说并没有什么用处了,它白白占据了一些存储空间,不清除掉就会非常浪费。retention 这个参数可以配置日志的最长保留时间。 比如我们想要设置日志文件最长保留 10 天,可以这么来配置:

1
logger.add('runtime.log', retention='10 days')

这样 log 文件里面就会保留最新 10 天的 log,妈妈再也不用担心 log 沉积的问题啦。

compression 配置

loguru 还可以配置文件的压缩格式,比如使用 zip 文件格式保存,示例如下:

1
logger.add('runtime.log', compression='zip')

这样可以更加节省存储空间。

字符串格式化

loguru 在输出 log 的时候还提供了非常友好的字符串格式化功能,像这样:

1
logger.info('If you are using Python {}, prefer {feature} of course!', 3.6, feature='f-strings')

这样在添加参数就非常方便了。

Traceback 记录

在很多情况下,如果遇到运行错误,而我们在打印输出 log 的时候万一不小心没有配置好 Traceback 的输出,很有可能我们就没法追踪错误所在了。 但用了 loguru 之后,我们用它提供的装饰器就可以直接进行 Traceback 的记录,类似这样的配置即可:

1
2
3
4
@logger.catch
def my_function(x, y, z):
# An error? It's caught anyway!
return 1 / (x + y + z)

我们做个测试,我们在调用时三个参数都传入 0,直接引发除以 0 的错误,看看会出现什么情况:

1
my_function(0, 0, 0)

运行完毕之后,可以发现 log 里面就出现了 Traceback 信息,而且给我们输出了当时的变量值,真的是不能再赞了!结果如下:

1
2
3
4
5
6
7
8
9
10
11
\> File "run.py", line 15, in <module>
my_function(0, 0, 0)
<function my_function at 0x1171dd510>

File "/private/var/py/logurutest/demo5.py", line 13, in my_function
return 1 / (x + y + z)
0
0
0

ZeroDivisionError: division by zero

因此,用 loguru 可以非常方便地实现日志追踪,debug 效率可能要高上十倍了? 另外 loguru 还有很多很多强大的功能,这里就不再一一展开讲解了,更多的内容大家可以看看 loguru 的官方文档详细了解一下:https://loguru.readthedocs.io/en/stable/index.html。 看完之后,是时候把自己的 logging 模块替换成 loguru 啦!

JavaScript

在夜幕读者群和算法反爬虫群的朋友都知道,我的新书《Python3 反爬虫原理与绕过实战》很快就要印刷出版了。 出版社的小姐姐们为本书设计了很多款封面

但目前暂未选定封面

之前我也有放出大章目录和配套代码,但详细目录和最新进展一直没机会公开。配套代码放在 GitHub 仓库,大章目录也在。 这次将详细目录呈现给大家。请大家先阅读《Python3 反爬虫原理与绕过实战》的内容提要

本书描述了爬虫技术与反爬虫技术的对抗过程,并详细介绍了这其中的原理和具体实现方法。首先讲 解开发环境的配置、Web 网站的构成、页面渲染以及动态网页和静态网页对爬虫造成的影响。然后介绍了 不同类型的反爬虫原理、具体实现和绕过方法,另外还涉及常见验证码的实现过程,并使用深度学习技术 完成了验证。最后介绍了常见的编码和加密原理、JavaScript 代码混淆知识、前端禁止事件以及与爬虫相 关的法律知识和风险点。 本书既适合需要储备反爬虫知识的前端工程师和后端工程师,也适合需要储备绕过知识的爬虫工程师、 爬虫爱好者以及 Python 程序员。

作者是谁

这本书谁写的?靠不靠谱呢? 这个靓仔就是我,韦世东。 作者韦世东是资深爬虫工程师,2019年华为云认证云享专家、掘金社区优秀作者、GitChat认证作者、搜狐产品技术约稿作者、夜幕团队成员。拥有七年互联网从业经验,擅长反爬虫的设计和绕过技巧。

详细目录

以下放出的章节目录为改版前的目录,大部分章和节都配套实战环节,实际上新版目录与这里的略有差异。

什么时候可以买到?

审核、校对和排版工作早已进行,按照正常流程来说月底送印,双十一之前会在各大在线书城(如京东、当当等)跟大家见面。 同时也会开启直播送书、抽奖送书等活动。想要参与活动的朋友可以添加我好友,微信号:Domfreez。加好友进群以获得书籍和活动的最新消息。欢迎大家保持对《Python3 反爬虫原理与绕过实战》的关注,新书发布后会有很多活动回馈给大家!

技术杂谈

大家有没有一种感觉,很多网站其实做得非常优秀,但是它们就是没有开发 PC (电脑)版的客户端,比如知乎、GitHub、微信公众号。 如果我们大多数时间都是使用 PC 开发或者办公的,每次开始时我们都需要打开浏览器输入它们的网址,进入对应的页面。另外一个浏览器中我们可能会开各种各样的选项卡,少则两三个,多则一二十个,这就导致某些我们常用的甚至重度依赖的网站在切换的时候就会不怎么方便。 比如挤在一堆浏览器里面的 GitHub,选项卡已经被挤得看不全了: image-20191009212626789 这时候,如果我们能有一个客户端,即 Window 上的 exe 程序或 Mac 上的 app 应用程序,它们的名字就叫做 GitHub、微信公众平台等等,打开之后只单独负责呈现 GitHub、微信公众号的内容,我们就可以免去在浏览器中来回寻找站点和切换站点的麻烦。 甚至说,在 Windows 上我们可以直接把这个应用放在桌面或把它 Pin 到任务栏上, Mac 上我们可以直接将它固定到 Dock 栏上,这样一键就打开了,省时省力。如果使用了快捷启动软件,比如 Wox (Windows)或 Alfred(Mac),直接输入 GitHub 或者微信公众平台,那就更方便唤出了,简直不要太方便。 而且,我个人感觉,用客户端软件比用网页更有一种「踏实感」,不知道大家会不会也有这种感觉。 所以,如果能将这些常用的或者重度依赖的网站转成客户端软件,那就再方便不过了。 比如我用的是 Mac,把 GitHub 转成客户端软件之后,我习惯性用 Alfred 呼出: image-20191009213959316 然后就打开了一个 GitHub.app: image-20191009214125953 然后把它固定到 Dock 栏上: image-20191009214254670 就仿佛拥有了一个 GitHub 的客户端,功能与网页一模一样,再也不用在浏览器里面切来切去。而且也不用担心版本更新的问题,因为它就是开了一个独立的网页,网页改版或者更新,内容就随着更新。 是不是很方便呢? 如果你觉得是,那就随着我来了解一下怎样实现吧。

nativefier

这里需要用到的一个工具,名字叫做 nativefier,是基于 electron 开发的,它的功能就是把任意的网页转成一个电脑客户端,即 Desktop Application, 有了这个软件,把网页转成电脑客户端只需要这么一条简单的命令:

1
nativefier <website>

比如把 Whatsapp 的网站打包成一个客户端就只需要执行这样的命令:

1
nativefier web.whatsapp.com

示意如下: Walkthrough 怎样,不论是什么网页,就可以使用它来转换成一个客户端软件。 另外它支持三大操作系统,Windows、Linux、Mac,即用它可以将网页转成 .exe.app 等格式。

安装

那么这软件究竟具体怎么来使用呢,第一步当然就是安装了。 由于 nativefier 是基于 electron 开发的,而后者又是基于 Node.js 的,所以要使用它必须要安装 Node.js,建议安装 6.0 以上版本。 另外在 Linux 和 Mac 平台可能需要安装其他的依赖。

  • 在 Linux 上需要安装 Wine 并配置好环境变量。
  • 在 Mac 上需要安装 iconutil、imagemagick,这两个依赖是为了帮助程序处理 App 的 icon 的。

具体的安装说明可以参见:https://github.com/jiahaog/nativefier#optional-dependencies。 以上步骤完成之后,使用 npm 安装 nativefier 即可:

1
npm install nativefier -g

安装完毕之后便可以使用 nativefier 命令了。

使用

下面我在 Mac 下以 GitHub 为例来介绍下怎样将 GitHub 打包成一个客户端软件。 像刚才介绍的一样,最简单直接的,运行下面的命令就好了:

1
nativefier https://github.com

它会尝试用 GitHub 主页的 title 来命名这个客户端,而 GitHub 的 title 比较长,叫做:

1
The worlds leading software development platform  GitHub

所以它会生成这样的一个客户端软件: image-20191009220450996 这个名字有点奇怪,我们可以使用命令的一个选项即可控制生成的客户端的名称,添加一个 name 参数即可:

1
nativefier --name GitHub https://github.com

这样便会生成一个名为 GitHub 的客户端: image-20191009220717549 另外我们可以看到客户端的图标也自动生成了,这个图标怎么来的呢?这个是用的 nativefier 维护的 icons,恰好 GitHub 在它们的收录范围内,所以就用上了。这些 icons 也是一个公开的 Repository,链接为: https://github.com/jiahaog/nativefier-icons,大家可以到这里搜集或者贡献图标。 如果我们觉得 nativefier 官方提供的图标不好看,想要自定义图标的话,也是可以的,只需要添加一个 icon 参数即可,这样便可以指定本地图片作为图标来生成了。 但值得注意的是,不同平台上要求的图标格式不一样。

  • Windows 上需要 ico 格式。
  • Linux 上需要 png 格式。
  • Mac 上需要 icns 格式,如果安装了上文所需要的依赖,使用 png 格式也是可以的。

具体的参数用法说明可以看:https://github.com/jiahaog/nativefier/blob/master/docs/api.md#icon。 好,那么在 Mac 上我安装了依赖,那就直接用 png 格式的图标了。 在这里我自己做了一个圆形的图标如下,命名为 github.png: 2019-10-09-141852 然后把图片使用下面的命令就可以自定义图标了:

1
nativefier --name GitHub --icon ./github.png https://github.com

这样就能生成自定义图标的客户端软件了。 打开之后,登录,我们就拥有了一个 GitHub 客户端了,界面和网页一模一样,但是已经摆脱了混杂选项卡的干扰,示意如下: image-20191009223006991 好了,这就是基本的用法,其实大部分情况只需要这几个参数就够了,如果想了解功能大家可以参考官方的 API 文档:https://github.com/jiahaog/nativefier/blob/master/docs/api.md#api。 如果想要生成其他的客户端,如微信公众平台、知乎等等都是可以的。 如微信公众平台就是这样的: image-20191009222257275

注意

在使用过程中我发现 name 参数对中文的支持并不好,总会生成一个 APP 的客户端,在这里推荐 name 使用英文名称,比如知乎用 Zhihu,微信平台用 WXMP 等等。 例如命令:

1
nativefier --name 知乎 --icon ./zhihu.png https://www.zhihu.com

可以用下面的命令代替:

1
nativefier --name Zhihu --icon ./zhihu.png https://www.zhihu.com

生成客户端软件知乎再手动修改下图标的名称即可。 另外生成的客户端软件是不支持插件的,如果你的站点对某些插件的依赖比较强,那就不建议使用 nativefier 转成的客户端了。 好了,这就是 nativefier 的基本用法,有了它我们就可以随意地将网页转成客户端软件了,快来试试吧!

技术杂谈

趁着周末,搭建了一下 NightTeam 的官方博客和官方主页,耗时数个小时,两个站点终于完工了。 由于 NightTeam 的域名是 nightteam.cn,所以这里官方博客使用了二级域名 blog.nightteam.cn,官方主页使用了根域名 nightteam.cn,现在两个站点都已经稳定运行在 GitHub Pages 上面了,大家如果感兴趣可以去看一下。

  • NightTeam HomePage:https://nightteam.cn/
  • NightTeam Blog: https://blog.nightteam.cn/

这里的主页就是用一个基本的静态页面搭建了,没有什么技术含量。博客相对复杂一点,使用了 Hexo 框架,采用了 Next 主题,在搭建的过程中我就顺手把搭建的流程大致记录下来了,在这里扩充一下形成一篇记录,毕竟好记性不如烂笔头。 于是,这篇《利用 GitHub 从零开始搭建一个博客》的文章就诞生了。

准备条件

在这里先跟大家说一些准备条件,有些同学可能一听到搭建博客就望而却步。弄个博客网站,不得有台服务器吗?不得搞数据库吗?不得注册域名吗?没事,如果都没有,那照样是能搭建一个博客的。 GitHub 是个好东西啊,它提供了 GitHub Pages 帮助我们来架设一个静态网站,这就解决了服务器的问题。 Hexo 这个博客框架没有那么重量级,它是 MarkDown 直接写文章的,然后 Hexo 可以直接将文章编译成静态网页文件并发布,所以这样文章的内容、标题、标签等信息就没必要存数据库里面了,是直接纯静态页面了,这就解决了数据库的问题。 GitHub Pages 允许每个账户创建一个名为 {username}.github.io 的仓库,另外它还会自动为这个仓库分配一个 github.io 的二级域名,这就解决了域名的问题,当然如果想要自定义域名的话,也可以支持。 所以说,基本上,先注册个 GitHub 账号就能搞了,下面我们来正式开始吧。

新建项目

首先在 GitHub 新建一个仓库(Repository),名称为 {username}.github.io,注意这个名比较特殊,必须要是 github.io 为后缀结尾的。比如 NightTeam 的 GitHub 用户名就叫 NightTeam,那我就新建一个 nightteam.github.io,新建完成之后就可以进行后续操作了。 另外如果 GitHub 没有配置 SSH 连接的建议配置一下,这样后面在部署博客的时候会更方便。

安装环境

安装 Node.js

首先在自己的电脑上安装 Node.js,下载地址:https://nodejs.org/zh-cn/download/,可以安装 Stable 版本。 安装完毕之后,确保环境变量配置好,能正常使用 npm 命令。

安装 Hexo

接下来就需要安装 Hexo 了,这是一个博客框架,Hexo 官方还提供了一个命令行工具,用于快速创建项目、页面、编译、部署 Hexo 博客,所以在这之前我们需要先安装 Hexo 的命令行工具。 命令如下:

1
npm install -g hexo-cli

安装完毕之后,确保环境变量配置好,能正常使用 hexo 命令。

初始化项目

接下来我们使用 Hexo 的命令行创建一个项目,并将其在本地跑起来,整体跑通看看。 首先使用如下命令创建项目:

1
hexo init {name}

这里的 name 就是项目名,我这里要创建 NightTeam 的博客,我就把项目取名为 nightteam 了,用了纯小写,命令如下:

1
hexo init nightteam

这样 nightteam 文件夹下就会出现 Hexo 的初始化文件,包括 themes、scaffolds、source 等文件夹,这些内容暂且先不用管是做什么的,我们先知道有什么,然后一步步走下去看看都发生了什么变化。 接下来我们首先进入新生成的文件夹里面,然后调用 Hexo 的 generate 命令,将 Hexo 编译生成 HTML 代码,命令如下:

1
hexo generate

可以看到输出结果里面包含了 js、css、font 等内容,并发现他们都处在了项目根目录下的 public 文件夹下面了。 然后我们利用 Hexo 提供的 server 命令把博客在本地运行起来,命令如下:

1
hexo server

运行之后命令行输出如下:

1
2
INFO  Start processing
INFO Hexo is running at http://localhost:4000 . Press Ctrl+C to stop.

它告诉我们在本地 4000 端口上就可以查看博客站点了,如图所示: 这样一个博客的架子就出来了,我们只用了三个命令就完成了。

部署

接下来我们来将这个初始化的博客进行一下部署,放到 GitHub Pages 上面验证一下其可用性。成功之后我们可以再进行后续的修改,比如修改主题、修改页面配置等等。 那么怎么把这个页面部署到 GitHub Pages 上面呢,其实 Hexo 已经给我们提供一个命令,利用它我们可以直接将博客一键部署,不需要手动去配置服务器或进行其他的各项配置。 部署命令如下:

1
hexo deploy

在部署之前,我们需要先知道博客的部署地址,它需要对应 GitHub 的一个 Repository 的地址,这个信息需要我们来配置一下。 打开根目录下的 _config.yml 文件,找到 Deployment 这个地方,把刚才新建的 Repository 的地址贴过来,然后指定分支为 master 分支,最终修改为如下内容:

1
2
3
4
5
6
# Deployment
## Docs: https://hexo.io/docs/deployment.html
deploy:
type: git
repo: {git repo ssh address}
branch: master

我的就修改为如下内容:

1
2
3
4
5
6
# Deployment
## Docs: https://hexo.io/docs/deployment.html
deploy:
type: git
repo: git@github.com:NightTeam/nightteam.github.io.git
branch: master

另外我们还需要额外安装一个支持 Git 的部署插件,名字叫做 hexo-deployer-git,有了它我们才可以顺利将其部署到 GitHub 上面,如果不安装的话,在执行部署命令时会报如下错误:

1
Deployer not found: git

好,那就让我们安装下这个插件,在项目目录下执行安装命令如下:

1
npm install hexo-deployer-git --save

安装成功之后,执行部署命令:

1
hexo deploy

运行结果类似如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
INFO  Deploying: git
INFO Clearing .deploy_git folder...
INFO Copying files from public folder...
INFO Copying files from extend dirs...
On branch master
nothing to commit, working directory clean
Counting objects: 46, done.
Delta compression using up to 8 threads.
Compressing objects: 100% (36/36), done.
Writing objects: 100% (46/46), 507.66 KiB | 0 bytes/s, done.
Total 46 (delta 3), reused 0 (delta 0)
remote: Resolving deltas: 100% (3/3), done.
To git@github.com:NightTeam/nightteam.github.io.git
* [new branch] HEAD -> master
Branch master set up to track remote branch master from git@github.com:NightTeam/nightteam.github.io.git.
INFO Deploy done: git

如果出现类似上面的内容,就证明我们的博客已经成功部署到 GitHub Pages 上面了,这时候我们访问一下 GitHub Repository 同名的链接,比如我的 NightTeam 博客的 Repository 名称取的是 nightteam.github.io,那我就访问 http://nightteam.github.io,这时候我们就可以看到跟本地一模一样的博客内容了。 这时候我们去 GitHub 上面看看 Hexo 上传了什么内容,打开之后可以看到 master 分支有了这样的内容: 仔细看看,这实际上是博客文件夹下面的 public 文件夹下的所有内容,Hexo 把编译之后的静态页面内容上传到 GitHub 的 master 分支上面去了。 这时候可能就有人有疑问了,那我博客的源码也想放到 GitHub 上面怎么办呢?其实很简单,新建一个其他的分支就好了,比如我这边就新建了一个 source 分支,代表博客源码的意思。 具体的添加过程就很简单了,参加如下命令:

1
2
3
4
5
6
git init
git checkout -b source
git add -A
git commit -m "init blog"
git remote add origin git@github.com:{username}/{username}.github.io.git
git push origin source

成功之后,可以到 GitHub 上再切换下默认分支,比如我就把默认的分支设置为了 source,当然不换也可以。

配置站点信息

完成如上内容之后,实际上我们只完成了博客搭建的一小步,因为我们仅仅是把初始化的页面部署成功了,博客里面还没有设置任何有效的信息。下面就让我们来进行一下博客的基本配置,另外换一个好看的主题,配置一些其他的内容,让博客真正变成属于我们自己的博客吧。 下面我就以自己的站点 NightTeam 为例,修改一些基本的配置,比如站点名、站点描述等等。 修改根目录下的 _config.yml 文件,找到 Site 区域,这里面可以配置站点标题 title、副标题 subtitle 等内容、关键字 keywords 等内容,比如我的就修改为如下内容:

1
2
3
4
5
6
# Site
title: NightTeam
subtitle: 一个专注技术的组织
description: 涉猎的主要编程语言为 Python、Rust、C++、Go,领域涵盖爬虫、深度学习、服务研发和对象存储等。
keywords: "Python, Rust, C++, Go, 爬虫, 深度学习, 服务研发, 对象存储"
author: NightTeam

这里大家可以参照格式把内容改成自己的。 另外还可以设置一下语言,如果要设置为汉语的话可以将 language 的字段设置为 zh-CN,修改如下:

1
language: zh-CN

这样就完成了站点基本信息的配置,完成之后可以看到一些基本信息就修改过来了,页面效果如下:

修改主题

目前来看,整个页面的样式个人感觉并不是那么好看,想换一个风格,这就涉及到主题的配置了。目前 Hexo 里面应用最多的主题基本就是 Next 主题了,个人感觉这个主题还是挺好看的,另外它支持的插件和功能也极为丰富,配置了这个主题,我们的博客可以支持更多的扩展功能,比如阅览进度条、中英文空格排版、图片懒加载等等。 那么首先就让我们来安装下 Next 这个主题吧,目前 Next 主题已经更新到 7.x 版本了,我们可以直接到 Next 主题的 GitHub Repository 上把这个主题下载下来。 主题的 GitHub 地址是:https://github.com/theme-next/hexo-theme-next,我们可以直接把 master 分支 Clone 下来。 首先命令行进入到项目的根目录,执行如下命令即可:

1
git clone https://github.com/theme-next/hexo-theme-next themes/next

执行完毕之后 Next 主题的源码就会出现在项目的 themes/next 文件夹下。 然后我们需要修改下博客所用的主题名称,修改项目根目录下的 _config.yml 文件,找到 theme 字段,修改为 next 即可,修改如下:

1
theme: next

然后本地重新开启服务,访问刷新下页面,就可以看到 next 主题就切换成功了,预览效果如下:

主题配置

现在我们已经成功切换到 next 主题上面了,接下来我们就对主题进行进一步地详细配置吧,比如修改样式、增加其他各项功能的支持,下面逐项道来。 Next 主题内部也提供了一个配置文件,名字同样叫做 _config.yml,只不过位置不一样,它在 themes/next 文件夹下,Next 主题里面所有的功能都可以通过这个配置文件来控制,下文所述的内容都是修改的 themes/next/_config.yml 文件。

样式

Next 主题还提供了多种样式,风格都是类似黑白的搭配,但整个布局位置不太一样,通过修改配置文件的 scheme 字段即可,我选了 Pisces 样式,修改 _config.yml (注意是 themes/next/_config.yml 文件)如下:

1
scheme: Pisces

刷新页面之后就会变成这种样式,如图所示: 另外还有几个可选项,比如:

1
2
3
4
# scheme: Muse
#scheme: Mist
scheme: Pisces
#scheme: Gemini

大家可以自行根据喜好选择。

favicon

favicon 就是站点标签栏的小图标,默认是用的 Hexo 的小图标,如果我们有站点 Logo 的图片的话,我们可以自己定制小图标。 但这并不意味着我们需要自己用 PS 自己来设计,已经有一个网站可以直接将图片转化为站点小图标,站点链接为:https://realfavicongenerator.net,到这里上传一张图,便可以直接打包下载各种尺寸和适配不同设备的小图标。 图标下载下来之后把它放在 themes/next/source/images 目录下面。 然后在配置文件里面找到 favicon 配置项,把一些相关路径配置进去即可,示例如下:

1
2
3
4
5
favicon:
small: /images/favicon-16x16.png
medium: /images/favicon-32x32.png
apple_touch_icon: /images/apple-touch-icon.png
safari_pinned_tab: /images/safari-pinned-tab.svg

配置完成之后刷新页面,整个页面的标签图标就被更新了。

avatar

avatar 这个就类似站点的头像,如果设置了这个,会在站点的作者信息旁边额外显示一个头像,比如我这边有一张 avatar.png 图片: 将其放置到 themes/next/source/images/avatar.png 路径,然后在主题 _config.yml 文件下编辑 avatar 的配置,修改为正确的路径即可。

1
2
3
4
5
6
7
8
9
10
# Sidebar Avatar
avatar:
# In theme directory (source/images): /images/avatar.gif
# In site directory (source/uploads): /uploads/avatar.gif
# You can also use other linking images.
url: /images/avatar.png
# If true, the avatar would be dispalyed in circle.
rounded: true
# If true, the avatar would be rotated with the cursor.
rotated: true

这里有 rounded 选项是是否显示圆形,rotated 是是否带有旋转效果,大家可以根据喜好选择是否开启。 效果如下: 配置完成之后就会显示头像。

rss

博客一般是需要 RSS 订阅的,如果要开启 RSS 订阅,这里需要安装一个插件,叫做 hexo-generator-feed,安装完成之后,站点会自动生成 RSS Feed 文件,安装命令如下:

1
npm install hexo-generator-feed --save

在项目根目录下运行这个命令,安装完成之后不需要其他的配置,以后每次编译生成站点的时候就会自动生成 RSS Feed 文件了。

code

作为程序猿,代码块的显示还是需要很讲究的,默认的代码块我个人不是特别喜欢,因此我把代码的颜色修改为黑色,并把复制按钮的样式修改为类似 Mac 的样式,修改 _config.yml 文件的 codeblock 区块如下:

1
2
3
4
5
6
7
8
9
10
11
12
codeblock:
# Code Highlight theme
# Available values: normal | night | night eighties | night blue | night bright
# See: https://github.com/chriskempson/tomorrow-theme
highlight_theme: night bright
# Add copy button on codeblock
copy_button:
enable: true
# Show text copy result.
show_result: true
# Available values: default | flat | mac
style: mac

修改前的代码样式: 修改后的代码样式: 嗯,个人觉得整体看起来逼格高了不少。

top

我们在浏览网页的时候,如果已经看完了想快速返回到网站的上端,一般都是有一个按钮来辅助的,这里也支持它的配置,修改 _config.yml 的 back2top 字段即可,我的设置如下:

1
2
3
4
5
6
back2top:
enable: true
# Back to top in sidebar.
sidebar: false
# Scroll percent label in b2t button.
scrollpercent: true

enable 默认为 true,即默认显示。sidebar 如果设置为 true,按钮会出现在侧栏下方,个人觉得并不是很好看,就取消了,scrollpercent 就是显示阅读百分比,个人觉得还不错,就将其设置为 true。 具体的效果大家可以设置后根据喜好选择。

reading_process

reading_process,阅读进度。大家可能注意到有些站点的最上侧会出现一个细细的进度条,代表页面加载进度和阅读进度,如果大家想设置的话也可以试试,我将其打开了,修改 _config.yml 如下:

1
2
3
4
5
6
reading_progress:
enable: true
# Available values: top | bottom
position: top
color: "#222"
height: 2px

设置之后显示效果如下:

bookmark

书签,可以根据阅读历史记录,在下次打开页面的时候快速帮助我们定位到上次的位置,大家可以根据喜好开启和关闭,我的配置如下:

1
2
3
4
5
6
7
bookmark:
enable: false
# Customize the color of the bookmark.
color: "#222"
# If auto, save the reading progress when closing the page or clicking the bookmark-icon.
# If manual, only save it by clicking the bookmark-icon.
save: auto

github_banner

在一些技术博客上,大家可能注意到在页面的右上角有个 GitHub 图标,点击之后可以跳转到其源码页面,可以为 GitHub Repository 引流,大家如果想显示的话可以自行选择打开,我的配置如下:

1
2
3
4
5
# `Follow me on GitHub` banner in the top-right corner.
github_banner:
enable: true
permalink: https://github.com/NightTeam/nightteam.github.io
title: NightTeam GitHub

记得修改下链接 permalink 和标题 title,显示效果如下: 可以看到在页面右上角显示了 GitHub 的图标,点击可以进去到 Repository 页面。

gitalk

由于 Hexo 的博客是静态博客,而且也没有连接数据库的功能,所以它的评论功能是不能自行集成的,但可以集成第三方的服务。 Next 主题里面提供了多种评论插件的集成,有 changyan | disqus | disqusjs | facebook_comments_plugin | gitalk | livere | valine | vkontakte 这些。 作为一名程序员,我个人比较喜欢 gitalk,它是利用 GitHub 的 Issue 来当评论,样式也比较不错。 首先需要在 GitHub 上面注册一个 OAuth Application,链接为:https://github.com/settings/applications/new,注册完毕之后拿到 Client ID、Client Secret 就可以了。 首先需要在 _config.yml 文件的 comments 区域配置使用 gitalk:

1
2
3
4
5
6
7
# Multiple Comment System Support
comments:
# Available values: tabs | buttons
style: tabs
# Choose a comment system to be displayed by default.
# Available values: changyan | disqus | disqusjs | facebook_comments_plugin | gitalk | livere | valine | vkontakte
active: gitalk

主要是 comments.active 字段选择对应的名称即可。 然后找打 gitalk 配置,添加它的各项配置:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# Gitalk
# Demo: https://gitalk.github.io
# For more information: https://github.com/gitalk/gitalk
gitalk:
enable: true
github_id: NightTeam
repo: nightteam.github.io # Repository name to store issues
client_id: {your client id} # GitHub Application Client ID
client_secret: {your client secret} # GitHub Application Client Secret
admin_user: germey # GitHub repo owner and collaborators, only these guys can initialize gitHub issues
distraction_free_mode: true # Facebook-like distraction free mode
# Gitalk's display language depends on user's browser or system environment
# If you want everyone visiting your site to see a uniform language, you can set a force language value
# Available values: en | es-ES | fr | ru | zh-CN | zh-TW
language: zh-CN

配置完成之后 gitalk 就可以使用了,点击进入文章页面,就会出现如下页面: GitHub 授权登录之后就可以使用了,评论的内容会自动出现在 Issue 里面。

pangu

我个人有个强迫症,那就是写中文和英文的时候中间必须要留有间距,一个简单直接的方法就是中间加个空格,但某些情况下可能习惯性不加或者忘记加了,这就导致中英文混排并不是那么美观。 pangu 就是来解决这个问题的,我们只需要在主题里面开启这个选项,在编译生成页面的时候,中英文之间就会自动添加空格,看起来更加美观。 具体的修改如下:

1
pangu: true

math

可能在一些情况下我们需要写一个公式,比如演示一个算法推导过程,MarkDown 是支持公式显示的,Hexo 的 Next 主题同样是支持的。 Next 主题提供了两个渲染引擎,分别是 mathjax 和 katex,后者相对前者来说渲染速度更快,而且不需要 JavaScript 的额外支持,但后者支持的功能现在还不如前者丰富,具体的对比可以看官方文档:https://theme-next.org/docs/third-party-services/math-equations。 所以我这里选择了 mathjax,通过修改配置即可启用:

1
2
3
4
5
6
7
8
9
10
11
12
13
math:
enable: true

# Default (true) will load mathjax / katex script on demand.
# That is it only render those page which has `mathjax: true` in Front-matter.
# If you set it to false, it will load mathjax / katex srcipt EVERY PAGE.
per_page: true

# hexo-renderer-pandoc (or hexo-renderer-kramed) required for full MathJax support.
mathjax:
enable: true
# See: https://mhchem.github.io/MathJax-mhchem/
mhchem: true

mathjax 的使用需要我们额外安装一个插件,叫做 hexo-renderer-kramed,另外也可以安装 hexo-renderer-pandoc,命令如下:

1
2
npm un hexo-renderer-marked --save
npm i hexo-renderer-kramed --save

另外还有其他的插件支持,大家可以到官方文档查看。

pjax

可能大家听说过 Ajax,没听说过 pjax,这个技术实际上就是利用 Ajax 技术实现了局部页面刷新,既可以实现 URL 的更换,有可以做到无刷新加载。 要开启这个功能需要先将 pjax 功能开启,然后安装对应的 pjax 依赖库,首先修改 _config.yml 修改如下:

1
pjax: true

然后安装依赖库,切换到 next 主题下,然后安装依赖库:

1
2
$ cd themes/next
$ git clone https://github.com/theme-next/theme-next-pjax source/lib/pjax

这样 pjax 就开启了,页面就可以实现无刷新加载了。 另外关于 Next 主题的设置还有挺多的,这里就介绍到这里了,更多的主题设置大家可以参考官方文档:https://theme-next.org/docs/

文章

现在整个站点只有一篇文章,那么我们怎样来增加其他的文章呢? 这个很简单,只需要调用 Hexo 提供的命令即可,比如我们要新建一篇「HelloWorld」的文章,命令如下:

1
hexo new hello-world

创建的文章会出现在 source/_posts 文件夹下,是 MarkDown 格式。 在文章开头通过如下格式添加必要信息:

1
2
3
4
5
6
7
8
9
10
11
\---
title: 标题 # 自动创建,如 hello-world
date: 日期 # 自动创建,如 2019-09-22 01:47:21
tags:
- 标签1
- 标签2
- 标签3
categories:
- 分类1
- 分类2
---

开头下方撰写正文,MarkDown 格式书写即可。 这样在下次编译的时候就会自动识别标题、时间、类别等等,另外还有其他的一些参数设置,可以参考文档:https://hexo.io/zh-cn/docs/writing.html

标签页

现在我们的博客只有首页、文章页,如果我们想要增加标签页,可以自行添加,这里 Hexo 也给我们提供了这个功能,在根目录执行命令如下:

1
hexo new page tags

执行这个命令之后会自动帮我们生成一个 source/tags/index.md 文件,内容就只有这样子的:

1
2
3
4
\---
title: tags
date: 2019-09-26 16:44:17
---

我们可以自行添加一个 type 字段来指定页面的类型:

1
2
type: tags
comments: false

然后再在主题的 _config.yml 文件将这个页面的链接添加到主菜单里面,修改 menu 字段如下:

1
2
3
4
5
6
7
8
9
menu:
home: / || home
#about: /about/ || user
tags: /tags/ || tags
#categories: /categories/ || th
archives: /archives/ || archive
#schedule: /schedule/ || calendar
#sitemap: /sitemap.xml || sitemap
#commonweal: /404/ || heartbeat

这样重新本地启动看下页面状态,效果如下: 可以看到左侧导航也出现了标签,点击之后右侧会显示标签的列表。

分类页

分类功能和标签类似,一个文章可以对应某个分类,如果要增加分类页面可以使用如下命令创建:

1
hexo new page categories

然后同样地,会生成一个 source/categories/index.md 文件。 我们可以自行添加一个 type 字段来指定页面的类型:

1
2
type: categories
comments: false

然后再在主题的 _config.yml 文件将这个页面的链接添加到主菜单里面,修改 menu 字段如下:

1
2
3
4
5
6
7
8
9
menu:
home: / || home
#about: /about/ || user
tags: /tags/ || tags
categories: /categories/ || th
archives: /archives/ || archive
#schedule: /schedule/ || calendar
#sitemap: /sitemap.xml || sitemap
#commonweal: /404/ || heartbeat

这样页面就会增加分类的支持,效果如下:

搜索页

很多情况下我们需要搜索全站的内容,所以一个搜索功能的支持也是很有必要的。 如果要添加搜索的支持,需要先安装一个插件,叫做 hexo-generator-searchdb,命令如下:

1
npm install hexo-generator-searchdb --save

然后在项目的 _config.yml 里面添加搜索设置如下:

1
2
3
4
5
search:
path: search.xml
field: post
format: html
limit: 10000

然后在主题的 _config.yml 里面修改如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
# Local search
# Dependencies: https://github.com/wzpan/hexo-generator-search
local_search:
enable: true
# If auto, trigger search by changing input.
# If manual, trigger search by pressing enter key or search button.
trigger: auto
# Show top n results per article, show all results by setting to -1
top_n_per_article: 5
# Unescape html strings to the readable one.
unescape: false
# Preload the search data when the page loads.
preload: false

这里用的是 Local Search,如果想启用其他是 Search Service 的话可以参考官方文档:https://theme-next.org/docs/third-party-services/search-services

404 页面

另外还需要添加一个 404 页面,直接在根目录 source 文件夹新建一个 404.md 文件即可,内容可以仿照如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
\---
title: 404 Not Found
date: 2019-09-22 10:41:27
---

<center>
对不起,您所访问的页面不存在或者已删除。
您可以<a href="https://blog.nightteam.cn>">点击此处</a>返回首页。
</center>

<blockquote class="blockquote-center">
NightTeam
</blockquote>

这里面的一些相关信息和链接可以替换成自己的。 增加了这个 404 页面之后就可以 完成了上面的配置基本就完成了大半了,其实 Hexo 还有很多很多功能,这里就介绍不过来了,大家可以直接参考官方文档:https://hexo.io/zh-cn/docs/ 查看更多的配置。

部署脚本

最后我这边还增加了一个简易版的部署脚本,其实就是重新 gererate 下文件,然后重新部署。在根目录下新建一个 deploy.sh 的脚本文件,内容如下:

1
2
3
hexo clean
hexo generate
hexo deploy

这样我们在部署发布的时候只需要执行:

1
sh deploy.sh

就可以完成博客的更新了,非常简单。

自定义域名

将页面修改之后可以用上面的脚本重新部署下博客,其内容便会跟着更新。 另外我们也可以在 GitHub 的 Repository 里面设置域名,找到 Settings,拉到下面,可以看到有个 GitHub Pages 的配置项,如图所示: 下面有个 custom domain 的选项,输入你想自定义的域名地址,然后添加 CNAME 解析就好了。 另外下面还有一个 Enforce HTTPS 的选项,GitHub Pages 会在我们配置自定义域名之后自动帮我们配置 HTTPS 服务。刚配置完自定义域名的时候可能这个选项是不可用的,一段时间后等到其可以勾选了,直接勾选即可,这样整个博客就会变成 HTTPS 的协议的了。 另外有一个值得注意的地方,如果配置了自定义域名,在目前的情况下,每次部署的时候这个自定义域名的设置是会被自动清除的。所以为了避免这个情况,我们需要在项目目录下面新建一个 CNAME 文件,路径为 source/CNAME,内容就是自定义域名。 比如我就在 source 目录下新建了一个 CNAME 文件,内容为:

1
blog.nightteam.cn

这样避免了每次部署的时候自定义域名被清除的情况了。 以上就是从零搭建一个 Hexo 博客的流程,希望对大家有帮助。

技术杂谈

so 文件调用

随着 Android 移动安全的高速发展,不管是为了执行效率还是程序的安全性等,关键代码下沉 native 层已成为基本操作。 native 层的开发就是通指的 JNI/NDK 开发,通过 JNI 可以实现 java 层和 native 层(主要是 C/C++ )的相互调用,native 层经编译后产生 so 动态链接库,so 文件具有可移植性广,执行效率高,保密性强等优点。 那么问题来了,如何调用 so 文件显得异常重要,当然你也可以直接分析 so 文件的伪代码,利用强悍的编程功底直接模拟关键操作,但是我想对于普通人来说头发还是比较重要的。 当前调用 so 文件的主流操作应该是: 1,基于 Unicorn 的各种实现(还在学习中,暂且不表) 2,Android 服务器的搭建,在 App 内起 http 服务完成调用 so 的需求(当然前提是过了 so 的效验等操作) 至于为什么选用 AndServer,好吧,不为什么,只是因为搜索到了它 为什么结合 Service,在学习 Android 开发的时候了解到了 Service 的生命周期,个人理解用 Service 去创建 Http 服务比较好。 当然也有 Application 的简单使用,因为在正式环境中,大多数 so 文件的逻辑中都有 context 的一些包名了,签名了的效验等,自定义 Application 的话获取 context 传参就好了。

libyemu.so 简介

这是我编译好的一个 so 文件,就是根据入参做下简单的字符串拼接(以下是 native 层编译前的 c 代码)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
extern "C"
JNIEXPORT jstring JNICALL
Java_com_fw_myapplication_ndktest_NdkTest_stringFromUTF(JNIEnv *env, jobject instance, jstring str_) {
jclass String_clazz = env->FindClass("java/lang/String");

jmethodID concat_methodID = env->GetMethodID(String_clazz, "concat", "(Ljava/lang/String;)Ljava/lang/String;");

jstring str = env->NewStringUTF(" from so --[NightTeam夜幕]");

jobject str1 = env->CallObjectMethod(str_, concat_methodID, str);

const char *chars = env->GetStringUTFChars((jstring)str1, 0);

return env->NewStringUTF(chars);
}

这部分代码还是有必要贴一下的,简单的静态注册使用了反射的思想,反射在逆向中至关重要 接下来是 java 代码,定义了 native 函数

1
2
3
4
5
6
7
8
9
package com.fw.myapplication.ndktest;

public class NdkTest {
public static native String stringFromUTF(String str);

static {
System.loadLibrary("yemu");
}
}

如果到这里有点懵逼的同学可能需要去补下 Android 开发基础了

Android 项目测试 so

先说下我的环境,因为这个环境影响太大了 1,AndroidStudio 3.4 2,手机 Android 6 架构 armeabi-v7a 打开 AndroidStudio 新建 project 在 module 的 build 中加这么一句,然后 sync 把编译好的 so 文件复制到 libs 文件夹下(和刚才的 jniLibs.srcDirs 对应) 把 so 对应的 java 代码也 copy 过来,注意包名类名的一致性 打开 activity_main.xml 文件为 TextView 添加 id 打开 MainActiviy.java 开始编码 这两行的意思就是,先从布局中找到对应 id 的 TextView,然后为其设置 Text(调用 native 函数的返回值) 下面测试一下咱们的 so 调用情况 可以看到咱们的 so 文件调用成功(这里咱们的 so 没有效验,只是测试 app 是否可以正常调用)

AndServer 代码编写

AndServer 官方文档:https://yanzhenjie.com/AndServer/ 打开官方文档,看看人家的入门介绍,新建 java 文件 如图经典 MVC 的 C 就写好了,定义了一个 nightteam_sign 接口,请求方式为 get,请求参数为 sign,调用 native 函数,然后返回 json,但是这里我想利用 Application 获取下 context 对象,取下包名,接下来自定义 Applictaion

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.nightteam.httpso;

import android.app.Application;

public class MyApp extends Application {
private static MyApp myApp;
public static MyApp getInstance() {
return myApp;
}

@Override
public void onCreate() {
super.onCreate();
myApp = this;
}
}

然后在 manifest 文件中指定要启动的 Application 然后修改 MyController.java 的代码 接下来把官方文档-服务器的代码 copy 下来 导入一些包,修改部分代码如下 新版本的 AndServer.serverBuilder 已经需要传递 context 了,这里把网络地址和端口号也修改为从构造参数中获取,到这里 AndServer 的东西基本完了,实际上咱们就搭建一个调 so 的接口,并没有过多的业务逻辑,所以代码就是使用的最简单的

Service 代码编写

咱们这里用按钮的点击事件启动 Service,故在 activity_main.xml 中添加一个 button 并指定点击事件 接下来编写自定义 Service 代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
package com.nightteam.httpso.Service;

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.util.Log;

import com.nightteam.httpso.ServerManager;

import java.net.InetAddress;
import java.net.UnknownHostException;

public class MyService extends Service {
private static final String TAG = "NigthTeam";

@Override
public void onCreate() {
super.onCreate();
Log.d(TAG, "onCreate: MyService");
new Thread() {
@Override
public void run() {
super.run();
InetAddress inetAddress = null;
try {
inetAddress = InetAddress.getByName("0.0.0.0");
Log.d(TAG, "onCreate: " + inetAddress.getHostAddress());
ServerManager serverManager = new ServerManager(getApplicationContext(), inetAddress, 8005);
serverManager.startServer();
} catch (UnknownHostException e) {
e.printStackTrace();
}

}
}.start();
}

@Override
public IBinder onBind(Intent intent) {
return null;
}

}

打上了几个 log,在子线程中启动 AndServer 的服务(何时使用 UI 线程和子线程是 Android 基础,这里就不赘述了) 注意一下,这里从 0.0.0.0 获取 inetAddress,可不要写错了,localhost 和 0.0.0.0 的区别请移步搜索引擎 然后就是向 ServerManager 的构造函数传递 context,inetAddress,port 用来 new 对象,随后开启服务 最后注意检查下 manifest 文件中 Service 的声明

开启 Service,并获取本机 ip

回到我们的 MainActivity.java 的 operate( button 的点击事件)编写启动 Service 代码

1
2
3
4
5
6
7
8
9
10
11
12
public void operate(View view) {
switch (view.getId()){
case R.id.id_bt_index:
//启动服务:创建-->启动-->销毁
//如果服务已经创建了,后续重复启动,操作的都是同一个服务,不会再重新创建了,除非你先销毁它
Intent it1 = new Intent(this, MyService.class);
Log.d(TAG, "operate: button");
startService(it1);
((Button) view).setText("服务已开启");
break;
}
}

到这里我们的服务基本搭建好了,但是为了方便起见,我想把咱们的本机 ip 显示在 App 上,这样我们就不用去设置再查看了 我在网上找到了一个获取 ip 地址的一个工具类,源码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
package com.nightteam.httpso;

import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.util.Enumeration;
import java.util.regex.Pattern;

public class NetUtils {

private static final Pattern IPV4_PATTERN = Pattern.compile("^(" +

"([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\\.){3}" +

"([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$");

private static boolean isIPv4Address(String input) {

return IPV4_PATTERN.matcher(input).matches();

}

//获取本机IP地址

public static InetAddress getLocalIPAddress() {

Enumeration<NetworkInterface> enumeration = null;

try {

enumeration = NetworkInterface.getNetworkInterfaces();

} catch (SocketException e) {

e.printStackTrace();

}

if (enumeration != null) {

while (enumeration.hasMoreElements()) {

NetworkInterface nif = enumeration.nextElement();

Enumeration<InetAddress> inetAddresses = nif.getInetAddresses();

if (inetAddresses != null)

while (inetAddresses.hasMoreElements()) {

InetAddress inetAddress = inetAddresses.nextElement();

if (!inetAddress.isLoopbackAddress() && isIPv4Address(inetAddress.getHostAddress())) {

return inetAddress;

}

}
}

}

return null;

}
}

把工具类 copy 到我们的 Android 项目中,继续在 MainActivity.java 中编码 获取了一下本机地址和 Android SDK 版本( Android 8 之后启动 Service 方式不一样)

申请权限,启动 App

最后一步就是为 app 申请网络权限了 随后连接我们的手机,运行项目,测试一下,点击开启服务 看下 AndroidStudio 日志 好像一切正常,在浏览器访问下试试( ip 就是 App 中显示的 ip 地址) 如图正常访问到了我们想要的内容 回过头来说下 Service,打开我们手机的设置,找到应用程序管理-运行中的服务(手机不同,方式不同) 可以看到我们的程序,运行了一个服务,这个服务就是咱们编码的 MyService 接下来杀掉该 App进程,再次查看运行中的服务 我这里在权限管理设置了自动运行,可以保持服务的运行。(这个地方还是根据系统有大小差异) 至此使用 App 起 http 服务调 so 就完成了


好了,上面就是利用 AndServer 打造 Android 服务器调 so 文件的整体思路和流程,如果你懒得看的话,直接用我写好的 App 修修补补也是可以的,只需要发送消息【AndServer搭建Web服务调so】到公众号【NightTeam】即可。


文章作者:「夜幕团队 NightTeam 」- 妄为 夜幕团队成立于 2019 年,团队成员包括崔庆才、周子淇、陈祥安、唐轶飞、冯威、蔡晋、戴煌金、张冶青和韦世东。 涉猎的主要编程语言为 Python、Rust、C++、Go,领域涵盖爬虫、深度学习、服务研发和对象存储等。团队非正亦非邪,只做认为对的事情,请大家小心。

技术杂谈

这是系列文章的第一篇,也是非常重要的一篇,希望大家能读懂我想要表达的意思。

系列文章开篇概述

相对于其他编程语言来说,Python 生态中最突出的就是第三方库。任何一个及格的 Python 开发者都使用过至少 5 款第三方库。 就爬虫领域而言,必将用到的例如网络请求库 Requests、网页解析库 Parsel 或 BeautifulSoup、数据库对象关系映射 Motor 或 SQLAlchemy、定时任务 Apscheduler、爬虫框架 Scrapy 等。 这些开源库的使用方法想必大家已经非常熟练了,甚至还修炼出了自己的一套技巧,日常工作中敲起键盘肯定也是哒哒哒的响。 但是你有没有想过:

  • 那个神奇的功能是如何实现的?
  • 这个功能背后的逻辑是什么?
  • 为什么要这样做而不是选择另一种写法?
  • 编写这样的库需要用到哪些知识?
  • 这个论点是否有明确的依据?

如果你从未这样想过,那说明你还没到达应该「渡劫」的时机;如果你曾提出过 3 个以上的疑问,那说明你即将到达那个重要的关口;如果你常常这么想,而且也尝试着寻找对应的答案,那么恭喜你,你现在正处于「渡劫」的关口之上。 偶有群友会抛出这样的问题:初级工程师、中级工程师、高级工程师如何界定? 这个问题有两种不同的观点,第一个是看工作职级,第二个则是看个人能力。工作职级是一个浮动很大的参照物,例如阿里巴巴的高级研发和我司的高级研发,职级名称都是「高级研发」,但能力可能会有很大的差距。 个人能力又如何评定呢? 难不成看代码写的快还是写的慢吗? 当然不是! 个人能力应当从广度和深度两个方面进行考量,这并没有一个明确的标准。当两人能力差异很大的时候,外人可以轻松的分辨孰强孰弱。 自己怎样分辨个人能力的进与退呢? 这就回到了上面提到的那些问题:WHO WHAT WHERE WHY WHEN HOW? 我想通过这篇文章告诉你,不要做那个用库用得很熟练的人,要做那个创造库的人。计算机世界如此吸引人,就是因为我们可以在这个世界里尽情创造。 你想做一个创造者吗? 如果不想,那现在你就可以关掉浏览器窗口,回到 Hub 的世界里。

内容介绍

这是一套系列文章,这个系列将为大家解读常见库(例如 WebSocket、HTTP、ASCII、Base64、MD5、AES、RSA)的协议规范和对应的代码实现,帮助大家「知其然,知其所以然」。

目标

这次我们要学习的是 WebSocket 协议规范和代码实现,也可以理解为从 0 开始编写 aiowebsocket 库。至于为什么选择它,那大概是因为全世界没有比我更熟悉的它的人了。 我是 aiowebsocket 库的作者,我花了 7 天编写这个库。写库的过程,让我深刻体会到造轮子和驾驶的区别,也让我有了飞速的进步。我希望用连载系列文章的形式帮助大家从驾驶者转换到创造者,拥有「编程思考」。

前置条件

WebSocket 是一种在单个 TCP 连接上进行全双工通信的协议,它的出现使客户端和服务器之间的数据交换变得更加简单。下图描述了双端交互的流程: WebSocket 通常被应用在实时性要求较高的场景,例如赛事数据、股票证券、网页聊天和在线绘图等。WebSocket 与 HTTP 协议完全不同,但同样被广泛应用。 无论是后端开发者、前端开发者、爬虫工程师或者信息安全工作者,都应该掌握 WebSocket 协议的知识。 我曾经发表过几篇关于 WebSocket 的文章:

  • 【严选-高质量文章】开发者必知必会的 WebSocket 协议
  • Python如何爬取实时变化的WebSocket数据
  • WebSocket 从入门到写出开源库

其中,《【严选-高质量文章】开发者必知必会的 WebSocket 协议》介绍了协议规范的相关知识。这篇文章的内容大体如下:

  • WebSocket 协议来源
  • WebSocket 协议的优点
  • WebSocket 协议规范
  • 一些实际代码演示

如果没有掌握 WebSocket 协议的朋友,我建议先去阅读这篇文章,尤其是对 WebSocket 协议规范介绍的那部分。 要想将协议规范 RFC6455 变成开源库,第一步就是要熟悉整个协议规范,所以你需要阅读【严选-高质量文章】开发者必知必会的 WebSocket 协议。当然,有能力的同学直接阅读 RFC6455 也未尝不可。 接着还需要了解编程语言中内置库 Socket 的基础用法,例如 Python 中的 socket 或者更高级更潮的 StreamsTransports and Protocols。如果你是 Go 开发者、Rust 开发者,请查找对应语言的内置库。 假设你已经熟悉了 RFC6455,你应该知道 Frame 打包和解包的时候需要用到位运算,正好我之前写过位运算相关的文章 7分钟全面了解位运算。 至于其它的,现用现学吧!

Python 网络通信之 Streams

WebSocket,也可以理解为在 WEB 应用中使用的 Socket,这意味着本篇将会涉及到 Socket 编程。上面提到,Python 中与 Socket 相关的有 socket、Streams、Transports and Protocols。其中 socket 是同步的,而另外两个是异步的,这俩属于你常听到的 asyncio。

Socket 通信过程

Socket 是端到端的通信,所以我们要搞清楚消息是怎么从一台机器发送到另一台机器的,这很重要。假设通信的两台机器为 Client 和 Server,Client 向 Server 发送消息的过程如下图所示:

Client 通过文件描述符的读写 API read & write 来访问操作系统内核中的网络模块为当前套接字分配的发送 send buffer 和接收 recv buffer 缓存。 Client 进程写消息到内核的发送缓存中,内核将发送缓存中的数据传送到物理硬件 NIC,也就是网络接口芯片 (Network Interface Circuit)。 NIC 负责将翻译出来的模拟信号通过网络硬件传递到服务器硬件的 NIC。 服务器的 NIC 再将模拟信号转成字节数据存放到内核为套接字分配的接收缓存中,最终服务器进程从接收缓存中读取数据即为源客户端进程传递过来的 消息。

上述通信过程的描述和图片均出自钱文品的深入理解 RPC 交互流程。 我尝试寻找通信过程中每个步骤的依据(尤其是 send buffer to NIC to recv buffer),(我翻阅了 TCP 的 RFC 和 Kernel.org)但遗憾的是并未找到有力的证明(一定是我太菜了),如果有朋友知道,可以评论告诉我或发邮件 zenrusts@sina.com 告诉我,我可以扩展出另一篇文章。

创建 Streams

那么问题来了:在 Python 中,我们如何实现端到端的消息发送呢? 答:Python 提供了一些对象帮助我们实现这个需求,其中相对简单易用的是 Streams。 Streams 是 Python Asynchronous I/O 中提供的 High-level APIs。Python 官方文档对 Streams 的介绍如下:

Streams are high-level async/await-ready primitives to work with network connections. Streams allow sending and receiving data without using callbacks or low-level protocols and transports.

我尬译一下:Streams 是用于网络连接的 high-level async/await-ready 原语。Streams 允许在不使用回调或 low-level protocols and transports 的情况下发送和接收数据。 Python 提供了 asyncio.open_connection() 让开发者创建 Streams,asyncio.open_connection() 将建立网络连接并返回 reader 和 writer 对象,这两个对象其实是 StreamReader 和 StreamWriter 类的实例。 开发者可以通过 StreamReader 从 IO 流中读取数据,通过 StreamWriter 将数据写入 IO 流。虽然文档并没有给出 IO 流的明确定义,但我猜它跟 buffer (也就是 send buffer to NIC to recv buffer 中的 buffer)有关,你也可以抽象的认为它就是 buffer。 有了 Streams,就有了端到端消息发送的完整实现。下面将通过一个例子来熟悉 Streams 的用法和用途。这是 Python 官方文档给出的双端示例,首先是 Server 端:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# TCP echo server using streams
# 本文出自「夜幕团队 NightTeam」 转载请联系并取得授权
import asyncio

async def handle_echo(reader, writer):
data = await reader.read(100)
message = data.decode()
addr = writer.get_extra_info('peername')

print(f"Received {message!r} from {addr!r}")

print(f"Send: {message!r}")
writer.write(data)
await writer.drain()

print("Close the connection")
writer.close()

async def main():
server = await asyncio.start_server(
handle_echo, '127.0.0.1', 8888)

addr = server.sockets[0].getsockname()
print(f'Serving on {addr}')

async with server:
await server.serve_forever()

asyncio.run(main())

接着是 Client 端:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# TCP echo client using streams
# 本文出自「夜幕团队 NightTeam」 转载请联系并取得授权
import asyncio

async def tcp_echo_client(message):
reader, writer = await asyncio.open_connection(
'127.0.0.1', 8888)

print(f'Send: {message!r}')
writer.write(message.encode())

data = await reader.read(100)
print(f'Received: {data.decode()!r}')

print('Close the connection')
writer.close()

asyncio.run(tcp_echo_client('Hello World!'))

将示例分别写入到 server.py 和 client.py 中,然后按序运行。此时 server.py 的窗口会输出如下内容:

1
2
3
4
Serving on ('127.0.0.1', 8888)
Received 'Hello World!' from ('127.0.0.1', 59534)
Send: 'Hello World!'
Close the connection

从输出中得知,服务启动的 address 和 port 为 ('127.0.0.1', 8888),从 ('127.0.0.1', 59534) 读取到内容为 Hello World! 的消息,接着将 Hello World! 返回给 ('127.0.0.1', 59534) ,最后关闭连接。 client.py 的窗口输出内容如下:

1
2
3
Send: 'Hello World!'
Received: 'Hello World!'
Close the connection

在创建连接后,Client 向指定的端发送了内容为 Hello World! 的消息,接着从指定的端接收到内容为 Hello World! 的消息,最后关闭连接。 有些读者可能不太理解,为什么 Client Send Hello World! ,而 Server 接收到之后也向 Client Send Hello World! 。双端的 Send 和 Received 都是 Hello World! ,这很容易让新手懵逼。实际上这就是一个普通的回显服务器示例,也就是说当 Server 收到消息时,将消息内容原封不动的返回给 Client。 这样只是为了演示,并无它意,但这样的示例却会给新手带来困扰。 以上是一个简单的 Socket 编程示例,整体思路理解起来还是很轻松的,接下来我们将逐步解读示例中的代码:

1
2
3
* client.py 中用 `asyncio.open_connection()` 连接指定的端,并获得 reader 和 writer 这两个对象。
* 然后使用 writer 对象中的 `write()` 方法将 `Hello World!` 写入到 IO 流中,该消息会被发送到 Server。
* 接着使用 reader 对象中的 `read()` 方法从 IO 流中读取消息,并将消息打印到终端。

看到这里,你或许会有另一个疑问:write() 只是将消息写入到 IO 流,并没有发送行为,那消息是如何传输到 Server 的呢? 由于无法直接跟进 CPython 源代码,所以我们无法得到确切的结果。但我们可以跟进 Python 代码,得知消息最后传输到 transport.write() ,如果你想知道更多,可以去看 Transports and Protocols 的介绍。你可以将这个过程抽象为上图的 Client to send buffer to NIC to recv buffer to Server。

功能模块设计

通过上面的学习,现在你已经掌握了 WebSocket 协议规范和 Python Streams 的基本用法,接下来就可以设计一个 WebSocket 客户端库了。 根据 RFC6455 的约定,WebSocket 之前是 HTTP,通过「握手」来升级协议。协议升级后进入真正的 WebSocket 通信,通信包含发送(Send)和接收(Recv)。文本消息要在传输过程前转换为 Frames,而接受端读取到消息后要将 Frames 转换成文本。当然,期间会有一些异常产生,我们可能需要自定义异常,以快速定位问题所在。现在我们得出了几个模块:

1
2
3
4
5
6
7
* 握手 - ShakeHands

* 传输 - Transports

* 帧处理 - Frames

* 异常 - Exceptions

一切准备就绪后,就可以进入真正的编码环节了。 由于实战编码篇幅太长,我决定放到下一期,这期的内容,读者们可能需要花费一些时间吸收。

小结

开篇我强调了「创造能力」有多么重要,甚至抛出了一些不是很贴切的例子,但我就是想告诉你,不要做调参?。 然后我告诉你,本篇文章要讲解的是 WebSocket。 接着又跟你说,要掌握 WebSocket 协议,如果你无法独立啃完 RFC6455,还可以看我写过的几篇关于 WebSocket 文章和位运算文章。 过了几分钟,给你展示了 Socket 的通信过程,虽然没有强有力的依据,但你可以假设这是对的。 喝了一杯白开水之后,我向你展示了 Streams 的具体用法并为你解读代码的作用,重要的是将 Streams 与 Socket 通信过程进行了抽象。 这些前置条件都确定后,我又带着你草草地设计了 WebSocket 客户端的功能模块。 下一篇文章将进入代码实战环节,请做好环境(Python 3.6+)准备。

总之,要想越过前面这座山,就请跟我来!


文章作者:「夜幕团队 NightTeam 」- 韦世东 夜幕团队成立于 2019 年,团队成员包括崔庆才、周子淇、陈祥安、唐轶飞、冯威、蔡晋、戴煌金、张冶青和韦世东。 涉猎的主要编程语言为 Python、Rust、C++、Go,领域涵盖爬虫、深度学习、服务研发和对象存储等。团队非正亦非邪,只做认为对的事情,请大家小心。

技术杂谈

时间过得真快,距离这个系列的上一篇文章《商业级4G代理搭建指南【准备篇】》发布的时间已经过了两个星期了,上个星期由于各种琐事缠身,周二开始就没空写文章了,所以就咕咕咕了。 那么在准备篇中,我们了解了一下搭建 4G 代理所需要的软硬件,也知道了各种选择的优劣势。现在,我们就可以开始实际搭建了,相信大家也是期待已久了。


基本思路

从这篇文章的标题中我们可以看出,这一次的搭建方案主要用到的是 Docker,你可能会很好奇,Docker 跟搭建 4G 代理有什么关系吗? 嗯,关系很大,我们把整件事情梳理一下,先来看看搭建 4G 代理时的基本流程:

  1. 调用网卡拨号,拨号成功后会创建一个虚拟网卡。(正常情况下使用这个虚拟网卡就能上网了)
  2. 在多网卡的情况下,重复第一步,会得到多个虚拟网卡。
  3. 启动代理服务器,使其使用虚拟网卡作为出网网卡,并使用接入内网的实体网卡作为入网网卡。 使用起来差不多是这样的

但是呢,有个问题,根据我之前的测试结果来看,目前在 Linux 环境下还没有一个 HTTP 代理服务器是可以做到分别指定出网网卡和入网网卡的,嗯…这就很麻烦了,因为如果我们无法这么做的话,就会出现类似于下面这样的问题:

  1. 出网和入网都在虚拟网卡上,使用代理服务器必须要走公网访问。
  2. 入网为实体网卡,但出网被代理服务器锁定为了某一个,无法利用到多网卡。

嗯…那么不用 HTTP 代理服务器,用那些经常被用来做一些骚操作的 Socks5 代理服务器呢?如果可以指定网卡的话,再用像 Privoxy 之类的工具把 Socks5 代理转成 HTTP 代理就好了。(某知名扶墙软件的 Windows 版本就是这么转的 HTTP 代理) 在经过一番尝试后,我发现虽然有些 Socks5 代理服务器的文档中是说可以指定网卡,但按照说明操作后,似乎并不能直接做到我想要的效果(要么还是锁定在某一个上面、要么上不了网),所以还是存在一些问题的。可能是需要配合路由表设置来进行操作吧,不过我对网络工程的了解不怎么深,搞了几天也没搞出来,于是乎还得想想别的办法。 这时候,我想到了一个东西——Docker,它可以用来解决这个问题! 因为 Docker 容器被创建后,不管外界的网卡有多少个,容器内部的网卡都只会有一个Docker自己的虚拟网卡(容器间通信用的)和一个本地环回接口(不用管它),而且我们在容器内进行拨号操作时,产生的那个新的虚拟网卡也不会影响到外界或其他容器,这样的话,代理服务器就不需要指定网卡了,直接启动就能跑! 那么现在整个流程就跑通了,进入实际操作环节看看吧!


系统方面

这个 Docker 版的搭建方式,系统方面的选择很多,由于我使用的样例设备是树莓派,所以这里就选择使用了 Raspbian(树莓派专属版 Debian)。如果你使用的是其他设备的话,直接选择一个自己常用的系统就好。 那么准备好之后的第一步当然是先下载并安装 Docker,这里我直接使用 Docker 官方提供的一键安装脚本来进行安装:

1
2
3
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh
# 出自官方文档:https://docs.docker.com/install/linux/docker-ce/debian/#install-using-the-convenience-script

这个一键安装脚本理论上来讲所有 Linux 发行版都可以使用,毕竟已经出来很长时间了,如果不行的话请自行使用搜索引擎查找相关资料。 装好 Docker 之后,你有两个选择:

  1. 进入体验模式,了解一下具体操作细节是怎么样的。
  2. 不看这一段,翻到本文最下方直接使用我写好的轮子。

启动容器

体验的话,我们就直接这么启动一个 Docker 容器吧,执行以下命令:

1
sudo docker run -it --rm --privileged -p 3128:3128 ubuntu:18.04 bash

上面这条命令的意思是,启动一个内部系统为 Ubuntu18.04 的容器,并进入容器内部的 Shell 执行 bash 命令,如果退出 bash 就自动销毁容器;然后映射容器内的端口3128到外界,映射出来的外界端口也是3128;最后 privileged 参数是开启特权模式,用于将网卡设备映射进容器内。 如果下载镜像很慢的话,可以搜一下“Docker 加速器”,也可以直接扶墙。

测试一下网卡是否正常

进入容器内部后,我们可以执行一下 ls /dev/ttyUSB* 看一下网卡有没有正常被识别出来(在容器外也是一样的,因为开了特权模式),如果是和我买的同一款 4G 网卡的话,在只插入一张网卡的情况下你会看到4个 ttyUSB 设备。 插入了三张网卡的样子,一共12个 ttyUSB 设备

不同 4G 网卡和硬件组合可能会有差异,请以实际情况为准。

如果你可以看到4✖4G网卡个数个 ttyUSB 设备的话,就说明没有问题,可以开始下一步了。

拨号上网

接下来要做的就是拨号了,拨号方面可以选择使用 Wvdial 这种工具,也可以选择使用像 Fanconn 这样的商家提供的拨号脚本(直接调用 PPPD),使用起来的效果会有一些区别。如果商家没有提供拨号脚本的话,就用 Wvdial 吧,它能自动生成配置,上手即用。 我这边的话,由于 Fanconn 的技术人员直接提供了个拨号脚本,那我就用这个脚本了,Wvdial 的文档网上有很多很详尽的,这里就不再多提,需要的朋友自行搜索即可。 如果你用的是 Fanconn 的这个拨号脚本(怎么弄进容器内就不用我说了吧?),那么直接在 apt install ppp 安装好拨号工具之后,用 chmod +x quectel-pppd.sh 给拨号脚本加个运行权限,然后 ./quectel-pppd.sh /dev/ttyUSB3 即可。

拨号时使用的 /dev/ttyUSB3 是指 4G 网卡的第四个通信端口,文档中的解释为:ttyUSB3→For PPP connections or AT command communication,翻译一下就是用于 PPP 连接或 AT 命令通信。

拨号之后用 ifconfig 之类的工具即可看到类似下图中的状态: 可以看到,如前文所述,现在有三个网卡,一个是 Docker 自己的、一个是本地环回接口(这个不用管)、一个是拨号产生的虚拟网卡。

如果不是在 Docker 容器内使用的话,还会有个 wwan0(或其他名字),那个是 4G 网卡本体。

测试是否能正常上网

现在如果你用 curl 的 \--interface 参数指定虚拟网卡进行请求的话(如:curl --interface ppp0 https://ip.cn),是已经可以请求成功的了,IP 也会是你所使用的 SIM 卡对应的运营商分配的。

由于 Docker 的镜像通常都是极度精简的,所以 Ubuntu 镜像里并没有预装像 net-tools、iputils-ping、vim、curl 之类的这些包,需要自行安装。所以如果你发现 ifconfig、ping、curl、vim 用不了,不要惊慌,这是正常现象,执行 apt install 包名 命令安装即可。

如果你无法直接请求成功的话,就可能是 DNS 解析出问题了,可以尝试 ping 一个公网 IP(如:ping 1.1.1.1)和一个域名(如:ping ip.cn),如果 IP 能 ping 通但域名会报 DNS 解析失败的话,就可以确认是 DNS 设置问题了。 4G 拨号时如果出现 DNS 设置问题,通常是因为拨号工具没有正常地将运营商返回的 DNS 服务器设置写入到配置中,我们可以手动配置一下(你要强制指定某一个 DNS 也可以):

1
2
3
# 以下为阿里云的公共DNS
echo 'nameserver 223.5.5.5' >> /etc/resolv.conf
echo 'nameserver 223.6.6.6' >> /etc/resolv.conf

在 Docker 容器中,这个 /etc/resolv.conf 文件可能还会有两条内容,是容器本身所需要的,建议不要删除/覆盖,否则会出现容器间无法使用容器名互相通信的情况。

启动代理服务器

那么在测试拨号后确实可以通过 4G 网卡上网了之后,我们就可以把代理服务器启动了,这里我使用的是 TinyProxy。

测试发现,Squid 对资源的占用更大一些,不利于多网卡情况下的使用,会影响到 4G 网卡的数量上限。

apt install tinyproxy 一波,然后 vim /etc/tinyproxy/tinyproxy.conf 修改一下配置。 要修改的配置主要有:

  • Port 配置项改为3128,因为我们前面映射出来的端口是3128。
  • Listen 配置项改为0.0.0.0,因为我们需要在其他设备上使用这个代理服务器。
  • Allow 配置项注释掉或改为0.0.0.0/0,默认的127.0.0.1会导致其他设备无法访问。

改完之后保存一波,然后就可以直接执行 tinyproxy 启动了…吗? 等等,还有一个操作要做!那就是将默认路由指向到虚拟网卡上,很简单,执行以下命令即可:

1
2
route del -net 0.0.0.0 eth0
route add -net 0.0.0.0 ppp0

这两条命令的意思是:先将默认的、指向 eth0 这个网卡的上网路由删除,然后添加一个同样的、指向 ppp0 这个网卡的路由。 改完默认路由后的效果就是,即使你不使用 curl 的 \--interface 参数,也能直接使用 4G 网卡上网了。

如果没有改默认路由的话,在不指定网卡的情况下,4G 网卡并不会被使用到,因为默认路由指向的是 Docker 自身的虚拟网卡,那个网卡通向你原本的内网环境。也就是说,IP 不会变!

那么现在,你可以执行 tinyproxy 启动代理服务器了。

测试代理服务器

好了,代理服务器应该已经正常启动了,现在我们可以在另一个设备上尝试连接那个容器中的代理服务器,看看是否能正常通过它使用 4G 网卡上网。 例如我这里树莓派分配到的IP是:192.168.137.66,那么我就可以用这样的 curl 命令或 Python 代码进行测试: curl:

1
2
curl "https://ip.cn"
curl -x "192.168.137.66:3128" "https://ip.cn"

Python:

1
2
3
4
5
import requests
resp = requests.get("https://ip.cn", proxies={"https": "http://192.168.137.66:3128"})
no_proxy_resp = requests.get("https://ip.cn")
print(resp.text)
print(no_proxy_resp.text)

测试出来的结果应该与前面在容器内部测试时的一致,在使用代理后 IP 就变成了运营商分配的基站 IP。

更换 IP

那么最核心的问题来了,怎么更换 IP 呢? 其实和使用那些拨号 VPS 架设代理服务器一样,我们只需要重新拨个号就能换 IP 了,直接 kill 掉 pppd 进程就可以让它断开拨号,断开后重新执行一遍拨号脚本就是重新拨号了。

断开拨号方面 Fanconn 的技术人员也提供了一个脚本,同样在 chmod +x quectel-ppp-kill 赋予运行权限之后,执行 ./quectel-ppp-kill 就可以了。

但需要注意的是,蜂窝网络的拨号在断开后,IP 仍然会保留一段时间(具体多久不清楚,可能跟连接的基站也有关系),所以我们需要强制性地让网卡重新搜网。

冷门小知识:手机上开启关闭飞行模式的效果就是重新搜网,通常只是关闭“移动数据”的话,效果是与断开拨号一致的。

怎么做呢?很简单,就两行命令:

1
2
AT+CFUN=0
AT+CFUN=1

但注意哦,这是 AT 命令,不是 Linux 下的 Shell 命令,AT 命令是一种调制解调器命令语言,我们如果需要将它执行起来,需要这么做:

1
2
3
echo "AT+CFUN=0" > /dev/ttyUSB2
# 中间间隔1秒左右
echo "AT+CFUN=1" > /dev/ttyUSB2

这里使用的 /dev/ttyUSB2 是指 4G 网卡的第三个通信端口,文档中的解释为:ttyUSB2→For AT command communication,与第四个通信端口类似,只是它不能用于 PPP 连接、只能用于 AT 命令通信而已。 不同样使用第四个通信端口的原因是那个端口有被占用的可能性,直接区分开最稳妥,本来网卡也就是提供了两个 AT 命令通信渠道的。

在使网卡重新搜网后的几秒至十几/几十秒内的时间里,你无法正常拨号,需要等待它初始化完成后才可以拨号成功,具体等待时间以信号强度为准,我测试的时候通常5秒以内就可以了。 所以如果你在断开后一直拨号失败,不妨过一会儿再试。


总结

那么现在操作流程也跑通了,我们也了解到了整个的内部细节,最后要做的就是把每个网卡都分别分配一个容器,这样我们就能实现文章开头所提到的——“使用虚拟网卡作为出网网卡,并使用接入内网的实体网卡作为入网网卡”的效果了。 实际操作起来的话,就是把指定网卡的部分给配置化,然后在启动容器的时候传入就好了,使用 Docker 的容器环境变量相关设置可以很轻松地实现这个功能。 最后,我们可以以这个思路,构建一个 docker-compose 模板,模板的核心内容一是做个简易的4G网卡容器集群,二是启动个 Squid,用来聚合代理服务器,这样我们使用的时候只需要指定一个代理服务器就能随机更换了,操作起来更加方便。


好了,上面就是 Docker 版搭建方式的思路和整个的搭建流程,如果你懒得看的话,直接用我写好的轮子也是可以的,只需要发送消息【Docker版4G代理】到公众号【NightTeam】即可。

评价

最后的最后,我给这个搭建方式打个评价吧。 这个搭建方式并不完美,因为变量太多,而且很多地方肯定不如系统级原生支持的那么稳定,长期使用可能会出现各种奇奇怪怪的问题。 然后 Docker 的资源占用其实挺高的,会浪费相当多的内存在启动容器上,如果只是两三个网卡还好,如果数量大一点的话,像树莓派2B 这种小内存的设备根本就扛不住。 另外代理服务器本身对资源的消耗也是比较高的,高频调用下对树莓派2B 的小 CPU 压力还是蛮大的,即使我对它的 CPU 进行了超频,在并发测试时也还是会出现轻松打满 CPU 的情况。 但是!截止目前,我还有两种基于路由器系统的搭建方案没写出来!所以…敬请期待后续的其他搭建方案(斜眼笑)。


文章作者:「夜幕团队 NightTeam」 - Loco 夜幕团队成立于 2019 年,团队包括崔庆才、周子淇、陈祥安、唐轶飞、冯威、蔡晋、戴煌金、张冶青和韦世东。 涉猎的编程语言包括但不限于 Python、Rust、C++、Go,领域涵盖爬虫、深度学习、服务研发、对象存储等。团队非正亦非邪,只做认为对的事情,请大家小心。

技术杂谈

在这个互联网时代,拥有流量就仿佛于拥有了一切。 我大约在 2014 年底开了自己的个人博客,当时就是想自己记录点学习总结,一个是方便查阅,二是锻炼一下自己写总结或者文章的能力,最初就是记录一些日常生活、编程学习的小知识点什么的。 一次偶然的机会我接触了爬虫,当时用 Python 写爬虫的仿佛也不多,正好有一位学长有研究,我也就跟着他学了起来,学的时候也是自己总结,然后把一些文章发表到博客上,累积了十几篇左右。不知道是什么原因,渐渐地好像爬虫火了起来,Python 也火了起来,不知不觉地我发现我的博客慢慢地流量涨起来了,一天几百、几千一直到现在上万的浏览量,SEO 也逐渐好了起来,说实话我当时都没有想到,感觉还是不少运气成分在里面的。 两年前左右我开了一个公众号,开始在公众号上面发一些文章,自己也逐渐从博客转战到公众号上面了,因为公众号的环境总体来说还是很不错的,尤其是对原创作者来说非常友好,非常尊重原创。转载文章需要开白、原创命中和保护机制、洗稿检测、及时的投诉处理让越来越多的技术人员也转到公众号上来了。所以越来越多的技术开发者都拥有了自己的公众号,变成了一个人人公号的时代。这导致了一个什么结果?竞争日益激烈,读者的可选择范围太多了,大家的涨粉之路也走得越来越艰辛了。 同样地我也遭受着同样的苦恼,这时候我突然想起来,我似乎还有个博客呢?最近写文都专注于公众号,没太有心思打理自己博客了。我在想要是能够把我的博客流量转换到我的公众号上来该多好呢?一来我的博客读者可以关注到我的公号平时发的文章或通知,二来也着实能为自己的公号涨一点粉丝,这样该多好啊? 思来想去我想到了一个法子,就是在浏览博客文章的时候,把后续内容的隐藏,留一个二维码,可以通过关注公众号解锁。 当时设想效果图就是这样子的: image-20190914224503383 文章在某个位置会渐变隐藏,同时浮现一个公众号的样子,需要扫码才能解锁。这时候读者扫码自动关注了公号,博客文章也自然而然地解锁,这样博客的读者就自然关注到公号上面来了。

功能要点

一听到这样的法子,大家肯定就骂起来了,文章还要解锁来看?每篇文章都要解锁一遍吗?以后如果再打开还需要次次解锁吗? 如果真的是这样,那我情愿不做这个功能,因为这太损伤「用户体验」了。为了尽量减少用户体验的损失,这个功能必须要满足以下几点:

  • 不要添加用户登录注册机制,一旦增加了这个机制,流程可能会大大复杂化,导致用户体验急剧下降。
  • 不能每打开一个页面都要解锁一次,读者访问了我的博客,只需要一次解锁,即可全面解锁博客所有文章。
  • 读者在关闭浏览器再重新打开浏览器浏览博客的时候,同样不能让读者再解锁一遍,要直接可看。
  • 读者在手机或其他移动设备上不方便操作,手机站点禁止启用本功能。

如果满足了这些条件,读者在一篇文章里面只要扫码解锁了一次,那么就可以永久解锁全站文章了,没有繁琐的登录注册功能,也不需要次次频繁解锁,这样用户体验就非常好了。 为了达成这个目的,我就开始开发这个功能了。

识别用户

那么怎么来实现呢?要实现上面的功能,其实最重要的就是来识别是哪一个用户,也就是说,我怎么知道到底是谁在浏览我的博客呢?我怎么来专门针对这个用户解锁呢? 有的同学可能说那就用 IP 地址呗,技术角度是可以实现的,但是其实仔细想想,用 IP 地址是很不友好的。一来是很多用户可能都是内网的 IP 地址,多个公户共享一个公网 IP 地址,所以假如两台设备接入了同一个公网 IP,我是无法判断到底解锁哪一台设备的。二来是,如果一个用户换了其他的地方或者用了 VPN,IP 地址变了,原本解锁的设备又变成非解锁状态了。这样也不好。 那么最方便简单的用来标识一个浏览设备的东西是什么?当然是 Cookies。Cookies 里面保存了浏览网页时自动生成的 Session ID,而且每一个用户都是不一样的,这样不就可以来唯一标识一台浏览设备了吗?

解锁逻辑

好,那有了用户的 ID,我怎么才能把用户 ID 和我的公众号关联起来呢?当然是把这个 ID 发到公众号后台,我来存起来就好了。然后博客这边定时检测我这边有没有把这个 ID 保存,如果保存了,那就呈现解锁状态,如果没有保存,那就呈现非解锁状态。 最开始我就设想,既然公众号要扫码关注,那么我能不能把这个 ID 也糅到二维码里面呢?这样关注公众号的时候既能查询到公众号,有传递过来一个 ID 作为参数,然后后台处理一下存起来就好了。 你别说还真有这个功能,我在微信平台官方文档里面查询到了一个「生成带参数的公众号二维码」,生成的二维码里面可以指定任意的参数,然后生成的二维码图案就是公众号的二维码,然后处理一下关注公众号的回调函数就可以执行某一些操作了。看到之后我就想起来了很多关注公众号自动登录的功能就是这么做的。 但是经过一系列操作,发现了一个很悲伤的事情,只有服务号才有这个功能,我一小小的订阅号,是没有这个权限的,不能生产带参数的二维码。哎,难道凉了吗? 不,没有,既然这个参数不能通过二维码传递,那就只好麻烦读者手动把这 ID 输入到我的公众号了,我的小小的订阅号还是有处理消息的功能的。我的公众号后台接收到消息,然后处理下这个消息 ID,然后存起来,那不就好了吗? 说干就干!

隐藏文章

怎么开始做呢?那就从隐藏文章开始做吧。首先这个隐藏不能是真正的后台的隐藏,需要在前台隐藏。如果是后台隐藏的话,搜索引擎所能爬到的我的网站内容就会缺失了,会影响 SEO 的。所以只需要前台 CSS 隐藏一下就好了。 怎样看起来隐藏得比较自然呢?就取文章的的一半的地方,把文章的下面部分用 CSS 藏起来,然后加个渐变效果就好了。 比如要隐藏一半的内容吧,首先可以获取文章区块的高度,然后把文章页面高度用 CSS 强制设置为原来的一半就好了,这个很好操作,然后再在最底下加个渐变的样子,仿佛底下还有文字的样子。 这个 CSS 用 background 属性就能实现了,参考代码如下:

1
2
3
4
5
#locker {
height: 240px;
width: 100%;
background: -webkit-gradient(linear, 0 top, 0 bottom, from(rgba(255, 255, 255, 0)), to(#fff));
}

这里就是设置个 240 像素的区块,然后从上面到下面是透明度渐变颜色就好了,整体效果是下面这个样子: image-20190914231647956 好,既然隐藏了,那么下面就加个提示吧,把公众号的二维码先放上,然后把那个 Session ID 放上,提示用户关注公众号后发送这个 ID 就能解锁了,但这个 ID 又不能太长,多少呢?六位吧那就。 类似做成这样的样子: image-20190914231805506 好,那么这个 ID 怎么获取的呢? 刚才说了,从 Cookies 里面获取就行了,找那个能够标识 Session ID 的一个 Cookies 字段,然后摘取其值的其中几位就行了,摘取的位置也有讲究,前几位仿佛重复率很高的样子,后面几位几乎不重复,那就截取最后六位数字吧。 好,然后我就在博客里面加了这么一点 JavaScript 代码来实现这个 ID 的提取:

1
2
3
4
5
6
7
8
9
10
11
12
13
function getCookie(name) {
var value = "; " + document.cookie;
var parts = value.split("; " + name + "=");
if (parts.length == 2) return parts.pop().split(";").shift();
}

function getToken() {
let value = getCookie('UM_distinctid')
if (!value) {
return defaultToken
}
return value.substring(value.length - 6).toUpperCase()
}

这里 getCookie 方法是用某个名字获取一个 Cookies 字段,getToken 方法是截取了 Cookies 这个字段值的后六位并做了大写处理。 这里我的一个可以用来标识 Session ID 的 Cookies 字段叫做 UM_distinctid,就用它了。 这样一来,每个用户浏览的时候就能生成这样的一个 ID 了,六位的。 胜利似乎越来越近了。

持久化存储

这里就又遇到一个问题,刚才不是说还要在用户关闭浏览器之后再重新打开,依然能保持解锁状态吗?这就要求这个 ID 在用户关闭又打开浏览器的时候是不变的。 这个怎么解?很简单,反正已经是从 Cookies 里面读了,这个 Cookies 持久化就行了,只要不在浏览器关闭后清除就行了,怎么办?设置个过期时间就好。 由于我的站点是 WordPress 做的,所以这个功能自动有了,如果没有的话用一些插件也能实现的。

公众号处理

好,现在 ID 也有了,用户扫码把这个 ID 发到公众号后台就行了吧,然后公众号对接开发者模式处理一下就好了。 这里就其实就很简单了,其实仅仅就是把用户的 OpenID 和这个码存到了一个数据库里面。我后台是用 Django 写的,所以用了 Django 里面的 Model,实现逻辑如下:

1
2
3
4
5
6
7
8
9
10
def unlock(source, target, content):
"""
解锁博客
:param target: 微信平台
:param source: 用户
:param content: 用户发来的码
:return:
"""
Unlock.objects.get_or_create(openid=source, token=content.upper())
return reply_text(source, target, '恭喜您已经解锁博客全部文章~')

就是这么两行,插入了一条数据,然后返回了一个信息提示。 插入之后怎么办呢?博客得知道我已经把这条数据插入进来了呀?那就再提供一个 API 查询吧,实现如下:

1
2
3
4
5
6
7
8
9
10
11
def is_locked(request):
"""
判断是否已经解锁
:param request: 包含token的请求
:return:
"""
token = request.GET.get('token')
result = Unlock.objects.filter(token=token.upper()).first()
return JsonResponse({
'locked': False if result else True
})

把这个方法对接一个 API 接口,比如 /api/locked?token=xxxxx,就可以知道是否解锁了。 所以,在公众号后台我就用开发者模式对接了这么两个功能,一个用来存,一个用来查。只要用户发送了这个能够用来表示自己浏览设备的码,我就存下来,然后博客定时请求这个 API 查询状态,如果返回结果是未解锁状态,那就继续锁住,如果是解锁状态。那就把博客解开。

博客端处理

那么博客端具体怎么来处理呢?就基本的轮询就好了,定时几秒查一次 API,然后把这个码当做参数传过去,然后根据查询结果执行解锁或非解锁操作就好了。 核心代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
(articleSelector).ready(function () {
var articleElement = $(articleSelector)[0]
if (articleElement) {
var height = articleElement.clientHeight
var halfHeight = height * 0.3
var token = getToken()
$('#locker').find('.token').text(token)
function detect() {
$.ajax({
url: 'https://weixin.cuiqingcai.com/api/locked/',
method: 'GET',
data: {
token: token
},
success: function (data) {
if (data.locked === true || data.locked === false) {
locked = data.locked
}
},
error: function (data) {
locked = false
}
})
}
}
})

这里就用基本的 jQuery 实现的,其实就是调了个 Ajax,也没啥高深的技巧。这里唯一值得注意的一点设计就是,如果 API 请求失败,这基本上证明我的 API 服务挂掉了,这里就需要把 locked 设置为 false,证明为解锁状态。这样,万一我的 API 后台挂了,博客会直接是解锁状态,这样就避免了读者永远无法解锁了。这是一个细节上的设计。 至此,一些技术上的问题就基本解决了。

手机端处理

最后回过头来看看,那个需求还没有满足? 读者在手机或其他移动设备上不方便操作,手机站点禁止启用本功能。那么怎么实现呢?很简单,判断一下浏览器的 User-Agent 就好了,这里实现了一个判断是否是 PC 的方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
var os = function () {
var ua = navigator.userAgent,
isWindowsPhone = /(?:Windows Phone)/.test(ua),
isSymbian = /(?:SymbianOS)/.test(ua) || isWindowsPhone,
isAndroid = /(?:Android)/.test(ua),
isFireFox = /(?:Firefox)/.test(ua),
isChrome = /(?:Chrome|CriOS)/.test(ua),
isTablet = /(?:iPad|PlayBook)/.test(ua) || (isAndroid && !/(?:Mobile)/.test(ua)) || (isFireFox && /(?:Tablet)/.test(ua)),
isPhone = /(?:iPhone)/.test(ua) && !isTablet,
isPc = !isPhone && !isAndroid && !isSymbian;
return {
isTablet: isTablet,
isPhone: isPhone,
isAndroid: isAndroid,
isPc: isPc
}
}()

这样一来,调用 os.isPC 就可以知道当前浏览器是不是手机浏览器了。 在处理的时候加上这个条件判断,就可以实现手机功能的解除了。

效果

可能大家想知道效果是如何的,这里就截图看看了,现在这个功能已经在我的博客 cuiqingcai.com 上线了,大家可以进去体验一下。 首先进去文章是这个样子的: image-20190914234237147 然后关注了公号,发送了代码: image-20190914234421831 发送完毕之后,大约一两秒之后,抬头看看博客,就是这个样子了: image-20190914234406442 这已经就完成了解锁和转化,读者可以全站永久解锁我的博客文章,我也增长了粉丝。 现在过一段时间就会有读者发来代码解锁,同时成为了我的粉丝,订阅号助手看到消息如下: image-20190914234720018 以上便是这个博客转化的思路分享和实现,大家也可以到我的博客体验一下,谢谢!

技术杂谈

今天这篇文章是要告诉你,业内多名实力强劲的开发者组建了一个服务于广大开发者的团队。现在,你可能会有下面这些疑问:

  • 为什么要组成团队呢?
  • 这个团队将会给广大开发者带来什么?
  • 团队成员有哪些?

好了,接下来用 3 分钟时间去了解这个团队吧!

夜幕团队简介

夜幕团队 NightTeam 于 2019 年 9 月 9 日正式成立,团队由爬虫领域中实力强劲的多名开发者组成:崔庆才、周子淇、陈祥安、唐轶飞、冯威、蔡晋、戴煌金、张冶青和韦世东。 NightTeam 涉猎的编程语言包括但不限于 Python、Rust、C++、Go,领域涵盖爬虫、深度学习、服务研发和对象存储等,团队技术实力十分雄厚。

为什么要组建一个团队?

据以往经验来看,产出一篇优质的技术文章所耗费的时间是相当长的,读者很难从单个作者那里获得成体系且覆盖面较广的知识。 对于作者而言,粉丝的积累、文章的持续编写都是一个慢跑的过程,很多优秀的作者会因为没有粉丝、投入产出比差距太大等因素暂停写作。 更有甚者,文章内容质量越来越低、标题越来越唬、广告越来越多,一门心思放在如何涨粉和变现上。如此循环,就会影响技术圈和技术生态的发展。 如果将那些优秀的作者联合起来(即合纵连横),共同运营一系列的技术媒体号,在不增加负担的情况下还能保证优质文章的产出,会怎么样呢?

我们也不知道,但是我们已经意识到了这个问题,也尝试着寻找答案。这就是夜幕团队 NightTeam 组建的大环境背景。

团队希望做什么事?

互联网是开放的,技术也是开放的。适当的共享可以加速我们的进步,无论是作者还是读者,都能够从分享的过程中获得一些东西。

在开发中,我们会用到一些库和框架。当我刚编程入门的时候,就想着有一天也要编写开源项目,为其他开发者提供帮助,这正是夜幕团队想要做的事。 当然,我们想要做的不仅仅是编写一个开源项目,我们更希望将知识分享出去,在技术圈中传播开来,让更多的人得到帮助。

团队能够为开发者带来什么?

读者的能力和阶段各不相同,每个人收获的内容也不同。宽泛来说,读者可以从夜幕团队 NightTeam 输出的内容中获得对待问题的处理方式、分析问题的思路、解决问题的技巧、问题背后的逻辑等。 假如你是一名中级爬虫工程师,那么夜幕团队 NightTeam 输出的内容可能会为你解决工作中遇到的一些反爬虫问题带来思路。

如果你是一名后端开发者,你也许会从我们发布的类似于【动图演示 - Redis 持久化 RDB/AOF 详解与实践】这样的文章中了解到 Redis 持久化的两种选择的差异和具体操作过程。

团队以什么形式输出内容?

大多数情况下,我们会用文章的形式输出内容。但有时候也会采用直播或者视频教程的方式,兴许还会有现场交流的机会。 为了增加传播广度和影响力,我们不仅仅在微信公众号上发布文章,还会将文章同步到业内著名的几个平台,例如掘金社区、CSDN、SF、V2EX、知乎、今日头条等。

团队成员介绍

团队的成员都是爬虫领域比较活跃的作者,同时也拥有非常强的实力,不会是那些只负责回答小白问题骗钱的盗名之辈。以下将不分先后的列出团队成员姓名、昵称和各自的介绍。 周子淇

昵称 Loco 前微信公众号「小周码字」号主、知乎专栏「手把手教你写爬虫」作者,幂度爬虫工程师。啥方向都搞,除了爬虫相关的文章以外还会写一些灰黑产操作研究、机器学习、造轮子、物联网设备研究、脑洞分享等各种奇奇怪怪的东西。

韦世东

昵称 Asyncins 图灵签约作者、电子工业出版社约稿作者、华为云认证云享专家、掘金社区优秀作者、GitChat 认证作者、搜狐产品技术约稿作者、开源项目 aiowebsocket 作者、微信公众号「Rust之禅」号主、「进击的Coder」运营者之一,有着丰富的爬虫经验,擅长反爬虫的绕过技巧。

崔庆才

昵称 静觅 畅销书《Python3网络爬虫开发实战》作者、微信公众号「进击的Coder」号主,微软中国工程师。主要研究网络爬虫、机器学习、Web 开发相关内容。

陈祥安

昵称 CXA 微信公众号「Python学习开发」号主、CSDN 线下沙龙特邀讲师、华为云享社区专家、阿里云栖社区专家、哔哩哔哩《陈祥安分析Python面试题》系列 UP 主、GitChat 热门文章《Python 常见的 170 道面试题全解析:2019 版》作者,马蜂窝高级爬虫工程师。

唐轶飞

昵称 大鱼 BruceDone 微信公众号「大鱼鱼塘」号主、「http://brucedone.com」站长,腾讯后端工程师。多年 Code 经验,擅长后端开发,语言了解但不限于 .NET、Python、Golang、SQL,兴趣包含但不限于爬虫,后端,数据库,深度学习。

冯 威

昵称 妄为 微信公众号「妄为写代码」号主,爬虫 Coder,佛系程序员。专注 JavaScript、Android 逆向以及验证码破解,对逆向有着丰富的经验。

蔡 晋

昵称 悦来客栈的老板 微信公众号「菜鸟学Python编程」号主,平时喜欢研究各大网站的反爬,熟悉常见网站的反爬操作,对反爬有着独到的见解。

戴煌金

昵称 咸鱼 微信公众号「咸鱼学Python」号主、华为云享专家。专注Python爬虫、JavaScript逆向,立志做一条最咸的咸鱼。

张冶青

昵称:MarvinZ 微信公众号「Crawlab漫游指南」号主、爬虫管理平台 Crawlab 作者、文章发布平台 ArtiPub 作者,知名外企前端开发工程师。专注前端、爬虫和数据分析。

如何与夜幕取得联系?

你可能想跟夜幕团队交流一些技术方面的问题,你可以发送消息“夜幕读者群”到我们的公众号「NightTeam」加入读者群,团队成员都在群里等你。 一些重要的事可以通过邮件与夜幕取得联系,夜幕团队的邮箱为 contact@nightteam.cn。 GitHub 也准备好了,我们会逐渐将开源项目迁移到团队的仓库中,地址为 https://github.com/nightteam

技术杂谈

舆情爬虫是网络爬虫一个比较重要的分支,舆情爬虫往往需要爬虫工程师爬取几百几千个新闻站点。比如一个新闻页面我们需要爬取其标题、正文、时间、作者等信息,如果用传统的方式来实现,每一个站点都要配置非常多的规则,如果要维护一个几百上千的站点,那人力成本简直太高了。 如果有一种方式可以在保证差不多的准确率的前提下,大幅提高提取效率的话,就需要用到智能文本提取了。 本文首先介绍一下智能文本提取的基本原理,让大家对智能提取有基本的了解。然后介绍几个比较基础的工具包,准确率并不是很高,可以尝试一用。最后再介绍几篇比较前沿的技术供大家参考。

智能文本提取

目前来说,智能文本提取可以分为三类:

  • 基于网页文档内容的提取方法
  • 基于 DOM 结构信息的提取方法
  • 基于视觉信息的提取方法

基于网页文档的提取方法将 HTML 文档视为文本进行处理,适用于处理含有大量文本信息且结构简单易于处理的单记录网页,或者具有实时要求的在线分析网页应用。 这种方式主要利用自然语言处理相关技术实现,通过理解 文本语义、分析上下文、设定提取规则等,实现对大段网页文档的快速处理。其中,较为知名的方法有TSIMMIS、Web-OQL、Serrano、FAR-SW 和 FOREST,但这些方法由于通常需要人工的参与,且存在耗时长、效率低的弊端。 基于 DOM 结构信息的方法将 HTML 文档解析为相应的 DOM 树,然后根据 DOM 树的语法结构创建提取规则, 相对于以前的方法而言有了更高的性能和准确率。 W4F 和 XWRAP 将 HTML 文档解析成 DOM 树,然后通过组件化引导用户通过人工选择或者标记生成目标包装器代码。Omini、IEPAD 和 ITE 提取 DOM 树上的关键路径, 获取其中存在的重复模式。MDR 和 DEPTA 挖掘了页面中的数据区域,得到数据记录的模式。CECWS 通过聚类算法从数据库中提取出自同一网站的一组页面,并进行 DOM 树结构的对比,删除其中的静态部分,保留动态内容作为信息提取的结果。虽然此类方法相对于上一类方法 具有较高的提取精度,且克服了对大段连续文本的依赖, 但由于网页的 DOM 树通常较深,含有大量 DOM 节点, 因此基于 DOM 结构信息的方法具有较高的时间和空间消耗。目前来说,大部分原理还是基于 DOM 节点的文本密度、标点符号密度等计算的,其准确率还是比较可观的。今天所介绍的 Readability 和 Newspaper 的库的实现原理就是类似。 目前比较先进的是基于视觉信息的网页信息提取方法,通过浏览器接口或者内核对目标网页预渲染,然后基于网页的视觉规律提取网页数据记录。经典的 VIPS 算法首先从 DOM 树中提取出所有合适的页面区域,然后根据这些页面和分割条重新构建 Web 页面的语义结构。作为对 VIPS 的拓展,ViNT、ViPER、ViDE 也成功利用了网页的视觉特征来实现数据提取。CMDR 为通过神经网络学习多记录型页面中的特征,结合基于 DOM 结构信息的 MDR 方法,挖掘社区论坛页面的数据区域。与上述方法不同,VIBS 将图像领域的 CNN 卷积神经网络运用于网页的截图,同时通过类 VIPS 算法生成视觉块,最后结合两个阶段的结果识别网页的正文区域。另外还有最新的国内提出的 VBIE 方法,基于网页视觉的基础上改进,可以实现无监督的网页信息提取。

以上内容主要参考自论文:《王卫红等:基于可视块的多记录型复杂网页信息提取算法》,算法可从该论文参考文献查阅。

下面我们来介绍两个比较基础的工具包 Readability 和 Newspaper 的用法,这两个包经我测试其实准确率并不是很好,主要是让大家大致对智能解析有初步的理解。后面还会介绍一些更加强大的智能化解析算法。

Readability

Readability 实际上是一个算法,并不是一个针对某个语言的库。其主要原理就是计算了 DOM 的文本密度,另外根据一些常见的 DOM 属性如 id、class 等计算了一些 DOM 的权重,最后分析得到了对应的 DOM 区块,进而提取出具体的文本内容。 现在搜索 Readability 其实已经找不到了,取而代之的是一个 JavaScript 工具包,叫做 mercury-parser,据我所知应该是 Readability 不维护了,换成了 mercury-parser。后者现在也做成了一个 Chrome 插件,大家可以下载使用一下。 回归正题,这次主要介绍的是 Python 的 Readability 实现,现在其实有很多开源版本,本文选取的是 https://github.com/buriy/python-readability,是基于最早的 Python 版本的 Readability 库 https://github.com/timbertson/python-readability 二次开发的,现在已经发布到了 PyPi,大家可以直接下载安装使用。 安装很简单,通过 pip 安装即可:

1
pip3 install readability-lxml

安装好了之后便可以通过导入 readability 使用了,下面我们随便从网上找一个新闻页面,比如:https://tech.163.com/19/0909/08/EOKA3CFB00097U7S.html,其页面截图如下页面示例 我们的目的就是它的正文、标题等内容。下面我们用 Readability 试一下,示例如下:

1
2
3
4
5
6
7
8
import requests
from readability import Document

url = 'https://tech.163.com/19/0909/08/EOKA3CFB00097U7S.html'
html = requests.get(url).content
doc = Document(html)
print('title:', doc.title())
print('content:', doc.summary(html_partial=True))

在这里我们直接用 requests 库对网页进行了请求,获取了其 HTML 页面内容,赋值为 html。 然后引入了 readability 里的 Document 类,使用 html 变量对其进行初始化,然后我们分别调用了 title 方法和 summary 方法获得了其标题和正文内容。 这里 title 方法就是获取文章标题的,summary 就是获取文章正文的,但是它获取的正文可能包含一些 HTML 标签。这个 summary 方法可以接收一个 html_partial 参数,如果设置为 True,返回的结果则不会再带有 <html><body> 标签。 看下运行结果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
title: 今年iPhone只有小改进?分析师:还有其他亮点_网易科技
content: <div><div class="post_text" id="endText">
<p class="otitle">
(原标题:Apple Bets More Cameras Can Keep iPhone Humming)
</p>
<p class="f_center"><img alt="今年iPhone只有小改进?分析师:还有其他亮点" src="http://cms-bucket.ws.126.net/2019/09/09/d65ba32672934045a5bfadd27f704bc1.jpeg"/><span>图示:苹果首席执行官蒂姆·库克(Tim Cook)在6月份举行的苹果全球开发者大会上。</span></p><p>网易科技讯 9月9日消息,据国外媒体报道,和过去的12个年头一样,新款
... 中间省略 ...
<p>苹果还即将推出包括电视节目和视频游戏等内容的新订阅服务。分析师表示,该公司最早可能在本周宣布TV+和Arcade等服务的价格和上线时间。</p><p>Strategy Analytics的尼尔·莫斯顿(Neil Mawston)表示,可穿戴设备和服务的结合将是苹果业务超越iPhone的关键。他说,上一家手机巨头诺基亚公司在试图进行类似业务转型时就陷入了困境之中。(辰辰)</p><p><b>相关报道:</b></p><p><a href="https://tech.163.com/19/0908/09/EOHS53RK000999LD.html" target="_self" urlmacroreplace="false">iPhone 11背部苹果Logo改为居中:为反向无线充电</a></p><p><a href="https://tech.163.com/19/0907/08/EOF60CBC00097U7S.html" target="_self" urlmacroreplace="false">2019年新iPhone传言汇总,你觉得哪些能成真</a>  </p><p/>
<p/>
<div class="ep-source cDGray">
<span class="left"><a href="http://tech.163.com/"><img src="https://static.ws.126.net/cnews/css13/img/end_tech.png" alt="王凤枝" class="icon"/></a> 本文来源:网易科技报道 </span>
<span class="ep-editor">责任编辑:王凤枝_NT2541</span>
</div>
</div>
</div>

可以看到,标题提取是正确的。正文其实也是正确的,不过这里还包含了一些 HTML 标签,比如 <img><p> 等,我们可以进一步通过一些解析库来解析。 看下源码吧,比如提取标题的方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
def normalize_entities(cur_title):
entities = {
u'u2014':'-',
u'u2013':'-',
u'&mdash;': '-',
u'&ndash;': '-',
u'u00A0': ' ',
u'u00AB': '"',
u'u00BB': '"',
u'&quot;': '"',
}
for c, r in entities.items():
if c in cur_title:
cur_title = cur_title.replace(c, r)

return cur_title

def norm_title(title):
return normalize_entities(normalize_spaces(title))

def get_title(doc):
title = doc.find('.//title')
if title is None or title.text is None or len(title.text) == 0:
return '[no-title]'

return norm_title(title.text)

def title(self):
"""Returns document title"""
return get_title(self._html(True))

title 方法实际上就是调用了一个 get_title 方法,它怎么做的?实际上就是用了一个 XPath 只解析了 <title> 标签里面的内容,别的没了。如果没有,那就返回 [no-title]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
def summary(self, html_partial=False):
ruthless = True
while True:
self._html(True)
for i in self.tags(self.html, 'script', 'style'):
i.drop_tree()
for i in self.tags(self.html, 'body'):
i.set('id', 'readabilityBody')
if ruthless:
self.remove_unlikely_candidates()
self.transform_misused_divs_into_paragraphs()
candidates = self.score_paragraphs()

best_candidate = self.select_best_candidate(candidates)

if best_candidate:
article = self.get_article(candidates, best_candidate,
html_partial=html_partial)
else:
if ruthless:
ruthless = False
continue
else:
article = self.html.find('body')
if article is None:
article = self.html
cleaned_article = self.sanitize(article, candidates)
article_length = len(cleaned_article or '')
retry_length = self.retry_length
of_acceptable_length = article_length >= retry_length
if ruthless and not of_acceptable_length:
ruthless = False
continue
else:
return cleaned_article

这里我删除了一些冗余的调试的代码,只保留了核心的代码,其核心实现就是先去除一些干扰内容,然后找出一些疑似正文的 candidates,然后再去寻找最佳匹配的 candidates 最后提取其内容返回即可。 然后再找到获取 candidates 方法里面的 score_paragraphs 方法,又追踪到一个 score_node 方法,就是为每一个节点打分的,其实现如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def score_node(self, elem):
content_score = self.class_weight(elem)
name = elem.tag.lower()
if name in ["div", "article"]:
content_score += 5
elif name in ["pre", "td", "blockquote"]:
content_score += 3
elif name in ["address", "ol", "ul", "dl", "dd", "dt", "li", "form", "aside"]:
content_score -= 3
elif name in ["h1", "h2", "h3", "h4", "h5", "h6", "th", "header", "footer", "nav"]:
content_score -= 5
return {
'content_score': content_score,
'elem': elem
}

这什么意思呢?你看如果这个节点标签是 div 或者 article 等可能表征正文区块的话,就加 5 分,如果是 aside 等表示侧栏的内容就减 3 分。这些打分也没有什么非常标准的依据,可能是根据经验累积的规则。 另外还有一些方法里面引用了一些正则匹配来进行打分或者替换,其定义如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 REGEXES = {
'unlikelyCandidatesRe': re.compile('combx|comment|community|disqus|extra|foot|header|menu|remark|rss|shoutbox|sidebar|sponsor|ad-break|agegate|pagination|pager|popup|tweet|twitter', re.I),
'okMaybeItsACandidateRe': re.compile('and|article|body|column|main|shadow', re.I),
'positiveRe': re.compile('article|body|content|entry|hentry|main|page|pagination|post|text|blog|story', re.I),
'negativeRe': re.compile('combx|comment|com-|contact|foot|footer|footnote|masthead|media|meta|outbrain|promo|related|scroll|shoutbox|sidebar|sponsor|shopping|tags|tool|widget', re.I),
'divToPElementsRe': re.compile('<(a|blockquote|dl|div|img|ol|p|pre|table|ul)', re.I),
#'replaceBrsRe': re.compile('(<br[^>]*>[ nrt]*){2,}',re.I),
#'replaceFontsRe': re.compile('<(/?)font[^>]*>',re.I),
#'trimRe': re.compile('^s+|s+$/'),
#'normalizeRe': re.compile('s{2,}/'),
#'killBreaksRe': re.compile('(<brs*/?>(s|&nbsp;?)*){1,}/'),
'videoRe': re.compile('https?://(www.)?(youtube|vimeo).com', re.I),
#skipFootnoteLink: /^s*([?[a-z0-9]{1,2}]?|^|edit|citation needed)s*$/i,
}

比如这里定义了 unlikelyCandidatesRe,就是不像 candidates 的 pattern,比如 foot、comment 等等,碰到这样的标签或 pattern 的话,在计算分数的时候都会减分,另外还有其他的 positiveRe、negativeRe 也是一样的原理,分别对匹配到的内容进行加分或者减分。 这就是 Readability 的原理,是基于一些规则匹配的打分模型,很多规则其实来源于经验的累积,分数的计算规则应该也是不断地调优得出来的。 另外其他的就没了,Readability 并没有提供提取时间、作者的方法,另外此种方法的准确率也是有限的,但多少还是省去了一些人工成本。

Newspaper

另外还有一个智能解析的库,叫做 Newspaper,提供的功能更强一些,但是准确率上个人感觉和 Readability 差不太多。 这个库分为 Python2 和 Python3 两个版本,Python2 下的版本叫做 newspaper,Python3 下的版本叫做 newspaper3k,这里我们使用 Python3 版本来进行测试。 其 GitHub 地址是:https://github.com/codelucas/newspaper,官方文档地址是:[https://newspaper.readthedocs.io](https://newspaper.readthedocs.io/)。 在安装之前需要安装一些依赖库,可以参考官方的说明:https://github.com/codelucas/newspaper#get-it-now。 安装好必要的依赖库之后,就可以使用 pip 安装了:

1
pip3 install newspaper3k

安装成功之后便可以导入使用了。 下面我们先用官方提供的实例来过一遍它的用法,官方提供的示例是使用了这个链接:https://fox13now.com/2013/12/30/new-year-new-laws-obamacare-pot-guns-and-drones/,其页面截图如下官方示例 下面用一个实例来感受一下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
from newspaper import Article

url = 'https://fox13now.com/2013/12/30/new-year-new-laws-obamacare-pot-guns-and-drones/'
article = Article(url)
article.download()
# print('html:', article.html)

article.parse()
print('authors:', article.authors)
print('date:', article.publish_date)
print('text:', article.text)
print('top image:', article.top_image)
print('movies:', article.movies)

article.nlp()
print('keywords:', article.keywords)
print('summary:', article.summary)

这里从 newspaper 库里面先导入了 Article 这个类,然后直接传入 url 即可,首先需要调用它的 download 方法,将网页爬取下来,否则直接进行解析会抛出错误的。

但我总感觉这个设计挺不友好的,parse 方法不能判断下,如果没执行 download 就自动执行 download 方法吗?如果不 download 其他的不什么都干不了吗?

好的,然后我们再执行 parse 方法进行网页的智能解析,这个功能就比较全了,能解析 authors、publish_date、text 等等,除了正文还能解析作者、发布时间等等。 另外这个库还提供了一些 NLP 的方法,比如获取关键词、获取文本摘要等等,在使用前需要先执行以下 nlp 方法。 最后运行结果如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
authors: ['Cnn Wire']
date: 2013-12-30 00:00:00
text: By Leigh Ann Caldwell

WASHINGTON (CNN) — Not everyone subscribes to a New Year’s resolution, but Americans will be required to follow new laws in 2014.

Some 40,000 measures taking effect range from sweeping, national mandates under Obamacare to marijuana legalization in Colorado, drone prohibition in Illinois and transgender protections in California.

Although many new laws are controversial, they made it through legislatures, public referendum or city councils and represent the shifting composition of American beliefs.
...
...
Colorado: Marijuana becomes legal in the state for buyers over 21 at a licensed retail dispensary.

(Sourcing: much of this list was obtained from the National Conference of State Legislatures).
top image: https://localtvkstu.files.wordpress.com/2012/04/national-news-e1486938949489.jpg?quality=85&strip=all
movies: []
keywords: ['drones', 'national', 'guns', 'wage', 'law', 'pot', 'leave', 'family', 'states', 'state', 'latest', 'obamacare', 'minimum', 'laws']
summary: Oregon: Family leave in Oregon has been expanded to allow eligible employees two weeks of paid leave to handle the death of a family member.
Arkansas: The state becomes the latest state requiring voters show a picture ID at the voting booth.
Minimum wage and former felon employmentWorkers in 13 states and four cities will see increases to the minimum wage.
New Jersey residents voted to raise the state’s minimum wage by $1 to $8.25 per hour.
California is also raising its minimum wage to $9 per hour, but workers must wait until July to see the addition.

这里省略了一些输出结果。 可以看到作者、日期、正文、关键词、标签、缩略图等信息都被打印出来了,还算是不错的。 但这个毕竟是官方的实例,肯定是好的,我们再测试一下刚才的例子,看看效果如何,网址还是:https://tech.163.com/19/0909/08/EOKA3CFB00097U7S.html,改写代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
from newspaper import Article

url = 'https://tech.163.com/19/0909/08/EOKA3CFB00097U7S.html'
article = Article(url, language='zh')
article.download()
# print('html:', article.html)

article.parse()
print('authors:', article.authors)
print('title:', article.title)
print('date:', article.publish_date)
print('text:', article.text)
print('top image:', article.top_image)
print('movies:', article.movies)

article.nlp()
print('keywords:', article.keywords)
print('summary:', article.summary)

这里我们将链接换成了新闻的链接,另外在 Article 初始化的时候还加了一个参数 language,其值为 zh,代表中文。 然后我们看下运行结果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
Building prefix dict from /usr/local/lib/python3.7/site-packages/jieba/dict.txt ...
Dumping model to file cache /var/folders/1g/l2xlw12x6rncs2p9kh5swpmw0000gn/T/jieba.cache
Loading model cost 1.7178938388824463 seconds.
Prefix dict has been built succesfully.
authors: []
title: 今年iPhone只有小改进?分析师:还有其他亮点
date: 2019-09-09 08:10:26+08:00
text: (原标题:Apple Bets More Cameras Can Keep iPhone Humming)

图示:苹果首席执行官蒂姆·库克(Tim Cook)在6月份举行的苹果全球开发者大会上。

网易科技讯 99日消息,据国外媒体报道,和过去的12个年头一样,新款iPhone将成为苹果公司本周所举行年度宣传活动的主角。但人们的注意力正转向需要推动增长的其他苹果产品和服务。
...
...
Strategy Analytics的尼尔·莫斯顿(Neil Mawston)表示,可穿戴设备和服务的结合将是苹果业务超越iPhone的关键。他说,上一家手机巨头诺基亚公司在试图进行类似业务转型时就陷入了困境之中。(辰辰)

相关报道:

iPhone 11背部苹果Logo改为居中:为反向无线充电

2019年新iPhone传言汇总,你觉得哪些能成真
top image: https://www.163.com/favicon.ico
movies: []
keywords: ['trust高级投资组合经理丹摩根dan', 'iphone', 'mawston表示可穿戴设备和服务的结合将是苹果业务超越iphone的关键他说上一家手机巨头诺基亚公司在试图进行类似业务转型时就陷入了困境之中辰辰相关报道iphone', 'xs的销售疲软状况迫使苹果在1月份下调了业绩预期这是逾15年来的第一次据贸易公司susquehanna', 'xs机型发布后那种令人失望的业绩重演iphone', '今年iphone只有小改进分析师还有其他亮点', 'more', 'xr和iphone', 'morgan说他们现在没有任何真正深入的进展只是想继续让iphone这款业务继续转下去他乐观地认为今年发布的新款手机将有足够多的新功能为一个非常成熟的产品增加额外的功能让火车继续前进这种仅限于此的态度说明了苹果自2007年发布首款iphone以来所面临的挑战iphone销售占苹果公司总营收的一半以上这让苹果陷入了一个尴尬的境地既要维持核心产品的销量另一方面又需要减少对它的依赖瑞银ubs今年5月份对8000名智能手机用户进行了相关调查其发布的年度全球调查报告显示最近iphone在人脸识别技术等方面的进步并没有引起一些消费者的共鸣他们基本上都认为苹果产品没有过去几年那么独特或者惊艳品牌也没有过去几年那么有吸引力很多人使用老款手机的时间更长自己认为也没有必要升级到平均售价949美元的新款iphone苹果需要在明年销售足够多的iphone以避免像去年9月份iphone', 'keep', '原标题apple']
summary: (原标题:Apple Bets More Cameras Can Keep iPhone Humming)图示:苹果首席执行官蒂姆·库克(Tim Cook)在6月份举行的苹果全球开发者大会上。网易科技讯 99日消息,据国外媒体报道,和过去的12个年头一样,新款iPhone将成为苹果公司本周所举行...亚公司在试图进行类似业务转型时就陷入了困境之中。(辰辰)相关报道:iPhone 11背部苹果Logo改为居中:为反向无线充电2019年新iPhone传言汇总,你觉得哪些能成真

中间正文很长省略了一部分,可以看到运行时首先加载了一些中文的库包,比如 jieba 所依赖的词表等等。 解析结果中,日期的确是解析对了,因为这个日期格式的的确比较规整,但这里还自动给我们加了东八区的时区,贴心了。作者没有提取出来,可能是没匹配到 来源 两个字吧,或者词库里面没有,标题、正文的提取还算比较正确,也或许这个案例的确是比较简单。 另外对于 NLP 部分,获取的关键词比较迷,长度有点太长了。summary 也有点冗余。 另外 Newspaper 还提供了一个较为强大的功能,就是 build 构建信息源。官方的介绍其功能就是构建一个新闻源,可以根据传入的 URL 来提取相关文章、分类、RSS 订阅信息等等。 我们用实例感受一下:

1
2
3
4
5
6
7
8
9
10
11
12
import newspaper

source = newspaper.build('http://www.sina.com.cn/', language='zh')
for category in source.category_urls():
print(category)

for article in source.articles:
print(article.url)
print(article.title)

for feed_url in source.feed_urls():
print(feed_url)

在这里我们传入了新浪的官网,调用了 build 方法,构建了一个 source,然后输出了相关的分类、文章、RSS 订阅等内容,运行结果如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
http://cul.news.sina.com.cn
http://www.sina.com.cn/
http://sc.sina.com.cn
http://jiangsu.sina.com.cn
http://gif.sina.com.cn
....
http://tj.sina.com.cn
http://travel.sina.com.cn
http://jiaoyi.sina.com.cn
http://cul.sina.com.cn
https://finance.sina.com.cn/roll/2019-06-12/doc-ihvhiqay5022316.shtml
经参头版:激发微观主体活力加速国企改革
http://eladies.sina.com.cn/feel/xinli/2018-01-25/0722/doc-ifyqwiqk0463751.shtml
我们别再联系了
http://finance.sina.com.cn/roll/2018-05-13/doc-ihamfahx2958233.shtml
新违约时代到来!违约“常态化”下的市场出清与换血
http://sports.sina.com.cn/basketball/2019worldcup/2019-09-08/doc-iicezzrq4390554.shtml
罗健儿26分韩国收首胜
...
http://travel.sina.com.cn/outbound/pages/2019-09-05/detail-iicezzrq3622449.shtml
菲律宾海滨大道 夜晚让人迷离
http://travel.sina.com.cn/outbound/pages/2016-08-19/detail-ifxvcnrv0334779.shtml
关岛 用双脚尽情享受阳光与海滩
http://travel.sina.com.cn/domestic/pages/2019-09-04/detail-iicezzrq3325092.shtml
秋行查干浩特草原
http://travel.sina.com.cn/outbound/pages/2019-09-03/detail-iicezueu3050710.shtml
白羊座的土豪之城迪拜
http://travel.sina.com.cn/video/baidang/2019-08-29/detail-ihytcitn2747327.shtml
肯辛顿宫藏着维多利亚的秘密
http://cd.auto.sina.com.cn/bdcs/2017-08-15/detail-ifyixias1051586.shtml

可以看到它输出了非常多的类别链接,另外还有很多文章列表,由于没有 RSS 订阅内容,这里没有显示。 下面把站点换成我的博客:https://cuiqingcai.com,博客截图如下博客截图 看看运行结果:

1
2
https://cuiqingcai.com
https://cuiqingcai.com

似乎不太行啊,一篇文章都没有,RSS 也没有,可见其功能还有待优化。 Newspaper 的基本用法介绍到这里,更加详细的用法可以参考官方文档:https://newspaper.readthedocs.io。个人感觉其中的智能解析可以用用,不过据我的个人经验,感觉还是很多解析不对或者解析不全的, 以上便是 Readability 和 Newspaper 的介绍。

其他方案

另外除了这两个库其实还有一些比较优秀的算法,由于我们处理的大多为中文文档,所以一些在中文上面的研究是比较有效的,在这里列几个值得借鉴的中文论文供大家参考:

  • 洪鸿辉等,基于文本及符号密度的网页正文提取方法
  • 梁东等,基于支持向量机的网页正文内容提取方法
  • 王卫红等,基于可视块的多记录型复杂网页信息提取算法

今天还看到一位大佬「青南」根据上面第一篇论文所实现的 GeneralNewsExtractor,GitHub 地址为:https://github.com/kingname/GeneralNewsExtractor,经测试准确率还不错,比 Readability 和 Newspaper 的解析效果要好。我也跟作者进行了交流,后续可能还会基于其他的 Feature 或依赖于视觉化的方法进行优化,大家可以关注下,谢谢!

技术杂谈

这两天想必大家应该被一个软件刷屏了,它的名字叫做 Zao,中文音译就叫“造”。它为什么这么火呢?是因为我们可以上传自己的一张照片,他就能把我们的脸替换成一些热门视频的男主或女主的脸,也就是视频换脸。 比如有人尝试了把尼古拉斯赵四的脸换到美国队长的脸上,美队的气质简直就是被垄断了,大家可以扫码看看: 美队变赵四 视频换脸技术大家应该早有耳闻,但这个软件有点意思,它抓住了几个点使得它一炮而红。 第一是这个软件的效果确实不错,我拿自己也做了实验,发现确实它渲染的一些结果几乎毫无违和感,毕竟这个软件核心拼的就是技术。 第二这个软件贴近于日常生活,我们可以把自己的照片上传,让我们真正成为视频里的主角。另外视频选材很有讲究,都是一些剪辑过的明星精彩镜头,这样我们生成的视频镜头会让我们有变成明星的感觉,非常有代入感。

技术实现

作为一名程序员,当然最关心的可能就是它的技术实现了,毋庸置疑它肯定是利用了深度学习的一些技术。我看了一些文章和调研,大体了解了一下,下面稍微分析一下里面用到的一些技术。 整体而言呢,这个过程分为三步,他们分别是:

  • 人脸定位
  • 人脸转换
  • 人脸融合

人脸定位

现在深度学习对于人脸识别和定位的研究技术已经非常成熟和精准了,其核心就是使用了卷积神经网络,即 CNN,不同的模型架构对于识别的准确率有不用的表现。 对于人脸的定位,一般是使用脸部的关键点定位的,这些点叫做 Landmarks。在一张人脸图像上,每张脸的轮廓和五官的位置都会被打上点,比如整个脸部的轮廓用一些点描出来,鼻子、眼睛、唇形同样用一些点描出来。 Facial Feature Detection 一般来说一张脸会用 68 个点来标记出来,每识别的模型接收一张人脸图像,输出这 68 个点的坐标,这样我们就可以实现人脸定位了。 现在现成的模型也很多了,比如 dlib,opencv 等开源工具包可以直接拿来使用了,如果要更精准地话可以使用更复杂的卷积神经网络模型来实现,大家可以了解下相关论文。

人脸生成

有了标记点以后,这个软件就可以把我们的人脸提取出来了,但是这有个问题,我们上传的是一张静态图片,总不能直接生硬地替换进去吧,比如我们上传的是一张正脸照片,那视频里的一些侧脸画面直接贴上那不就没法看了吗? 这时候就要用到另外一个核心技术叫做人脸生成技术,有了它我们就可以对人脸进行生成了,比如根据一张正脸图生成一张侧脸图。目前人脸生成技术主要有两种,有 GAN(生成对抗网络)和 VAE(变分自编码器),下面简单介绍一下它们的原理。 对于 GAN 来说,它叫做生成对抗网络,为什么叫对抗网络呢?是因为模型在训练的过程中一直有两个东西在做对抗,这俩东西分别叫 Generator(生成器)和 Discriminator(判别器)。前者主要负责生成一张人脸,越像越牛逼。后者主要负责判断分辨前者生成的人脸是不是真的,判定越准越牛逼。二者在这个过程中为了变得越来越牛逼,前者就会尽力去生成更像的人脸来欺骗后者,后者也会尽力去判别生成的人脸是不是真的来打击前者。这样二者在不断地训练和对抗过程中,前者生成的结果就会越来越好了。 对于 VAE 呢,它是通过一些无监督学习的方式将人脸信息进行压缩,由编码器把它表示成一个短向量,这些向量里就包含了人脸的基本信息,比如肤色、唇形等信息,这样整个模型就可以学习到人脸的共性。然后,解码器将向量解码,将其转换为某一特定的人脸。这样就等于经过一层中间向量完成了从一张人脸到另一张人脸的转换。

图像融合

最后的阶段就是图像融合了,也就是把生成的新的人脸和原来图像的背景融合,使之不会产生违和感。 在这个软件中,视频是由一帧一帧组成的,那么在转换的时候也需要一帧一帧处理,最后处理完成后再合成整个视频。 以上也就是我所了解到的变脸的一些方法。

安全性

有人说,这个技术不是什么好技术。万一有人拿着我们的照片一变脸,就能够把我们任意的表情和头部动作模拟出来,拿着去做认证,比如刷脸支付什么的咋办,那我们的钱不就被盗刷了吗? 对于这个问题,支付宝官方也做了回应,支付宝称刷脸支付实际上会通过软硬件结合的方式进行检测,其会判断被刷物体是否是照片、视频或者软件模拟的方式生成的,可以有效避免身份冒用情况。其中有一个核心技术就是通过 3D 结构光摄像头来进行信息采集和识别,如果被拍摄物体是平面的,也就是说如果是照片或者视频,是无法通过检测的。 支付宝回应 这时候我自然而然想到,既然用的是 3D 结构光摄像头,那么如果用了 3D 打印技术把一个人的肖像打印出来,或者用一个非常逼真的蜡像来进行刷脸识别,能不能通过呢?我看了一些报道,发现不少案例的确通过了刷脸测试,比如解开了 iPhone 面部识别锁等等。但要通过 3D 打印技术来模拟一个人的肖像成本还是蛮高的,所以基本上也不太会有人来搞这些。 如果对此还心有余悸的话,支付宝还回应称,即便是真的被盗刷了,支付宝也会通过保险公司进行全额赔付。 所以基本上是不用担心其安全性的,尤其是 Zao 这个软件的出现是没有对刷脸支付的风险造成大的影响的,其就是增加了一个活体视频模拟的实现,对刷脸支付的安全性没有出现大的突破性威胁。

隐私性

这个就要好好说一下了,这个软件的出现同时引起了另一个轩然大波,那就是其中的隐私条款。 其隐私条款有一条是这样的:

用户上传发布内容后,意味着同意授予 ZAO 及其关联公司以及 ZAO 用户在“全球范围内完全免费、不可撤销、永久、可转授权和可再许可的权利”,“包括但不限于可以对用户内容进行全部或部分的修改与编辑(如将短视频中的人脸或者声音换成另一个人的人脸或者声音等)以及对修改前后的用户内容进行信息网络传播以及《著作权法》规定的由著作权人享有的全部著作财产权利及邻接权利”。

这条款没人说还真没注意到,因为一般咱用一个软件,一般不会去仔细看它的条款,那么密密麻麻的一坨,有几个人会去仔细看呢?但要不同意,这个软件还没法用,所以用过这个软件的人,这个条款一定是已经同意了。 这条条款其实是很过分的,同意授予 Zao 及其关联公司以及 Zao 用户在“全球范围内完全免费、不可撤销、永久、可转授权和可再许可的权利。注意这里有几个字,完全免费、不可撤销、永久、可转授权、可再许可,这几个词就代表我们已经把我们的肖像权永久授予了 Zao 及其关联公司了,而且不能撤销,账号注销了也不能撤销,也就是以后它们可以有权利永久滥用我们的肖像。更可怕的是,其中还有一个词叫可转授权,那也就是说,Zao 可以对我们的肖像权进行转授权,你懂得,给点钱,啥办不到呢?这就更无法控制了,这可能就意味着,世界上任何一个人可能都能获得我们的肖像权。 所以说,如果你还没用的话,一定要谨慎谨慎再谨慎! 哎,反正我已经同意了,貌似我现在也没什么办法了。

社会影响

这个软件的出现,更深一点想,其实它所隐含的影响还是蛮大的。 有了这个变脸技术,如果有人获得了我们在条款里面所”捐出“的肖像权,拿着我们的照片去生产那种你懂得的影片,把视频里面的男主或者女主换成我们的人脸,然后到处传播,或者以此作为敲诈勒索的工具。即便我们有理,那也说不清了,首先这个条款已经说了它们可以有权利随意使用我们的肖像,所以告侵犯肖像权已经行不通了,而且即使我们有证据证明这是假的,但这种视频的传播也一定会带来非常大的影响。 按照现在大众们的观念,比如说一张图,我们如果不信的话可以说它是 P 的,但如果换做是视频的话,很多人可能就会相信了,因为很多人不知道视频中的肖像也可以伪造得这么真了,毕竟很多人并不知道这种技术。因此,有了这种技术的出现,以后视频类的证据,可能也不可信了。因此这个软件的出现,可以说从另一个侧面昭示,以后视频也不能作为犯案的证据和验证人的真伪的依据了。 所以以后可能是这样子的:

  • 坐在电脑面前的网络女主播,即便不开美颜和滤镜,你所看到的她也不是真的她了。
  • 你要给人打个钱,说开个视频吧,我看看是不是真的你,即便看到的是他,你也不能信了。
  • 有人要 Qiao Zha 你,把你的人脸换成 Zuo An 分子的脸,你到哪里说理去?
  • 某一天,你作为男女主角,出现在了 P 站和 91….

我一开始想的还没这么深,边想边写,写到这,我自己都开始后怕了… 怎么甚至感觉,以后的社会可能会乱套了呢?这可能就是 AI 发展的一个隐患吧。 所以写到最后,虽然这个软件很有意思,但还是劝大家还没有用的就不要用了吧,真的很可怕。同时我也不知道这个软件这样的条款和做法会不会有什么问题,但还是希望能引起有关部门的注意。 以后,也希望大家也可以在使用软件的时候,要更加谨慎和小心,有条款就稍微看一看,尤其是对于这种和用户隐私相关的软件,要更加心存戒备。

参考文章

本文参考来源:

  • 机器之心:刷屏的 ZAO 换脸 APP 你玩了吗?
  • 支付宝推出的刷脸支付是基于“活体检测”技术做支撑

技术杂谈

开发者如何学好 MongoDB

作为一名研发,数据库是或多或少都会接触到的技术。MongoDB 是热门的 NoSQL 之一,我们怎样才能学好 MongoDB 呢? 本篇文章,我们将从以下几方面讨论这个话题:

  1. MongoDB 是什么
  2. 我如何确定我需要学习 MongoDB
  3. 开发者应该掌握 MongoDB 的哪些知识
  4. 学习的选择和困境

我们先来了解一下,MongoDB 为何物。 NoSQL 泛指非关系型数据库,该词是关系型数据库(即 SQL)的相对称呼。MongoDB 是非关系型数据库(NoSQL)中较为人熟知的一种。它拥有很多优秀特性,例如高性能、高可用、支持丰富的查询语句、无需预定义数据模型和水平可伸缩等,适合存储结构化、半结构化的文档和特定格式的文档,这些特性使它受到众多开发者的青睐。 我们通过几个例子来看看 MySQL 与 MongoDB 的差异。 与 MySQL 数据库不同的是,MongoDB 不需要预先定义表和字段,这正是它灵活性的体现。MongoDB 可以拥有多个数据库,每个数据库可以拥有多个集合,每个集合可以存储多份文档,这种关系与 SQL 数据库中的“数据库、表、数据”相当。下图描述了 MongoDB 中数据库、集合和文档的关系: 数据库 fotoo 中有两个集合,它们分别是 playerbooks。每个集合中都包含了许多文档,例如集合 books 中关于书籍《红楼梦》的文档,集合 player 中关于球员 James 的文档。 在查询方面,一个简单的 MySQL 查询语句为 SELECT * FROM tablename,对应的 MongoDB 查询语句为 db.tablename.find()。在面对多步骤的查询条件时,MongoDB 更游刃有余。例如: “统计数据库 articscore 大于 70 且小于 90 的文档数量” 这样的需求,用 MongoDB 的聚合操作就可以轻松完成,对应示例如下:

1
2
3
4
\> db.artic.aggregate([
... {$match: {score: {$gt: 70, $lt: 90}}},
... {$group: {_id: null, number: {$sum: 1}}}
... ])

这个例子或许简单了些,在 MySQL 中我们可以用 countwhere 完成,但如果复杂度再提高四五个等级呢?例如在此基础上增加对某个字段的运算、替换、排序、分组计数、增删字段,用 MySQL 来实现就会很头疼,而 MongoDB 的聚合可以让我们轻松地完成这类复杂需求。

我如何确定我需要学习 MongoDB

MongoDB 是近些年涌现的几十种 NoSQL 中第一梯队的成员,另外一个为人熟知的是 Redis。你可能会有”我如何确定我需要学习 MongoDB 呢?“ 这样的疑问,面对这个问题,我们可以通过 MongoDB 的特点和应用场景着手。

  • MongoDB 适合存储结构确定或不确定的文档。例如爬虫爬取的信息常缺失字段的情况或字段参差不齐的情况;
  • 对数据库可用性要求较高的情况。MySQL 这类数据库要做到负载均衡、自动容灾和数据同步需要借助外部工具,而 MongoDB 的复制集可以让我们轻松完成这一系列的工作。相对接借助第三方工具来说,复制集的稳定性更高。
  • 分库分表是 WEB 开发中常用到的数据库优化手段,MySQL 的分库分表要考虑的问题非常多,例如字段冗余、数据组装跨节点分页、排序和数据迁移等,而 MongoDB 的分片可以让我们轻松完成“分库分表”的工作。MongoDB 的分片机制使我们不必将心思放在由“分库分表”带来的问题,而是专注于具体需求。
  • 同样的,MySQL 的权限控制、定义数据模型、数据库备份和恢复等功能在 MongoDB 上也有。
  • MongoDB 中支持地理位置的存储和查询,这意味着 MongoDB 可以用于共享单车、共享雨伞、汽车定位等业务中。

我们常用的关系型数据库无法满足 WEB2.0 时代的需求,在实际应用中暴露了很多难以克服的问题。NoSQL 的产生就是为了解决例如海量数据的存储弹性可伸缩灵活性等方面的挑战,所以作为一名合格的开发者,应该抽空学习 SQL 以外的数据库知识。

开发者应该掌握 MongoDB 的哪些知识

学习前,我们需要明白自身定位:专业 DBA 或者日常开发使用。MongoDB 有完善的培训体系和对应的认证考试,对于希望成为专业 DBA 的朋友我建议到 MongoDB 官方网站了解。而对于仅需要满足日常开发需求的朋友,我建议学习的内容如下:

  • MongoDB 在各个平台的安装方法
  • MongoDB 数据库和集合的基本操作
  • MongoDB 文档 CRUD 操作,包括能够丰富 CRUD 的投影和修饰符等
  • MongoDB 流式聚合操作,这能够在数据库层面轻松完成复杂数据的处理,而不是用编程语言来处理
  • MongoDB 的数据模型,虽然它可以存储不规则的文档,但有些情况下定义数据模型可以提高查询效率

当然,除了这些基本操作之外我们还可以学习更多的知识提高个人竞争力,这些知识是:

  • MongoDB 执行计划和索引,执行计划可以让我们清楚的了解到查询语句的效率,而索引则是优化查询效率的常用手段
  • MongoDB 的复制集,这是提高 MongoDB 可用性,保证数据服务不停机的最佳手段
  • MongoDB 的分片,分片能够在数据量变得庞大之后保证效率
  • MongoDB 的事物,如果你将 MongoDB 用于 WEB 网站,那么事物是你必须学习的知识
  • MongoDB 数据库备份和还原,有了复制集后,备份就显得不是那么重要了,但并不是没有这个需求。而且 MongoDB 的备份可以精细到文档,这就非常有意义了。

学习的选择和困境

有一定工作经验的开发者,大多数情况下都会选择自学。有些在网上搜索对应的文章,有些则直接翻阅官方文档。我推荐的方式是翻阅官方文档,在遇到难以理解的观点时通过搜索引擎查找网友分享的文章。 自学的优点很多,缺点也很明显。例如:

  • 断断续续的学习,难以保持专注导致知识吸收不好
  • 耗费时间很长,虽然知道应该学习哪些方面的知识,但文档并不是按你所想而规划的,所以翻阅文档要费很多功夫
  • 知识不成体系,东看看西看看,没有归纳容易忘记
  • 学习就需要记笔记,这又是一件很费时间的事情
  • 官方文档有些观点难以理解,卡在半路很难受
  • 零星学了一两个月,也不确定学会了没有,内心毫无把握

如果不自学,就得找一些成体系的课程来帮助自己快速进步,少走弯路。知识付费时代,在条件允许的情况下适当地投入也是很好的选择。但面对动辄几百块的视频课程,不少开发者还是感觉略有压力,毕竟我们搬砖的经济压力也非常大。培训班就更不用说了,很少有专业教授单个数据库知识的,而且费用比视频课程更贵。 考虑到这些问题,这里推荐韦世东的 GitChat 文章 《超高性价比的 MongoDB 零基础快速入门实战教程》,这也是一个收费教程,但它售价不到 10 块钱。文章作者韦世东是:图灵签约作者、电子工业出版社约稿作者,华为云认证云享专家、掘金社区优秀作者、GitChat 认证作者,开源项目 aiowebsocket 作者。所以在文章质量上,大家可以放心。 这篇文章的内容几乎囊括了上面我们提到的所有知识点,看完这篇仅 5 万词的文章,你将收获:

  • 文档的 CRUD 操作和 Cursor 对象
  • 掌握流式聚合操作,轻松面对任何数据处理需求
  • 了解 MongoDB 的查询效率和优化
  • 如何提高 MongoDB 的可用性
  • 如何应对数据服务故障
  • 理解 MongoDB 的访问控制
  • 学会用数据模型降低数据冗余,提高效率
  • 掌握 mongodump 数据备份与还原方法

这样就可以胜任日常开发中对数据库操作能力的要求了。这篇文章适合对 MongoDB 感兴趣的零基础开发者或者有一定基础,想要继续巩固和加深学习的开发者。文章篇幅很长,内容详尽,不乏优质配图,例如描述复制集节点关系的图: 描述节主点掉线,重新选举主节点的图 如果你觉得有学习 MongoDB 的需要,且这篇文章规划的内容是你想要的内容,那么请长按下方图片识别二维码,前往订阅文章吧!

Python

在做程序开发的时候,我们经常会用到一些测试数据,相信大多数同学是这么来造测试数据的:

1
2
3
4
5
6
7
8
test1
test01
test02
测试1
测试2
测试数据1
这是一段测试文本
这是一段很长很长很长的测试文本...

中枪的请举手。 不仅要自己手动敲这些测试数据,还敲的这么假。那有啥办法呢?难不成有什么东西能自动给我造点以假乱真的数据啊?你别说,还真有! 在 Python 中有个神库,叫做 Faker,它可以自动帮我们来生成各种各样的看起来很真的”假“数据,让我们来看看吧!

安装

首先让我们来看看这个库的安装方法,实际上装起来非常简单,使用 pip 安装即可,Python3 版本的安装命令如下:

1
pip3 install faker

安装好了之后,我们使用最简单的例子来生成几个假数据试试:

1
2
3
4
5
6
from faker import Faker

faker = Faker()
print('name:', faker.name())
print('address:', faker.address())
print('text:', faker.text())

首先我们从 faker 这个包里面导入一个 Faker 类,然后将其实例化为 faker 对象,依次调用它的 name、address、text 方法,看下运行效果:

1
2
3
4
5
6
name: Nicholas Wilson
address: 70561 Simmons Road Apt. 893
Lake Raymondville, HI 35240
text: Both begin bring federal space.
Official start idea specific. Able under young fire.
Who show line traditional easy people. Until economic lead event case. Technology college his director style.

看到这里给我们生成了看起来很真的英文姓名、地址、长文本。 但我们是中国人,我们肯定想要生成中文的吧,不用担心,这个库对非常多的语言都有支持,当然也包括中文了,具体的支持的语言列表可以见:https://faker.readthedocs.io/en/master/locales.html。 这里几个比较常见的语言代号列一下:

  • 简体中文:zh_CN
  • 繁体中文:zh_TW
  • 美国英文:en_US
  • 英国英文:en_GB
  • 德文:de_DE
  • 日文:ja_JP
  • 韩文:ko_KR
  • 法文:fr_FR

那么如果要生成中文,只需要在 Faker 类的第一个参数传入对应的语言代号即可,例如简体中文就传入 zh_CN,所以上面的代码改写如下:

1
2
3
4
5
6
from faker import Faker

faker = Faker('zh_CN')
print('name:', faker.name())
print('address:', faker.address())
print('text:', faker.text())

运行结果如下:

1
2
3
4
5
6
7
name: 何琳
address: 宁夏回族自治区六盘水县南溪北镇街f座 912311
text: 经营软件积分开始次数专业.美国留言一种管理人民解决两个.支持只有地方一切.
文化目前东西的是不过所以.系统觉得这种为什一下他们.时候以及这样继续是一状态威望.
网站密码情况.问题一点那个还是.其实过程详细.
中国历史环境电话规定.经验上海控制不要生活.朋友运行项目我们.
以后今天那些使用免费国家加入但是.内容简介空间次数最大一个.日期通过得到日本北京.

可以看到一段中文的姓名、地址、长文本便生成了。看起来地址是省份、地级市、县级市、街道是随机组合的,文本也是一些随机的词组合而成的,但其实这样已经比文章一开头列的测试数据强太多了。 上面的代码每次运行得到的结果都是不同的,因为生成的结果都是随机组合而成的。

Provider

接下来让我们详细看下 faker 可以都生成什么类型的数据,具体的可用 API 可以看 https://faker.readthedocs.io/en/master/locales/zh_CN.html,这里面列出来了可用的所有方法。 但打开之后可以发现,这里面多了一个 Provider 对象,那么这个 Provider 是怎么一回事呢? 实际上这个 faker 库在设计上,为了解耦,将 Provider 对象做成了 Faker 对象的”插件“。Faker 可以添加一个个 Provider 对象,Provider 对象为 Faker 对象提供了生成某项数据的核心实现。就相当于 Faker 对象是一个生成器,它的生成功能依赖于什么呢?依赖于 Provider,是 Provider 提供给了 Faker 对象生成某项数据的能力。 正是因为 Faker 对象内置了一些 Provider 对象,Faker 对象才可以生成刚才所要求的姓名、地址和文本。 那么这时候我们肯定就很好奇了,既然 Faker 对象有生成数据的能力,那么它一定内置了一些默认的 Provider 对象,下面我们来打印看一下:

1
2
3
4
from faker import Faker

faker = Faker('zh_CN')
print(faker.providers)

运行结果如下:

1
[<faker.providers.user_agent.Provider object at 0x10249de48>, <faker.providers.ssn.zh_CN.Provider object at 0x10249dc18>, <faker.providers.python.Provider object at 0x10249dd68>, <faker.providers.profile.Provider object at 0x10249dcc0>, <faker.providers.phone_number.zh_CN.Provider object at 0x10249dc88>, <faker.providers.person.zh_CN.Provider object at 0x10249de80>, <faker.providers.misc.Provider object at 0x10249df60>, <faker.providers.lorem.zh_CN.Provider object at 0x10249dc50>, <faker.providers.job.zh_CN.Provider object at 0x10249de10>, <faker.providers.isbn.Provider object at 0x10249c6d8>, <faker.providers.internet.zh_CN.Provider object at 0x10249c828>, <faker.providers.geo.en_US.Provider object at 0x102484748>, <faker.providers.file.Provider object at 0x102484828>, <faker.providers.date_time.en_US.Provider object at 0x1023789e8>, <faker.providers.currency.Provider object at 0x102484780>, <faker.providers.credit_card.Provider object at 0x1024845f8>, <faker.providers.company.zh_CN.Provider object at 0x102499ef0>, <faker.providers.color.en_US.Provider object at 0x1023532e8>, <faker.providers.barcode.Provider object at 0x101cb6d30>, <faker.providers.bank.en_GB.Provider object at 0x102378f98>, <faker.providers.automotive.en_US.Provider object at 0x1017a5c50>, <faker.providers.address.zh_CN.Provider object at 0x101787c18>]

还真不少,通过名字可以看到有 user_agent、phone_number、isbn、credit_card 等 Provider,其中具有语言差异化的 Provider 还单独区分了语言,比如 phone_number 代表电话号码,这个不同语言的不同,所以这里就又分了一层 zh_CN,作了语言的区分。 这样一来,通用的 Provider 就直接处在某个 Provider 类别的模块中,具有语言差异的 Provider 就又根据不同的语言进一步划分了模块,设计上非常科学,易扩展又不冗余。 知道了 Faker 具有这么多 Provider 之后,我们来看看刚才调用的 name、address 等方法又和 Provider 有什么关系呢? 我们将 name、address、text 等方法打印一下看看:

1
2
3
4
5
6
from faker import Faker

faker = Faker('zh_CN')
print('name:', faker.name)
print('address:', faker.address)
print('text:', faker.text)

注意这里没有调用,而是直接打印了这三个方法,这样可以直接输出方法的对象形式的描述,结果如下:

1
2
3
name: <bound method Provider.name of <faker.providers.person.zh_CN.Provider object at 0x10f6dea58>>
address: <bound method Provider.address of <faker.providers.address.zh_CN.Provider object at 0x10e9e6cf8>>
text: <bound method Provider.text of <faker.providers.lorem.zh_CN.Provider object at 0x10f6dfda0>>

恍然大悟,原来我们调用的方法就是 Faker 对象调用的 Provider 里面的对应方法,比如 name 就是 faker.providers.person.zhCN.Provider 里面的 name 方法,二者是一致的,我们扒一扒源码验证下,源码在:[[https://github.com/joke2k/faker/blob/master/faker/providers/person/__init](https://github.com/joke2k/faker/blob/master/faker/providers/person/__init_)_.py]([https://github.com/joke2k/faker/blob/master/faker/providers/person/__init__.py),果不其然,里面定义了](https://github.com/joke2k/faker/blob/master/faker/providers/person/__init__.py),果不其然,里面定义了) name 方法,然后 Faker 动态地将这个方法引入进来了,就可以使用了。

方法列举

既然有这么多 Provider,下面我们再详细地看看还有哪些常用的方法吧,下面进行一部分简单的梳理,参考来源文档地址为:https://faker.readthedocs.io/en/master/providers.html

Address

Address,用于生成一些和地址相关的数据,如地址、城市、邮政编码、街道等内容, 用法如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
faker.address()
# '新疆维吾尔自治区杰县南湖武汉街D座 253105'
faker.building_number()
# 'B座'
faker.city()
# '璐县'
faker.city_name()
# '贵阳'
faker.city_suffix()
# '县'
faker.country()
# '阿拉斯加'
faker.country_code(representation="alpha-2")
# 'CR'
faker.district()
# '西峰'
faker.postcode()
# '726749'
faker.province()
# '福建省'
faker.street_address()
# '余路N座'
faker.street_name()
# '李路'
faker.street_suffix()
# '路'

Color

Color,用于生成和颜色相关的数据,如 HEX、RGB、RGBA 等格式的颜色,用法如下:

1
2
3
4
5
6
7
8
9
10
11
12
faker.color_name()
# 'DarkKhaki'
faker.hex_color()
# '#97d14e'
faker.rgb_color()
# '107,179,51'
faker.rgb_css_color()
# 'rgb(20,46,70)'
faker.safe_color_name()
# 'navy'
faker.safe_hex_color()
# '#dd2200'

Company

Company,用于生成公司相关数据,如公司名、公司前缀、公司后缀等内容,用法如下:

1
2
3
4
5
6
7
8
9
10
faker.bs()
# 'grow rich initiatives'
faker.catch_phrase()
# 'Self-enabling encompassing function'
faker.company()
# '恒聪百汇网络有限公司'
faker.company_prefix()
# '晖来计算机'
faker.company_suffix()
# '信息有限公司'

Credit Card

Credit Card,用于生成信用卡相关数据,如过期时间、银行卡号、安全码等内容,用法如下:

1
2
3
4
5
6
7
8
9
10
faker.credit_card_expire(start="now", end="+10y", date_format="%m/%y")
# '08/20'
faker.credit_card_full(card_type=None)
# 'Mastercardn玉兰 范n5183689713096897 01/25nCVV: 012n'
faker.credit_card_number(card_type=None)
# '4009911097184929918'
faker.credit_card_provider(card_type=None)
# 'JCB 15 digit'
faker.credit_card_security_code(card_type=None)
# '259'

Date Time

Date Time,用于生成时间相关数据,如年份、月份、星期、出生日期等内容,可以返回 datetime 类型的数据,用法如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
faker.am_pm()
# 'AM'
faker.century()
# 'X'
faker.date(pattern="%Y-%m-%d", end_datetime=None)
# '1997-06-16'
faker.date_between(start_date="-30y", end_date="today")
# datetime.date(2000, 8, 30)
faker.date_between_dates(date_start=None, date_end=None)
# datetime.date(2019, 7, 30)
faker.date_object(end_datetime=None)
# datetime.date(1978, 3, 12)
faker.date_of_birth(tzinfo=None, minimum_age=0, maximum_age=115)
# datetime.date(2012, 6, 3)
faker.date_this_century(before_today=True, after_today=False)
# datetime.date(2011, 6, 12)
faker.date_this_decade(before_today=True, after_today=False)
# datetime.date(2011, 8, 22)
faker.date_this_month(before_today=True, after_today=False)
# datetime.date(2019, 7, 25)
faker.date_this_year(before_today=True, after_today=False)
# datetime.date(2019, 7, 22)
faker.date_time(tzinfo=None, end_datetime=None)
# datetime.datetime(2018, 8, 11, 22, 3, 34)
faker.date_time_ad(tzinfo=None, end_datetime=None, start_datetime=None)
# datetime.datetime(1566, 8, 26, 16, 25, 30)
faker.date_time_between(start_date="-30y", end_date="now", tzinfo=None)
# datetime.datetime(2015, 1, 31, 4, 14, 10)
faker.date_time_between_dates(datetime_start=None, datetime_end=None, tzinfo=None)
# datetime.datetime(2019, 7, 30, 17, 51, 44)
faker.date_time_this_century(before_now=True, after_now=False, tzinfo=None)
# datetime.datetime(2002, 9, 25, 23, 59, 49)
faker.date_time_this_decade(before_now=True, after_now=False, tzinfo=None)
# datetime.datetime(2010, 5, 25, 20, 20, 52)
faker.date_time_this_month(before_now=True, after_now=False, tzinfo=None)
# datetime.datetime(2019, 7, 19, 18, 4, 6)
faker.date_time_this_year(before_now=True, after_now=False, tzinfo=None)
# datetime.datetime(2019, 3, 15, 11, 4, 18)
faker.day_of_month()
# '04'
faker.day_of_week()
# 'Monday'
faker.future_date(end_date="+30d", tzinfo=None)
# datetime.date(2019, 8, 12)
faker.future_datetime(end_date="+30d", tzinfo=None)
# datetime.datetime(2019, 8, 24, 2, 59, 4)
faker.iso8601(tzinfo=None, end_datetime=None)
# '1987-07-01T18:33:56'
faker.month()
# '11'
faker.month_name()
# 'August'
faker.past_date(start_date="-30d", tzinfo=None)
# datetime.date(2019, 7, 25)
faker.past_datetime(start_date="-30d", tzinfo=None)
# datetime.datetime(2019, 7, 18, 22, 46, 51)
faker.time(pattern="%H:%M:%S", end_datetime=None)
# '16:22:30'
faker.time_delta(end_datetime=None)
# datetime.timedelta(0)
faker.time_object(end_datetime=None)
# datetime.time(22, 12, 15)
faker.time_series(start_date="-30d", end_date="now", precision=None, distrib=None, tzinfo=None)
# <generator object Provider.time_series at 0x7fcbce0604f8>
faker.timezone()
# 'Indian/Comoro'
faker.unix_time(end_datetime=None, start_datetime=None)
# 1182857626
faker.year()
# '1970'

File

File,用于生成文件和文件路径相关的数据,包括文件扩展名、文件路径、MIME_TYPE、磁盘分区等内容,用法如下:

1
2
3
4
5
6
7
8
9
10
11
12
faker.file_extension(category=None)
# 'flac'
faker.file_name(category=None, extension=None)
# '然后.numbers'
faker.file_path(depth=1, category=None, extension=None)
# '/关系/科技.mov'
faker.mime_type(category=None)
# 'video/ogg'
faker.unix_device(prefix=None)
# '/dev/sdd'
faker.unix_partition(prefix=None)
# '/dev/xvds3'

Geo

Geo,用于生成和地理位置相关的数据,包括经纬度,时区等等信息,用法如下:

1
2
3
4
5
6
7
8
9
10
11
12
faker.coordinate(center=None, radius=0.001)
# Decimal('-114.420686')
faker.latitude()
# Decimal('-9.772541')
faker.latlng()
# (Decimal('-27.0730915'), Decimal('-5.919460'))
faker.local_latlng(country_code="US", coords_only=False)
# ('41.47892', '-87.45476', 'Schererville', 'US', 'America/Chicago')
faker.location_on_land(coords_only=False)
# ('12.74482', '4.52514', 'Argungu', 'NG', 'Africa/Lagos')
faker.longitude()
# Decimal('40.885895')

Internet

Internet,用于生成和互联网相关的数据,包括随机电子邮箱、域名、IP 地址、URL、用户名、后缀名等内容,用法如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
faker.ascii_company_email(*args, **kwargs)
# 'xuna@xiaqian.cn'
faker.ascii_email(*args, **kwargs)
# 'min59@60.cn'
faker.ascii_free_email(*args, **kwargs)
# 'min75@gmail.com'
faker.ascii_safe_email(*args, **kwargs)
# 'cliu@example.com'
faker.company_email(*args, **kwargs)
# 'ilong@99.cn'
faker.domain_name(levels=1)
# 'xiulan.cn'
faker.domain_word(*args, **kwargs)
# 'luo'
faker.email(*args, **kwargs)
# 'maoxiulan@hotmail.com'
faker.free_email(*args, **kwargs)
# 'yanshen@gmail.com'
faker.free_email_domain(*args, **kwargs)
# 'yahoo.com'
faker.hostname(*args, **kwargs)
# 'lt-18.pan.cn'
faker.image_url(width=None, height=None)
# 'https://placekitten.com/51/201'
faker.ipv4(network=False, address_class=None, private=None)
# '192.233.68.5'
faker.ipv4_network_class()
# 'a'
faker.ipv4_private(network=False, address_class=None)
# '10.9.97.93'
faker.ipv4_public(network=False, address_class=None)
# '192.51.22.7'
faker.ipv6(network=False)
# 'de57:9c6f:a38c:9864:10ec:6442:775d:5f02'
faker.mac_address()
# '99:80:5c:ab:8c:a9'
faker.safe_email(*args, **kwargs)
# 'tangjuan@example.net'
faker.slug(*args, **kwargs)
# ''
faker.tld()
# 'cn'
faker.uri()
# 'http://fangfan.org/app/tag/post/'
faker.uri_extension()
# '.php'
faker.uri_page()
# 'about'
faker.uri_path(deep=None)
# 'app'
faker.url(schemes=None)
# 'http://mingli.cn/'
faker.user_name(*args, **kwargs)
# 'jie54'

Job

Job,用于生成和职业相关的数据,用法如下:

1
2
faker.job()
# '烫工'

Lorem

Lorem,用于生成一些假文字数据,包括句子、自然段、长文本、关键词等,另外可以传入不同的参数来控制生成的长度,用法如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
faker.paragraph(nb_sentences=3, variable_nb_sentences=True, ext_word_list=None)
# '包括的是报告那些一点.图片地址基本全部.'
faker.paragraphs(nb=3, ext_word_list=None)
# [ '计划规定这样所以组织商品其中.参加成为不同发表地区.精华科技谢谢大家需要.一下手机上海中文工程.',
# '非常相关是一就是一个一种文章发生.增加那些以及之后以下你的.',
# '学生应该出来分析增加关系组织.评论来源朋友注册应该需要单位.感觉最后无法发现选择人民.']
faker.sentence(nb_words=6, variable_nb_words=True, ext_word_list=None)
# '介绍结果自己解决处理.'
faker.sentences(nb=3, ext_word_list=None)
# ['查看其实一次学习登录浏览是一他们.', '而且资源的人事情.', '科技价格免费大学教育.']
faker.text(max_nb_chars=200, ext_word_list=None)
# ('只是当前国内中文所以.威望系统在线虽然.n'
# '图片人民非常合作这种谢谢更新.名称详细直接社会一直首页完全.n'
# '重要更多只要市场.必须只是学生音乐.系统美国类别这些一切环境.n'
# '但是的话人民美国关于.n'
# '情况专业国际看到研究.音乐环境市场搜索发现.n'
# '工具还是到了今天位置人民.留言作者品牌工程项目必须.上海精华现在我们新闻应该关系.n'
# '更新经济能力全部资源如果.手机能够登录国内.')
faker.texts(nb_texts=3, max_nb_chars=200, ext_word_list=None)
# [ '成功可能推荐你的行业.地区而且推荐.n'
# '网络不断是一主要必须.开始安全服务.n'
# '应该网上通过以后通过大学.管理要求有关国际阅读当前.为了应该结果点击公司开始怎么.n'
# '成功一次最大生产网站.这种加入她的地址有限.n'
# '根据新闻汽车起来非常主题显示必须.有些建设来自作者电话支持.n'
# '只是资源还是由于经济事情喜欢.为什中文大小得到服务.网络密码是否免费参加一次社区欢迎.',
# '部门活动技术.商品影响发生行业密码完成.就是部门结果资料学习当然.或者帮助城市要求首页市场教育你们.n'
# '专业完全分析处理城市大学什么.n'
# '文件非常国际全部起来积分公司.资料的是电影没有.这是本站需要.n'
# '合作重要没有现在市场开发空间.您的会员推荐成功教育进行中国.n'
# '文件不是如果评论.因为经验设备规定.n'
# '加入一起影响网上大家运行在线如果.工程企业这种以后.',
# '空间市场出现必须基本电话.显示一个标准其他设计作品.工程不断新闻问题更多更新这么.n'
# '一起简介网上内容不会.任何知道各种两个.类别事情经营那么投资市场.n'
# '那些使用介绍公司朋友人民你们浏览.应该表示一点一般说明主要谢谢.电话回复起来经验一个来源加入.n'
# '地区法律其他表示虽然.参加社会喜欢有限论坛一般发布.类别目前文化可以.n'
# '报告质量工作主要.企业发布完全.得到名称作者等级两个论坛只要电话.']
faker.word(ext_word_list=None)
# '注意'
faker.words(nb=3, ext_word_list=None, unique=False)
# ['责任', '组织', '以后']

在这里每个方法的参数是不同的,具体的参数解释可以见源代码每个方法的注释:https://github.com/joke2k/faker/blob/master/faker/providers/lorem/init.py

Misc

Misc,用于生成生成一些混淆数据,比如密码、sha1、sha256、md5 等加密后的内容,用法如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
faker.boolean(chance_of_getting_true=50)
# True
faker.md5(raw_output=False)
# '3166fa26ffd3f2a33e020dfe11191ac6'
faker.null_boolean()
# False
faker.password(length=10, special_chars=True, digits=True, upper_case=True, lower_case=True)
# 'W7Ln8La@%O'
faker.sha1(raw_output=False)
# 'c8301a2a79445439ee5287f38053e4b3a05eac79'
faker.sha256(raw_output=False)
# '1e909d331e20cf241aaa2da894deae5a3a75e5cdc35c053422d9b8e7ccfa0402'
faker.uuid4(cast_to=<class 'str'>)
# '6e6fe387-6877-48d9-94ea-4263c4c71aa5'

Person

Person,用于生成和人名相关的数据,包括姓氏、名字、全名、英文名等内容,还能区分男女名字,用法如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
faker.first_name()
# '颖'
faker.first_name_female()
# '芳'
faker.first_name_male()
# '利'
faker.first_romanized_name()
# 'Jing'
faker.last_name()
# '温'
faker.last_name_female()
# '寇'
faker.last_name_male()
# '陈'
faker.last_romanized_name()
# 'Lei'
faker.name()
# '黄明'
faker.name_female()
# '张凯'
faker.name_male()
# '黄鹏'

User-Agent

User-Agent,用于生成和浏览器 User-Agent 相关的内容,可以定制各种浏览器,还可以传入版本信息来控制生成的内容,用法如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
faker.chrome(version_from=13, version_to=63, build_from=800, build_to=899)
# ('Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/5332 (KHTML, like Gecko) '
# 'Chrome/40.0.837.0 Safari/5332')
faker.firefox()
# ('Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_8_9; rv:1.9.4.20) '
# 'Gecko/2019-05-02 05:58:44 Firefox/3.6.19')
faker.internet_explorer()
# 'Mozilla/5.0 (compatible; MSIE 8.0; Windows NT 5.2; Trident/3.0)'
faker.linux_platform_token()
# 'X11; Linux i686'
faker.linux_processor()
# 'x86_64'
faker.mac_platform_token()
# 'Macintosh; U; PPC Mac OS X 10_12_5'
faker.mac_processor()
# 'U; Intel'
faker.opera()
# 'Opera/9.77.(Windows NT 4.0; vi-VN) Presto/2.9.182 Version/11.00'
faker.safari()
# ('Mozilla/5.0 (Macintosh; PPC Mac OS X 10_7_1 rv:5.0; or-IN) '
# 'AppleWebKit/535.9.4 (KHTML, like Gecko) Version/5.0.2 Safari/535.9.4')
faker.user_agent()
# 'Opera/8.69.(X11; Linux i686; ml-IN) Presto/2.9.170 Version/11.00'
faker.windows_platform_token()
# 'Windows NT 6.1'

以上仅仅列了一部分,还有更多的功能大家可以查看官方文档的内容,链接为:https://faker.readthedocs.io/en/master/locales/zh_CN.html

其他 Provider

另外还有一些社区贡献的 Provider,如 WiFi、微服务相关的,大家可以查看文档的说明,另外需要额外安装这些扩展包并自行添加 Provider,文档见:https://faker.readthedocs.io/en/master/communityproviders.html。 添加 Provider 需要调用 add_provider 方法,用法示例如下:

1
2
3
4
5
6
from faker import Faker
from faker.providers import internet

faker = Faker()
faker.add_provider(internet)
print(faker.ipv4_private())

还有更多的内容大家可以参考官方文档,链接:https://faker.readthedocs.io/

Python

实例引入

我们知道 Python 是一种动态语言,在声明一个变量时我们不需要显式地声明它的类型,例如下面的例子:

1
2
a = 2
print('1 + a =', 1 + a)

运行结果:

1
1 + a = 3

这里我们首先声明了一个变量 a,并将其赋值为了 2,然后将最后的结果打印出来,程序输出来了正确的结果。但在这个过程中,我们没有声明它到底是什么类型。 但如果这时候我们将 a 变成一个字符串类型,结果会是怎样的呢?改写如下:

1
2
a = '2'
print('1 + a =', 1 + a)

运行结果:

1
TypeError: unsupported operand type(s) for +: 'int' and 'str'

直接报错了,错误原因是我们进行了字符串类型的变量和数值类型变量的加和,两种数据类型不同,是无法进行相加的。 如果我们将上面的语句改写成一个方法定义:

1
2
def add(a):
return a + 1

这里定义了一个方法,传入一个参数,然后将其加 1 并返回。 如果这时候如果用下面的方式调用,传入的参数是一个数值类型:

1
add(2)

则可以正常输出结果 3。但如果我们传入的参数并不是我们期望的类型,比如传入一个字符类型,那么就会同样报刚才类似的错误。 但又由于 Python 的特性,很多情况下我们并不用去声明它的类型,因此从方法定义上面来看,我们实际上是不知道一个方法的参数到底应该传入什么类型的。 这样其实就造成了很多不方便的地方,在某些情况下一些复杂的方法,如果不借助于一些额外的说明,我们是不知道参数到底是什么类型的。 因此,Python 中的类型注解就显得比较重要了。

类型注解

在 Python 3.5 中,Python PEP 484 引入了类型注解(type hints),在 Python 3.6 中,PEP 526 又进一步引入了变量注解(Variable Annotations),所以上面的代码我们改写成如下写法:

1
2
3
4
5
a: int = 2
print('5 + a =', 5 + a)

def add(a: int) -> int:
return a + 1

具体的语法是可以归纳为两点:

  • 在声明变量时,变量的后面可以加一个冒号,后面再写上变量的类型,如 int、list 等等。
  • 在声明方法返回值的时候,可以在方法的后面加一个箭头,后面加上返回值的类型,如 int、list 等等。

PEP 8 中,具体的格式是这样规定的:

  • 在声明变量类型时,变量后方紧跟一个冒号,冒号后面跟一个空格,再跟上变量的类型。
  • 在声明方法返回值的时候,箭头左边是方法定义,箭头右边是返回值的类型,箭头左右两边都要留有空格。

有了这样的声明,以后我们如果看到这个方法的定义,我们就知道传入的参数类型了,如调用 add 方法的时候,我们就知道传入的需要是一个数值类型的变量,而不是字符串类型,非常直观。 但值得注意的是,这种类型和变量注解实际上只是一种类型提示,对运行实际上是没有影响的,比如调用 add 方法的时候,我们传入的不是 int 类型,而是一个 float 类型,它也不会报错,也不会对参数进行类型转换,如:

1
add(1.5)

我们传入的是一个 float 类型的数值 1.5,看下运行结果:

1
2.5

可以看到,运行结果正常输出,而且 1.5 并没有经过强制类型转换变成 1,否则结果会变成 2。 因此,类型和变量注解只是提供了一种提示,对于运行实际上没有任何影响。 不过有了类型注解,一些 IDE 是可以识别出来并提示的,比如 PyCharm 就可以识别出来在调用某个方法的时候参数类型不一致,会提示 WARNING。 比如上面的调用,如果在 PyCharm 中,就会有如下提示内容:

1
2
Expected type 'int', got 'float' instead
This inspection detects type errors in function call expressions. Due to dynamic dispatch and duck typing, this is possible in a limited but useful number of cases. Types of function parameters can be specified in docstrings or in Python 3 function annotations.

另外也有一些库是支持类型检查的,比如 mypy,安装之后,利用 mypy 即可检查出 Python 脚本中不符合类型注解的调用情况。 上面只是用一个简单的 int 类型做了实例,下面我们再看下一些相对复杂的数据结构,例如列表、元组、字典等类型怎么样来声明。 可想而知了,列表用 list 表示,元组用 tuple 表示,字典用 dict 来表示,那么很自然地,在声明的时候我们就很自然地写成这样了:

1
2
3
names: list = ['Germey', 'Guido']
version: tuple = (3, 7, 4)
operations: dict = {'show': False, 'sort': True}

这么看上去没有问题,确实声明为了对应的类型,但实际上并不能反映整个列表、元组的结构,比如我们只通过类型注解是不知道 names 里面的元素是什么类型的,只知道 names 是一个列表 list 类型,实际上里面都是字符串 str 类型。我们也不知道 version 这个元组的每一个元素是什么类型的,实际上是 int 类型。但这些信息我们都无从得知。因此说,仅仅凭借 list、tuple 这样的声明是非常“弱”的,我们需要一种更强的类型声明。 这时候我们就需要借助于 typing 模块了,它提供了非常“强“的类型支持,比如 List[str]Tuple[int, int, int] 则可以表示由 str 类型的元素组成的列表和由 int 类型的元素组成的长度为 3 的元组。所以上文的声明写法可以改写成下面的样子:

1
2
3
4
5
from typing import List, Tuple, Dict

names: List[str] = ['Germey', 'Guido']
version: Tuple[int, int, int] = (3, 7, 4)
operations: Dict[str, bool] = {'show': False, 'sort': True}

这样一来,变量的类型便可以非常直观地体现出来了。 目前 typing 模块也已经被加入到 Python 标准库中,不需要安装第三方模块,我们就可以直接使用了。

typing

下面我们再来详细看下 typing 模块的具体用法,这里主要会介绍一些常用的注解类型,如 List、Tuple、Dict、Sequence 等等,了解了每个类型的具体使用方法,我们可以得心应手的对任何变量进行声明了。 在引入的时候就直接通过 typing 模块引入就好了,例如:

1
from typing import List, Tuple

List

List、列表,是 list 的泛型,基本等同于 list,其后紧跟一个方括号,里面代表了构成这个列表的元素类型,如由数字构成的列表可以声明为:

1
var: List[int or float] = [2, 3.5]

另外还可以嵌套声明都是可以的:

1
var: List[List[int]] = [[1, 2], [2, 3]]

Tuple、NamedTuple

Tuple、元组,是 tuple 的泛型,其后紧跟一个方括号,方括号中按照顺序声明了构成本元组的元素类型,如 Tuple[X, Y] 代表了构成元组的第一个元素是 X 类型,第二个元素是 Y 类型。 比如想声明一个元组,分别代表姓名、年龄、身高,三个数据类型分别为 str、int、float,那么可以这么声明:

1
person: Tuple[str, int, float] = ('Mike', 22, 1.75)

同样地也可以使用类型嵌套。 NamedTuple,是 collections.namedtuple 的泛型,实际上就和 namedtuple 用法完全一致,但个人其实并不推荐使用 NamedTuple,推荐使用 attrs 这个库来声明一些具有表征意义的类。

Dict、Mapping、MutableMapping

Dict、字典,是 dict 的泛型;Mapping,映射,是 collections.abc.Mapping 的泛型。根据官方文档,Dict 推荐用于注解返回类型,Mapping 推荐用于注解参数。它们的使用方法都是一样的,其后跟一个中括号,中括号内分别声明键名、键值的类型,如:

1
2
def size(rect: Mapping[str, int]) -> Dict[str, int]:
return {'width': rect['width'] + 100, 'height': rect['width'] + 100}

这里将 Dict 用作了返回值类型注解,将 Mapping 用作了参数类型注解。 MutableMapping 则是 Mapping 对象的子类,在很多库中也经常用 MutableMapping 来代替 Mapping。

Set、AbstractSet

Set、集合,是 set 的泛型;AbstractSet、是 collections.abc.Set 的泛型。根据官方文档,Set 推荐用于注解返回类型,AbstractSet 用于注解参数。它们的使用方法都是一样的,其后跟一个中括号,里面声明集合中元素的类型,如:

1
2
def describe(s: AbstractSet[int]) -> Set[int]:
return set(s)

这里将 Set 用作了返回值类型注解,将 AbstractSet 用作了参数类型注解。

Sequence

Sequence,是 collections.abc.Sequence 的泛型,在某些情况下,我们可能并不需要严格区分一个变量或参数到底是列表 list 类型还是元组 tuple 类型,我们可以使用一个更为泛化的类型,叫做 Sequence,其用法类似于 List,如:

1
2
def square(elements: Sequence[float]) -> List[float]:
return [x ** 2 for x in elements]

NoReturn

NoReturn,当一个方法没有返回结果时,为了注解它的返回类型,我们可以将其注解为 NoReturn,例如:

1
2
def hello() -> NoReturn:
print('hello')

Any

Any,是一种特殊的类型,它可以代表所有类型,静态类型检查器的所有类型都与 Any 类型兼容,所有的无参数类型注解和返回类型注解的都会默认使用 Any 类型,也就是说,下面两个方法的声明是完全等价的:

1
2
3
4
5
def add(a):
return a + 1

def add(a: Any) -> Any:
return a + 1

原理类似于 object,所有的类型都是 object 的子类。但如果我们将参数声明为 object 类型,静态参数类型检查便会抛出错误,而 Any 则不会,具体可以参考官方文档的说明:https://docs.python.org/zh-cn/3/library/typing.html?highlight=typing#the-any-type

TypeVar

TypeVar,我们可以借助它来自定义兼容特定类型的变量,比如有的变量声明为 int、float、None 都是符合要求的,实际就是代表任意的数字或者空内容都可以,其他的类型则不可以,比如列表 list、字典 dict 等等,像这样的情况,我们可以使用 TypeVar 来表示。 例如一个人的身高,便可以使用 int 或 float 或 None 来表示,但不能用 dict 来表示,所以可以这么声明:

1
2
3
4
height = 1.75
Height = TypeVar('Height', int, float, None)
def get_height() -> Height:
return height

这里我们使用 TypeVar 声明了一个 Height 类型,然后将其用于注解方法的返回结果。

NewType

NewType,我们可以借助于它来声明一些具有特殊含义的类型,例如像 Tuple 的例子一样,我们需要将它表示为 Person,即一个人的含义,但但从表面上声明为 Tuple 并不直观,所以我们可以使用 NewType 为其声明一个类型,如:

1
2
Person = NewType('Person', Tuple[str, int, float])
person = Person(('Mike', 22, 1.75))

这里实际上 person 就是一个 tuple 类型,我们可以对其像 tuple 一样正常操作。

Callable

Callable,可调用类型,它通常用来注解一个方法,比如我们刚才声明了一个 add 方法,它就是一个 Callable 类型:

1
print(Callable, type(add), isinstance(add, Callable))

运行结果:

1
typing.Callable <class 'function'> True

在这里虽然二者 add 利用 type 方法得到的结果是 function,但实际上利用 isinstance 方法判断确实是 True。 Callable 在声明的时候需要使用 Callable[[Arg1Type, Arg2Type, ...], ReturnType] 这样的类型注解,将参数类型和返回值类型都要注解出来,例如:

1
2
3
4
5
def date(year: int, month: int, day: int) -> str:
return f'{year}-{month}-{day}'

def get_date_fn() -> Callable[[int, int, int], str]:
return date

这里首先声明了一个方法 date,接收三个 int 参数,返回一个 str 结果,get_date_fn 方法返回了这个方法本身,它的返回值类型就可以标记为 Callable,中括号内分别标记了返回的方法的参数类型和返回值类型。

Union

Union,联合类型,Union[X, Y] 代表要么是 X 类型,要么是 Y 类型。 联合类型的联合类型等价于展平后的类型:

1
Union[Union[int, str], float] == Union[int, str, float]

仅有一个参数的联合类型会坍缩成参数自身,比如:

1
Union[int] == int

多余的参数会被跳过,比如:

1
Union[int, str, int] == Union[int, str]

在比较联合类型的时候,参数顺序会被忽略,比如:

1
Union[int, str] == Union[str, int]

这个在一些方法参数声明的时候比较有用,比如一个方法,要么传一个字符串表示的方法名,要么直接把方法传过来:

1
2
3
4
5
6
def process(fn: Union[str, Callable]):
if isinstance(fn, str):
# str2fn and process
pass
elif isinstance(fn, Callable):
fn()

这样的声明在一些类库方法定义的时候十分常见。

Optional

Optional,意思是说这个参数可以为空或已经声明的类型,即 Optional[X] 等价于 Union[X, None]。 但值得注意的是,这个并不等价于可选参数,当它作为参数类型注解的时候,不代表这个参数可以不传递了,而是说这个参数可以传为 None。 如当一个方法执行结果,如果执行完毕就不返回错误信息, 如果发生问题就返回错误信息,则可以这么声明:

1
2
def judge(result: bool) -> Optional[str]:
if result: return 'Error Occurred'

Generator

如果想代表一个生成器类型,可以使用 Generator,它的声明比较特殊,其后的中括号紧跟着三个参数,分别代表 YieldType、SendType、ReturnType,如:

1
2
3
4
5
def echo_round() -> Generator[int, float, str]:
sent = yield 0
while sent >= 0:
sent = yield round(sent)
return 'Done'

在这里 yield 关键字后面紧跟的变量的类型就是 YieldType,yield 返回的结果的类型就是 SendType,最后生成器 return 的内容就是 ReturnType。 当然很多情况下,生成器往往只需要 yield 内容就够了,我们是不需要 SendType 和 ReturnType 的,可以将其设置为空,如:

1
2
3
4
def infinite_stream(start: int) -> Generator[int, None, None]:
while True:
yield start
start += 1

案例实战

接下来让我们看一个实际的项目,看看经常用到的类型一般是怎么使用的。 这里我们看的库是 requests-html,是由 Kenneth Reitz 所开发的,其 GitHub 地址为:https://github.com/psf/requests-html,下面我们主要看看它的源代码中一些类型是如何声明的。 这个库的源代码其实就一个文件,那就是 https://github.com/psf/requests-html/blob/master/requests_html.py,我们看一下它里面的一些 typing 的定义和方法定义。 首先 Typing 的定义部分如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
from typing import Set, Union, List, MutableMapping, Optional

_Find = Union[List['Element'], 'Element']
_XPath = Union[List[str], List['Element'], str, 'Element']
_Result = Union[List['Result'], 'Result']
_HTML = Union[str, bytes]
_BaseHTML = str
_UserAgent = str
_DefaultEncoding = str
_URL = str
_RawHTML = bytes
_Encoding = str
_LXML = HtmlElement
_Text = str
_Search = Result
_Containing = Union[str, List[str]]
_Links = Set[str]
_Attrs = MutableMapping
_Next = Union['HTML', List[str]]
_NextSymbol = List[str]

这里可以看到主要用到的类型有 Set、Union、List、MutableMapping、Optional,这些在上文都已经做了解释,另外这里使用了多次 Union 来声明了一些新的类型,如 _Find 则要么是是 Element 对象的列表,要么是单个 Element 对象,_Result 则要么是 Result 对象的列表,要么是单个 Result 对象。另外 _Attrs 其实就是字典类型,这里用 MutableMapping 来表示了,没有用 Dict,也没有用 Mapping。 接下来再看一个 Element 类的声明:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
class Element(BaseParser):
"""An element of HTML.
:param element: The element from which to base the parsing upon.
:param url: The URL from which the HTML originated, used for ``absolute_links``.
:param default_encoding: Which encoding to default to.
"""

__slots__ = [
'element', 'url', 'skip_anchors', 'default_encoding', '_encoding',
'_html', '_lxml', '_pq', '_attrs', 'session'
]

def __init__(self, *, element, url: _URL, default_encoding: _DefaultEncoding = None) -> None:
super(Element, self).__init__(element=element, url=url, default_encoding=default_encoding)
self.element = element
self.tag = element.tag
self.lineno = element.sourceline
self._attrs = None

def __repr__(self) -> str:
attrs = ['{}={}'.format(attr, repr(self.attrs[attr])) for attr in self.attrs]
return "<Element {} {}>".format(repr(self.element.tag), ' '.join(attrs))

@property
def attrs(self) -> _Attrs:
"""Returns a dictionary of the attributes of the :class:`Element <Element>`
(`learn more <https://www.w3schools.com/tags/ref_attributes.asp>`_).
"""
if self._attrs is None:
self._attrs = {k: v for k, v in self.element.items()}

# Split class and rel up, as there are ussually many of them:
for attr in ['class', 'rel']:
if attr in self._attrs:
self._attrs[attr] = tuple(self._attrs[attr].split())

return self._attrs

这里 __init__ 方法接收非常多的参数,同时使用 _URL_DefaultEncoding 进行了参数类型注解,另外 attrs 方法使用了 _Attrs 进行了返回结果类型注解。 整体看下来,每个参数的类型、返回值都进行了清晰地注解,代码可读性大大提高。 以上便是类型注解和 typing 模块的详细介绍。

Python

相对免费代理来说,付费代理的稳定性相对更高一点,本节介绍一下爬虫付费代理的相关使用过程。

1. 付费代理分类

在这里将付费代理分为两类:

  • 提供接口获取海量代理,按天或者按量付费,如讯代理
  • 搭建了代理隧道,直接设置固定域名代理,如阿布云

本节讲解一下这两种代理的使用方法,分别以两家代表性的代理网站为例进行讲解。

2. 讯代理

讯代理个人使用过代理有效率还是蛮高的,此处非广告,其官网为:http://www.xdaili.cn/,如图 9-5 所示: 图 9-5 讯代理官网 有多种类别的代理可供选购,摘抄其官网的各类别代理介绍如下:

  • 优质代理: 适合对代理IP需求量非常大,但能接受代理有效时长较短(10~30分钟),小部分不稳定的客户
  • 独享动态: 适合对代理IP稳定性要求非常高,且可以自主控制的客户,支持地区筛选。
  • 独享秒切: 适合对代理IP稳定性要求非常高,且可以自主控制的客户,快速获取IP,地区随机分配
  • 动态混拨: 适合对代理IP需求量大,代理IP使用时效短(3分钟),切换快的客户
  • 优质定制: 如果优质代理的套餐不能满足您的需求,请使用定制服务

一般选择第一类别优质代理即可,代理量比较大,但是代理的稳定性没那么高,有一些代理也是不可用的,所以这种代理的使用方式就需要借助于上一节所说的代理池,我们自己再做一次筛选,确保代理可用。 可以购买一天的试一下效果,购买之后会提供一个 API 来提取代理,如图 9-6 所示: 图 9-6 提取页面 比如在这里我的提取 API 为:http://www.xdaili.cn/ipagent/greatRecharge/getGreatIp?spiderId=da289b78fec24f19b392e04106253f2a&orderno=YZ20177140586mTTnd7&returnType=2&count=20,可能已过期,在此仅做演示。 在这里指定了提取数量为 20,提取格式为 Json,直接访问链接即可提取代理,结果如图 9-7 所示: 图 9-7 提取结果 接下来我们要做的就是解析这个 Json,然后将其放入我们的代理池中。 当然如果信赖讯代理的话也可以不做代理池筛选,直接使用,不过我个人还是推荐再使用代理池筛选一遍,提高可用几率。 根据上一节代理池的写法,我们只需要在 Crawler 中再加入一个 crawl 开头的方法即可。 方法实现如下:

1
2
3
4
5
6
7
8
9
10
11
12
def crawl_xdaili(self):
"""
获取讯代理
:return: 代理
"""
url = 'http://www.xdaili.cn/ipagent/greatRecharge/getGreatIp?spiderId=da289b78fec24f19b392e04106253f2a&orderno=YZ20177140586mTTnd7&returnType=2&count=20'
html = get_page(url)
if html:
result = json.loads(html)
proxies = result.get('RESULT')
for proxy in proxies:
yield proxy.get('ip') + ':' + proxy.get('port')

这样我们就在代理池中接入了讯代理,获取讯代理的结果之后,解析 Json,返回代理即可。 这样代理池运行之后就会抓取和检测该接口返回的代理了,如果可用,那么就会被设为 100,通过代理池接口即可获取到。 以上以讯代理为例说明了此种批量提取代理的使用方法。

3. 阿布云代理

阿布云代理提供了代理隧道,代理速度快而且非常稳定,此处依然非广告,其官网为:https://www.abuyun.com/,如图 9-8 所示: 图 9-8 阿布云官网 阿布云的代理主要分为两种,专业版和动态版,另外还有定制版,摘抄官网的介绍如下:

  • 专业版,多个请求锁定一个代理 IP,海量 IP 资源池需求,近 300 个区域全覆盖,代理 IP 可连续使用1分钟,适用于请求 IP 连续型业务
  • 动态版,每个请求一个随机代理 IP,海量 IP 资源池需求,近 300 个区域全覆盖,适用于爬虫类业务
  • 定制版,灵活按照需求定制,定制 IP 区域,定制 IP 使用时长,定制 IP 每秒请求数

关于专业版和动态版的更多介绍可以查看官网:https://www.abuyun.com/http-proxy/dyn-intro.html。 对于爬虫来说,推荐使用动态版,购买之后可以在后台看到代理隧道的用户名和密码,如图 9-9 所示: 图 9-9 阿布云代理后台 可以发现整个代理的连接域名为 proxy.abuyun.com,端口为 9020,均是固定的,但是使用之后每次的 IP 都会更改,这其实就是利用了代理隧道实现。 其官网原理介绍如下:

  • 云代理通过代理隧道的形式提供高匿名代理服务,支持 HTTP/HTTPS 协议。
  • 云代理在云端维护一个全局 IP 池供代理隧道使用,池中的 IP 会不间断更新,以保证同一时刻 IP 池中有几十到几百个可用代理IP。
  • 需要注意的是代理IP池中有部分 IP 可能会在当天重复出现多次。
  • 动态版HTTP代理隧道会为每个请求从 IP 池中挑选一个随机代理 IP。
  • 无须切换代理 IP,每一个请求一个随机代理IP。
  • HTTP代理隧道有并发请求限制,默认每秒只允许 5 个请求。如果需要更多请求数,请额外购买。

注意默认套餐的并发请求是 5 个,如果需要更多需要另外购买。 使用的教程在官网也有,链接为:https://www.abuyun.com/http-proxy/dyn-manual-python.html,提供了 Requests、Urllib、Scrapy 的接入方式。 以 Requests 为例,接入示例如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import requests

url = 'http://httpbin.org/get'

# 代理服务器
proxy_host = 'proxy.abuyun.com'
proxy_port = '9020'

# 代理隧道验证信息
proxy_user = 'H01234567890123D'
proxy_pass = '0123456789012345'

proxy_meta = 'http://%(user)s:%(pass)s@%(host)s:%(port)s' % {
'host': proxy_host,
'port': proxy_port,
'user': proxy_user,
'pass': proxy_pass,
}
proxies = {
'http': proxy_meta,
'https': proxy_meta,
}
response = requests.get(url, proxies=proxies)
print(response.status_code)
print(response.text)

在这里其实就是使用了代理认证,在前面我们也提到过类似的设置方法,运行结果如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
200
{
"args": {},
"headers": {
"Accept": "*/*",
"Accept-Encoding": "gzip, deflate",
"Connection": "close",
"Host": "httpbin.org",
"User-Agent": "python-requests/2.18.1"
},
"origin": "60.207.237.111",
"url": "http://httpbin.org/get"
}

输出结果的 origin 即为代理IP的实际地址,可以多次运行测试,可以发现每次请求 origin 都会在变化,这就是动态版代理的效果。 这种效果其实跟我们之前的代理池的随机代理效果类似,都是随机取出了一个当前可用代理。 但是此服务相比于维护代理池来说,使用更加方便,配置简单,省时省力,在价格可以接受的情况下,个人推荐此种代理。

4. 结语

以上便是付费代理的相关使用方法,稳定性相比免费代理更高,可以自行选购合适的代理。

Python

我们在上一节了解了代理的设置方法,利用代理我们可以解决目标网站封 IP 的问题,而在网上又有大量公开的免费代理,其中有一部分可以拿来使用,或者我们也可以购买付费的代理 IP,价格也不贵。但是不论是免费的还是付费的,都不能保证它们每一个都是可用的,毕竟可能其他人也可能在用此 IP 爬取同样的目标站点而被封禁,或者代理服务器突然出故障或网络繁忙。一旦我们选用了一个不可用的代理,势必会影响我们爬虫的工作效率。 所以说,在用代理时,我们需要提前做一下筛选,将不可用的代理剔除掉,保留下可用代理,接下来在获取代理时从可用代理里面取出直接使用就好了。 所以本节我们来搭建一个高效易用的代理池。

1. 准备工作

要实现代理池我们首先需要成功安装好了 Redis 数据库并启动服务,另外还需要安装 Aiohttp、Requests、RedisPy、PyQuery、Flask 库,如果没有安装可以参考第一章的安装说明。

2. 代理池的目标

代理池要做到易用、高效,我们一般需要做到下面的几个目标:

  • 基本模块分为四块,获取模块、存储模块、检查模块、接口模块。
  • 获取模块需要定时去各大代理网站抓取代理,代理可以是免费公开代理也可以是付费代理,代理的形式都是 IP 加端口,尽量从不同来源获取,尽量抓取高匿代理,抓取完之后将可用代理保存到数据库中。
  • 存储模块负责存储抓取下来的代理。首先我们需要保证代理不重复,另外我们还需要标识代理的可用情况,而且需要动态实时处理每个代理,所以说,一种比较高效和方便的存储方式就是使用 Redis 的 Sorted Set,也就是有序集合。
  • 检测模块需要定时将数据库中的代理进行检测,在这里我们需要设置一个检测链接,最好是爬取哪个网站就检测哪个网站,这样更加有针对性,如果要做一个通用型的代理,那可以设置百度等链接来检测。另外我们需要标识每一个代理的状态,如设置分数标识,100 分代表可用,分数越少代表越不可用,检测一次如果可用,我们可以将其立即设置为100 满分,也可以在原基础上加 1 分,当不可用,可以将其减 1 分,当减到一定阈值后就直接从数据库移除。通过这样的标识分数,我们就可以区分出代理的可用情况,选用的时候会更有针对性。
  • 接口模块需要用 API 来提供对外服务的接口,其实我们可以直接连数据库来取,但是这样就需要知道数据库的连接信息,不太安全,而且需要配置连接,所以一个比较安全和方便的方式就是提供一个 Web API 接口,通过访问接口即可拿到可用代理。另外由于可用代理可能有多个,我们可以提供随机返回一个可用代理的接口,这样保证每个可用代理都可以取到,实现负载均衡。

以上便是设计代理的一些基本思路,那么接下来我们就设计一下整体的架构,然后用代码该实现代理池。

3. 代理池的架构

根据上文的描述,代理池的架构可以是这样的,如图 9-1 所示: 图 9-1 代理池架构 代理池分为四个部分,获取模块、存储模块、检测模块、接口模块。

  • 存储模块使用Redis的有序集合,用以代理的去重和状态标识,同时它也是中心模块和基础模块,将其他模块串联起来。
  • 获取模块定时从代理网站获取代理,将获取的代理传递给存储模块,保存到数据库。
  • 检测模块定时通过存储模块获取所有代理,并对其进行检测,根据不同的检测结果对代理设置不同的标识。
  • 接口模块通过 Web API 提供服务接口,其内部还是连接存储模块,获取可用的代理。

4. 代理池的实现

接下来我们分别用代码来实现一下这四个模块。

存储模块

存储在这里我们使用 Redis 的有序集合,集合的每一个元素都是不重复的,对于代理代理池来说,集合的元素就变成了一个个代理,也就是 IP 加端口的形式,如 60.207.237.111:8888,这样的一个代理就是集合的一个元素。另外有序集合的每一个元素还都有一个分数字段,分数是可以重复的,是一个浮点数类型,也可以是整数类型。该集合会根据每一个元素的分数对集合进行排序,数值小的排在前面,数值大的排在后面,这样就可以实现集合元素的排序了。 对于代理池来说,这个分数可以作为我们判断一个代理可用不可用的标志,我们将 100 设为最高分,代表可用,0 设为最低分,代表不可用。从代理池中获取代理的时候会随机获取分数最高的代理,注意这里是随机,这样可以保证每个可用代理都会被调用到。 分数是我们判断代理稳定性的重要标准,在这里我们设置分数规则如下:

  • 分数 100 为可用,检测器会定时循环检测每个代理可用情况,一旦检测到有可用的代理就立即置为 100,检测到不可用就将分数减 1,减至 0 后移除。
  • 新获取的代理添加时将分数置为 10,当测试可行立即置 100,不可行分数减 1,减至 0 后移除。

这是一种解决方案,当然可能还有更合理的方案。此方案的设置有一定的原因,在此总结如下:

  • 当检测到代理可用时立即置为 100,这样可以保证所有可用代理有更大的机会被获取到。你可能会说为什么不直接将分数加 1 而是直接设为最高 100 呢?设想一下,我们有的代理是从各大免费公开代理网站获取的,如果一个代理并没有那么稳定,平均五次请求有两次成功,三次失败,如果按照这种方式来设置分数,那么这个代理几乎不可能达到一个高的分数,也就是说它有时是可用的,但是我们筛选是筛选的分数最高的,所以这样的代理就几乎不可能被取到,当然如果想追求代理稳定性的化可以用这种方法,这样可确保分数最高的一定是最稳定可用的。但是在这里我们采取可用即设置 100 的方法,确保只要可用的代理都可以被使用到。
  • 当检测到代理不可用时,将分数减 1,减至 0 后移除,一共 100 次机会,也就是说当一个可用代理接下来如果尝试了 100 次都失败了,就一直减分直到移除,一旦成功就重新置回 100,尝试机会越多代表将这个代理拯救回来的机会越多,这样不容易将曾经的一个可用代理丢弃,因为代理不可用的原因可能是网络繁忙或者其他人用此代理请求太过频繁,所以在这里设置为 100 级。
  • 新获取的代理分数设置为 10,检测如果不可用就减 1,减到 0 就移除,如果可用就置 100。由于我们很多代理是从免费网站获取的,所以新获取的代理无效的可能性是非常高的,可能不足 10%,所以在这里我们将其设置为 10,检测的机会没有可用代理 100 次那么多,这也可以适当减少开销。

以上便是代理分数的一个设置思路,不一定是最优思路,但个人实测实用性还是比较强的。 所以我们就需要定义一个类来操作数据库的有序集合,定义一些方法来实现分数的设置,代理的获取等等。 实现如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
MAX_SCORE = 100
MIN_SCORE = 0
INITIAL_SCORE = 10
REDIS_HOST = 'localhost'
REDIS_PORT = 6379
REDIS_PASSWORD = None
REDIS_KEY = 'proxies'

import redis
from random import choice

class RedisClient(object):
def __init__(self, host=REDIS_HOST, port=REDIS_PORT, password=REDIS_PASSWORD):
"""
初始化
:param host: Redis 地址
:param port: Redis 端口
:param password: Redis密码
"""
self.db = redis.StrictRedis(host=host, port=port, password=password, decode_responses=True)

def add(self, proxy, score=INITIAL_SCORE):
"""
添加代理,设置分数为最高
:param proxy: 代理
:param score: 分数
:return: 添加结果
"""
if not self.db.zscore(REDIS_KEY, proxy):
return self.db.zadd(REDIS_KEY, score, proxy)

def random(self):
"""
随机获取有效代理,首先尝试获取最高分数代理,如果不存在,按照排名获取,否则异常
:return: 随机代理
"""
result = self.db.zrangebyscore(REDIS_KEY, MAX_SCORE, MAX_SCORE)
if len(result):
return choice(result)
else:
result = self.db.zrevrange(REDIS_KEY, 0, 100)
if len(result):
return choice(result)
else:
raise PoolEmptyError

def decrease(self, proxy):
"""
代理值减一分,小于最小值则删除
:param proxy: 代理
:return: 修改后的代理分数
"""
score = self.db.zscore(REDIS_KEY, proxy)
if score and score > MIN_SCORE:
print('代理', proxy, '当前分数', score, '减1')
return self.db.zincrby(REDIS_KEY, proxy, -1)
else:
print('代理', proxy, '当前分数', score, '移除')
return self.db.zrem(REDIS_KEY, proxy)

def exists(self, proxy):
"""
判断是否存在
:param proxy: 代理
:return: 是否存在
"""
return not self.db.zscore(REDIS_KEY, proxy) == None

def max(self, proxy):
"""
将代理设置为MAX_SCORE
:param proxy: 代理
:return: 设置结果
"""
print('代理', proxy, '可用,设置为', MAX_SCORE)
return self.db.zadd(REDIS_KEY, MAX_SCORE, proxy)

def count(self):
"""
获取数量
:return: 数量
"""
return self.db.zcard(REDIS_KEY)

def all(self):
"""
获取全部代理
:return: 全部代理列表
"""
return self.db.zrangebyscore(REDIS_KEY, MIN_SCORE, MAX_SCORE)

首先定义了一些常量,如 MAX_SCORE、MIN_SCORE、INITIAL_SCORE 分别代表最大分数、最小分数、初始分数。REDIS_HOST、REDIS_PORT、REDIS_PASSWORD 分别代表了 Redis 的连接信息,即地址、端口、密码。REDIS_KEY 是有序集合的键名,可以通过它来获取代理存储所使用的有序集合。 接下来定义了一个 RedisClient 类,用以操作 Redis 的有序集合,其中定义了一些方法来对集合中的元素进行处理,主要功能如下:

  • init() 方法是初始化的方法,参数是Redis的连接信息,默认的连接信息已经定义为常量,在 init() 方法中初始化了一个 StrictRedis 的类,建立 Redis 连接。这样当 RedisClient 类初始化的时候就建立了Redis的连接。
  • add() 方法向数据库添加代理并设置分数,默认的分数是 INITIAL_SCORE 也就是 10,返回结果是添加的结果。
  • random() 方法是随机获取代理的方法,首先获取 100 分的代理,然后随机选择一个返回,如果不存在 100 分的代理,则按照排名来获取,选取前 100 名,然后随机选择一个返回,否则抛出异常。
  • decrease() 方法是在代理检测无效的时候设置分数减 1 的方法,传入代理,然后将此代理的分数减 1,如果达到最低值,那么就删除。
  • exists() 方法判断代理是否存在集合中
  • max() 方法是将代理的分数设置为 MAX_SCORE,即 100,也就是当代理有效时的设置。
  • count() 方法返回当前集合的元素个数。
  • all() 方法返回所有的代理列表,供检测使用。

定义好了这些方法,我们可以在后续的模块中调用此类来连接和操作数据库,非常方便。如我们想要获取随机可用的代理,只需要调用 random() 方法即可,得到的就是随机的可用代理。

获取模块

获取模块的逻辑相对简单,首先需要定义一个 Crawler 来从各大网站抓取代理,示例如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
import json
from .utils import get_page
from pyquery import PyQuery as pq

class ProxyMetaclass(type):
def __new__(cls, name, bases, attrs):
count = 0
attrs['__CrawlFunc__'] = []
for k, v in attrs.items():
if 'crawl_' in k:
attrs['__CrawlFunc__'].append(k)
count += 1
attrs['__CrawlFuncCount__'] = count
return type.__new__(cls, name, bases, attrs)

class Crawler(object, metaclass=ProxyMetaclass):
def get_proxies(self, callback):
proxies = []
for proxy in eval("self.{}()".format(callback)):
print('成功获取到代理', proxy)
proxies.append(proxy)
return proxies

def crawl_daili66(self, page_count=4):
"""
获取代理66
:param page_count: 页码
:return: 代理
"""
start_url = 'http://www.66ip.cn/{}.html'
urls = [start_url.format(page) for page in range(1, page_count + 1)]
for url in urls:
print('Crawling', url)
html = get_page(url)
if html:
doc = pq(html)
trs = doc('.containerbox table tr:gt(0)').items()
for tr in trs:
ip = tr.find('td:nth-child(1)').text()
port = tr.find('td:nth-child(2)').text()
yield ':'.join([ip, port])

def crawl_proxy360(self):
"""
获取Proxy360
:return: 代理
"""
start_url = 'http://www.proxy360.cn/Region/China'
print('Crawling', start_url)
html = get_page(start_url)
if html:
doc = pq(html)
lines = doc('div[name="list_proxy_ip"]').items()
for line in lines:
ip = line.find('.tbBottomLine:nth-child(1)').text()
port = line.find('.tbBottomLine:nth-child(2)').text()
yield ':'.join([ip, port])

def crawl_goubanjia(self):
"""
获取Goubanjia
:return: 代理
"""
start_url = 'http://www.goubanjia.com/free/gngn/index.shtml'
html = get_page(start_url)
if html:
doc = pq(html)
tds = doc('td.ip').items()
for td in tds:
td.find('p').remove()
yield td.text().replace(' ', '')

为了实现灵活,在这里我们将获取代理的一个个方法统一定义一个规范,如统一定义以 crawl 开头,这样扩展的时候只需要添加 crawl 开头的方法即可。 在这里实现了几个示例,如抓取代理 66、Proxy360、Goubanjia 三个免费代理网站,这些方法都定义成了生成器,通过 yield 返回一个个代理。首先将网页获取,然后用PyQuery 解析,解析出IP加端口的形式的代理然后返回。 然后定义了一个 get_proxies() 方法,将所有以 crawl 开头的方法调用一遍,获取每个方法返回的代理并组合成列表形式返回。 你可能会想知道是怎样获取了所有以 crawl 开头的方法名称的。其实这里借助于元类来实现,定义了一个 ProxyMetaclass,Crawl 类将它设置为元类,元类中实现了 new() 方法,这个方法有固定的几个参数,其中第四个参数 attrs 中包含了类的一些属性,这其中就包含了类中方法的一些信息,我们可以遍历 attrs 这个变量即可获取类的所有方法信息。所以在这里我们在 new() 方法中遍历了 attrs 的这个属性,就像遍历一个字典一样,键名对应的就是方法的名称,接下来判断其开头是否是 crawl,如果是,则将其加入到 CrawlFunc 属性中,这样我们就成功将所有以 crawl 开头的方法定义成了一个属性,就成功动态地获取到所有以 crawl 开头的方法列表了。 所以说,如果要做扩展的话,我们只需要添加一个以 crawl开头的方法,例如抓取快代理,我们只需要在 Crawler 类中增加 crawl_kuaidaili() 方法,仿照其他的几个方法将其定义成生成器,抓取其网站的代理,然后通过 yield 返回代理即可,所以这样我们可以非常方便地扩展,而不用关心类其他部分的实现逻辑。 代理网站的添加非常灵活,不仅可以添加免费代理,也可以添加付费代理,一些付费代理的提取方式其实也类似,也是通过 Web 的形式获取,然后进行解析,解析方式可能更加简单,如解析纯文本或 Json,解析之后以同样的方式返回即可,在此不再添加,可以自行扩展。 既然定义了这个 Crawler 类,我们就要调用啊,所以在这里再定义一个 Getter 类,动态地调用所有以 crawl 开头的方法,然后获取抓取到的代理,将其加入到数据库存储起来。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
from db import RedisClient
from crawler import Crawler

POOL_UPPER_THRESHOLD = 10000

class Getter():
def __init__(self):
self.redis = RedisClient()
self.crawler = Crawler()

def is_over_threshold(self):
"""
判断是否达到了代理池限制
"""
if self.redis.count() >= POOL_UPPER_THRESHOLD:
return True
else:
return False

def run(self):
print('获取器开始执行')
if not self.is_over_threshold():
for callback_label in range(self.crawler.__CrawlFuncCount__):
callback = self.crawler.__CrawlFunc__[callback_label]
proxies = self.crawler.get_proxies(callback)
for proxy in proxies:
self.redis.add(proxy)

Getter 类就是获取器类,这其中定义了一个变量 POOL_UPPER_THRESHOLD 表示代理池的最大数量,这个数量可以灵活配置,然后定义了 is_over_threshold() 方法判断代理池是否已经达到了容量阈值,它就是调用了 RedisClient 的 count() 方法获取代理的数量,然后加以判断,如果数量达到阈值则返回 True,否则 False。如果不想加这个限制可以将此方法永久返回 True。 接下来定义了 run() 方法,首先判断了代理池是否达到阈值,然后在这里就调用了 Crawler 类的 CrawlFunc 属性,获取到所有以 crawl 开头的方法列表,依次通过 get_proxies() 方法调用,得到各个方法抓取到的代理,然后再利用 RedisClient 的 add() 方法加入数据库,这样获取模块的工作就完成了。

检测模块

在获取模块中,我们已经成功将各个网站的代理获取下来了,然后就需要一个检测模块来对所有的代理进行一轮轮的检测,检测可用就设置为 100,不可用就分数减 1,这样就可以实时改变每个代理的可用情况,在获取有效代理的时候只需要获取分数高的代理即可。 由于代理的数量非常多,为了提高代理的检测效率,我们在这里使用异步请求库 Aiohttp 来进行检测。 Requests 作为一个同步请求库,我们在发出一个请求之后需要等待网页加载完成之后才能继续执行程序。也就是这个过程会阻塞在等待响应这个过程,如果服务器响应非常慢,比如一个请求等待十几秒,那么我们使用 Requests 完成一个请求就会需要十几秒的时间,中间其实就是一个等待响应的过程,程序也不会继续往下执行,而这十几秒的时间其实完全可以去做其他的事情,比如调度其他的请求或者进行网页解析等等。 异步请求库就解决了这个问题,它类似 JavaScript 中的回调,意思是说在请求发出之后,程序可以继续接下去执行去做其他的事情,当响应到达时,会通知程序再去处理这个响应,这样程序就没有被阻塞,充分把时间和资源利用起来,大大提高效率。 对于响应速度比较快的网站,可能 Requests 同步请求和 Aiohttp 异步请求的效果差距没那么大,可对于检测代理这种事情,一般是需要十多秒甚至几十秒的时间,这时候使用 Aiohttp 异步请求库的优势就大大体现出来了,效率可能会提高几十倍不止。 所以在这里我们的代理检测使用异步请求库 Aiohttp,实现示例如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
VALID_STATUS_CODES = [200]
TEST_URL = 'http://www.baidu.com'
BATCH_TEST_SIZE = 100

class Tester(object):
def __init__(self):
self.redis = RedisClient()

async def test_single_proxy(self, proxy):
"""
测试单个代理
:param proxy: 单个代理
:return: None
"""
conn = aiohttp.TCPConnector(verify_ssl=False)
async with aiohttp.ClientSession(connector=conn) as session:
try:
if isinstance(proxy, bytes):
proxy = proxy.decode('utf-8')
real_proxy = 'http://' + proxy
print('正在测试', proxy)
async with session.get(TEST_URL, proxy=real_proxy, timeout=15) as response:
if response.status in VALID_STATUS_CODES:
self.redis.max(proxy)
print('代理可用', proxy)
else:
self.redis.decrease(proxy)
print('请求响应码不合法', proxy)
except (ClientError, ClientConnectorError, TimeoutError, AttributeError):
self.redis.decrease(proxy)
print('代理请求失败', proxy)

def run(self):
"""
测试主函数
:return: None
"""
print('测试器开始运行')
try:
proxies = self.redis.all()
loop = asyncio.get_event_loop()
# 批量测试
for i in range(0, len(proxies), BATCH_TEST_SIZE):
test_proxies = proxies[i:i + BATCH_TEST_SIZE]
tasks = [self.test_single_proxy(proxy) for proxy in test_proxies]
loop.run_until_complete(asyncio.wait(tasks))
time.sleep(5)
except Exception as e:
print('测试器发生错误', e.args)

在这里定义了一个类 Tester,init() 方法中建立了一个 RedisClient 对象,供类中其他方法使用。接下来定义了一个 test_single_proxy() 方法,用来检测单个代理的可用情况,其参数就是被检测的代理,注意这个方法前面加了 async 关键词,代表这个方法是异步的,方法内部首先创建了 Aiohttp 的 ClientSession 对象,此对象类似于 Requests 的 Session 对象,可以直接调用该对象的 get() 方法来访问页面,在这里代理的设置方式是通过 proxy 参数传递给 get() 方法,请求方法前面也需要加上 async 关键词标明是异步请求,这也是 Aiohttp 使用时的常见写法。 测试的链接在这里定义常量为 TEST_URL,如果针对某个网站有抓取需求,建议将 TEST_URL 设置为目标网站的地址,因为在抓取的过程中,可能代理本身是可用的,但是该代理的 IP 已经被目标网站封掉了。例如,如要抓取知乎,可能其中某些代理是可以正常使用,比如访问百度等页面是完全没有问题的,但是可能对知乎来说可能就被封了,所以可以将 TEST_URL 设置为知乎的某个页面的链接,当请求失败时,当代理被封时,分数自然会减下来,就不会被取到了。 如果想做一个通用的代理池,则不需要专门设置 TEST_URL,可以设置为一个不会封 IP 的网站,也可以设置为百度这类响应稳定的网站。 另外我们还定义了 VALID_STATUS_CODES 变量,是一个列表形式,包含了正常的状态码,如可以定义成 [200],当然对于某些检测目标网站可能会出现其他的状态码也是正常的,可以自行配置。 获取 Response 后需要判断响应的状态,如果状态码在 VALID_STATUS_CODES 这个列表里,则代表代理可用,调用 RedisClient 的 max() 方法将代理分数设为 100,否则调用 decrease() 方法将代理分数减 1,如果出现异常也同样将代理分数减 1。 另外在测试的时候设置了批量测试的最大值 BATCH_TEST_SIZE 为 100,也就是一批测试最多测试 100个,这可以避免当代理池过大时全部测试导致内存开销过大的问题。 随后在 run() 方法里面获取了所有的代理列表,使用 Aiohttp 分配任务,启动运行,这样就可以进行异步检测了,写法可以参考 Aiohttp 的官方示例:http://aiohttp.readthedocs.io/。 这样测试模块的逻辑就完成了。

接口模块

通过上述三个模块我们已经可以做到代理的获取、检测和更新了,数据库中就会以有序集合的形式存储各个代理还有对应的分数,分数 100 代表可用,分数越小代表越不可用。 但是我们怎样来方便地获取可用代理呢?用 RedisClient 类来直接连接 Redis 然后调用 random() 方法获取当然没问题,这样做效率很高,但是有这么几个弊端:

  • 需要知道 Redis 的用户名和密码,如果这个代理池是给其他人使用的就需要告诉他连接的用户名和密码信息,这样是很不安全的。
  • 代理池如果想持续运行需要部署在远程服务器上运行,如果远程服务器的 Redis 是只允许本地连接的,那么就没有办法远程直连 Redis 获取代理了。
  • 如果爬虫所在的主机没有连接 Redis 的模块,或者爬虫不是由 Python 语言编写的,那么就无法使用 RedisClient 来获取代理了。
  • 如果 RedisClient 类或者数据库结构有更新,那么在爬虫端还需要去同步这些更新。

综上考虑,为了使得代理池可以作为一个独立服务运行,我们最好增加一个接口模块,以 Web API 的形式暴露可用代理。 这样获取代理只需要请求一下接口即可,以上的几个缺点弊端可以解决。 我们在这里使用一个比较轻量级的库 Flask 来实现这个接口模块,实现示例如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
from flask import Flask, g
from db import RedisClient

__all__ = ['app']
app = Flask(__name__)

def get_conn():
if not hasattr(g, 'redis'):
g.redis = RedisClient()
return g.redis

@app.route('/')
def index():
return '<h2>Welcome to Proxy Pool System</h2>'

@app.route('/random')
def get_proxy():
"""
获取随机可用代理
:return: 随机代理
"""
conn = get_conn()
return conn.random()

@app.route('/count')
def get_counts():
"""
获取代理池总量
:return: 代理池总量
"""
conn = get_conn()
return str(conn.count())

if __name__ == '__main__':
app.run()

在这里我们声明了一个 Flask 对象,定义了三个接口,分别是首页、随机代理页、获取数量页。 运行之后 Flask 会启动一个 Web 服务,我们只需要访问对应的接口即可获取到可用代理。

调度模块

这个模块其实就是调用以上所定义的三个模块,将以上三个模块通过多进程的形式运行起来,示例如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
TESTER_CYCLE = 20
GETTER_CYCLE = 20
TESTER_ENABLED = True
GETTER_ENABLED = True
API_ENABLED = True

from multiprocessing import Process
from api import app
from getter import Getter
from tester import Tester

class Scheduler():
def schedule_tester(self, cycle=TESTER_CYCLE):
"""
定时测试代理
"""
tester = Tester()
while True:
print('测试器开始运行')
tester.run()
time.sleep(cycle)

def schedule_getter(self, cycle=GETTER_CYCLE):
"""
定时获取代理
"""
getter = Getter()
while True:
print('开始抓取代理')
getter.run()
time.sleep(cycle)

def schedule_api(self):
"""
开启API
"""
app.run(API_HOST, API_PORT)

def run(self):
print('代理池开始运行')
if TESTER_ENABLED:
tester_process = Process(target=self.schedule_tester)
tester_process.start()

if GETTER_ENABLED:
getter_process = Process(target=self.schedule_getter)
getter_process.start()

if API_ENABLED:
api_process = Process(target=self.schedule_api)
api_process.start()

在这里还有三个常量,TESTER_ENABLED、GETTER_ENABLED、API_ENABLED 都是布尔类型,True 或者 False。标明了测试模块、获取模块、接口模块的开关,如果为 True,则代表模块开启。 启动入口是 run() 方法,其分别判断了三个模块的开关,如果开启的话,就新建一个 Process 进程,设置好启动目标,然后调用 start() 方法运行,这样三个进程就可以并行执行,互不干扰。 三个调度方法结构也非常清晰,比如 schedule_tester() 方法,这是用来调度测试模块的方法,首先声明一个 Tester 对象,然后进入死循环不断循环调用其 run() 方法,执行完一轮之后就休眠一段时间,休眠结束之后重新再执行。在这里休眠时间也定义为一个常量,如 20 秒,这样就会每隔 20 秒进行一次代理检测。 最后整个代理池的运行只需要调用 Scheduler 的 run() 方法即可启动。 以上便是整个代理池的架构和相应实现逻辑。

5. 运行

接下来我们将代码整合一下,将代理运行起来,运行之后的输出结果如图 9-2 所示: 图 9-2 运行结果 以上是代理池的控制台输出,可以看到可用代理设置为 100,不可用代理分数减 1。 接下来我们再打开浏览器,当前配置了运行在 5555 端口,所以打开:http://127.0.0.1:5555,即可看到其首页,如图 9-3 所示: 图 9-3 首页页面 再访问:http://127.0.0.1:5555/random,即可获取随机可用代理,如图 9-4 所示: 图 9-4 获取代理页面 所以后面我们只需要访问此接口即可获取一个随机可用代理,非常方便。 获取代理的代码如下:

1
2
3
4
5
6
7
8
9
10
11
import requests

PROXY_POOL_URL = 'http://localhost:5555/random'

def get_proxy():
try:
response = requests.get(PROXY_POOL_URL)
if response.status_code == 200:
return response.text
except ConnectionError:
return None

获取下来之后便是一个字符串类型的代理,可以按照上一节所示的方法设置代理,如 Requests 的使用方法如下:

1
2
3
4
5
6
7
8
9
10
11
12
import requests

proxy = get_proxy()
proxies = {
'http': 'http://' + proxy,
'https': 'https://' + proxy,
}
try:
response = requests.get('http://httpbin.org/get', proxies=proxies)
print(response.text)
except requests.exceptions.ConnectionError as e:
print('Error', e.args)

有了代理池之后,我们再取出代理即可有效防止IP被封禁的情况。

6. 本节代码

本节代码地址为:https://github.com/Python3WebSpider/ProxyPool

7. 结语

本节我们实现了一个比较高效的代理池来获取随机可用的代理,整个内容比较多,需要好好理解一下。 在后文我们会利用代理池来实现数据的抓取。

Python

在前面我们介绍了多种请求库,如 Requests、Urllib、Selenium 等。我们接下来首先贴近实战,了解一下代理怎么使用,为后面了解代理池、ADSL 拨号代理的使用打下基础。 下面我们来梳理一下这些库的代理的设置方法。

1. 获取代理

在做测试之前,我们需要先获取一个可用代理,搜索引擎搜索“代理”关键字,就可以看到有许多代理服务网站,在网站上会有很多免费代理,比如西刺:http://www.xicidaili.com/,这里列出了很多免费代理,但是这些免费代理大多数情况下都是不好用的,所以比较靠谱的方法是购买付费代理,很多网站都有售卖,数量不用多,买一个稳定可用的即可,可以自行选购。 或者如果我们本机有相关代理软件的话,软件一般会在本机创建 HTTP 或 SOCKS 代理服务,直接使用此代理也可以。 在这里我的本机安装了一部代理软件,它会在本地 9743 端口上创建 HTTP 代理服务,也就是代理为 127.0.0.1:9743,另外还会在 9742 端口创建 SOCKS 代理服务,也就是代理为 127.0.0.1:9742,我只要设置了这个代理就可以成功将本机 IP 切换到代理软件连接的服务器的 IP了。 所以本节下面的示例里我使用上述代理来演示其设置方法,你可以自行替换成自己的可用代理,设置代理后测试的网址是:http://httpbin.org/get,访问该站点可以得到请求的一些相关信息,其中 origin 字段就是客户端的 IP,我们可以根据它来判断代理是否设置成功,也就是是否成功伪装了IP。 下面我们来看下各个库的代理设置方式。

2. Urllib

首先我们以最基础的 Urllib 为例,来看一下代理的设置方法,代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
from urllib.error import URLError
from urllib.request import ProxyHandler, build_opener

proxy = '127.0.0.1:9743'
proxy_handler = ProxyHandler({
'http': 'http://' + proxy,
'https': 'https://' + proxy
})
opener = build_opener(proxy_handler)
try:
response = opener.open('http://httpbin.org/get')
print(response.read().decode('utf-8'))
except URLError as e:
print(e.reason)

运行结果如下:

1
2
3
4
5
6
7
8
9
10
11
{
"args": {},
"headers": {
"Accept-Encoding": "identity",
"Connection": "close",
"Host": "httpbin.org",
"User-Agent": "Python-urllib/3.6"
},
"origin": "106.185.45.153",
"url": "http://httpbin.org/get"
}

在这里我们需要借助于 ProxyHandler 设置代理,参数是字典类型,键名为协议类型,键值是代理,注意此处代理前面需要加上协议,即 http 或者 https,此处设置了 http 和 https 两种代理,当我们请求的链接是 http 协议的时候,它会调用 http 代理,当请求的链接是 https 协议的时候,它会调用https代理,所以此处生效的代理是:http://127.0.0.1:9743。 创建完 ProxyHandler 对象之后,我们需要利用 build_opener() 方法传入该对象来创建一个 Opener,这样就相当于此 Opener 已经设置好代理了,接下来直接调用它的 open() 方法即可使用此代理访问我们所想要的链接。 运行输出结果是一个 Json,它有一个字段 origin,标明了客户端的 IP,此处的 IP 验证一下,确实为代理的 IP,而并不是我们真实的 IP,所以这样我们就成功设置好代理,并可以隐藏真实 IP 了。 如果遇到需要认证的代理,我们可以用如下的方法设置:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
from urllib.error import URLError
from urllib.request import ProxyHandler, build_opener

proxy = 'username:password@127.0.0.1:9743'
proxy_handler = ProxyHandler({
'http': 'http://' + proxy,
'https': 'https://' + proxy
})
opener = build_opener(proxy_handler)
try:
response = opener.open('http://httpbin.org/get')
print(response.read().decode('utf-8'))
except URLError as e:
print(e.reason)

这里改变的只是 proxy 变量,只需要在代理前面加入代理认证的用户名密码即可,其中 username 就是用户名,password 为密码,例如 username 为foo,密码为 bar,那么代理就是 foo:bar@127.0.0.1:9743。 如果代理是 SOCKS5 类型,那么可以用如下方式设置代理:

1
2
3
4
5
6
7
8
9
10
11
12
import socks
import socket
from urllib import request
from urllib.error import URLError

socks.set_default_proxy(socks.SOCKS5, '127.0.0.1', 9742)
socket.socket = socks.socksocket
try:
response = request.urlopen('http://httpbin.org/get')
print(response.read().decode('utf-8'))
except URLError as e:
print(e.reason)

此处需要一个 Socks 模块,可以通过如下命令安装:

1
pip3 install PySocks

本地我有一个 SOCKS5 代理,运行在 9742 端口,运行成功之后和上文 HTTP 代理输出结果是一样的:

1
2
3
4
5
6
7
8
9
10
11
{
"args": {},
"headers": {
"Accept-Encoding": "identity",
"Connection": "close",
"Host": "httpbin.org",
"User-Agent": "Python-urllib/3.6"
},
"origin": "106.185.45.153",
"url": "http://httpbin.org/get"
}

结果的 origin 字段同样为代理的 IP,设置代理成功。

3. Requests

对于 Requests 来说,代理设置更加简单,我们只需要传入 proxies 参数即可。 还是以上例中的代理为例,我们来看下 Requests 的代理的设置:

1
2
3
4
5
6
7
8
9
10
11
12
import requests

proxy = '127.0.0.1:9743'
proxies = {
'http': 'http://' + proxy,
'https': 'https://' + proxy,
}
try:
response = requests.get('http://httpbin.org/get', proxies=proxies)
print(response.text)
except requests.exceptions.ConnectionError as e:
print('Error', e.args)

运行结果:

1
2
3
4
5
6
7
8
9
10
11
12
{
"args": {},
"headers": {
"Accept": "*/*",
"Accept-Encoding": "gzip, deflate",
"Connection": "close",
"Host": "httpbin.org",
"User-Agent": "python-requests/2.18.1"
},
"origin": "106.185.45.153",
"url": "http://httpbin.org/get"
}

可以发现 Requests 的代理设置比 Urllib 简单很多,只需要构造代理字典即可,然后通过 proxies 参数即可设置代理,不需要重新构建 Opener。 可以发现其运行结果的 origin 也是代理的 IP,证明代理已经设置成功。 如果代理需要认证,同样在代理的前面加上用户名密码即可,代理的写法就变成:

1
proxy = 'username:password@127.0.0.1:9743'

和 Urllib 一样,只需要将 username 和 password 替换即可。 如果需要使用 SOCKS5 代理,则可以使用如下方式:

1
2
3
4
5
6
7
8
9
10
11
12
import requests

proxy = '127.0.0.1:9742'
proxies = {
'http': 'socks5://' + proxy,
'https': 'socks5://' + proxy
}
try:
response = requests.get('http://httpbin.org/get', proxies=proxies)
print(response.text)
except requests.exceptions.ConnectionError as e:
print('Error', e.args)

在这里需要额外安装一个 Socks 模块,命令如下:

1
pip3 install "requests[socks]"

运行结果是完全相同的:

1
2
3
4
5
6
7
8
9
10
11
12
{
"args": {},
"headers": {
"Accept": "*/*",
"Accept-Encoding": "gzip, deflate",
"Connection": "close",
"Host": "httpbin.org",
"User-Agent": "python-requests/2.18.1"
},
"origin": "106.185.45.153",
"url": "http://httpbin.org/get"
}

另外还有一种设置方式,和 Urllib 中的方法相同,使用 socks 模块,也需要像上文一样安装该库,设置方法如下:

1
2
3
4
5
6
7
8
9
10
11
import requests
import socks
import socket

socks.set_default_proxy(socks.SOCKS5, '127.0.0.1', 9742)
socket.socket = socks.socksocket
try:
response = requests.get('http://httpbin.org/get')
print(response.text)
except requests.exceptions.ConnectionError as e:
print('Error', e.args)

这样也可以设置 SOCKS5 代理,运行结果完全相同,相比第一种方法,此方法是全局设置,不同情况可以选用不同的方法。

4. Selenium

Selenium 同样也可以设置代理,在这里分两种介绍,一个是有界面浏览器,以 Chrome 为例介绍,另一种是无界面浏览器,以 PhantomJS 为例介绍。

Chrome

对于 Chrome 来说,用 Selenium 设置代理的方法也非常简单,设置方法如下:

1
2
3
4
5
6
7
from selenium import webdriver

proxy = '127.0.0.1:9743'
chrome_options = webdriver.ChromeOptions()
chrome_options.add_argument('--proxy-server=http://' + proxy)
browser = webdriver.Chrome(chrome_options=chrome_options)
browser.get('http://httpbin.org/get')

在这里我们通过 ChromeOptions 来设置代理,在创建 Chrome 对象的时候通过 chrome_options 参数传递即可。 这样在运行之后便会弹出一个 Chrome 浏览器,访问目标链接之后输出结果如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
{
"args": {},
"headers": {
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8",
"Accept-Encoding": "gzip, deflate",
"Accept-Language": "zh-CN,zh;q=0.8",
"Connection": "close",
"Host": "httpbin.org",
"Upgrade-Insecure-Requests": "1",
"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.115 Safari/537.36"
},
"origin": "106.185.45.153",
"url": "http://httpbin.org/get"
}

可以看到 origin 同样为代理 IP 的地址,代理设置成功。 如果代理是认证代理,则设置方法相对比较麻烦,方法如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
import zipfile

ip = '127.0.0.1'
port = 9743
username = 'foo'
password = 'bar'

manifest_json = """
{
"version": "1.0.0",
"manifest_version": 2,
"name": "Chrome Proxy",
"permissions": [
"proxy",
"tabs",
"unlimitedStorage",
"storage",
"<all_urls>",
"webRequest",
"webRequestBlocking"
],
"background": {
"scripts": ["background.js"]
}
}
"""

background_js = """
var config = {
mode: "fixed_servers",
rules: {
singleProxy: {
scheme: "http",
host: "%(ip)s",
port: %(port)s
}
}
}

chrome.proxy.settings.set({value: config, scope: "regular"}, function() {});

function callbackFn(details) {
return {
authCredentials: {
username: "%(username)s",
password: "%(password)s"
}
}
}

chrome.webRequest.onAuthRequired.addListener(
callbackFn,
{urls: ["<all_urls>"]},
['blocking']
)
""" % {'ip': ip, 'port': port, 'username': username, 'password': password}

plugin_file = 'proxy_auth_plugin.zip'
with zipfile.ZipFile(plugin_file, 'w') as zp:
zp.writestr("manifest.json", manifest_json)
zp.writestr("background.js", background_js)
chrome_options = Options()
chrome_options.add_argument("--start-maximized")
chrome_options.add_extension(plugin_file)
browser = webdriver.Chrome(chrome_options=chrome_options)
browser.get('http://httpbin.org/get')

在这里需要在本地创建一个 manifest.json 配置文件和 background.js 脚本来设置认证代理,运行之后本地会生成一个 proxy_auth_plugin.zip 文件保存配置。 运行结果和上例一致,origin 同样为代理 IP。

PhantomJS

对于 PhantomJS,代理设置方法可以借助于 service_args 参数,也就是命令行参数,代理设置方法如下:

1
2
3
4
5
6
7
8
9
from selenium import webdriver

service_args = [
'--proxy=127.0.0.1:9743',
'--proxy-type=http'
]
browser = webdriver.PhantomJS(service_args=service_args)
browser.get('http://httpbin.org/get')
print(browser.page_source)

在这里我们只需要使用 service_args 参数,将命令行的一些参数定义为列表,在初始化的时候传递即可。 运行结果:

1
2
3
4
5
6
7
8
9
10
11
12
13
{
"args": {},
"headers": {
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
"Accept-Encoding": "gzip, deflate",
"Accept-Language": "zh-CN,en,*",
"Connection": "close",
"Host": "httpbin.org",
"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X) AppleWebKit/538.1 (KHTML, like Gecko) PhantomJS/2.1.0 Safari/538.1"
},
"origin": "106.185.45.153",
"url": "http://httpbin.org/get"
}

运行结果的 origin 同样为代理的 IP,设置代理成功。 如果需要认证,那么只需要再加入 —proxy-auth 选项即可,这样参数就改为:

1
2
3
4
5
service_args = [
'--proxy=127.0.0.1:9743',
'--proxy-type=http',
'--proxy-auth=username:password'
]

将 username 和 password 替换为认证所需的用户名和密码即可。

5. 本节代码

本节代码地址为:https://github.com/Python3WebSpider/ProxySettings

6. 结语

本节介绍了前文所介绍的请求库的代理设置方法,稍作了解即可,后面我们会使用这些方法来搭建代理池和爬取网站,进一步加深印象。

Python

我们在做爬虫的过程中经常会遇到这样的情况,最初爬虫正常运行,正常抓取数据,一切看起来都是那么的美好,然而一杯茶的功夫可能就会出现错误,比如 403 Forbidden,这时候打开网页一看,可能会看到“您的 IP 访问频率太高”这样的提示,或者跳出一个验证码让我们输入,输入之后才可能解封,但是输入之后过一会儿就又这样了。 出现这样的现象的原因是网站采取了一些反爬虫的措施,比如服务器会检测某个 IP 在单位时间内的请求次数,如果超过了这个阈值,那么会直接拒绝服务,返回一些错误信息,这种情况可以称之为封 IP,于是乎就成功把我们的爬虫禁掉了。 既然服务器检测的是某个 IP 单位时间的请求次数,那么我们借助某种方式来伪装我们的 IP,让服务器识别不出是由我们本机发起的请求,不就可以成功防止封 IP 了吗? 所以这时候代理就派上用场了,本章我们会详细介绍一下代理的基本知识及各种代理的使用方式,帮助爬虫脱离封 IP 的苦海。 本章接下来会介绍代理的设置、代理池的维护、付费代理的使用、ADSL拨号代理的搭建方法。

Python

本节我们来介绍一下新浪微博宫格验证码的识别,此验证码是一种新型交互式验证码,每个宫格之间会有一条指示连线,指示了我们应该的滑动轨迹,我们需要按照滑动轨迹依次从起始宫格一直滑动到终止宫格才可以完成验证,如图 8-24 所示: 图 8-24 验证码示例 鼠标滑动后的轨迹会以黄色的连线来标识,如图 8-25 所示: 图 8-25 滑动过程 我们可以访问新浪微博移动版登录页面就可以看到如上验证码,链接为:https://passport.weibo.cn/signin/login,当然也不是每次都会出现验证码,一般当频繁登录或者账号存在安全风险的时候会出现。 接下来我们就来试着识别一下此类验证码。

1. 本节目标

本节我们的目标是用程序来识别并通过微博宫格验证码的验证。

2. 准备工作

本次我们使用的 Python 库是 Selenium,使用的浏览器为 Chrome,在此之前请确保已经正确安装好了 Selenium 库、Chrome浏览器并配置好了 ChromeDriver,相关流程可以参考第一章的说明。

3. 识别思路

要识别首先要从探寻规律入手,那么首先我们找到的规律就是此验证码的四个宫格一定是有连线经过的,而且每一条连线上都会相应的指示箭头,连线的形状多样,如C型、Z型、X型等等,如图 8-26、8-27、8-28 所示: 图 8-26 C 型 图 8-27 Z 型 图 8-28 X 型 而同时我们发现同一种类型它的连线轨迹是相同的,唯一不同的就是连线的方向,如图 8-29、8-30 所示: 图 8-29 反向连线 图 8-30 正向连线 这两种验证码的连线轨迹是相同的,但是由于连线上面的指示箭头不同导致滑动的宫格顺序就有所不同。 所以要完全识别滑动宫格顺序的话就需要具体识别出箭头的朝向,而观察一下整个验证码箭头朝向一共可能有 8 种,而且会出现在不同的位置,如果要写一个箭头方向识别算法的话需要都考虑到不同箭头所在的位置,我们需要找出各个位置的箭头的像素点坐标,同时识别算法还需要计算其像素点变化规律,这个工作量就变得比较大。 这时我们可以考虑用模板匹配的方法,模板匹配的意思就是将一些识别目标提前保存下来并做好标记,称作模板,在这里我们就可以获取验证码图片并做好拖动顺序的标记当做模板。在匹配的时候来对比要新识别的目标和每一个模板哪个是匹配的,如果找到匹配的模板,则被匹配到的模板就和新识别的目标是相同的,这样就成功识别出了要新识别的目标了。模板匹配在图像识别中也是非常常用的一种方法,实现简单而且易用性好。 模板匹配方法如果要效果好的话,我们必须要收集到足够多的模板才可以,而对于微博宫格验证码来说,宫格就 4 个,验证码的样式最多就是 4 3 2 * 1 = 24种,所以我们可以直接将所有模板都收集下来。 所以接下来我们需要考虑的就是用何种模板来进行匹配,是只匹配箭头还是匹配整个验证码全图呢?我们来权衡一下这两种方式的匹配精度和工作量:

  • 首先是精度问题。如果要匹配箭头的话,我们比对的目标只有几个像素点范围的箭头,而且我们需要精确知道各个箭头所在的像素点,一旦像素点有所偏差,那么匹配模板的时候会直接错位,导致匹配结果大打折扣。如果匹配全图,我们无需关心箭头所在位置,同时还有连线帮助辅助匹配,所以匹配精度上显然是全图匹配精度更高。
  • 其次是工作量的问题。如果要匹配箭头的话,我们需要将所有不同朝向的箭头模板都保存下来,而相同位置箭头的朝向可能不一,相同朝向的箭头位置可能不一,这时候我们需要都算出各个箭头的位置并将其逐个截出来保存成模板,同时在匹配的时候也需要依次去探寻验证码对应位置是否有匹配模板。如果匹配全图的话,我们不需要关心每个箭头的位置和朝向,只需要将验证码全图保存下来即可,在匹配的时候也不需要再去计算箭头的位置,所以工作量上明显是匹配全图更小。

所以综上考虑,我们选用全图匹配的方式来进行识别。 所以到此为止,我们就可以使用全图模板匹配的方法来识别这个宫格验证码了,找到匹配的模板之后,我们就可以得到事先为模板定义的拖动顺序,然后模拟拖动即可。

4. 获取模板

在开始之前,我们需要做一下准备工作,先将 24 张验证码全图保存下来,保存工作难道需要手工来做吗?当然不是的,因为验证码是随机的,一共有 24 种,所以我们可以写一段程序来批量保存一些验证码图片,然后从中筛选出需要的图片就好了,代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
import time
from io import BytesIO
from PIL import Image
from selenium import webdriver
from selenium.common.exceptions import TimeoutException
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

USERNAME = ''
PASSWORD = ''

class CrackWeiboSlide():
def __init__(self):
self.url = 'https://passport.weibo.cn/signin/login'
self.browser = webdriver.Chrome()
self.wait = WebDriverWait(self.browser, 20)
self.username = USERNAME
self.password = PASSWORD

def __del__(self):
self.browser.close()

def open(self):
"""
打开网页输入用户名密码并点击
:return: None
"""
self.browser.get(self.url)
username = self.wait.until(EC.presence_of_element_located((By.ID, 'loginName')))
password = self.wait.until(EC.presence_of_element_located((By.ID, 'loginPassword')))
submit = self.wait.until(EC.element_to_be_clickable((By.ID, 'loginAction')))
username.send_keys(self.username)
password.send_keys(self.password)
submit.click()

def get_position(self):
"""
获取验证码位置
:return: 验证码位置元组
"""
try:
img = self.wait.until(EC.presence_of_element_located((By.CLASS_NAME, 'patt-shadow')))
except TimeoutException:
print('未出现验证码')
self.open()
time.sleep(2)
location = img.location
size = img.size
top, bottom, left, right = location['y'], location['y'] + size['height'], location['x'], location['x'] + size['width']
return (top, bottom, left, right)

def get_screenshot(self):
"""
获取网页截图
:return: 截图对象
"""
screenshot = self.browser.get_screenshot_as_png()
screenshot = Image.open(BytesIO(screenshot))
return screenshot

def get_image(self, name='captcha.png'):
"""
获取验证码图片
:return: 图片对象
"""
top, bottom, left, right = self.get_position()
print('验证码位置', top, bottom, left, right)
screenshot = self.get_screenshot()
captcha = screenshot.crop((left, top, right, bottom))
captcha.save(name)
return captcha

def main(self):
"""
批量获取验证码
:return: 图片对象
"""
count = 0
while True:
self.open()
self.get_image(str(count) + '.png')
count += 1

if __name__ == '__main__':
crack = CrackWeiboSlide()
crack.main()

其中这里需要将 USERNAME 和 PASSWORD 修改为自己微博的用户名密码,运行一段时间后便可以发现在本地多了很多以数字命名的验证码,如图 8-31 所示: 图 8-31 获取结果 在这里我们只需要挑选出不同的24张验证码图片并命名保存就好了,名称可以直接取作宫格的滑动的顺序,如某张验证码图片如图 8-32 所示: 图 8-32 验证码示例 我们将其命名为 4132.png 即可,也就是代表滑动顺序为 4-1-3-2,按照这样的规则,我们将验证码整理为如下 24 张图,如图 8-33 所示: 图 8-33 整理结果 如上的 24 张图就是我们的模板,接下来我们在识别的时候只需要遍历模板进行匹配即可。

5. 模板匹配

上面的代码已经实现了将验证码保存下来的功能,通过调用 get_image() 方法我们便可以得到验证码图片对象,得到验证码对象之后我们就需要对其进行模板匹配了,定义如下的方法进行匹配:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
from os import listdir

def detect_image(self, image):
"""
匹配图片
:param image: 图片
:return: 拖动顺序
"""
for template_name in listdir(TEMPLATES_FOLDER):
print('正在匹配', template_name)
template = Image.open(TEMPLATES_FOLDER + template_name)
if self.same_image(image, template):
# 返回顺序
numbers = [int(number) for number in list(template_name.split('.')[0])]
print('拖动顺序', numbers)
return numbers

在这里 TEMPLATES_FOLDER 就是模板所在的文件夹,在这里我们用 listdir() 方法将所有模板的文件名称获取出来,然后对其进行遍历,通过 same_image() 方法对验证码和模板进行比对,如果成功匹配,那么就将匹配到的模板文件名转为列表,如匹配到了 3124.png,则返回结果 [3, 1, 2, 4]。 比对的方法实现如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
def is_pixel_equal(self, image1, image2, x, y):
"""
判断两个像素是否相同
:param image1: 图片1
:param image2: 图片2
:param x: 位置x
:param y: 位置y
:return: 像素是否相同
"""
# 取两个图片的像素点
pixel1 = image1.load()[x, y]
pixel2 = image2.load()[x, y]
threshold = 20
if abs(pixel1[0] - pixel2[0]) < threshold and abs(pixel1[1] - pixel2[1]) < threshold and abs(
pixel1[2] - pixel2[2]) < threshold:
return True
else:
return False

def same_image(self, image, template):
"""
识别相似验证码
:param image: 待识别验证码
:param template: 模板
:return:
"""
# 相似度阈值
threshold = 0.99
count = 0
for x in range(image.width):
for y in range(image.height):
# 判断像素是否相同
if self.is_pixel_equal(image, template, x, y):
count += 1
result = float(count) / (image.width * image.height)
if result > threshold:
print('成功匹配')
return True
return False

在这里比对图片也是利用了遍历像素的方法,same_image() 方法接收两个参数,image 为待检测的验证码图片对象,template 是模板对象,由于二者大小是完全一致的,所以在这里我们遍历了图片的所有像素点,比对二者同一位置的像素点是否相同,如果相同就计数加 1,最后计算一下相同的像素点占总像素的比例,如果该比例超过一定阈值那就判定为图片完全相同,匹配成功。在这里设定阈值为 0.99,即如果二者有 0.99 以上的相似比则代表匹配成功。 这样通过上面的方法,依次匹配 24 个模板,如果验证码图片正常,总能找到一个匹配的模板,这样最后就可以得到宫格的滑动顺序了。

6. 模拟拖动

得到了滑动顺序之后,我们接下来就是根据滑动顺序来拖动鼠标连接各个宫格了,方法实现如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
def move(self, numbers):
"""
根据顺序拖动
:param numbers:
:return:
"""
# 获得四个按点
circles = self.browser.find_elements_by_css_selector('.patt-wrap .patt-circ')
dx = dy = 0
for index in range(4):
circle = circles[numbers[index] - 1]
# 如果是第一次循环
if index == 0:
# 点击第一个按点
ActionChains(self.browser)
.move_to_element_with_offset(circle, circle.size['width'] / 2, circle.size['height'] / 2)
.click_and_hold().perform()
else:
# 小幅移动次数
times = 30
# 拖动
for i in range(times):
ActionChains(self.browser).move_by_offset(dx / times, dy / times).perform()
time.sleep(1 / times)
# 如果是最后一次循环
if index == 3:
# 松开鼠标
ActionChains(self.browser).release().perform()
else:
# 计算下一次偏移
dx = circles[numbers[index + 1] - 1].location['x'] - circle.location['x']
dy = circles[numbers[index + 1] - 1].location['y'] - circle.location['y']

在这里方法接收的参数就是宫格的点按顺序,如 [3, 1, 2, 4]。首先我们利用 find_elements_by_css_selector() 方法获取到四个宫格元素,是一个列表形式,每个元素代表一个宫格,接下来我们遍历了宫格的点按顺序,再做一系列对应操作。 其中如果是第一个宫格,那就直接鼠标点击并保持动作,否则移动到下一个宫格。如果是最后一个宫格,那就松开鼠标,否则计算移动到下一个宫格的偏移量。 通过四次循环,我们便可以成功操作浏览器完成宫格验证码的拖拽填充,松开鼠标之后即可识别成功。 运行效果如图 8-34 所示: 图 8-34 运行效果 鼠标会慢慢的从起始位置移动到终止位置,最后一个宫格松开之后便完成了验证码的识别。 至此,微博宫格验证码的识别就全部完成了。 识别完成之后验证码窗口会自动关闭,接下来直接点击登录按钮即可完成微博登录。

7. 本节代码

本节代码地址为:https://github.com/Python3WebSpider/CrackWeiboSlide

8. 结语

本节我们介绍了一种常用的模板匹配识别图片的方式来识别验证码,并模拟了鼠标拖拽动作来实现验证码的识别。如果遇到类似的验证码,可以采用同样的思路进行识别。

Python

上一节我们实现了极验验证码的识别,但是除了极验其实还有另一种常见的且应用广泛的验证码,比较有代表性的就是点触验证码。 可能你对这个名字比较陌生,但是肯定见过类似的验证码,比如 12306,这就是一种典型的点触验证码,如图 8-18 所示: 图 8-18 12306 验证码 我们需要直接点击图中符合要求的图,如果所有答案均正确才会验证成功,如果有一个答案错误,验证就会失败,这种验证码就可以称之为点触验证码。 另外还有一个专门提供点触验证码服务的站点,叫做 TouClick,其官方网站为:https://www.touclick.com/,本节就以它为例讲解一下此类验证码的识别过程。

1. 本节目标

本节我们的目标是用程序来识别并通过点触验证码的验证。

2. 准备工作

本次我们使用的 Python 库是 Selenium,使用的浏览器为 Chrome,在此之前请确保已经正确安装好了 Selenium 库、Chrome浏览器并配置好了 ChromeDriver,相关流程可以参考第一章的说明。

3. 了解点触验证码

TouClick 官方网站的验证码样式如图 8-19 所示: 图 8-19 验证码样式 和 12306 站点有相似之处,不过这次是点击图片中的文字,不是图片了,另外还有各种形形色色的点触验证码,其交互形式可能略有不同,但基本原理都是类似的。 接下来我们就来统一实现一下此类点触验证码的识别过程。

4. 识别思路

此种验证码的如果依靠图像识别的话识别难度非常之大。 例如就 12306 来说,其识别难点有两个点,第一点是文字识别,如图 8-20 所示: 图 8-20 12306 验证码 如点击图中所有的漏斗,“漏斗”二字其实都经过变形、放缩、模糊处理了,如果要借助于前面我们讲的 OCR 技术来识别,识别的精准度会大打折扣,甚至得不到任何结果。第二点是图像的识别,我们需要将图像重新转化文字,可以借助于各种识图接口,可经我测试识别正确结果的准确率非常低,经常会出现匹配不正确或匹配不出结果的情况,而且图片本身的的清晰度也不够,所以识别难度会更大,更何况需要同时识别出八张图片的结果,且其中几个答案需要完全匹配正确才能验证通过,综合来看,此种方法基本是不可行的。 再拿 TouClick 来说,如图 8-21 所示: 图 8-21 验证码示例 我们需要从这幅图片中识别出植株二字,但是图片的背景或多或少会有干扰,导致 OCR 几乎不会识别出结果,有人会说,直接识别白色的文字不就好了吗?但是如果换一张验证码呢?如图 8-22 所示: 图 8-22 验证码示例 这张验证码图片的文字又变成了蓝色,而且还又有白色阴影,识别的难度又会大大增加。 那么此类验证码就没法解了吗?答案当然是有,靠什么?靠人。 靠人解决?那还要程序做什么?不要急,这里说的人并不是我们自己去解,在互联网上存在非常多的验证码服务平台,平台 7x24 小时提供验证码识别服务,一张图片几秒就会获得识别结果,准确率可达 90% 以上,但是就需要花点钱来购买服务了,毕竟平台都是需要盈利的,不过不用担心,识别一个验证码只需要几分钱。 在这里我个人比较推荐的一个平台是超级鹰,其官网为:https://www.chaojiying.com,非广告。 其提供的服务种类非常广泛,可识别的验证码类型非常多,其中就包括此类点触验证码。 另外超级鹰平台同样支持简单的图形验证码识别,如果 OCR 识别有难度,同样可以用本节相同的方法借助此平台来识别,下面是此平台提供的一些服务:

  • 英文数字,提供最多20位英文数字的混合识别
  • 中文汉字,提供最多7个汉字的识别
  • 纯英文,提供最多12位的英文的识别
  • 纯数字,提供最多11位的数字的识别
  • 任意特殊字符,提供不定长汉字英文数字、拼音首字母、计算题、成语混合、 集装箱号等字符的识别
  • 坐标选择识别,如复杂计算题、选择题四选一、问答题、点击相同的字、物品、动物等返回多个坐标的识别

具体如有变动以官网为准:https://www.chaojiying.com/price.html。 而本节我们需要解决的就是属于最后一类,坐标多选识别的情况,我们需要做的就是将验证码图片提交给平台,然后平台会返回识别结果在图片中的坐标位置,接下来我们再解析坐标模拟点击就好了。 原理非常简单,下面我们就来实际用程序来实验一下。

5. 注册账号

在开始之前,我们需要先注册一个超级鹰账号并申请一个软件ID,注册页面链接为:https://www.chaojiying.com/user/reg/,注册完成之后还需要在后台开发商中心添加一个软件ID,最后一件事就是充值一些题分,充值多少可以根据价格和识别量自行决定。

6. 获取API

做好上面的准备工作之后我们就可以开始用程序来对接验证码的识别了。 首先我们可以到官方网站下载对应的 Python API,链接为:https://www.chaojiying.com/api-14.html,但是此 API 是Python2 版本的,是用 Requests 库来实现的,我们可以简单更改几个地方即可将其修改为 Python3 版本。 修改之后的API如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
import requests
from hashlib import md5

class Chaojiying(object):

def __init__(self, username, password, soft_id):
self.username = username
self.password = md5(password.encode('utf-8')).hexdigest()
self.soft_id = soft_id
self.base_params = {
'user': self.username,
'pass2': self.password,
'softid': self.soft_id,
}
self.headers = {
'Connection': 'Keep-Alive',
'User-Agent': 'Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.1; Trident/4.0)',
}

def post_pic(self, im, codetype):
"""
im: 图片字节
codetype: 题目类型 参考 http://www.chaojiying.com/price.html
"""
params = {
'codetype': codetype,
}
params.update(self.base_params)
files = {'userfile': ('ccc.jpg', im)}
r = requests.post('http://upload.chaojiying.net/Upload/Processing.php', data=params, files=files, headers=self.headers)
return r.json()

def report_error(self, im_id):
"""
im_id:报错题目的图片ID
"""
params = {
'id': im_id,
}
params.update(self.base_params)
r = requests.post('http://upload.chaojiying.net/Upload/ReportError.php', data=params, headers=self.headers)
return r.json()

这里定义了一个 Chaojiying 类,其构造函数接收三个参数,分别是超级鹰的用户名、密码以及软件ID,保存好以备使用。 接下来是最重要的一个方法叫做 post_pic(),这里需要传入图片对象和验证码的代号,该方法会将图片对象和相关信息发给超级鹰的后台进行识别,然后将识别成功的 Json 返回回来。 另一个方法叫做 report_error(),这个是发生错误的时候的回调,如果验证码识别错误,调用此方法会返还相应的题分。 接下来我们以 TouClick 的官网为例来进行演示点触验证码的识别过程,链接为:http://admin.touclick.com/,如果没有注册账号可以先注册一个。

7. 初始化

首先我们需要初始化一些变量,如 WebDriver、Chaojiying对象等等,代码实现如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
EMAIL = 'cqc@cuiqingcai.com'
PASSWORD = ''
# 超级鹰用户名、密码、软件ID、验证码类型
CHAOJIYING_USERNAME = 'Germey'
CHAOJIYING_PASSWORD = ''
CHAOJIYING_SOFT_ID = 893590
CHAOJIYING_KIND = 9102

class CrackTouClick():
def __init__(self):
self.url = 'http://admin.touclick.com/login.html'
self.browser = webdriver.Chrome()
self.wait = WebDriverWait(self.browser, 20)
self.email = EMAIL
self.password = PASSWORD
self.chaojiying = Chaojiying(CHAOJIYING_USERNAME, CHAOJIYING_PASSWORD, CHAOJIYING_SOFT_ID)

这里的账号和密码请自行修改。

8. 获取验证码

接下来的第一步就是完善相关表单,然后模拟点击呼出验证码,此步非常简单,代码实现如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def open(self):
"""
打开网页输入用户名密码
:return: None
"""
self.browser.get(self.url)
email = self.wait.until(EC.presence_of_element_located((By.ID, 'email')))
password = self.wait.until(EC.presence_of_element_located((By.ID, 'password')))
email.send_keys(self.email)
password.send_keys(self.password)

def get_touclick_button(self):
"""
获取初始验证按钮
:return:
"""
button = self.wait.until(EC.element_to_be_clickable((By.CLASS_NAME, 'touclick-hod-wrap')))
return button

在这里 open() 方法负责填写表单,get_touclick_button() 方法则是获取验证码按钮,随后触发点击即可。 接下来我们需要类似上一节极验验证码图像获取一样,首先获取验证码图片的位置和大小,随后从网页截图里面截取相应的验证码图片就好了。代码实现如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
def get_touclick_element(self):
"""
获取验证图片对象
:return: 图片对象
"""
element = self.wait.until(EC.presence_of_element_located((By.CLASS_NAME, 'touclick-pub-content')))
return element

def get_position(self):
"""
获取验证码位置
:return: 验证码位置元组
"""
element = self.get_touclick_element()
time.sleep(2)
location = element.location
size = element.size
top, bottom, left, right = location['y'], location['y'] + size['height'], location['x'], location['x'] + size[
'width']
return (top, bottom, left, right)

def get_screenshot(self):
"""
获取网页截图
:return: 截图对象
"""
screenshot = self.browser.get_screenshot_as_png()
screenshot = Image.open(BytesIO(screenshot))
return screenshot

def get_touclick_image(self, name='captcha.png'):
"""
获取验证码图片
:return: 图片对象
"""
top, bottom, left, right = self.get_position()
print('验证码位置', top, bottom, left, right)
screenshot = self.get_screenshot()
captcha = screenshot.crop((left, top, right, bottom))
return captcha

在这里 get_touclick_image() 方法即为从网页截图中截取对应的验证码图片,其中验证码图片的相对位置坐标由 get_position() 方法返回得到,最后我们得到的是一个 Image 对象。

9. 识别验证码

随后我们调用 Chaojiying 对象的 post_pic() 方法即可把图片发送给超级鹰后台,在这里发送的图像是字节流格式,代码实现如下:

1
2
3
4
5
6
image = self.get_touclick_image()
bytes_array = BytesIO()
image.save(bytes_array, format='PNG')
# 识别验证码
result = self.chaojiying.post_pic(bytes_array.getvalue(), CHAOJIYING_KIND)
print(result)

这样运行之后 result 变量就是超级鹰后台的识别结果,可能运行需要等待几秒,毕竟后台还有人工来完成识别。 返回的结果是一个 Json,如果识别成功后一个典型的返回结果类似如下:

1
{'err_no': 0, 'err_str': 'OK', 'pic_id': '6002001380949200001', 'pic_str': '132,127|56,77', 'md5': '1f8e1d4bef8b11484cb1f1f34299865b'}

其中 pic_str 就是识别的文字的坐标,是以字符串形式返回的,每个坐标都以 | 分隔,所以接下来我们只需要将其解析之后再模拟点击即可,代码实现如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
def get_points(self, captcha_result):
"""
解析识别结果
:param captcha_result: 识别结果
:return: 转化后的结果
"""
groups = captcha_result.get('pic_str').split('|')
locations = [[int(number) for number in group.split(',')] for group in groups]
return locations

def touch_click_words(self, locations):
"""
点击验证图片
:param locations: 点击位置
:return: None
"""
for location in locations:
print(location)
ActionChains(self.browser).move_to_element_with_offset(self.get_touclick_element(), location[0], location[1]).click().perform()
time.sleep(1)

在这里我们用 get_points() 方法将识别结果变成了列表的形式,最后 touch_click_words() 方法则通过调用 move_to_element_with_offset() 方法依次传入解析后的坐标,然后点击即可。 这样我们就可以模拟完成坐标的点选了,运行效果如图 8-23 所示: 图 8-23 点选效果 最后我们需要做的就是点击提交验证的按钮等待验证通过,再点击登录按钮即可成功登录,后续实现在此不再赘述。 这样我们就借助于在线验证码平台完成了点触验证码的识别,此种方法也是一种通用方法,用此方法来识别 12306 等验证码也是完全相同的原理。

10. 本节代码

本节代码地址为:https://github.com/Python3WebSpider/CrackTouClick

11. 结语

本节我们通过在线打码平台辅助完成了验证码的识别,这种识别方法非常强大,几乎任意的验证码都可以识别,如果遇到难题,借助于打码平台无疑是一个极佳的选择。

Python

上节我们了解了图形验证码的识别,简单的图形验证码我们可以直接利用 Tesserocr 来识别,但是近几年又出现了一些新型验证码,如滑动验证码,比较有代表性的就是极验验证码,它需要拖动拼合滑块才可以完成验证,相对图形验证码来说识别难度上升了几个等级,本节来讲解下极验验证码的识别过程。

1. 本节目标

本节我们的目标是用程序来识别并通过极验验证码的验证,其步骤有分析识别思路、识别缺口位置、生成滑块拖动路径,最后模拟实现滑块拼合通过验证。

2. 准备工作

本次我们使用的 Python 库是 Selenium,使用的浏览器为 Chrome,在此之前请确保已经正确安装好了 Selenium 库、Chrome浏览器并配置好了 ChromeDriver,相关流程可以参考第一章的说明。

3. 了解极验验证码

极验验证码其官网为:http://www.geetest.com/,它是一个专注于提供验证安全的系统,主要验证方式是拖动滑块拼合图像,若图像完全拼合,则验证成功,即可以成功提交表单,否则需要重新验证,样例如图8-5 和 8-6 所示: 图 8-5 验证码示例 图 8-6 验证码示例 现在极验验证码已经更新到了 3.0 版本,截至 2017 年 7 月全球已有十六万家企业正在使用极验,每天服务响应超过四亿次,广泛应用于直播视频、金融服务、电子商务、游戏娱乐、政府企业等各大类型网站,下面是斗鱼、魅族的登录页面,可以看到其都对接了极验验证码,如图 8-7 和 8-8 所示: 图 8-7 斗鱼登录页面 图 8-8 魅族登录页面

4. 极验验证码的特点

这种验证码相较于图形验证码来说识别难度更大,极验验证码首先需要在前台验证通过,对于极验 3.0,我们首先需要点击按钮进行智能验证,如果验证不通过,则会弹出滑动验证的窗口,随后需要拖动滑块拼合图像进行验证,验证之后会生成三个加密参数,参数随后通过表单提交到后台,后台还会进行一次验证。 另外极验还增加了机器学习的方法来识别拖动轨迹,官方网站的安全防护说明如下:

  • 三角防护之防模拟

恶意程序模仿人类行为轨迹对验证码进行识别。针对模拟,极验拥有超过 4000 万人机行为样本的海量数据。利用机器学习和神经网络构建线上线下的多重静态、动态防御模型。识别模拟轨迹,界定人机边界。

  • 三角防护之防伪造

恶意程序通过伪造设备浏览器环境对验证码进行识别。针对伪造,极验利用设备基因技术。深度分析浏览器的实际性能来辨识伪造信息。同时根据伪造事件不断更新黑名单,大幅提高防伪造能力。

  • 三角防护之防暴力

恶意程序短时间内进行密集的攻击,对验证码进行暴力识别 针对暴力,极验拥有多种验证形态,每一种验证形态都有利用神经网络生成的海量图库储备,每一张图片都是独一无二的,且图库不断更新,极大程度提高了暴力识别的成本。 另外极验的验证相对于普通验证方式更加方便,体验更加友好,其官方网站说明如下:

  • 点击一下,验证只需要 0.4 秒

极验始终专注于去验证化实践,让验证环节不再打断产品本身的交互流程,最终达到优化用户体验和提高用户转化率的效果。

  • 全平台兼容,适用各种交互场景

极验兼容所有主流浏览器甚至古老的IE6,也可以轻松应用在iOS和Android移动端平台,满足各种业务需求,保护网站资源不被滥用和盗取。

  • 面向未来,懂科技,更懂人性

极验在保障安全同时不断致力于提升用户体验,精雕细琢的验证面板,流畅顺滑的验证动画效果,让验证过程不再枯燥乏味。 因此,相较于一般验证码,极验的验证安全性和易用性有了非常大的提高。

5. 识别思路

但是对于应用了极验验证码的网站,识别并不是没有办法的。如果我们直接模拟表单提交的话,加密参数的构造是个问题,参数构造有问题服务端就会校验失败,所以在这里我们采用直接模拟浏览器动作的方式来完成验证,在 Python 中我们就可以使用 Selenium 来通过完全模拟人的行为的方式来完成验证,此验证成本相对于直接去识别加密算法容易不少。 首先我们找到一个带有极验验证的网站,最合适的当然为极验官方后台了,链接为:https://account.geetest.com/login,首先可以看到在登录按钮上方有一个极验验证按钮,如图 8-9 所示: 图 8-9 验证按钮 此按钮为智能验证按钮,点击一下即可智能验证,一般来说如果是同一个 Session,一小段时间内第二次登录便会直接通过验证,如果智能识别不通过,则会弹出滑动验证窗口,我们便需要拖动滑块来拼合图像完成二步验证,如图 8-10 所示: 图 8-10 拖动示例 验证成功后验证按钮便会变成如下状态,如图 8-11 所示: 图 8-11 验证成功结果 接下来我们便可以进行表单提交了。 所以在这里我们要识别验证需要做的有三步:

  • 模拟点击验证按钮
  • 识别滑动缺口的位置
  • 模拟拖动滑块

第一步操作是最简单的,我们可以直接用 Selenium 模拟点击按钮即可。 第二步操作识别缺口的位置比较关键,需要用到图像的相关处理方法,那缺口怎么找呢?首先来观察一下缺口的样子,如图 8-12 和 8-13 所示: 图 8-12 缺口示例 图 8-13 缺口示例 可以看到缺口的四周边缘有明显的断裂边缘,而且边缘和边缘周围有明显的区别,我们可以实现一个边缘检测算法来找出缺口的位置。对于极验来说,我们可以利用和原图对比检测的方式来识别缺口的位置,因为在没有滑动滑块之前,缺口其实是没有呈现的,如图 8-14 所示: 图 8-14 初始状态 所以我们可以同时获取两张图片,设定一个对比阈值,然后遍历两张图片找出相同位置像素 RGB 差距超过此阈值的像素点位置,那么此位置就是缺口的位置。 第三步操作看似简单,但是其中的坑比较多,极验验证码增加了机器轨迹识别,匀速移动、随机速度移动等方法都是不行的,只有完全模拟人的移动轨迹才可以通过验证,而人的移动轨迹一般是先加速后减速的,这又涉及到物理学中加速度的相关问题,我们需要模拟这个过程才能成功。 有了基本的思路之后就让我们用程序来实现一下它的识别过程吧。

6. 初始化

首先这次我们选定的链接为:https://account.geetest.com/login,也就是极验的管理后台登录页面,在这里我们首先初始化一些配置,如 Selenium 对象的初始化及一些参数的配置:

1
2
3
4
5
6
7
8
9
10
EMAIL = 'test@test.com'
PASSWORD = '123456'

class CrackGeetest():
def __init__(self):
self.url = 'https://account.geetest.com/login'
self.browser = webdriver.Chrome()
self.wait = WebDriverWait(self.browser, 20)
self.email = EMAIL
self.password = PASSWORD

其中 EMAIL 和 PASSWORD 就是登录极验需要的用户名和密码,如果没有的话可以先注册一下。

7. 模拟点击

随后我们需要实现第一步的操作,也就是模拟点击初始的验证按钮,所以我们定义一个方法来获取这个按钮,利用显式等待的方法来实现:

1
2
3
4
5
6
7
def get_geetest_button(self):
"""
获取初始验证按钮
:return: 按钮对象
"""
button = self.wait.until(EC.element_to_be_clickable((By.CLASS_NAME, 'geetest_radar_tip')))
return button

获取之后就会获取一个 WebElement 对象,调用它的 click() 方法即可模拟点击,代码如下:

1
2
3
# 点击验证按钮
button = self.get_geetest_button()
button.click()

到这里我们第一步的工作就完成了。

8. 识别缺口

接下来我们需要识别缺口的位置,首先我们需要将前后的两张比对图片获取下来,然后比对二者的不一致的地方即为缺口。首先我们需要获取不带缺口的图片,利用 Selenium 选取图片元素,然后得到其所在位置和宽高,随后获取整个网页的截图,再从截图中裁切出来即可,代码实现如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def get_position(self):
"""
获取验证码位置
:return: 验证码位置元组
"""
img = self.wait.until(EC.presence_of_element_located((By.CLASS_NAME, 'geetest_canvas_img')))
time.sleep(2)
location = img.location
size = img.size
top, bottom, left, right = location['y'], location['y'] + size['height'], location['x'], location['x'] + size[
'width']
return (top, bottom, left, right)

def get_geetest_image(self, name='captcha.png'):
"""
获取验证码图片
:return: 图片对象
"""
top, bottom, left, right = self.get_position()
print('验证码位置', top, bottom, left, right)
screenshot = self.get_screenshot()
captcha = screenshot.crop((left, top, right, bottom))
return captcha

在这里 get_position() 函数首先获取了图片对象,然后获取了它的位置和宽高,随后返回了其左上角和右下角的坐标。而 get_geetest_image() 方法则是获取了网页截图,然后调用了 crop() 方法将图片再裁切出来,返回的是 Image 对象。 随后我们需要获取第二张图片,也就是带缺口的图片,要使得图片出现缺口,我们只需要点击一下下方的滑块即可,触发这个动作之后,图片中的缺口就会显现,实现如下:

1
2
3
4
5
6
7
def get_slider(self):
"""
获取滑块
:return: 滑块对象
"""
slider = self.wait.until(EC.element_to_be_clickable((By.CLASS_NAME, 'geetest_slider_button')))
return slider

利用 get_slider() 方法获取滑块对象,接下来调用其 click() 方法即可触发点击,缺口图片即可呈现:

1
2
3
# 点按呼出缺口
slider = self.get_slider()
slider.click()

随后还是调用 get_geetest_image() 方法将第二张图片获取下来即可。 到现在我们就已经得到了两张图片对象了,分别赋值给变量 image1 和 image2,接下来对比图片获取缺口即可。要对比图片的不同之处,我们在这里遍历图片的每个坐标点,获取两张图片对应像素点的 RGB 数据,然后判断二者的 RGB 数据差异,如果差距超过在一定范围内,那就代表两个像素相同,继续比对下一个像素点,如果差距超过一定范围,则判断像素点不同,当前位置即为缺口位置,代码实现如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
def is_pixel_equal(self, image1, image2, x, y):
"""
判断两个像素是否相同
:param image1: 图片1
:param image2: 图片2
:param x: 位置x
:param y: 位置y
:return: 像素是否相同
"""
# 取两个图片的像素点
pixel1 = image1.load()[x, y]
pixel2 = image2.load()[x, y]
threshold = 60
if abs(pixel1[0] - pixel2[0]) < threshold and abs(pixel1[1] - pixel2[1]) < threshold and abs(
pixel1[2] - pixel2[2]) < threshold:
return True
else:
return False

def get_gap(self, image1, image2):
"""
获取缺口偏移量
:param image1: 不带缺口图片
:param image2: 带缺口图片
:return:
"""
left = 60
for i in range(left, image1.size[0]):
for j in range(image1.size[1]):
if not self.is_pixel_equal(image1, image2, i, j):
left = i
return left
return left

get_gap() 方法即为获取缺口位置的方法,此方法的参数为两张图片,一张为带缺口图片,另一张为不带缺口图片,在这里遍历两张图片的每个像素,然后利用 is_pixel_equal() 方法判断两张图片同一位置的像素是否相同,比对的时候比较了两张图 RGB 的绝对值是否均小于定义的阈值 threshold,如果均在阈值之内,则像素点相同,继续遍历,否则遇到不相同的像素点就是缺口的位置。 在这里比如两张对比图片如下,如图 8-15 和 8-16 所示: 图 8-15 初始状态 图 8-16 后续状态 两张图片其实有两处明显不同的地方,一个就是待拼合的滑块,一个就是缺口,但是滑块的位置会出现在左边位置,缺口会出现在与滑块同一水平线的位置,所以缺口一般会在滑块的右侧,所以要寻找缺口的话,我们直接从滑块右侧寻找即可,所以在遍历的时候我们直接设置了遍历的起始横坐标为 60,也就是在滑块的右侧开始识别,这样识别出的结果就是缺口的位置了。 到现在为止,我们就可以获取缺口的位置了,剩下最后一步模拟拖动就可以完成验证了。

9. 模拟拖动

模拟拖动的这个过程说复杂并不复杂,只是其中的坑比较多。现在我们已经获取到了缺口的位置,接下来只需要调用拖动的相关函数将滑块拖动到对应位置不就好了吗?然而事实很残酷,如果匀速拖动,极验必然会识别出来这是程序的操作,因为人是无法做到完全匀速拖动的,极验利用机器学习模型筛选出此类数据,归类为机器操作,验证码识别失败。 随后我又尝试了分段模拟,将拖动过程划分几段,每段设置一个平均速度,同时速度围绕该平均速度小幅度随机抖动,同样无法完成验证。 最后尝试了完全模拟加速减速的过程通过了验证,在前段滑块需要做匀加速运动,后面需要做匀减速运动,在这里利用物理学的加速度公式即可完成。 设滑块滑动的加速度用 a 来表示,当前速度用 v 表示,初速度用 v0 表示,位移用 x 表示,所需时间用 t 表示,则它们之间满足如下关系:

1
2
x = v0 * t + 0.5 * a * t * t 
v = v0 + a * t

接下来我们利用两个公式可以构造一个轨迹移动算法,计算出先加速后减速的运动轨迹,代码实现如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
def get_track(self, distance):
"""
根据偏移量获取移动轨迹
:param distance: 偏移量
:return: 移动轨迹
"""
# 移动轨迹
track = []
# 当前位移
current = 0
# 减速阈值
mid = distance * 4 / 5
# 计算间隔
t = 0.2
# 初速度
v = 0

while current < distance:
if current < mid:
# 加速度为正2
a = 2
else:
# 加速度为负3
a = -3
# 初速度v0
v0 = v
# 当前速度v = v0 + at
v = v0 + a * t
# 移动距离x = v0t + 1/2 * a * t^2
move = v0 * t + 1 / 2 * a * t * t
# 当前位移
current += move
# 加入轨迹
track.append(round(move))
return track

在这里我们定义了 get_track() 方法,传入的参数为移动的总距离,返回的是运动轨迹,用 track 表示,它是一个列表,列表的每个元素代表每次移动多少距离。 首先定义了一个变量 mid,即减速的阈值,也就是加速到什么位置就开始减速,在这里定义为 4/5,即模拟前 4/5 路程是加速过程,后 1/5 是减速过程。 随后定义了当前位移的距离变量 current,初始为 0,随后进入 while 循环,循环的条件是当前位移小于总距离。在循环里我们分段定义了加速度,其中加速过程加速度定义为2,减速过程加速度定义为 -3,随后再套用位移公式计算出某个时间段内的位移,同时将当前位移更新并记录到轨迹里即可。 这样直到运动轨迹达到总距离时即终止循环,最后得到的 track 即记录了每个时间间隔移动了多少位移,这样滑块的运动轨迹就得到了。 最后我们只需要按照该运动轨迹拖动滑块即可,方法实现如下:

1
2
3
4
5
6
7
8
9
10
11
12
def move_to_gap(self, slider, tracks):
"""
拖动滑块到缺口处
:param slider: 滑块
:param tracks: 轨迹
:return:
"""
ActionChains(self.browser).click_and_hold(slider).perform()
for x in tracks:
ActionChains(self.browser).move_by_offset(xoffset=x, yoffset=0).perform()
time.sleep(0.5)
ActionChains(self.browser).release().perform()

在这里传入的参数为滑块对象和运动轨迹,首先调用ActionChains 的 click_and_hold() 方法按住拖动底部滑块,随后遍历运动轨迹获取每小段位移距离,调用 move_by_offset() 方法移动此位移,最后移动完成之后调用 release() 方法松开鼠标即可。 这样再经过测试,验证就通过了,识别完成,效果图 8-17 所示: 图 8-17 识别成功结果 最后,我们只需要将表单完善,模拟点击登录按钮即可完成登录,成功登录后即跳转到后台。 至此,极验验证码的识别工作即全部完成,此识别方法同样适用于其他使用极验3.0的网站,原理都是相同的。

10. 本节代码

本节代码地址为:https://github.com/Python3WebSpider/CrackGeetest

11. 结语

本节我们分析并实现了极验验证码的识别,其关键在于识别的思路,如怎样识别缺口位置,怎样生成运动轨迹等,学会了这些思路后以后我们再遇到类似原理的验证码同样可以完成识别过程。

Python

本节我们首先来尝试识别最简单的一种验证码,图形验证码,这种验证码出现的最早,现在也很常见,一般是四位字母或者数字组成的,例如中国知网的注册页面就有类似的验证码,链接为:http://my.cnki.net/elibregister/commonRegister.aspx,页面如图 8-1 所示: 图 8-1 知网注册页面 表单的最后一项就是图形验证码,我们必须完全输入正确图中的字符才可以完成注册。

1. 本节目标

本节我们就以知网的验证码为例,讲解一下利用 OCR 技术识别此种图形验证码的方法。

2. 准备工作

识别图形验证码需要的库有 Tesserocr,如果没有安装可以参考第一章的安装说明。

3. 获取验证码

为了便于实验,我们先将验证码的图片保存到本地,以供测试。 打开开发者工具,找到验证码元素,可以看到这是一张图片,它的 src 属性是 CheckCode.aspx,在这里我们直接将这个链接打开:http://my.cnki.net/elibregister/CheckCode.aspx,就可以看到一个验证码,直接右键保存下来即可,将名称命名为 code.jpg,如图 8-2 所示: 图 8-2 验证码 这样我们就可以得到一张验证码图片供下面测试识别使用了。

4. 识别测试

接下来我们新建一个项目,将验证码图片放到项目根目录下,用 Tesserocr 库来识别一下该验证码试试,代码如下:

1
2
3
4
5
6
import tesserocr
from PIL import Image

image = Image.open('code.jpg')
result = tesserocr.image_to_text(image)
print(result)

在这里我们首先新建了一个 Image 对象,然后调用了 Tesserocr 的 image_to_text() 方法,传入该 Image 对象即可完成识别,实现过程非常简单,识别结果如下:

1
JR42

另外 Tesserocr 还有一个更加简单的方法直接将图片文件转为字符串可以达到同样的效果,代码如下:

1
2
import tesserocr
print(tesserocr.file_to_text('image.png'))

不过经测试此种方法的识别效果不如上一种方法好。

5. 验证码处理

如上的图片识别基本没有难度,只是新建一个 Image 对象,然后调用 image_to_text() 方法即可得出图片的识别结果。 接下来我们换一个验证码试一下,命名为 code2.jpg,如图 8-3 所示: 图 8-3 验证码 重新用下面的代码测试一下:

1
2
3
4
5
6
import tesserocr
from PIL import Image

image = Image.open('code2.jpg')
result = tesserocr.image_to_text(image)
print(result)

这时可以看到如下输出结果:

1
FFKT

发现这次识别和实际的结果有所偏差,这是因为验证码内的多余线条干扰了图片的识别。 对于这种情况,我们还需要做一下额外的处理,如转灰度、二值化等操作。 我们可以利用 Image 对象的 convert() 方法参数传入 L 即可将图片转化为灰度图像,代码如下:

1
2
image = image.convert('L')
image.show()

传入 1 即可将图片进行二值化处理:

1
2
image = image.convert('1')
image.show()

另外我们还可以指定二值化的阈值,上面的方法采用的是默认阈值127,不过我们不能用原图直接转化,可以先转为灰度图像,然后再指定二值化阈值转化,代码如下:

1
2
3
4
5
6
7
8
9
10
11
image = image.convert('L')
threshold = 80
table = []
for i in range(256):
if i < threshold:
table.append(0)
else:
table.append(1)

image = image.point(table, '1')
image.show()

在这里我们指定了一个变量 threshold 代表二值化阈值,阈值设置为 80,处理之后我们看一下结果,如图 8-4 所示: 图 8-4 处理结果 经过处理之后我们发现原来的验证码中的线条已经被去除了,而且整个验证码变得黑白分明,这时重新识别验证码,代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import tesserocr
from PIL import Image

image = Image.open('code2.jpg')

image = image.convert('L')
threshold = 127
table = []
for i in range(256):
if i < threshold:
table.append(0)
else:
table.append(1)

image = image.point(table, '1')
result = tesserocr.image_to_text(image)
print(result)

即可发现运行结果变成了:

1
PFRT

识别正确。 可见对于一些有干扰的图片,我们做一些灰度和二值化处理,会提高其识别正确率。

6. 本节代码

本节代码地址为:https://github.com/Python3WebSpider/CrackImageCode

7. 结语

本节我们了解了利用 Tesserocr 识别验证码的过程,对于简单的图形验证码我们可以直接用它来得到结果,如果要提高识别的准确度还可以对验证码图片做一下预处理。

Python

当今时代,许多网站为了反爬虫采用了各种各样的措施,其中之一便是使用验证码,随着技术的发展,验证码的花样也越来越多,最初可能是几个数字组合的简单的图形验证码,后来加入了英文字母和混淆曲线使得验证码更加复杂,有的网站还可能看到中文字符的验证码,使得识别愈发困难。 而后来 12306 验证码的出现又开辟了验证码的新纪元,用过 12306 的肯定多少为它的验证码头疼过,它需要我们去识别文字,然后再点击文字描述相符的图片,只有完全正确才可以验证通过。现在这种交互式验证码越来越多,如极验滑动验证码需要滑动拼合滑块才可以完成验证,点触的验证码需要完全点击正确的结果才可以完成验证,另外还有一些滑动宫格验证码,计算题验证码等等五花八门。 验证码变得越来越复杂,爬虫的工作也变得愈发艰难,有时候我们必须通过验证码的验证才可以访问页面,所以本章专门来针对验证码的识别做一下统一的讲解。 本章涉及的验证码有普通图形验证码、极验滑动验证码、点触验证码、微博宫格验证码,识别的方式和思路各有不同,了解了这几个验证码的识别方式之后,我们可以举一反三,用类似的方法识别其他类型的验证码。

生活笔记

人生一共就是由几个10年组成的,每个10年都有不同的经历,不同的心境,每个10年追求的东西都不一样。 鱼与熊掌不可兼得,在追求的过程中你总要有取舍,该取什么?该舍什么?

10岁时

应该不再计较家里给的零花钱多少,不和别人家的孩子比较穿名牌服装;少不更事,和人家比吃穿,还情有可原,年纪到了整数就该懂事了。

20岁时

不再计较自己的家庭出身,不再计较父母的职业十几岁时,会和别的孩子比较家庭出身,比爹娘官大官小,恨不得都投生帝王之家、将相之门,也是人之常情。 但如果到了“弱冠”之年,还弱不禁风,尚无自立之志,出身贫寒的还为家庭自卑,老觉得抬不起头来;出身富豪的还处处依靠父母,在家庭荫护下养尊处优,那就会一辈子都没出息。

30岁时

已成家立业,为父为母,有了几年家庭生活的经验。大丈夫该不再计较妻子的容貌,深知贤惠比美貌更重要,会过日子的媳妇比会打扮的媳妇更让人待见; 老婆该不再计较老公的身高,明白能力比身高更有作用,没有谋生能力的老公,纵然长成丈二金刚,还不如卖炊饼的大郎。

40岁时

不再计较别人的议论,谁爱说啥就说啥,自己想咋过就咋过。 人言可畏,想想上世纪30年代的阮玲玉还成如今的明星,一星期听不到他的绯闻轶事没人对他议论纷纷,他就急得火烧火燎的。 咱们虽然没有明星那高深道行,但不会再轻易被别人议论左右,这点本事应该有的,否则也对不起“不惑”这两个字啊。

50岁时

不再计较无处不在的不平之事,不再计较别人的成功对自己的压力,不再眼红他人的财。 半百之年,曾经沧海,阋人无数,见惯秋月春风,不再大惊小怪;历尽是非成败,不再愤愤不平看新贵飞扬跋扈,可不动声色;看大款挥金如土,也气定神闲,耐住性子。

60岁时

如果从政,该不再计较官大官小,退了体,官大官小一个样,都是退体干部。 如果经商,该不再计较利大利小,钱是挣不完的,再能花也是有限的,心态平和对自己身体有好处。 如果舞文弄墨,当不再计较文名大小,文坛座次。

70岁时

人到古稀,该不再计较的东西更多,看淡的事情更广。 年轻时争得你死我活的东西,现在只会淡然一笑。 中年时费尽心机格外计较的东西,如今看来已无关紧要。一生多少事,“都付笑谈中”。 这个岁数的老人,要有三样特别积极健康的身体、和谐的家庭、良好的名声。 人生在世,如果计较的东西太多,名利地位,金钱美色,样样都不肯放手,那就会如牛重负,活得很累。 反之,什么都不计较,什么都马马虎虎,什么都可以凑合,那也未免太对不起自己,活得没啥意思。 人生智慧 聪明的人,有生活智慧的人,会有所为,有所不为。他们只计较对自己最重要的东西, 并且知道什么年龄该计较什么,不该计较什么,有取有舍,收放自如。

Python

相比常用的 os.path而言,pathlib 对于目录路径的操作更简介也更贴近 Pythonic。但是它不单纯是为了简化操作,还有更大的用途

概述

pathlib 是Python内置库,Python 文档给它的定义是 Object-oriented filesystem paths(面向对象的文件系统路径)。pathlib 提供表示文件系统路径的类,其语义适用于不同的操作系统。路径类在纯路径之间划分,纯路径提供纯粹的计算操作而没有I / O,以及具体路径,它继承纯路径但也提供I / O操作。 听起来有点绕?那就对了,毕竟这是直译过来的,但这并不影响我们喜爱它。 我们通过几个例子来了解它吧

举个栗子

相对于 os 模块的 path 方法,Python3 标准库 pathlib 模块的 Path 对路径的操作会更简单。

获取当前文件路径

使用 os 模块时,有两种方法可以直接获取当前文件路径:

1
2
3
4
5
6
import os

value1 = os.path.dirname(__file__)
value2 = os.getcwd()
print(value1)
print(value2)

pathlib 获取当前文件路径应该怎么写呢? 官方文档给出了建议 插眼传送 动手试一试

1
2
3
4
import pathlib

value1 = pathlib.Path.cwd()
print(value1)

它是如何实现的

文档中有介绍,它以 os.getcwd() 的形式将路径返回。我们去源码中一探究竟(Pycharm 编辑器快捷键 ctrl+鼠标左键点击即可跟进指定对象) 原来它是对 os 模块中一些对象进行了封装,看 cwd 的注释: Return a new path pointing to the current working directory 意为:返回指向当前工作目录的新路径。 看起来也没什么特别的,但是为什么官方特意将它推出呢?

其他的封装

pathlib 封装了很多的 os path ,文档中有写明,如:

1
2
3
4
5
6
7
8
# 关系说明
os.path.expanduser() --> pathlib.Path.home()

os.path.expanduser() --> pathlib.Path.expanduser()

os.stat() --> pathlib.Path.stat()

os.chmod() --> pathlib.Path.chmod()

官网文档截图: 详细请查看官方文档:插眼传送

再举几个栗子

刚才的案例并不能说明什么,只是让我们了解到 pathlib 的构成,接下来让我们感受一下它带给我们的便捷。

获取上层/上层目录

也就是获取它爷爷的名字 os 模块的写法为:

1
2
3
import os

print(os.path.dirname(os.path.dirname(os.getcwd())))

如果用 pathlib 来实现:

1
2
3
import pathlib

print(pathlib.Path.cwd().parent.parent)

parent 就完事了,这是不是更贴近 Pythonic ? 像写英语一样写代码。 如果你只需要找到它爸爸,那就使用一次:

1
2
3
import pathlib

print(pathlib.Path.cwd().parent)

你还可以继续往祖辈上找:

1
2
3
import pathlib

print(pathlib.Path.cwd().parent.parent.parent)

相对与之前 os 模块使用的多层 os.path.dirname,使用 parent 是不是便捷很多?

路径拼接

如果你要在它爷爷辈那里拼接路径,那么你需要写这么长一串代码:

1
2
3
import os

print(os.path.join(os.path.dirname(os.path.dirname(os.getcwd())), "关注", "微信公众号", "【进击的", "Coder】"))

当你用 pathlib 的时候,你一定能够感受到快乐:

1
2
3
4
import pathlib

parts = ["关注", "微信公众号", "【进击的", "Coder】"]
print(pathlib.Path.cwd().parent.parent.joinpath(*parts))

而且你还可以通过增加或减少 parent 的数量,来实现它祖辈的调节,美哉。

PurePath

上面的操作大部分都通过 pathlib 中的 Path 实现,其实它还有另一个模块 PurePath。

PurePath 是一个纯路径对象,纯路径对象提供了实际上不访问文件系统的路径处理操作。有三种方法可以访问这些类,我们也称之为flavor。

上面这句话来自于官方文档,听起来还是有点绕,我们还是通过栗子来了解它吧

PurePath.match

让我们来判断一下,当前文件路径是否有符合 ‘*.py’ 规则的文件

1
2
3
import pathlib

print(pathlib.PurePath(__file__).match('*.py'))

很显然,我们编写代码的 coder.py 就符合规则,所以输出是 True。 为什么我要拿这个来举例呢?再深入想一下 pathlib.PurePath 后面能够跟着 match,那说明它应该是个对象,而不是一个路径字符串。为了验证这个想法,把代码改一改:

1
2
3
4
5
6
7
8
import pathlib
import os

os_path = os.path.dirname(__file__)
pure_path = pathlib.PurePath(__file__)
print(os_path, type(os_path))
print(pure_path, type(pure_path))
print(pathlib.PurePath(__file__).match('*.py'))

打印通过 os.path 获取当前路径的结果,得出一个路径字符串;而通过 pathlib.Pure 则获得的是一个 PurePosixPath 对象,并且得到的路径包括了当前文件 coder.py。 这就有点悬疑了, PurePosixPath 究竟是什么? pathlib 可以操作两种文件系统的路径,一种是 Windows 文件系统,另一种称为非 Windows 文件系统,对应的对象是 pathlib.PurePosixPathPureWindowsPath,不过不用担心,这些类并非是指定在某些操作系统上运行才能够使用,无论你运行的是哪个系统,都可以实例化所有这些类,因为它们不提供任何进行系统调用的操作。 不提供任何进行系统调用的操作,这又是什么?真是越听越深了 文档在最开始给出了这么一段描述:

Pure paths are useful in some special cases; for example: If you want to manipulate Windows paths on a Unix machine (or vice versa). You cannot instantiate a WindowsPath when running on Unix, but you can instantiate PureWindowsPath. You want to make sure that your code only manipulates paths without actually accessing the OS. In this case, instantiating one of the pure classes may be useful since those simply don’t have any OS-accessing operations. 翻译:纯路径在某些特殊情况下很有用; 例如: 如果要在Unix计算机上操作Windows路径(反之亦然)。WindowsPath在Unix上运行时无法实例化,但可以实例化PureWindowsPath。 您希望确保您的代码仅操作路径而不实际访问操作系统。在这种情况下,实例化其中一个纯类可能很有用,因为那些只是没有任何操作系统访问操作。

还附上了一张图: 一下子也不是很理解,这是什么意思。不要紧,继续往下看。

对应关系

通过以上的例子我们可以感受到,它不仅封装了 os.path 相关常用方法,还集成了 os 的其他模块,比如创建文件夹 Path.mkdir。 如果你担心记不住,没关系的,文档一直都在。并且文档给我们列出了对应关系表

基本用法

Path.iterdir()  # 遍历目录的子目录或者文件 Path.is_dir()  # 判断是否是目录 Path.glob()  # 过滤目录(返回生成器) Path.resolve()  # 返回绝对路径 Path.exists()  # 判断路径是否存在 Path.open()  # 打开文件(支持with) Path.unlink()  # 删除文件或目录(目录非空触发异常)

基本属性

Path.parts  # 分割路径 类似os.path.split(), 不过返回元组 Path.drive  # 返回驱动器名称 Path.root  # 返回路径的根目录 Path.anchor  # 自动判断返回drive或root Path.parents  # 返回所有上级目录的列表

改变路径

Path.with_name()  # 更改路径名称, 更改最后一级路径名 Path.with_suffix()  # 更改路径后缀

拼接路径

Path.joinpath()  # 拼接路径 Path.relative_to()  # 计算相对路径

测试路径

Path.match()  # 测试路径是否符合pattern Path.is_dir()  # 是否是文件 Path.is_absolute()  # 是否是绝对路径 Path.is_reserved()  # 是否是预留路径 Path.exists()  # 判断路径是否真实存在

其他方法

Path.cwd()  # 返回当前目录的路径对象 Path.home()  # 返回当前用户的home路径对象 Path.stat()  # 返回路径信息, 同os.stat() Path.chmod()  # 更改路径权限, 类似os.chmod() Path.expanduser()  # 展开~返回完整路径对象 Path.mkdir()  # 创建目录 Path.rename()  # 重命名路径 Path.rglob()  # 递归遍历所有子目录的文件

pathlib 回顾

通过上面的几个例子,我们对 pathlib 应该有一个大体的了解,接下来再回顾一下官方给 pathlib 库的定义:

This module offers classes representing filesystem paths with semantics appropriate for different operating systems. Path classes are divided between pure paths, which provide purely computational operations without I/O, and concrete paths, which inherit from pure paths but also provide I/O operations. 释义:pathlib 提供表示文件系统路径的类,其语义适用于不同的操作系统。路径类在纯路径之间划分,纯路径提供纯粹的计算操作而没有I / O,以及具体路径,它继承纯路径但也提供I / O操作。

回顾刚才这张图,重新理解 pathlib 如果你以前从未使用过这个模块,或者只是不确定哪个类适合您的任务,那么Path很可能就是您所需要的。它为代码运行的平台实例化一个具体路径。 总结:pathlib 不单纯是对 os 中一些模块或方法进行封装,而是为了兼容不同的操作系统,它为每类操作系统定义了接口。你希望在UNIX机器上操作Windows的路径,然而直接操作是做不到的,所以为你创建了一套接口 PurePath,你可以通过接口来实现你的目的(反之亦然)

技术杂谈

6月6日工信部正式向中国电信、中国移动、中国联通、中国广电发放5G商用牌照。自此,中国正式进入5G商用元年。 就中国而讲,2G时代门户网站林立、社交软件初起,3G时代智能手机大战、社交类软件成为王者,4G时代直播与短视频风光无二、信息流成热话题,那5G时代谁能独领风骚? 在5G还未全面普及之前,我们回顾一下并不遥远的昨天,在2G、3G、4G的兴起时,哪些公司应运而生,成为巨头,哪些巨头又轰然倒塌,成为历史的一部分。 2G时代,QQ崛起,阿里京东起家,门户网站林立 中国互联网的发展至今也只20年有余,自20世纪90年代末,中国人从1G时代代表性手机大哥大(摩托罗拉)手机换成了2G时代代表性手机诺基亚,彼时手机不只是接打电话,增加了发短信甚至邮件的功能。 20世纪90年代末期中国,还处在纸媒、广播和电视一统天下的传统媒体时代,但经济的迅猛发展已经造成信息饥渴,彼时媒体所提供的信息无论从丰富程度还是传播速度上都很难满足用户需求。 一个从美国麻省理工学院(MIT)攻读博士学位归来的“天之骄子”带回了一个新鲜事物,由于被美国互联网的发展深深震撼,张朝阳回国创建了中国第一家门户网站——搜狐。那是在1998年,阿里巴巴还没诞生,马化腾的QQ也未问世,李彦宏还在美国硅谷,中国互联网的舞台上,也只有张朝阳和他的搜狐。 竞争对手还未成长,搜狐独享巨大的互联网红利,2000年就上市,占据着中国门户网站头部企业的位置。 同样1998年,在搜狐成立后不到10个月,王志东的新浪网于年底成立,当时的口号是在互联网上建立全球最大的华人网站。以体育新闻传播为起点的新浪迅速扩张,进阶成为综合性新闻门户。 当时中国门户网站受资本青睐的程度,以及上市的速度堪称一个时代的奇迹,新浪网虽成立晚了搜狐10个月,但却比搜狐早了3个月在纳斯达克敲钟。 与搜狐新浪以门户网站起家不同,网易1997年成立之初以搜索引擎和免费邮箱系统立身,赶上门户网站热潮席卷中国,1998年丁磊带领网易挥师北上,落户北京,公司战略也从“系统集成商”正式转向“互联网服务提供商”。自此,网易与搜狐、新浪成为中国三大门户网站。 在张朝阳、丁磊等都借互联网东风大搞门户网站捞第一波红利的时候,在深圳创业的马化腾开始琢磨做社交。马化腾与大学同学合伙成立腾讯,当时主要做“无线网络寻呼系统”,就是将互联网和寻呼机结合,使得寻呼机可以收到互联网的传唤,并且可以收看新闻乃至电子邮件等功能。 但不可逆的是当时寻呼机业务已处于颓势,1998年,身处2G时代,手机在市场上肆意生长。马化腾当机立断,转头做IM(即时通讯软件),OICQ应运而生,OICQ1999年2月10日发布了第一个版本——OICQ 99 beta build 0210,就此,颠覆未来20年中文互联网的明星产品QQ诞生了。 此后腾讯围绕QQ延展出多款产品,包括QQ宠物、QQ空间、QQ游戏等,这为腾讯带来盈利的同时留存了海量互联网用户。QQ在中国整个2G时代都占据着社交软件第一把交椅,为腾讯后续布局游戏等可以提供天然入口,这让腾讯的产品可以轻而易举地碾压竞品。 而之后改变中国互联网格局的阿里巴巴也是在2G时代诞生的。1999年,马云带领下的18为创始人创建阿里巴巴集团。2003年,淘宝网创立,作为新生事物的淘宝网出奇制胜——没和ebay易趣争抢既有的存量市场,而是收割疯狂生长的增量市场;仅仅通过1年时间,这家“倒过来看世界”的互联网公司,就成了中国网络购物市场的领军企业。 而2004年,支付宝创立,中国第三方支付模式雏形初现。值得一提的是,同年诞生的淘宝旺旺将即时聊天工具和网络购物相联系起来,是阿里巴巴做网上零售的法宝。这时候的淘宝旺旺并没有和QQ对标,还处在阿里腾讯之间还是各自领域狂奔的时代。 在2005年淘宝的成交额就突破80亿元,甚至超越了沃尔玛。 在马云创立淘宝网,大搞电商之时,在中关村卖了几年光盘的刘强东坐不住了,2004年,京东多媒体网正式开通。或许与刘强东卖3C产品起家有关,京东电子商务平台是主打3C产品,与淘宝对标的同时又有自己清晰的定位,虽然都是做电商,但同质化并不严重。 3G时代,智能手机展露头角,巨头大战社交 整个2G时代其实属于PC端互联网,2G的手机只能打电话发短信,上网很困难。但3G通信标准将信息传输率提高了一个数量级,这是一个飞跃,3G时代真正意义上而言是移动互联网的开端,从此手机打电话的功能降到了次要的位置,而数据通信,也就是上网,成为了主要功能。 乔布斯2007年拿着一款智能手机iPhone1出现,宣布苹果主宰移动互联网时代的开始。从此手机不再以功能为主,而是以应用软件(APP)为主,APP store 更是一个划时代产品,让用户可以轻而易举地购买下载所需的应用。 中国的3G时代稍晚于美国,2009年1月,工信部为中国移动、联通、电信发布3G牌照,中国从此进入3G时代。 在智能手机初探中国市场的时间节点,三星、诺基亚、HTC等占据了巨大部分江山,而中国2G时代的功能机科健、波导、海尔等相继淡出市场,国产的智能机中兴、华为、酷派、联想等完全靠三大运营商的销售渠道生存,打着性价比旗号的合约机始终比不上价格更高的三星、HTC的中低端手机。 但2011年小米的横空出世打破了这个壁垒。3G网络在中国越来越普及,彼时在国外品牌占据中国市场,而国产智能手机厂商仅能依附三大运营商销售,而当苹果手机最具冲击力的一代iPhone4席卷全球时,一个叫雷军的人拿出了他的第一代产品——小米1,冲进中国智能手机市场。 三星与HTC主流机型定价4000元,而小米1999的超高性价比+饥饿营销,搅动了中国智能手机市场,成为3G时代崛起的手机巨头,2012年2月,“屌丝”一词横空出世,有人说它是为屌丝而生,谁能想到日后它更是成为世界最年轻的500强? 如果说QQ的问世是一个偶然,那微信出道是无数竞争的结果。 移动互联网兴起,当然PC端依然沉淀着大量用户,彼时的QQ为了顾及PC端的用户,界面、功能更照顾PC端,以至于没能及时赶上移动互联网的浪潮,但一个叫张小龙的人彻底颠覆了社交。 2011年1月,微信横空出世,这款主打IM的应用程序契合3G时代的特点,可以发送文字、语音、图片、视频等,一出现就借助QQ的天然优势,并打通通信录,迅速推广,以至于后续发展成为国民软件,腾讯也借此拿到了通向移动互联网第一张门票,腾讯能成为今天的巨头公司,而且地位难以撼动,微信功不可没。 其实在腾讯布局社交之时,2G时代崛起的门户大咖搜狐、新浪也瞄准了社交这个大蛋糕。只不过新浪瞄准的是信息即时分享,而搜狐一直在拾人牙慧。新浪微博自2009年一经问世便牢牢掌控着微博头把交椅的位置,就连腾讯微博的冲击也未动摇半分。 搜狐看QQ火爆便做了搜Q,见微博火爆便做了搜狐微博,还做了社区社交“白社会”,但无一例外遭遇失败。连张朝阳本人都说,“微信微博左右扇了我两个耳光。”最近张朝阳又推出“狐友”,硬要推着石头上山的张朝阳不知还有没有气力。 而前面提到2G时代阿里推出淘宝旺旺却忙着做电商,没有正面硬刚QQ,但此时看到微信在庞大的社交领域带来的巨大流量时,马云坐不住了。2013年,阿里巴巴推出了来往,这是阿里推出的即时通讯软件,也是阿里第一款独立于电商业务之外的社交产品,其核心功能是实现熟人之间的社交。 原因是马云认为腾讯已经“侵入”了阿里的地盘,要用来往去砸微信的场子,但结果大家都知晓了。但马云并不灰心,之后用支付宝做社交还是失败,只是钉钉的成功才稍找回点面子。 另外值得一提的是,3G时代,LBS应用于地图等会对4G时代滴滴、共享单车等的崛起起到推手的作用。 4G时代,团购直播视频手游异军突起,共享出行风口正盛,巨头布局信息流 如果说1G到2G是划时代的进步,而3G的短暂存在只是一个过渡,因为短短几年后,网速产生质的飞跃的4G时代迅速到来。 3G传播速度相对2G较快,可以较好满足手机上网等需求,只是播放高清视频还是比较困难。而4G的速度几乎满足无线用户所有需求。 彼时移动互联网光速发展,大面积吞噬PC互联网流量和用户。比PC端更加便捷的移动端生活服务类应用风靡中国,O2O模式成了风口上的猪。巨头们纷纷布局,阿里有口碑网,腾讯有微团购,百度则买来糯米网,但谁也不曾想最后的赢家不是巨头而是王兴的美团网,2015年,美团网与大众点评合并,重构了O2O模式。 美团成为4G时代崛起的巨头,而腾讯依靠着微信的社交流量巨大入口也不会败,阿里则有支付宝这个生活服务类的大平台,甚至日后提出新零售概念取代O2O成为新的风口,这场大战里,仿佛只有百度掉队了,从PC互联网时代跨到移动互联网时代,百度要做的产品是在抢夺自己PC端的用户,这让百度似乎有点手足无措。 网速加快受益最大的无疑是直播与视频。2016年前后,资本涌入直播赛道,以斗鱼、虎牙、YY、熊猫、全民等为首的游戏直播平台,纷纷宣布获得融资,疯狂烧钱抢夺主播和用户,以映客、花椒等移动端为主的直播也趁势而起。 彼时直播行业一片混乱,违法违规直播大行其道,随着监管力度加大,资本退场,直播赛道也一地鸡毛,也只是留下虎牙、斗鱼等直播巨头。 4G时代网速加快的同时,运营商提速降费,这让依靠文字和图片获取信息的用户越来越不满足,短视频有着天时地利人和,在用户需求之下诞生。其中以抖音、快手为代表的的社交媒体类短视频最为火爆,而以秒拍、西瓜为代表的的新闻资讯类也广受媒体和用户欢迎,以B站为首的BBS类更是抓住了细分市场。 今年年初Vlog的流行也只是吹了一阵,现已没有当时的热度,看起来短视频的风还会继续吹下去。 2G时代的三大门户巨头搜狐新浪和网易,如今搜狐和新浪的体量与网易已不是一个级别的,新浪尚有微博撑着场面,搜狐却实实在在地掉队了,网易又是如何始终保持盈利的呢?其中一个很重要的支撑点就是网易的游戏帝国,而4G时代更让网易如虎添翼。 曾经风靡全国的PC端回合制游戏“梦幻西游”,手机版一经上线便俘获众多老玩家,这个游戏特点之一就是烧钱。一位玩梦幻的朋友告诉盒饭财经,这个游戏里,充值几万也只是低端玩家而已,动辄砸百万的大有人在,而广受女性玩家喜爱的手游阴阳师也是一个人民币玩家的游戏。 从网易公布的财报不难看出,近几年网易游戏收入占每季度总收入都超过6成,与还靠着新闻资讯的新浪搜狐不同,网易应4G时代实现业务重心迁徙,还能算是互联网一线巨头。 守着微信这个巨大流量入口的腾讯布局游戏更显得理所当然,从PC端的QQ衍生出的众多小游戏为起点,到英雄联盟的大火,3G时代的天天酷跑,再到4G移动互联网时代手游吃鸡(和平精英)、王者荣耀,腾讯在每个时代都在游戏产业上走得很稳。 目前,腾讯游戏占中国游戏市场规模的5成以上,不过与网易不同的是,腾讯一直追求的是薄利多销策略。游戏内道具价格相比网易较为低廉,能取得超过千亿的年收入,全靠用户基数众多。 在PC端流量急剧下降,移动端用户暴涨之时,广告投放方也开始思考有的放矢,PC端时代是买广告位,而4G大数据时代就是买用户,这也称为信息流广告。 信息流广告最大的优势是不浪费资源,运用大数据针对性投放,既然有利可图,便成为各大巨头争先布局的板块,而这其中最为突出的就是今日头条和百度。 说起今日头条,这个曾经“小而美”的公司今年内发展成为TMD(头条、美团、滴滴)的首字母巨头,核心是张一鸣,但也得益于4G时代的浪潮。 今日头条的大获成功最引以为傲的是算法,虽然是新闻资讯类产品,但张一鸣的主创团队全是技术,不需要文字编辑。他们只做一件事,用纯技术算法手段从海量的内容中去搜索挖掘有价值的内容,最关键的是这些内容可以根据客户的需要进行“定制化”推送。这在信息爆炸时代,人们可以摆脱浩瀚无垠的信息海洋,只读取精准定制的有价值信息。 而依靠着强大的算法,什么火他做什么。微博火,做微头条,知乎火,做悟空问答,短视频直播时代到来,做火山小视频、西瓜视频、抖音,头条系产品依靠其强大的算法打造着一个又一个爆款。 2G时代,两大电商平台阿里和京东相争,虽然不是一个体量级,但是淘宝假货风行,一度让阿里痛下决心清理商家,而这些商家顺势被一个叫黄峥的人收走了,2015年,主打社交电商的拼多多应运而生。对了,这个黄峥还跟着别人和巴菲特吃过午餐。 而拼多多背后除了创始人黄峥,腾讯是第二大股东,而微信的天然社交入口让拼多多尝够了甜头,短短三年便上市,如今月活量已超过京东直逼淘宝。很显然,腾讯非常乐见有一家公司能威胁到阿里的主业务。 前文提到,LBS的应用为4G时代的滴滴发展起到推手的作用,2012年滴滴成立以来直至2014年都是缓慢上升期。但是自2014年以后,4G手机进一步普及,滴滴迅猛发展,短短一年便成为出行当之无愧的No.1,而滴滴2014年接入微信,这为滴滴提供了天然的流量入口。 但滴滴的竞品快的接入支付宝,此时阿里与腾讯在各个重合的领域相争已是司空见惯。但当时占领市场只有一个秘诀——烧钱,各种补贴各种红包雨,滴滴快的的烧钱战略持续了相当长一段时间,直到2015年滴滴快的的合并,让出行市场成为一家独大。 如果说滴滴是划时代的出行产品,那共享单车的出现引领了一个共享经济时代。 2004年,一个年轻人连同4个校友,提出“以共享经济+智能硬件,解决最后一公里出行问题”的经营理念,创立ofo共享单车项目,起先他们通过定制,将自行车通过车身号、机械锁绑定APP的方式,提供密码解锁用车的方式,在北京大学推出这一项目。这个项目的创始人叫戴威,北京大学光华管理学院的毕业生。 2015年1月27日,做媒体出身的胡玮炜和运营大牛王晓峰,在北京成立了一家名为“北京摩拜科技有限公司“的公司,他们的愿景是“让自行车回归生活”。 自此,共享单车风口吹起,共享单车“颜色大战”一触即发。而中国互联网创投倒贴钱抢市场,等日后一家独大再赚钱的逻辑,再一次在共享单车上体现的淋漓尽致。当时也就ofo和摩拜两家独大,但风口过得似乎有些快,风口过后,一地鸡毛。摩拜卖身美团,ofo深陷押金风波半死不活,老三哈罗单车如今倒是坐收渔翁之利。 5G时代,谁又能领风骚? 2G、3G、4G时代,随着互联网的发展,一些巨头应时代而生,而一些公司没能及时跟上时代的发展而掉队,还有像腾讯阿里等长盛不衰而又相互掣肘。2G、3G已然开始退网,4G时代方兴未艾,而5G时代紧赶着来了。 5G会直接加速万物互联的进程,改变我们与世界的交互界面。除了VR游戏、无人驾驶、智能物联等应用外,移动办公、会议直播、视频监控、智能城市等都会在5G的大网络下运行。智能手机厂商忙着推出5G手机,而互联网科技巨头在推出5G应用,虽然用户还未感觉到5G的速度,但这个赛道已经热得发烫。 阿里腾讯继续两强争霸?还是迷途的百度能否东山再起?是否还有头条、美团一样突然崛起的巨头?5G时代,一切皆有可能。 来源:https://www.chinaventure.com.cn/news/83-20190726-346438.html

技术杂谈

如果大家对 Python 爬虫有所了解的话,想必你应该听说过 Selenium 这个库,这实际上是一个自动化测试工具,现在已经被广泛用于网络爬虫中来应对 JavaScript 渲染的页面的抓取。 但 Selenium 用的时候有个麻烦事,就是环境的相关配置,得安装好相关浏览器,比如 Chrome、Firefox 等等,然后还要到官方网站去下载对应的驱动,最重要的还需要安装对应的 Python Selenium 库,确实是不是很方便,另外如果要做大规模部署的话,环境配置的一些问题也是个头疼的事情。 那么本节就介绍另一个类似的替代品,叫做 Pyppeteer。注意,是叫做 Pyppeteer,不是 Puppeteer。Puppeteer 是 Google 基于 Node.js 开发的一个工具,有了它我们可以通过 JavaScript 来控制 Chrome 浏览器的一些操作,当然也可以用作网络爬虫上,其 API 极其完善,功能非常强大。 而 Pyppeteer 又是什么呢?它实际上是 Puppeteer 的 Python 版本的实现,但他不是 Google 开发的,是一位来自于日本的工程师依据 Puppeteer 的一些功能开发出来的非官方版本。 在 Pyppetter 中,实际上它背后也是有一个类似 Chrome 浏览器的 Chromium 浏览器在执行一些动作进行网页渲染,首先说下 Chrome 浏览器和 Chromium 浏览器的渊源。

Chromium 是谷歌为了研发 Chrome 而启动的项目,是完全开源的。二者基于相同的源代码构建,Chrome 所有的新功能都会先在 Chromium 上实现,待验证稳定后才会移植,因此 Chromium 的版本更新频率更高,也会包含很多新的功能,但作为一款独立的浏览器,Chromium 的用户群体要小众得多。两款浏览器“同根同源”,它们有着同样的 Logo,但配色不同,Chrome 由蓝红绿黄四种颜色组成,而 Chromium 由不同深度的蓝色构成。

总的来说,两款浏览器的内核是一样的,实现方式也是一样的,可以认为是开发版和正式版的区别,功能上基本是没有太大区别的。 Pyppeteer 就是依赖于 Chromium 这个浏览器来运行的。那么有了 Pyppeteer 之后,我们就可以免去那些繁琐的环境配置等问题。如果第一次运行的时候,Chromium 浏览器没有安全,那么程序会帮我们自动安装和配置,就免去了繁琐的环境配置等工作。另外 Pyppeteer 是基于 Python 的新特性 async 实现的,所以它的一些执行也支持异步操作,效率相对于 Selenium 来说也提高了。 那么下面就让我们来一起了解下 Pyppeteer 的相关用法吧。

安装

首先就是安装问题了,由于 Pyppeteer 采用了 Python 的 async 机制,所以其运行要求的 Python 版本为 3.5 及以上。 安装方式非常简单:

1
pip3 install pyppeteer

好了,安装完成之后我们命令行下测试下:

1
\>>> import pyppeteer

如果没有报错,那么就证明安装成功了。

快速上手

接下来我们测试下基本的页面渲染操作,这里我们选用的网址为:http://quotes.toscrape.com/js/,这个页面是 JavaScript 渲染而成的,用基本的 requests 库请求得到的 HTML 结果里面是不包含页面中所见的条目内容的。 为了证明 requests 无法完成正常的抓取,我们可以先用如下代码来测试一下:

1
2
3
4
5
6
7
import requests
from pyquery import PyQuery as pq

url = 'http://quotes.toscrape.com/js/'
response = requests.get(url)
doc = pq(response.text)
print('Quotes:', doc('.quote').length)

这里首先使用 requests 来请求网页内容,然后使用 pyquery 来解析页面中的每一个条目。观察源码之后我们发现每个条目的 class 名为 quote,所以这里选用了 .quote 这个 CSS 选择器来选择,最后输出条目数量。 运行结果:

1
Quotes: 0

结果是 0,这就证明使用 requests 是无法正常抓取到相关数据的。因为什么?因为这个页面是 JavaScript 渲染而成的,我们所看到的内容都是网页加载后又执行了 JavaScript 之后才呈现出来的,因此这些条目数据并不存在于原始 HTML 代码中,而 requests 仅仅抓取的是原始 HTML 代码。 好的,所以遇到这种类型的网站我们应该怎么办呢? 其实答案有很多:

  • 分析网页源代码数据,如果数据是隐藏在 HTML 中的其他地方,以 JavaScript 变量的形式存在,直接提取就好了。
  • 分析 Ajax,很多数据可能是经过 Ajax 请求时候获取的,所以可以分析其接口。
  • 模拟 JavaScript 渲染过程,直接抓取渲染后的结果。

而 Pyppeteer 和 Selenium 就是用的第三种方法,下面我们再用 Pyppeteer 来试试,如果用 Pyppeteer 实现如上页面的抓取的话,代码就可以写为如下形式:

1
2
3
4
5
6
7
8
9
10
11
12
13
import asyncio
from pyppeteer import launch
from pyquery import PyQuery as pq

async def main():
browser = await launch()
page = await browser.newPage()
await page.goto('http://quotes.toscrape.com/js/')
doc = pq(await page.content())
print('Quotes:', doc('.quote').length)
await browser.close()

asyncio.get_event_loop().run_until_complete(main())

运行结果:

1
Quotes: 10

看运行结果,这说明我们就成功匹配出来了 class 为 quote 的条目,总数为 10 条,具体的内容可以进一步使用 pyquery 解析查看。 那么这里面的过程发生了什么? 实际上,Pyppeteer 整个流程就完成了浏览器的开启、新建页面、页面加载等操作。另外 Pyppeteer 里面进行了异步操作,所以需要配合 async/await 关键词来实现。 首先, launch 方法会新建一个 Browser 对象,然后赋值给 browser,然后调用 newPage 方法相当于浏览器中新建了一个选项卡,同时新建了一个 Page 对象。然后 Page 对象调用了 goto 方法就相当于在浏览器中输入了这个 URL,浏览器跳转到了对应的页面进行加载,加载完成之后再调用 content 方法,返回当前浏览器页面的源代码。然后进一步地,我们用 pyquery 进行同样地解析,就可以得到 JavaScript 渲染的结果了。 另外其他的一些方法如调用 asyncio 的 get_event_loop 等方法的相关操作则属于 Python 异步 async 相关的内容了,大家如果不熟悉可以了解下 Python 的 async/await 的相关知识。 好,通过上面的代码,我们就可以完成 JavaScript 渲染页面的爬取了。 在这个过程中,我们没有配置 Chrome 浏览器,没有配置浏览器驱动,免去了一些繁琐的步骤,同样达到了 Selenium 的效果,还实现了异步抓取,爽歪歪! 接下来我们再看看另外一个例子,这个例子可以模拟网页截图,保存 PDF,另外还可以执行自定义的 JavaScript 获得特定的内容,代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import asyncio
from pyppeteer import launch

async def main():
browser = await launch()
page = await browser.newPage()
await page.goto('http://quotes.toscrape.com/js/')
await page.screenshot(path='example.png')
await page.pdf(path='example.pdf')
dimensions = await page.evaluate('''() => {
return {
width: document.documentElement.clientWidth,
height: document.documentElement.clientHeight,
deviceScaleFactor: window.devicePixelRatio,
}
}''')

print(dimensions)
# >>> {'width': 800, 'height': 600, 'deviceScaleFactor': 1}
await browser.close()

asyncio.get_event_loop().run_until_complete(main())

这里我们又用到了几个新的 API,完成了网页截图保存、网页导出 PDF 保存、执行 JavaScript 并返回对应数据。 首先 screenshot 方法可以传入保存的图片路径,另外还可以指定保存格式 type、清晰度 quality、是否全屏 fullPage、裁切 clip 等各个参数实现截图。 截图的样例如下: 可以看到它返回的就是 JavaScript 渲染后的页面。 pdf 方法也是类似的,只不过页面保存格式不一样,最后得到一个多页的 pdf 文件,样例如下: 可见其内容也是 JavaScript 渲染后的内容,另外这个方法还可以指定放缩大小 scale、页码范围 pageRanges、宽高 width 和 height、方向 landscape 等等参数,导出定制化的 pdf 用这个方法就十分方便。 最后我们又调用了 evaluate 方法执行了一些 JavaScript,JavaScript 传入的是一个函数,使用 return 方法返回了网页的宽高、像素大小比率三个值,最后得到的是一个 JSON 格式的对象,内容如下:

1
{'width': 800, 'height': 600, 'deviceScaleFactor': 1}

OK,实例就先感受到这里,还有太多太多的功能还没提及。 总之利用 Pyppeteer 我们可以控制浏览器执行几乎所有动作,想要的操作和功能基本都可以实现,用它来自由地控制爬虫当然就不在话下了。

详细用法

了解了基本的实例之后,我们再来梳理一下 Pyppeteer 的一些基本和常用操作。Pyppeteer 的几乎所有功能都能在其官方文档的 API Reference 里面找到,链接为:https://miyakogi.github.io/pyppeteer/reference.html,用到哪个方法就来这里查询就好了,参数不必死记硬背,即用即查就好

开启浏览器

使用 Pyppeteer 的第一步便是启动浏览器,首先我们看下怎样启动一个浏览器,其实就相当于我们点击桌面上的浏览器图标一样,把它开起来。用 Pyppeteer 完成同样的操作,只需要调用 launch 方法即可。 我们先看下 launch 方法的 API,链接为:https://miyakogi.github.io/pyppeteer/reference.html#pyppeteer.launcher.launch,其方法定义如下:

1
pyppeteer.launcher.launch(options: dict = None, **kwargs) → pyppeteer.browser.Browser

可以看到它处于 launcher 模块中,参数没有在声明中特别指定,返回类型是 browser 模块中的 Browser 对象,另外观察源码发现这是一个 async 修饰的方法,所以调用它的时候需要使用 await。 接下来看看它的参数:

  • ignoreHTTPSErrors (bool): 是否要忽略 HTTPS 的错误,默认是 False。
  • headless (bool): 是否启用 Headless 模式,即无界面模式,如果 devtools 这个参数是 True 的话,那么该参数就会被设置为 False,否则为 True,即默认是开启无界面模式的。
  • executablePath (str): 可执行文件的路径,如果指定之后就不需要使用默认的 Chromium 了,可以指定为已有的 Chrome 或 Chromium。
  • slowMo (int|float): 通过传入指定的时间,可以减缓 Pyppeteer 的一些模拟操作。
  • args (List[str]): 在执行过程中可以传入的额外参数。
  • ignoreDefaultArgs (bool): 不使用 Pyppeteer 的默认参数,如果使用了这个参数,那么最好通过 args 参数来设定一些参数,否则可能会出现一些意想不到的问题。这个参数相对比较危险,慎用。
  • handleSIGINT (bool): 是否响应 SIGINT 信号,也就是可以使用 Ctrl + C 来终止浏览器程序,默认是 True。
  • handleSIGTERM (bool): 是否响应 SIGTERM 信号,一般是 kill 命令,默认是 True。
  • handleSIGHUP (bool): 是否响应 SIGHUP 信号,即挂起信号,比如终端退出操作,默认是 True。
  • dumpio (bool): 是否将 Pyppeteer 的输出内容传给 process.stdout 和 process.stderr 对象,默认是 False。
  • userDataDir (str): 即用户数据文件夹,即可以保留一些个性化配置和操作记录。
  • env (dict): 环境变量,可以通过字典形式传入。
  • devtools (bool): 是否为每一个页面自动开启调试工具,默认是 False。如果这个参数设置为 True,那么 headless 参数就会无效,会被强制设置为 False。
  • logLevel (int|str): 日志级别,默认和 root logger 对象的级别相同。
  • autoClose (bool): 当一些命令执行完之后,是否自动关闭浏览器,默认是 True。
  • loop (asyncio.AbstractEventLoop): 时间循环对象。

好了,知道这些参数之后,我们可以先试试看。 首先可以试用下最常用的参数 headless,如果我们将它设置为 True 或者默认不设置它,在启动的时候我们是看不到任何界面的,如果把它设置为 False,那么在启动的时候就可以看到界面了,一般我们在调试的时候会把它设置为 False,在生产环境上就可以设置为 True,我们先尝试一下关闭 headless 模式:

1
2
3
4
5
6
7
8
import asyncio
from pyppeteer import launch

async def main():
await launch(headless=False)
await asyncio.sleep(100)

asyncio.get_event_loop().run_until_complete(main())

运行之后看不到任何控制台输出,但是这时候就会出现一个空白的 Chromium 界面了: 但是可以看到这就是一个光秃秃的浏览器而已,看一下相关信息: 看到了,这就是 Chromium,上面还写了开发者内部版本,可以认为是开发版的 Chrome 浏览器就好。 另外我们还可以开启调试模式,比如在写爬虫的时候会经常需要分析网页结构还有网络请求,所以开启调试工具还是很有必要的,我们可以将 devtools 参数设置为 True,这样每开启一个界面就会弹出一个调试窗口,非常方便,示例如下:

1
2
3
4
5
6
7
8
9
10
import asyncio
from pyppeteer import launch

async def main():
browser = await launch(devtools=True)
page = await browser.newPage()
await page.goto('https://www.baidu.com')
await asyncio.sleep(100)

asyncio.get_event_loop().run_until_complete(main())

刚才说过 devtools 这个参数如果设置为了 True,那么 headless 就会被关闭了,界面始终会显现出来。在这里我们新建了一个页面,打开了百度,界面运行效果如下: 这时候我们可以看到上面的一条提示:”Chrome 正受到自动测试软件的控制”,这个提示条有点烦,那咋关闭呢?这时候就需要用到 args 参数了,禁用操作如下:

1
browser = await launch(headless=False, args=['--disable-infobars'])

这里就不再写完整代码了,就是在 launch 方法中,args 参数通过 list 形式传入即可,这里使用的是 —disable-infobars 的参数。 另外有人就说了,这里你只是把提示关闭了,有些网站还是会检测到是 webdriver 吧,比如淘宝检测到是 webdriver 就会禁止登录了,我们可以试试:

1
2
3
4
5
6
7
8
9
10
import asyncio
from pyppeteer import launch

async def main():
browser = await launch(headless=False)
page = await browser.newPage()
await page.goto('https://www.taobao.com')
await asyncio.sleep(100)

asyncio.get_event_loop().run_until_complete(main())

运行时候进行一下登录,然后就会弹出滑块,自己手动拖动一下,然后就报错了,界面如下: 爬虫的时候看到这界面是很让人崩溃的吧,而且这时候我们还发现了页面的 bug,整个浏览器窗口比显示的内容窗口要大,这个是某些页面会出现的情况,让人看起来很不爽。 我们可以先解决一下这个显示的 bug,需要设置下 window-size 还有 viewport,代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import asyncio
from pyppeteer import launch

width, height = 1366, 768

async def main():
browser = await launch(headless=False,
args=[f'--window-size={width},{height}'])
page = await browser.newPage()
await page.setViewport({'width': width, 'height': height})
await page.goto('https://www.taobao.com')
await asyncio.sleep(100)

asyncio.get_event_loop().run_until_complete(main())

这样整个界面就正常了: OK,那刚才所说的 webdriver 检测问题怎样来解决呢?其实淘宝主要通过 window.navigator.webdriver 来对 webdriver 进行检测,所以我们只需要使用 JavaScript 将它设置为 false 即可,代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
import asyncio
from pyppeteer import launch

async def main():
browser = await launch(headless=False, args=['--disable-infobars'])
page = await browser.newPage()
await page.goto('https://login.taobao.com/member/login.jhtml?redirectURL=https://www.taobao.com/')
await page.evaluate(
'''() =>{ Object.defineProperties(navigator,{ webdriver:{ get: () => false } }) }''')
await asyncio.sleep(100)

asyncio.get_event_loop().run_until_complete(main())

这里没加输入用户名密码的代码,当然后面可以自行添加,下面打开之后,我们点击输入用户名密码,然后这时候会出现一个滑动条,这里滑动的话,就可以通过了,如图所示: OK,这样的话我们就成功规避了 webdriver 的检测,使用鼠标拖动模拟就可以完成淘宝的登录了。 还有另一种方法可以进一步免去淘宝登录的烦恼,那就是设置用户目录。平时我们已经注意到,当我们登录淘宝之后,如果下次再次打开浏览器发现还是登录的状态。这是因为淘宝的一些关键 Cookies 已经保存到本地了,下次登录的时候可以直接读取并保持登录状态。 那么这些信息保存在哪里了呢?其实就是保存在用户目录下了,里面不仅包含了浏览器的基本配置信息,还有一些 Cache、Cookies 等各种信息都在里面,如果我们能在浏览器启动的时候读取这些信息,那么启动的时候就可以恢复一些历史记录甚至一些登录状态信息了。 这也就解决了一个问题:很多朋友在每次启动 Selenium 或 Pyppeteer 的时候总是是一个全新的浏览器,那就是没有设置用户目录,如果设置了它,每次打开就不再是一个全新的浏览器了,它可以恢复之前的历史记录,也可以恢复很多网站的登录信息。 那么这个怎么来做呢?很简单,在启动的时候设置 userDataDir 就好了,示例如下:

1
2
3
4
5
6
7
8
9
10
import asyncio
from pyppeteer import launch

async def main():
browser = await launch(headless=False, userDataDir='./userdata', args=['--disable-infobars'])
page = await browser.newPage()
await page.goto('https://www.taobao.com')
await asyncio.sleep(100)

asyncio.get_event_loop().run_until_complete(main())

好,这里就是加了一个 userDataDir 的属性,值为 userdata,即当前目录的 userdata 文件夹。我们可以首先运行一下,然后登录一次淘宝,这时候我们同时可以观察到在当前运行目录下又多了一个 userdata 的文件夹,里面的结构是这样子的: 具体的介绍可以看官方的一些说明,如:https://chromium.googlesource.com/chromium/src/+/master/docs/user_data_dir.md,这里面介绍了 userdatadir 的相关内容。 再次运行上面的代码,这时候可以发现现在就已经是登录状态了,不需要再次登录了,这样就成功跳过了登录的流程。当然可能时间太久了,Cookies 都过期了,那还是需要登录的。 好了,本想把 Pyppeteer 的用法详细介绍完的,结果只 launch 的方法就介绍这么多了,后面的内容放到其他文章来介绍了,其他的内容后续文章会陆续放出,谢谢。

本节代码获取

公众号”进击的Coder”回复”Pyppeteer”即可获取本节全部代码。

技术杂谈

正则表达式30分钟入门教程(https://deerchao.net/tutorials/regex/regex.htm

本教程目标:30分钟内让你明白正则表达式是什么,并对它有一些基本的了解,让你可以在自己的程序或网页里使用它。

正则表达式 必知必会(https://www.zybuluo.com/Yano/note/475174

Zjmainstay学习笔记 | 正则表达式(http://www.zjmainstay.cn/regexp

《精通正则表达式 第三版》

  1. 最后,推荐一本动物书《精通正则表达式 第三版》

【顺手提供】精通正则表达式:第三版 PDF (高清-中文-带标签)

关注本公众号【离不开的网】,后台回复 “ 正则pdf ” 即可。

相关好文推荐

  1. 想精通正则表达式 这几个正则表达式学习资料及工具你必须有 :https://www.cnblogs.com/3rocks/p/11212724.html

  2. 菜鸟教程-正则表达式 :https://www.runoob.com/regexp/regexp-tutorial.html

  3. 正则表达式速查表 :https://www.jb51.net/article/67634.htm

  4. 细说python正则表达式 :https://www.jianshu.com/p/147fab022566

  5. 路人甲的关于正则表达式 :https://zhuanlan.zhihu.com/p/21341872?refer=passer

  6. 最全的常用正则表达式大全——包括校验数字、字符、一些特殊的需求等等 :http://www.cnblogs.com/zxin/archive/2013/01/26/2877765.html

  7. 深入理解正则表达式 :https://www.cnblogs.com/China3S/archive/2013/11/30/3451971.html

原文链接:https://mp.weixin.qq.com/s/CGSUJntKtvOrV1o-R2GrRw 来源公众号:离不开的网

Python

日志概述

百度百科的日志概述: Windows网络操作系统都设计有各种各样的日志文件,如应用程序日志,安全日志、系统日志、Scheduler服务日志、FTP日志、WWW日志、DNS服务器日志等等,这些根据你的系统开启的服务的不同而有所不同。我们在系统上进行一些操作时,这些日志文件通常会记录下我们操作的一些相关内容,这些内容对系统安全工作人员相当有用。比如说有人对系统进行了IPC探测,系统就会在安全日志里迅速地记下探测者探测时所用的IP、时间、用户名等,用FTP探测后,就会在FTP日志中记下IP、时间、探测所用的用户名等。 我映像中的日志: 查看日志是开发人员日常获取信息、排查异常、发现问题的最好途径,日志记录中通常会标记有异常产生的原因、发生时间、具体错误行数等信息,这极大的节省了我们的排查时间,无形中提高了编码效率。

日志分类

我们可以按照输出终端进行分类,也可以按照日志级别进行分类。输出终端指的是将日志在控制台输出显示和将日志存入文件;日志级别指的是 Debug、Info、WARNING、ERROR以及CRITICAL等严重等级进行划分。

Python 的 logging

logging提供了一组便利的日志函数,它们分别是:debug()、 info()、 warning()、 error() 和 critical()。logging函数根据它们用来跟踪的事件的级别或严重程度来命名。标准级别及其适用性描述如下(以严重程度递增排序): 每个级别对应的数字值为 CRITICAL:50,ERROR:40,WARNING:30,INFO:20,DEBUG:10,NOTSET:0。 Python 中日志的默认等级是 WARNING,DEBUG 和 INFO 级别的日志将不会得到显示,在 logging 中更改设置。

日志输出

输出到控制台

使用 logging 在控制台打印日志,这里我们用 Pycharm 编辑器来观察:

1
2
3
4
5
import logging

logging.debug('崔庆才丨静觅、韦世东丨奎因')
logging.warning('邀请你关注微信公众号【进击的 Coder】')
logging.info('和大佬一起coding、共同进步')

从上图运行的结果来看,的确只显示了 WARNING 级别的信息,验证了上面的观点。同时也在控制台输出了日志内容,默认情况下 Python 中使用 logging 模块中的函数打印日志,日志只会在控制台输出,而不会保存到日文件。 有什么办法可以改变默认的日志级别呢? 当然是有的,logging 中提供了 basicConfig 让使用者可以适时调节默认日志级别,我们可以将上面的代码改为:

1
2
3
4
5
6
import logging

logging.basicConfig(level=logging.DEBUG)
logging.debug('崔庆才丨静觅、韦世东丨奎因')
logging.warning('邀请你关注微信公众号【进击的 Coder】')
logging.info('和大佬一起coding、共同进步')

在 basicConfig 中设定 level 参数的级别即可。 思考:如果设定级别为 logging.INFO,那 DEBUG 信息能够显示么?

保存到文件

刚才演示了如何在控制台输出日志内容,并且自由设定日志的级别,那现在就来看看如何将日志保存到文件。依旧是强大的 basicConfig,我们再将上面的代码改为:

1
2
3
4
5
6
import logging

logging.basicConfig(level=logging.DEBUG, filename='coder.log', filemode='a')
logging.debug('崔庆才丨静觅、韦世东丨奎因')
logging.warning('邀请你关注微信公众号【进击的 Coder】')
logging.info('和大佬一起coding、共同进步')

在配置中填写 filename (指定文件名) 和 filemode (文件写入方式),控制台的日志输出就不见了,那么 coder.log 会生成么? 在 .py 文件的同级目录生成了名为 coder.log 的日志。 通过简单的代码设置,我们就完成了日志文件在控制台和文件中的输出。那既在控制台显示又能保存到文件中呢?

强大的 logging

logging所提供的模块级别的日志记录函数是对logging日志系统相关类的封装 logging 模块提供了两种记录日志的方式:

  • 使用logging提供的模块级别的函数
  • 使用Logging日志系统的四大组件

这里提到的级别函数就是上面所用的 DEBGE、ERROR 等级别,而四大组件则是指 loggers、handlers、filters 和 formatters 这几个组件,下图简单明了的阐述了它们各自的作用: 日志器(logger)是入口,真正工作的是处理器(handler),处理器(handler)还可以通过过滤器(filter)和格式器(formatter)对要输出的日志内容做过滤和格式化等处理操作。

四大组件

下面介绍下与logging四大组件相关的类:Logger, Handler, Filter, Formatter。 Logger类 Logger 对象有3个工作要做:

1
2
3
1)向应用程序代码暴露几个方法,使应用程序可以在运行时记录日志消息;
2)基于日志严重等级(默认的过滤设施)或filter对象来决定要对哪些日志进行后续处理;
3)将日志消息传送给所有感兴趣的日志handlers。

Logger对象最常用的方法分为两类:配置方法 和 消息发送方法 最常用的配置方法如下: 关于Logger.setLevel()方法的说明: 内建等级中,级别最低的是DEBUG,级别最高的是CRITICAL。例如setLevel(logging.INFO),此时函数参数为INFO,那么该logger将只会处理INFO、WARNING、ERROR和CRITICAL级别的日志,而DEBUG级别的消息将会被忽略/丢弃。 logger对象配置完成后,可以使用下面的方法来创建日志记录: 那么,怎样得到一个Logger对象呢?一种方式是通过Logger类的实例化方法创建一个Logger类的实例,但是我们通常都是用第二种方式—logging.getLogger()方法。 logging.getLogger()方法有一个可选参数name,该参数表示将要返回的日志器的名称标识,如果不提供该参数,则其值为’root’。若以相同的name参数值多次调用getLogger()方法,将会返回指向同一个logger对象的引用。

1
2
3
4
5
关于logger的层级结构与有效等级的说明:

logger的名称是一个以'.'分割的层级结构,每个'.'后面的logger都是'.'前面的logger的children,例如,有一个名称为 foo 的logger,其它名称分别为 foo.bar, foo.bar.baz 和 foo.bam都是 foo 的后代。
logger有一个"有效等级(effective level)"的概念。如果一个logger上没有被明确设置一个level,那么该logger就是使用它parent的level;如果它的parent也没有明确设置level则继续向上查找parent的parent的有效level,依次类推,直到找到个一个明确设置了level的祖先为止。需要说明的是,root logger总是会有一个明确的level设置(默认为 WARNING)。当决定是否去处理一个已发生的事件时,logger的有效等级将会被用来决定是否将该事件传递给该logger的handlers进行处理。
child loggers在完成对日志消息的处理后,默认会将日志消息传递给与它们的祖先loggers相关的handlers。因此,我们不必为一个应用程序中所使用的所有loggers定义和配置handlers,只需要为一个顶层的logger配置handlers,然后按照需要创建child loggers就可足够了。我们也可以通过将一个logger的propagate属性设置为False来关闭这种传递机制。

Handler Handler对象的作用是(基于日志消息的level)将消息分发到handler指定的位置(文件、网络、邮件等)。Logger对象可以通过addHandler()方法为自己添加0个或者更多个handler对象。比如,一个应用程序可能想要实现以下几个日志需求:

1
2
3
4
1)把所有日志都发送到一个日志文件中;
2)把所有严重级别大于等于error的日志发送到stdout(标准输出);
3)把所有严重级别为critical的日志发送到一个email邮件地址。
这种场景就需要3个不同的handlers,每个handler复杂发送一个特定严重级别的日志到一个特定的位置。

一个handler中只有非常少数的方法是需要应用开发人员去关心的。对于使用内建handler对象的应用开发人员来说,似乎唯一相关的handler方法就是下面这几个配置方法: 需要说明的是,应用程序代码不应该直接实例化和使用Handler实例。因为Handler是一个基类,它只定义了素有handlers都应该有的接口,同时提供了一些子类可以直接使用或覆盖的默认行为。下面是一些常用的Handler: Formater Formater对象用于配置日志信息的最终顺序、结构和内容。与logging.Handler基类不同的是,应用代码可以直接实例化Formatter类。另外,如果你的应用程序需要一些特殊的处理行为,也可以实现一个Formatter的子类来完成。 Formatter类的构造方法定义如下:

1
logging.Formatter.__init__(fmt=None, datefmt=None, style='%')

该构造方法接收3个可选参数:

  • fmt:指定消息格式化字符串,如果不指定该参数则默认使用message的原始值
  • datefmt:指定日期格式字符串,如果不指定该参数则默认使用”%Y-%m-%d %H:%M:%S”
  • style:Python 3.2新增的参数,可取值为 ‘%’, ‘{‘和 ‘$’,如果不指定该参数则默认使用’%’

Filter Filter可以被Handler和Logger用来做比level更细粒度的、更复杂的过滤功能。Filter是一个过滤器基类,它只允许某个logger层级下的日志事件通过过滤。该类定义如下:

1
2
class logging.Filter(name='')
filter(record)

比如,一个filter实例化时传递的name参数值为’A.B’,那么该filter实例将只允许名称为类似如下规则的loggers产生的日志记录通过过滤:’A.B’,’A.B,C’,’A.B.C.D’,’A.B.D’,而名称为’A.BB’, ‘B.A.B’的loggers产生的日志则会被过滤掉。如果name的值为空字符串,则允许所有的日志事件通过过滤。 filter方法用于具体控制传递的record记录是否能通过过滤,如果该方法返回值为0表示不能通过过滤,返回值为非0表示可以通过过滤。

1
2
3
4
说明:

如果有需要,也可以在filter(record)方法内部改变该record,比如添加、删除或修改一些属性。
我们还可以通过filter做一些统计工作,比如可以计算下被一个特殊的logger或handler所处理的record数量等。

实战演练

上面文绉绉的说了(复制/粘贴)那么多,现在应该动手实践了。 现在我需要既将日志输出到控制台、又能将日志保存到文件,我应该怎么办? 利用刚才所学的知识,我们可以构思一下: 看起来好像也不难,挺简单的样子,但是实际如此吗? 在实际的工作或应用中,我们或许还需要指定文件存放路径、用随机数作为日志文件名、显示具体的信息输出代码行数、日志信息输出日期和日志写入方式等内容。再构思一下: 具体代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
import os
import logging
import uuid
from logging import Handler, FileHandler, StreamHandler

class PathFileHandler(FileHandler):
def __init__(self, path, filename, mode='a', encoding=None, delay=False):

filename = os.fspath(filename)
if not os.path.exists(path):
os.mkdir(path)
self.baseFilename = os.path.join(path, filename)
self.mode = mode
self.encoding = encoding
self.delay = delay
if delay:
Handler.__init__(self)
self.stream = None
else:
StreamHandler.__init__(self, self._open())

class Loggers(object):
# 日志级别关系映射
level_relations = {
'debug': logging.DEBUG, 'info': logging.INFO, 'warning': logging.WARNING,
'error': logging.ERROR, 'critical': logging.CRITICAL
}

def __init__(self, filename='{uid}.log'.format(uid=uuid.uuid4()), level='info', log_dir='log',
fmt='%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s'):
self.logger = logging.getLogger(filename)
abspath = os.path.dirname(os.path.abspath(__file__))
self.directory = os.path.join(abspath, log_dir)
format_str = logging.Formatter(fmt) # 设置日志格式
self.logger.setLevel(self.level_relations.get(level)) # 设置日志级别
stream_handler = logging.StreamHandler() # 往屏幕上输出
stream_handler.setFormatter(format_str)
file_handler = PathFileHandler(path=self.directory, filename=filename, mode='a')
file_handler.setFormatter(format_str)
self.logger.addHandler(stream_handler)
self.logger.addHandler(file_handler)

if __name__ == "__main__":
txt = "关注公众号【进击的 Coder】,回复『日志代码』可以领取文章中完整的代码以及流程图"
log = Loggers(level='debug')
log.logger.info(4)
log.logger.info(5)
log.logger.info(txt)

文件保存后运行,运行结果如下图所示: 日志确实在控制台输出了,再来看一下目录内是否生成有指定的文件和文件夹: 文件打开后可以看到里面输出的内容: 正确的学习方式是什么 是一步步的看着文章介绍,等待博主结论? 是拿着代码运行,跑一遍? 都不是,应该是一边看着文章,一边拿着示例代码琢磨和研究,到底哪里可以改进、哪里可以设计得更好。如果你需要文章中所用到的示例代码和流程图,那么关注微信公众号【进击的 Coder】,回复『日志代码』就可以领取文章中完整的代码以及流程图。毕竟,学习是一件勤劳的事。 参考资料: 云游道士博文 nancy05博文

技术杂谈

位运算是我们在编程中常会遇到的操作,但仍然有很多开发者并不了解位运算,这就导致在遇到位运算时会“打退堂鼓”。实际上,位运算并没有那么复杂,只要我们了解其运算基础和运算符的运算规则,就能够掌握位运算的知识。接下来,我们一起学习位运算的相关知识。 程序中的数在计算机内存中都是以二进制的形式存在的,位运算就是直接对整数在内存中对应的二进制位进行操作。

注意:本文只讨论整数运算,小数运算不在本文研究之列

位运算的基础

我们常用的 35 等数字是十进制表示,而位运算的基础是二进制。即人类采用十进制,机器采用的是二进制,要深入了解位运算,就需要了解十进制和二进制的转换方法和对应关系。

二进制

十进制转二进制时,采用“除 2 取余,逆序排列”法:

  1. 用 2 整除十进制数,得到商和余数;
  2. 再用 2 整除商,得到新的商和余数;
  3. 重复第 1 和第 2 步,直到商为 0;
  4. 将先得到的余数作为二进制数的高位,后得到的余数作为二进制数的低位,依次排序;

排序结果就是该十进制数的二进制表示。例如十进制数 101 转换为二进制数的计算过程如下:

1
2
3
4
5
6
7
101 % 2 = 501
50 % 2 = 250
25 % 2 = 121
12 % 2 = 60
6 % 2 = 30
3 % 2 = 11
1 % 2 = 01

逆序排列即二进制中的从高位到低位排序,得到 7 位二进制数为 1100101,如果要转换为 8 位二进制数,就需要在最高位补 0。即十进制数的 8 位二进制数为 01100101。 其完整过程如下图所示: 有网友整理了常见的进制与 ASCII 码对照表,表内容如下: ASCII 控制字符 ASCII 可显示字符

补码

现在,我们已经了解到二进制与十进制的换算方法,并拥有了进制对照表。但在开始学习位运算符之前,我们还需要了解补码的知识。 数值有正负之分,那么仅有 01 的二进制如何表示正负呢? 人们设定,二进制中最高位为 0 代表正,为 1 则代表负。例如 0000 1100 对应的十进制为 12,而 1000 1100 对应的十进制为 \-12。这种表示被称作原码。但新的问题出现了,原本二进制的最高位始终为 0,为了表示正负又多出了 1,在执行运算时就会出错。举个例子,1 + (-2) 的二进制运算如下:

1
2
3
0000 0001 + 1000 0010 
= 1000 0011
= -3

这显然是有问题的,问题就处在这个代表正负的最高位。接着,人们又弄出了反码(二进制各位置的 01 互换,例如 0000 1100 的反码为 1111 0011)。此时,运算就会变成这样:

1
2
3
4
5
0000 0001 + 1111 1101
= 1111 1110
# 在转换成十进制前,需要再次反码
= 1000 0001
= -1

这次好像正确了。但它仍然有例外,我们来看一下 1 + (-1)

1
2
3
4
0000 0001 + 1111 + 1110
= 1111 1111
= 1000 0000
= -0

零是没有正负之分的,为了解决这个问题,就搞出了补码的概念。补码是为了让负数变成能够加的正数,所以 负数的补码= 负数的绝对值取反 + 1,例如 \-1 的补码为:

1
2
3
4
\-1 的绝对值 1
= 0000 0001 # 1 的二进制原码
= 1111 1110 # 原码取反
= 1111 1111 # +1 后得到补码

\-1 补码推导的完整过程如下图所示: 反过来,由补码推导原码的过程为 原码 = 补码 - 1,再求反。要注意的是,反码过程中,最高位的值不变,这样才能够保证结果的正负不会出错。例如 1 + (-6)1 + (-9) 的运算过程如下:

1
2
3
4
5
6
# 1 的补码 + -6 的补码
0000 0001 + 1111 1010
= 1111 1011 # 补码运算结果
= 1111 1010 # 对补码减 1,得到反码
= 1000 0101 # 反码取反,得到原码
= -5 # 对应的十进制
1
2
3
4
5
6
# 1 的补码 + -9 的补码
0000 0001 + 1111 0111
= 1111 1000 # 补码运算结果
= 1111 0111 # 对补码减 1,得到反码
= 1000 1000 # 反码取反,得到原码
= -8 # 对应的十进制

要注意的是,正数的补码与原码相同,不需要额外运算。也可以说,补码的出现就是为了解决负数运算时的符号问题。

人生苦短 我用 Python。 崔庆才|静觅 邀请你关注微信公众号:进击的Coder

运算符介绍

位运算分为 6 种,它们是:

名称

符号

按位与

&

按位或

|

按位异或

^

按位取反

~

左移运算

<<

右移运算

>>

按位与

按位与运算将参与运算的两数对应的二进制位相与,当对应的二进制位均为 1 时,结果位为 1,否则结果位为 0。按位与运算的运算符为 &,参与运算的数以补码方式出现。举个例子,将数字 5 和数字 8 进行按位与运算,其实是将数字 5 对应的二进制 0000 0101 和数字 8 对应的二进制 0000 1000 进行按位与运算,即:

1
2
3
0000 0101
&
0000 1000

根据按位与的规则,将各个位置的数进行比对。运算过程如下:

1
2
3
4
5
0000 0101
&
0000 1000
---- ----
0000 0000

由于它们对应位置中没有“均为 1 ”的情况,所以得到的结果是 0000 0000。数字 58 按位与运算的完整过程如下图: 将结果换算成十进制,得到 0,即 5&8 = 0

按位或

按位或运算将参与运算的两数对应的二进制位相或,只要对应的二进制位中有 1,结果位为 1,否则结果位为 0。按位或运算的运算符为 |,参与运算的数以补码方式出现。举个例子,将数字 3 和数字 7 进行按位或运算,其实是将数字 3 对应的二进制 0000 0011和数字 7 对应的二进制 0000 0111 进行按位或运算,即:

1
2
3
0000 0011
|
0000 0111

根据按位或的规则,将各个位置的数进行比对。运算过程如下:

1
2
3
4
5
0000 0011
|
0000 0111
---- ----
0000 0111

最终得到的结果为 0000 0111。将结果换算成十进制,得到 7,即 3|7 = 7

按位异或

按位异或运算将参与运算的两数对应的二进制位相异或,当对应的二进制位值不同时,结果位为 1,否则结果位为 0。按位异或的运算符为 ^,参与运算的数以补码方式出现。举个例子,将数字 12 和数字 7 进行按位异或运算,其实是将数字 12 对应的二进制 0000 1100 和数字 7 对应的二进制 0000 0111 进行按位异或运算,即:

1
2
3
0000 1100
^
0000 0111

根据按位异或的规则,将各个位置的数进行比对。运算过程如下:

1
2
3
4
5
0000 1100
^
0000 0111
---- ----
0000 1011

最终得到的结果为 0000 1011。将结果换算成十进制,得到 11,即 12^7 = 11

按位取反

按位取反运算将二进制数的每一个位上面的 0 换成 11 换成 0。按位取反的运算符为 ~,参与运算的数以补码方式出现。举个例子,对数字 9 进行按位取反运算,其实是将数字 9 对应的二进制 0000 1001 进行按位取反运算,即:

1
2
3
4
~0000 1001
= 0000 1001 # 补码,正数补码即原码
= 1111 1010 # 取反
= -10

最终得到的结果为 \-10。再来看一个例子,\-20 按位取反的过程如下:

1
2
3
4
~0001 0100
= 1110 1100 # 补码
= 0001 0011 # 取反
= 19

最终得到的结果为 19。我们从示例中找到了规律,按位取反的结果用数学公式表示: 我们可以将其套用在 9\-20 上:

1
2
9 = -(9 + 1) = -10
~(-20) = -((-20) + 1) = 19

这个规律也可以作用于数字 0 上,即 ~0 = -(0 + 1) = -1

左移运算

左移运算将数对应的二进位全部向左移动若干位,高位丢弃,低位补 0。左移运算的运算符为 <<。举个例子,将数字 5 左移 4 位,其实是将数字 5 对应的二进制 0000 0101 中的二进位向左移动 4 位,即:

1
2
3
4
5 << 4
= 0000 0101 << 4
= 0101 0000 # 高位丢弃,低位补 0
= 80

数字 5 左移 4 位的完整运算过程如下图: 最终结果为 80。这等效于: 也就是说,左移运算的规律为:

右移运算

右移运算将数对应的二进位全部向右移动若干位。对于左边的空位,如果是正数则补 0,负数可能补 01 (Turbo C 和很多编译器选择补 1)。右移运算的运算符为 \>>。举个例子,将数字 80 右移 4 位,其实是将数字 80 对应的二进制 0101 0000 中的二进位向右移动 4 位,即:

1
2
3
4
80 >> 4
= 0101 0000 >> 4
= 0000 0101 # 正数补0,负数补1
= 5

最终结果为 5。这等效于: 也就是说,右移运算的规律为: 要注意的是,不能整除时,取整数。这中除法取整的规则类似于 PYTHON 语言中的地板除。

超酷人生 我用 Rust 韦世东|奎因 邀请你关注微信公众号:Rust之禅

位运算的应用

在掌握了位运算的知识后,我们可以在开发中尝试使用它。坊间一直流传着位运算的效率高,速度快,但从未见过文献证明,所以本文不讨论效率和速度的问题。如果正在阅读文章的你有相关文献,请留言告知,谢谢。 判断数字奇偶 通常,我们会通过取余来判断数字是奇数还是偶数。例如判断 101 的奇偶用的方法是:

1
2
3
4
5
# python
if 101 % 2:
print('偶数')
else:
print('奇数')

我们也可以通过位运算中的按位与来实现奇偶判断,例如:

1
2
3
4
5
# python
if 101 & 1:
print('奇数')
else:
print('偶数')

这是因为奇数的二进制最低位始终为 1,而偶数的二进制最低为始终为 0。所以,无论任何奇数与 10000 0001 相与得到的都是 1,任何偶数与其相与得到的都是 0变量交换 在 C 语言中,两个变量的交换必须通过第三个变量来实现。伪代码如下:

1
2
3
4
5
6
7
# 伪代码
a = 3, b = 5
c = a
a = b
b = a
--------
a = 5, b = 3

在 PYTHON 语言中并没有这么麻烦,可以直接交换。对应的 PYTHON 代码如下:

1
2
3
4
# python
a, b = 3, 5
a, b = b, a
print(a, b)

代码运行结果为 5 3。但大部分编程语言都不支持 PYTHON 这种写法,在这种情况下我们可以通过位运算中的按位异或来实现变量的交换。对应的伪代码如下:

1
2
3
4
5
# 伪代码
a = 3, b = 5
a = a ^ b
b = a ^ b
a = a ^ b

最后,a = 5, b = 3。我们可以用 C 语言和 PYTHON 语言进行验证,对应的 PYTHON 代码如下:

1
2
3
4
5
6
# python
a, b = 3, 5
a = a ^ b
b = a ^ b
a = a ^ b
print(a, b)

代码运行结果为 5 3,说明变量交换成功。对应的 C 代码如下:

1
2
3
4
5
6
7
8
9
10
#include<stdio.h>
void main()
{
int a = 3, b = 5;
printf("交换前:a=%d , b=%dn",a,b);
a = a^b;
b = a^b;
a = a^b;
printf("交换后:a=%d , b=%dn",a, b);
}

代码运行结果如下:

1
2
交换前:a=3 , b=5
交换后:a=5 , b=3

这说明变量交换成功。 求 x 与 2 的 n 次方乘积 设一个数为 x,求 x2n 次方乘积。这用数学来计算都是非常简单的: 在位运算中,要实现这个需求只需要用到左移运算,即 x << n取 x 的第 k 位 即取数字 x 对应的二进制的第 k 位上的二进制值。假设数字为 5,其对应的二进制为 0000 0101,取第 k 位二进制值的位运算为 x >> k & 1。我们可以用 PYTHON 代码进行验证:

1
2
3
4
# python
x = 5 # 0000 0101
for i in range(8):
print(x >> i & 1)

代码运行结果如下:

1
2
3
4
5
6
7
8
1
0
1
0
0
0
0
0

这说明位运算的算法是正确的,可以满足我们的需求。 判断赋值

1
2
3
4
if a == x:
x = b
else:
x = a

等效于 x = a ^ b ^ x。我们可以通过 PYTHON 代码来验证:

1
2
3
4
5
6
7
# python
a, b, x = 6, 9, 6
if a == x:
x = b
else:
x = a
print(a, b, x)

代码运行结果为 699,与之等效的代码如下:

1
2
3
4
# python
a, b, x = 6, 9, 6
x = a ^ b ^ x
print(a, b, x)

这样就省去了 if else 的判断语句。 代替地板除 二分查找是最常用的算法之一,但它有一定的前提条件:二分查找的目标必须采用顺序存储结构,且元素有序排列。例如 PYTHON 中的有序列表。二分查找的最优复杂度为 O(1),最差时间复杂度为 O(log n)。举个例子,假设我们需要从列表 [1, 3, 5, 6, 7, 8, 12, 22, 23, 43, 65, 76, 90, 543] 中找到指定元素的下标,对应的 PYTHON 代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# python
def search(lis: list, x: int) -> int:
"""非递归二分查找
返回指定元素在列表中的索引
-1 代表不存在"""
mix_index = 0
max_index = len(lis) - 1
while mix_index <= max_index:
midpoint = (mix_index + max_index) // 2
if lis[midpoint] < x:
mix_index = mix_index + 1
elif lis[midpoint] > x:
max_index = max_index - 1
else:
return midpoint
return -1

lists = [1, 3, 5, 6, 7, 8, 12, 22, 23, 43, 65, 76, 90, 543]
res = search(lists, 76)
print(res)

在取列表中间值时使用的语句是 midpoint = (mix_index + max_index) // 2,即地板除,我们可以将其替换为 midpoint = (mix_index + max_index) >> 1 最终得到的结果是相同的。这是因为左移 1位 等效于乘以 2,而右移 1 位等效于除以 2。这样的案例还有很多,此处不再赘述。 至此,我们已经对位运算有了一定的了解,希望你在工作中使用位运算。更多 Saoperation 和知识请扫描下方二维码。

Python

本节主要内容有:

  • 通过requests库模拟表单提交
  • 通过pandas库提取网页表格

上周五,大师兄发给我一个网址,哭哭啼啼地求我:“去!把这个网页上所有年所有县所有作物的数据全爬下来,存到Access里!” 我看他可怜,勉为其难地挥挥手说:“好嘞,马上就开始!”

目标分析

大师兄给我的网址是这个:https://www.ctic.org/crm?tdsourcetag=s_pctim_aiomsg 打开长这样: 根据我学爬虫并不久的经验,通常只要把年月日之类的参数附加到url里面去,然后用requests.get拿到response解析html就完了,所以这次应该也差不多——除了要先想办法获得具体有哪些年份、地名、作物名称,其他部分拿以前的代码稍微改改就能用了,毫无挑战性工作,生活真是太无聊了 点击 View Summary 后出现目标网页长这样 那个大表格的数据就是目标数据了,好像没什么了不起的—— 有点不对劲 目标数据所在网页的网址是这样的:https://www.ctic.org/crm/?action=result ,刚刚选择的那些参数并没有作为url的参数啊!网址网页都变了,所以也不是ajax 这和我想象的情况有巨大差别啊

尝试获取目标页面

让我来康康点击View Summary这个按钮时到底发生了啥:右键View Summary检查是这样: 实话说,这是我第一次遇到要提交表单的活儿。以前可能是上天眷顾我,统统get就能搞定,今天终于让我碰上一个post了。 点击View Summary,到DevTools里找network第一条: 不管三七二十一,post一下试试看

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import requests

url = 'https://www.ctic.org/crm?tdsourcetag=s_pctim_aiomsg'
headers = {'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) '
'AppleWebKit/537.36 (KHTML, like Gecko) '
'Chrome/74.0.3729.131 Safari/537.36',
'Host': 'www.ctic.org'}
data = {'_csrf': 'SjFKLWxVVkkaSRBYQWYYCA1TMG8iYR8ReUYcSj04Jh4EBzIdBGwmLw==',
'CRMSearchForm[year]': '2011',
'CRMSearchForm[format]': 'Acres',
'CRMSearchForm[area]': 'County',
'CRMSearchForm[region]': 'Midwest',
'CRMSearchForm[state]': 'IL',
'CRMSearchForm[county]': 'Adams',
'CRMSearchForm[crop_type]': 'All',
'summary': 'county'}
response = requests.post(url, data=data, headers=headers)
print(response.status_code)

果不其然,输出400……我猜这就是传说中的cookies在搞鬼吗?《Python3网络爬虫实战》只看到第6章的我不禁有些心虚跃跃欲试呢! 首先,我搞不清cookies具体是啥,只知道它是用来维持会话的,应该来自于第一次get,搞出来看看先:

1
2
3
4
response1 = requests.get(url, headers=headers)
if response1.status_code == 200:
cookies = response1.cookies
print(cookies)

输出:

1
<RequestsCookieJar[<Cookie PHPSESSID=52asgghnqsntitqd7c8dqesgh6 for www.ctic.org/>, <Cookie _csrf=2571c72a4ca9699915ea4037b967827150715252de98ea2173b162fa376bad33s%3A32%3A%22TAhjwgNo5ElZzV55k3DMeFoc5TWrEmXj%22%3B for www.ctic.org/>]>

Nah,看不懂,不看不管,直接把它放到post里试试

1
2
response2 = requests.post(url, data=data, headers=headers, cookies=cookies)
print(response2.status_code)

还是400,气氛突然变得有些焦灼,我给你cookies了啊,你还想要啥?! 突然,我发现一件事:post请求所带的data中那个一开始就显得很可疑的_csrf我仿佛在哪儿见过? 那个我完全看不懂的cookies里好像就有一个_csrf啊!但是两个_csrf的值很明显结构不一样,试了一下把data里的_csrf换成cookies里的_csrf确实也不行。 但是我逐渐有了一个想法:这个两个_csrf虽然不相等,但是应该是匹配的,我刚刚的data来自浏览器,cookies来自python程序,所以不匹配! 于是我又点开浏览器的DevTools,Ctrl+F搜索了一下,嘿嘿,发现了: 这三处。 第一处那里的下一行的csrf_token很明显就是post请求所带的data里的_csrf,另外两个是js里的函数,虽然js没好好学但也能看出来这俩是通过post请求获得州名和县名的,Binggo!一下子解决两个问题。 为了验证我的猜想,我打算先直接用requests获取点击View Summary前的页面的HTML和cookies,将从HTML中提取的csrf_token值作为点击View Summarypost请求的data里的_csrf值,同时附上cookies,这样两处_csrf就应该是匹配的了:

1
2
3
4
5
6
7
8
from lxml import etree
response1 = requests.get(url, headers=headers)
cookies = response1.cookies
html = etree.HTML(response1.text)
csrf_token = html.xpath('/html/head/meta[3]/@content')[0]
data.update({'_csrf': csrf_token})
response2 = requests.post(url, data=data, headers=headers, cookies=cookies)
print(response2.status_code)

输出200,虽然和Chrome显示的302不一样,但是也表示成功,那就不管了。把response2.text写入html文件打开看是这样: Yeah,数据都在!说明我的猜想是对的!那一会再试试我从没用过的requests.Session()维持会话,自动处理cookies

尝试pandas库提取网页表格

现在既然已经拿到了目标页面的HTML,那在获取所有年、地区、州名、县名之前,先测试一下pandas.read_html提取网页表格的功能。 pandas.read_html这个函数时在写代码时IDE自动补全下拉列表里瞄到的,一直想试试来着,今天乘机拉出来溜溜:

1
2
3
import pandas as pd
df = pd.read_html(response2.text)[0]
print(df)

输出: Yeah!拿到了,确实比自己手写提取方便,而且数值字符串自动转成数值,优秀!

准备所有参数

接下来要获取所有年、地区、州名、县名。年份和地区是写死在HTML里的,直接xpath获取: 州名、县名根据之前发现的两个js函数,要用post请求来获得,其中州名要根据地区名获取,县名要根据州名获取,套两层循环就行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
def new():
session = requests.Session()
response = session.get(url=url, headers=headers)
html = etree.HTML(response.text)
return session, html

session, html = new()
years = html.xpath('//*[@id="crmsearchform-year"]/option/text()')
regions = html.xpath('//*[@id="crmsearchform-region"]/option/text()')
_csrf = html.xpath('/html/head/meta[3]/@content')[0]
region_state = {}
state_county = {}
for region in regions:
data = {'region': region, '_csrf': _csrf}
response = session.post(url_state, data=data)
html = etree.HTML(response.json())
region_state[region] = {x: y for x, y in
zip(html.xpath('//option/@value'),
html.xpath('//option/text()'))}
for state in region_state[region]:
data = {'state': state, '_csrf': _csrf}
response = session.post(url_county, data=data)
html = etree.HTML(response.json())
state_county[state] = html.xpath('//option/@value')

啧啧,使用requests.Session就完全不需要自己管理cookies了,方便!具体获得的州名县名就不放出来了,实在太多了。然后把所有年、地区、州名、县名的可能组合先整理成csv文件,一会直接从csv里读取并构造post请求的data字典:

1
2
3
4
5
6
7
8
9
10
11
12
remain = [[str(year), str(region), str(state), str(county)] 
for year in years for region in regions
for state in region_state[region] for county in state_county[state]]
remain = pd.DataFrame(remain, columns=['CRMSearchForm[year]',
'CRMSearchForm[region]',
'CRMSearchForm[state]',
'CRMSearchForm[county]'])
remain.to_csv('remain.csv', index=False)
# 由于州名有缩写和全称,也本地保存一份
import json
with open('region_state.json', 'w') as json_file:
json.dump(region_state, json_file, indent=4)

我看了一下,一共49473行——也就是说至少要发送49473个post请求才能爬完全部数据,纯手工获取的话大概要点击十倍这个数字的次数……

正式开始

那么开始爬咯

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
import pyodbc
with open("region_state.json") as json_file:
region_state = json.load(json_file)
data = pd.read_csv('remain.csv')
# 读取已经爬取的
cnxn = pyodbc.connect('DRIVER={Microsoft Access Driver (*.mdb, *.accdb)};'
'DBQ=./ctic_crm.accdb')
crsr = cnxn.cursor()
crsr.execute('select Year_, Region, State, County from ctic_crm')
done = crsr.fetchall()
done = [list(x) for x in done]
done = pd.DataFrame([list(x) for x in done], columns=['CRMSearchForm[year]',
'CRMSearchForm[region]',
'CRMSearchForm[state]',
'CRMSearchForm[county]'])
done['CRMSearchForm[year]'] = done['CRMSearchForm[year]'].astype('int64')
state2st = {y: x for z in region_state.values() for x, y in z.items()}
done['CRMSearchForm[state]'] = [state2st[x]
for x in done['CRMSearchForm[state]']]
# 排除已经爬取的
remain = data.append(done)
remain = remain.drop_duplicates(keep=False)
total = len(remain)
print(f'{total} left.n')
del data

# %%
remain['CRMSearchForm[year]'] = remain['CRMSearchForm[year]'].astype('str')
columns = ['Crop',
'Total_Planted_Acres',
'Conservation_Tillage_No_Till',
'Conservation_Tillage_Ridge_Till',
'Conservation_Tillage_Mulch_Till',
'Conservation_Tillage_Total',
'Other_Tillage_Practices_Reduced_Till15_30_Residue',
'Other_Tillage_Practices_Conventional_Till0_15_Residue']
fields = ['Year_', 'Units', 'Area', 'Region', 'State', 'County'] + columns
data = {'CRMSearchForm[format]': 'Acres',
'CRMSearchForm[area]': 'County',
'CRMSearchForm[crop_type]': 'All',
'summary': 'county'}
headers = {'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) '
'AppleWebKit/537.36 (KHTML, like Gecko) '
'Chrome/74.0.3729.131 Safari/537.36',
'Host': 'www.ctic.org',
'Upgrade-Insecure-Requests': '1',
'DNT': '1',
'Connection': 'keep-alive'}
url = 'https://www.ctic.org/crm?tdsourcetag=s_pctim_aiomsg'
headers2 = headers.copy()
headers2 = headers2.update({'Referer': url,
'Origin': 'https://www.ctic.org'})
def new():
session = requests.Session()
response = session.get(url=url, headers=headers)
html = etree.HTML(response.text)
_csrf = html.xpath('/html/head/meta[3]/@content')[0]
return session, _csrf
session, _csrf = new()
for _, row in remain.iterrows():
temp = dict(row)
data.update(temp)
data.update({'_csrf': _csrf})
while True:
try:
response = session.post(url, data=data, headers=headers2, timeout=15)
break
except Exception as e:
session.close()
print(e)
print('nSleep 30s.n')
time.sleep(30)
session, _csrf = new()
data.update({'_csrf': _csrf})

df = pd.read_html(response.text)[0].dropna(how='all')
df.columns = columns
df['Year_'] = int(temp['CRMSearchForm[year]'])
df['Units'] = 'Acres'
df['Area'] = 'County'
df['Region'] = temp['CRMSearchForm[region]']
df['State'] = region_state[temp['CRMSearchForm[region]']][temp['CRMSearchForm[state]']]
df['County'] = temp['CRMSearchForm[county]']
df = df.reindex(columns=fields)
for record in df.itertuples(index=False):
tuple_record = tuple(record)
sql_insert = f'INSERT INTO ctic_crm VALUES {tuple_record}'
sql_insert = sql_insert.replace(', nan,', ', null,')
crsr.execute(sql_insert)
crsr.commit()
print(total, row.to_list())
total -= 1
else:
print('Done!')
crsr.close()
cnxn.close()

注意中间有个try...except..语句,是因为不定时会发生Connection aborted的错误,有时9000次才断一次,有时一次就断,这也是我加上了读取已经爬取的排除已经爬取的原因,而且担心被识别出爬虫,把headers写的丰富了一些(好像并没有什么卵用),并且每次断开都暂停个30s并重新开一个会话 然后把程序开着过了一个周末,命令行里终于打出了Done!,到Access里一看有816288条记录,心想:下次试试多线程(进程)和代理池。


周一,我把跑出来的数据发给大师兄,大师兄回我:“好的”。 隔着屏幕我都能感受到滔滔不绝的敬仰和感激之情, 一直到现在,大师兄都感动地说不出话来。

JavaScript

前言

本篇博文来自一次公司内部的前端分享,从多个方面讨论了在设计接口时遵循的原则,总共包含了七个大块。系卤煮自己总结的一些经验和教训。本篇博文同时也参考了其他一些文章,相关地址会在后面贴出来。很难做到详尽充实,如果有好的建议或者不对的地方,还望不吝赐教斧正。

一、接口的流畅性

好的接口是流畅易懂的,他主要体现如下几个方面: 1.简单 操作某个元素的css属性,下面是原生的方法:

1
document.querySelector('#id').style.color = 'red';

封装之后

1
2
3
4
function a(selector, color) {
document.querySelector(selector).style.color = color
}
a('#a', 'red');

从几十个字母长长的一行到简简单单的一个函数调用,体现了api设计原则之一:简单易用。 2.可阅读性 a(‘#a’, ‘red’)是个好函数,帮助我们简单实用地改变某个元素,但问题来了,如果第一次使用该函数的人来说会比较困惑,a函数是啥函数,没有人告诉他。开发接口有必要知道一点,大多数人都是懒惰的(包括卤煮自己),从颜色赋值这个函数来说,虽然少写了代码,但是增加了单词字母的个数,使得它不再好记。每次做这件事情的时候都需要有映射关系: a—->color. 如果是简单的几个api倒是无所谓,但是通常一套框架都有几十甚至上百的api,映射成本增加会使得程序员哥哥崩溃。 我们需要的就是使得接口名称有意义,下面我们改写一下a函数:

1
2
function letSomeElementChangeColor(selector, color) {
document.querySelectorAll(selector, color).style.color = color; }

letSomeElementChangeColor相对于a来说被赋予了现实语言上的意义,任何人都不需要看说明也能知道它的功能。 3.减少记忆成本 我们刚刚的函数太长了,letSomeElementChangeColor虽然减少了映射成本,有了语言上的意义,但是毫无疑问增加了记忆成本。要知道,包括学霸在内,任何人都不喜欢背单词。不仅仅在此处,原生获取dom的api也同样有这个问题: document.getElementsByClassName; document.getElementsByName; document.querySelectorAll;这些api给人的感觉就是单词太长了,虽然他给出的意义是很清晰,然而这种做法是建立在牺牲简易性和简忆性的基础上进行的。于是我们又再次改写这个之前函数

1
2
3
function setColor(selector, color) {
xxxxxxxxxxxx
}

在语言意义不做大的变化前提下,缩减函数名称。使得它易读易记易用。 4.可延伸 所谓延伸就是指函数的使用像流水一样按照书写的顺序执行形成执行链条:

1
2
3
document.getElementById('id').style.color = 'red';
document.getElementById('id').style.fontSize = '12px';
document.getElementById('id').style.backgourdColor = 'pink';

如果我们需要实现像以上有强关联性的业务时,用我们之前的之前的方法是再次封装两个函数 setFontSize, setbackgroundColor; 然后执行它们 setColor(‘id’, ‘red’);setFontSiez(‘id’, ’12px’); setbackgroundColor(‘id’, ‘pink’); 显然,这样的做法没有懒出境界来;id元素每次都需要重新获取,影响性能,失败;每次都需要添加新的方法,失败; 每次还要调用这些方法,还是失败。下面我们将其改写为可以延伸的函数 首先将获取id方法封装成对象,然后再对象的每个方法中返回这个对象:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
function getElement(selector) {
this.style = document.querySelecotrAll(selector).style;
}

getElement.prototype.color = function(color) {
this.style.color = color;
return this;
}
getElement.prototype.background = function(bg) {
this.style.backgroundColor = bg;
return this;
}
getElement.prototype.fontSize = function(size) {
this.style.fontSize = size;
return this;
}

//调用
var el = new getElement('#id')
el.color('red').background('pink').fontSize('12px');

简单、流畅、易读,它们看起来就像行云流水一样,即在代码性能上得到了提升优化,又在视觉上悦目。后面我们会在参数里面讲到如何继续优化。 所以,大家都比较喜欢用jquery的api,虽然一个$符号并不代表任何现实意义,但简单的符号有利于我们的使用。它体现了以上的多种原则,简单,易读,易记,链式写法,多参处理。 nightmare:

1
2
3
document.getElementById('id').style.color = 'red';
document.getElementById('id').style.fontSize = '12px';
document.getElementById('id').style.backgourdColor = 'pink';

dream:

1
$('id').css({color:'red', fontSize:'12px', backgroundColor:'pink'})

二、一致性

1.接口的一致性 相关的接口保持一致的风格,一整套 API 如果传递一种熟悉和舒适的感觉,会大大减轻开发者对新工具的适应性。 命名这点事:既要短,又要自描述,最重要的是保持一致性 “在计算机科学界只有两件头疼的事:缓存失效和命名问题” — Phil Karlton 选择一个你喜欢的措辞,然后持续使用。选择一种风格,然后保持这种风格。 Nightmare:

1
2
3
4
setColor,
letBackGround
changefontSize
makedisplay

dream:

1
2
3
4
setColor;
setBackground;
setFontSize
set.........

尽量地保持代码风格和命名风格,使别人读你的代码像是阅读同一个人写的文章一样。

三、参数的处理

1.参数的类型 判断参数的类型为你的程序提供稳定的保障

1
2
3
4
5
//我们规定,color接受字符串类型
function setColor(color) {
if(typeof color !== 'string') return;
dosomething
}

2.使用json方式传参 使用json的方式传值很多好处,它可以给参数命名,可以忽略参数的具体位置,可以给参数默认值等等 比如下面这种糟糕的情况:

1
function fn(param1, param2...............paramN)

你必须对应地把每一个参数按照顺序传入,否则你的方法就会偏离你预期去执行,正确的方法是下面的做法。

1
2
3
4
5
6
7
8
function fn(json) {
//为必须的参数设置默认值
var default = extend({
param: 'default',
param1: 'default'
......
},json)
}

这段函数代码,即便你不传任何参数进来,他也会预期运行。因为在声明的时候,你会根据具体的业务预先决定参数的缺省值。

四、可扩展性

软件设计最重要的原则之一:永远不修改接口,而是去扩展它!可扩展性同时会要求接口的职责单一,多职责的接口很难扩展。 举个栗子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//需要同时改变某个元素的字体和背景
// Nightmare:
function set(selector, color) {
document.querySelectroAll(selector).style.color = color;
document.querySelectroAll(selector).style.backgroundColor = color;
}

//无法扩展改函数,如果需要再次改变字体的大小的话,只能修改此函数,在函数后面填加改变字体大小的代码

//Dream
function set(selector, color) {
var el = document.querySelectroAll(selector);
el.style.color = color;
el.style.backgroundColor = color;
return el;
}

//需要设置字体、背景颜色和大小
function setAgain (selector, color, px) {
var el = set(selector, color)
el.style.fontSize = px;
return el;
}

以上只是简单的添加颜色,业务复杂而代码又不是你写的时候,你就必须去阅读之前的代码再修改它,显然是不符合开放-封闭原则的。修改后的function是返回了元素对象,使得下次需要改变时再次得到返回值做处理。 2.this的运用 可扩展性还包括对this的以及call和apply方法的灵活运用:

1
2
3
4
5
6
7
8
9
function sayBonjour() {
alert(this.a)
}

obj.a = 1;
obj.say = sayBonjour;
obj.say();//1
//or
sayBonjour.call||apply(obj);//1

五、对错误的处理

1.预见错误 可以用 类型检测 typeof 或者try…catch。 typeof 会强制检测对象不抛出错误,对于未定义的变量尤其有用。 2.抛出错误 大多数开发者不希望出错了还需要自己去找带对应得代码,最好方式是直接在console中输出,告诉用户发生了什么事情。我们可以用到浏览器为我们提供的api输出这些信息:console.log/warn/error。你还可以为自己的程序留些后路: try…catch。

1
2
3
4
5
6
7
8
9
10
11
12
13
function error (a) {
if(typeof a !== 'string') {
console.error('param a must be type of string')
}
}

function error() {
try {
// some code excucete here maybe throw wrong
}catch(ex) {
console.wran(ex);
}
}

六、可预见性

可预见性味程序接口提供健壮性,为保证你的代码顺利执行,必须为它考虑到非正常预期的情况。我们看下不可以预见的代码和可预见的代码的区别用之前的setColor

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
//nighware
function set(selector, color) {
document.getElementById(selector).style.color = color;
}

//dream
zepto.init = function(selector, context) {
var dom
// If nothing given, return an empty Zepto collection
if (!selector) return zepto.Z()
// Optimize for string selectors
else if (typeof selector == 'string') {
selector = selector.trim()
// If it's a html fragment, create nodes from it
// Note: In both Chrome 21 and Firefox 15, DOM error 12
// is thrown if the fragment doesn't begin with <
if (selector[0] == '<' && fragmentRE.test(selector))
dom = zepto.fragment(selector, RegExp.$1, context), selector = null
// If there's a context, create a collection on that context first, and select
// nodes from there
else if (context !== undefined) return $(context).find(selector)
// If it's a CSS selector, use it to select nodes.
else dom = zepto.qsa(document, selector)
}
// If a function is given, call it when the DOM is ready
else if (isFunction(selector)) return $(document).ready(selector)
// If a Zepto collection is given, just return it
else if (zepto.isZ(selector)) return selector
else {
// normalize array if an array of nodes is given
if (isArray(selector)) dom = compact(selector)
// Wrap DOM nodes.
else if (isObject(selector))
dom = [selector], selector = null
// If it's a html fragment, create nodes from it
else if (fragmentRE.test(selector))
dom = zepto.fragment(selector.trim(), RegExp.$1, context), selector = null
// If there's a context, create a collection on that context first, and select
// nodes from there
else if (context !== undefined) return $(context).find(selector)
// And last but no least, if it's a CSS selector, use it to select nodes.
else dom = zepto.qsa(document, selector)
}
// create a new Zepto collection from the nodes found
return zepto.Z(dom, selector)
}

以上是zepto的源码,可以看见,作者在预见传入的参数时做了很多的处理。其实可预见性是为程序提供了若干的入口,无非是一些逻辑判断而已。zepto在这里使用了很多的是非判断,这样做的好处当然是代码比之前更健壮,但同时导致了代码的冗长,不适合阅读。总之,可预见性真正需要你做的事多写一些对位置实物的参数。把外部的检测改为内部检测。是的使用的人用起来舒心放心开心。呐!做人嘛最重要的就是海森啦。

七、注释和文档的可读性

一个最好的接口是不需要文档我们也会使用它,但是往往接口量一多和业务增加,接口使用起来也会有些费劲。所以接口文档和注释是需要认真书写的。注释遵循简单扼要地原则,给多年后的自己也给后来者看:

1
2
3
4
5
6
7
8
9
10
//注释接口,为了演示PPT用
function commentary() {
//如果你定义一个没有字面意义的变量时,最好为它写上注释:a:没用的变量,可以删除
var a;

//在关键和有歧义的地方写上注释,犹如画龙点睛:路由到hash界面后将所有的数据清空结束函数
return go.Navigate('hash', function(){
data.clear();
});
}

最后

推荐markdown语法书写API文档,github御用文档编写语法。简单、快速,代码高亮、话不多说上图 卤煮在此也推荐几个在线编辑的网站。诸君可自行前往练习使用。 https://www.zybuluo.com/mdeditor http://mahua.jser.me/

参考博文

前端头条-javascript的api设计原则 原文:http://www.cnblogs.com/constantince/p/5580003.html

JavaScript

在这篇文章中,我们将介绍一些用于AJAX调用的最好的JS库,包括jQuery,Axios和Fetch。欢迎查看代码示例! AJAX是用来对服务器进行异步HTTP调用的一系列web开发技术客户端框架。 AJAX即Asynchronous JavaScript and XML(异步JavaScript和XML)。AJAX曾是web开发界的一个常见名称,许多流行的JavaScript小部件都是使用AJAX构建的。例如,有些特定的用户交互(如按下按钮)会异步调用到服务器,服务器会检索数据并将其返回给客户端——所有这些都不需要重新加载网页。

AJAX的现代化重新引入

JavaScript已经进化了,现在我们使用前端库和/或如React、Angular、Vue等框架构建了动态的网站。AJAX的概念也经历了重大变化,因为现代异步JavaScript调用涉及检索JSON而不是XML。有很多库允许你从客户端应用程序对服务器进行异步调用。有些进入到浏览器标准,有些则有很大的用户基础,因为它们不但灵活而且易于使用。有些支持promises,有些则使用回调。在本文中,我将介绍用于从服务器获取数据的前5个AJAX库。

Fetch API

Fetch API是XMLHttpRequest的现代替代品,用于从服务器检索资源。与XMLHttpRequest不同的是,它具有更强大的功能集和更有意义的命名。基于其语法和结构,Fetch不但灵活而且易于使用。但是,与其他AJAX HTTP库区别开来的是,它具有所有现代Web浏览器的支持。Fetch遵循请求-响应的方法,也就是说,Fetch提出请求并返回解析到Response对象的promise。 你可以传递Request对象来获取,或者,也可以仅传递要获取的资源的URL。下面的示例演示了使用Fetch创建简单的GET请求。

1
2
3
4
5
6
7
8
fetch('https://www.example.com', {
method: 'get'
})
.then(response => response.json())
.then(jsonData => console.log(jsonData))
.catch(err => {
//error block
})

正如你所看到的,Fetch的then方法返回了一个响应对象,你可以使用一系列的then 进行进一步的操作。我使用.json() 方法将响应转换为JSON并将其输出到控制台。 假如你需要POST表单数据或使用Fetch创建AJAX文件上传,将会怎么样?此时,除了Fetch之外,你还需要一个输入表单,并使用FormData库来存储表单对象。

1
2
3
4
5
6
7
8
var input = document.querySelector('input[type="file"]')
var data = new FormData()
data.append('file', input.files[0])
data.append('user', 'blizzerand')
fetch('/avatars', {
method: 'POST',
body: data
})

你可以在官方的Mozilla web文档中阅读更多关于Fetch API的信息。

Axios

Axios是一个基于XMLHttpRequest而构建的现代JavaScript库,用于进行AJAX调用。它允许你从浏览器和服务器发出HTTP请求。此外,它还支持ES6原生的Promise API。Axios的其他突出特点包括:

  • 拦截请求和响应。
  • 使用promise转换请求和响应数据。
  • 自动转换JSON数据。
  • 取消实时请求。

要使用Axios,你需要先安装它。

1
npm install axios

下面是一个演示Axios行动的基本例子。

1
2
3
4
5
6
7
8
// Make a request for a user with a given ID
axios.get('/user?ID=12345')
.then(function (response) {
console.log(response);
})
.catch(function (error) {
console.log(error);
});

与Fetch相比,Axios的语法更简单。让我们做一些更复杂的事情,比如我们之前使用Fetch创建的AJAX文件上传器。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
var data = new FormData();
data.append('foo', 'bar');
data.append('file', document.getElementById('file').files[0]);
var config = {
onUploadProgress: function(progressEvent) {
var percentCompleted = Math.round( (progressEvent.loaded * 100) / progressEvent.total );
}
};
axios.put('/upload/server', data, config)
.then(function (res) {
output.className = 'container';
output.innerHTML = res.data;
})
.catch(function (err) {
output.className = 'container text-danger';
output.innerHTML = err.message;
});

Axios更具可读性。Axios也非常受React和Vue等现代库的欢迎。

jQuery

jQuery曾经是JavaScript中的一个前线库,用于处理从AJAX调用到操纵DOM内容的所有事情。虽然随着其他前端库的“冲击”,其相关性有所降低,但你仍然可以使用jQuery来进行异步调用。 如果你之前使用过jQuery,那么这可能是最简单的解决方案。但是,你将不得不导入整个jQuery库以使用$.ajax方法。虽然这个库有特定于域的方法,例如$.getJSON,$.get和$.post,但是其语法并不像其他的AJAX库那么简单。以下代码用于编写基本的GET请求。

1
2
3
4
5
6
7
8
9
10
11
$.ajax({
url: '/users',
type: "GET",
dataType: "json",
success: function (data) {
console.log(data);
}
fail: function () {
console.log("Encountered an error")
}
});

jQuery好的地方在于,如果你有疑问,那么你可以找到大量的支持和文档。我发现了很多使用FormData()和jQuery进行AJAX文件上传的例子。下面是最简单的方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
var formData = new FormData();
formData.append('file', $('#file')[0].files[0]);
$.ajax({
url : 'upload.php',
type : 'POST',
data : formData,
processData: false, // tell jQuery not to process the data
contentType: false, // tell jQuery not to set contentType
success : function(data) {
console.log(data);
alert(data);
}
});

SuperAgent

SuperAgent是一个轻量级和渐进式的AJAX库,更侧重于可读性和灵活性。SuperAgent还拥有一个温和的学习曲线,不像其他库。它有一个针对Node.js API相同的模块。SuperAgent有一个接受GET、POST、PUT、DELETE和HEAD等方法的请求对象。然后你可以调用.then(),.end()或新的.await()方法来处理响应。例如,以下代码为使用SuperAgent的简单GET请求。

1
2
3
4
5
6
7
8
request
.post('/api/pet')
.send({ name: 'Manny', species: 'cat' })
.set('X-API-Key', 'foobar')
.set('Accept', 'application/json')
.then(function(res) {
alert('yay got ' + JSON.stringify(res.body));
});

如果你想要做更多的事情,比如使用此AJAX库上传文件,那该怎么做呢? 同样超级easy。

1
2
3
4
5
6
7
request
.post('/upload')
.field('user[name]', 'Tobi')
.field('user[email]', 'tobi@learnboost.com')
.field('friends[]', ['loki', 'jane'])
.attach('image', 'path/to/tobi.png')
.then(callback);

如果你有兴趣了解更多关于SuperAgent的信息,那么它们有一系列很不错的文档来帮助你开始这个旅程。

Request——简化的HTTP客户端

Request库是进行HTTP调用最简单的方法之一。结构和语法与在Node.js中处理请求的方式非常相似。目前,该项目在GitHub上有18K个星,值得一提的是,它是可用的最流行的HTTP库之一。 下面是一个例子:

1
2
3
4
5
6
var request = require('request');
request('http://www.google.com', function (error, response, body) {
console.log('error:', error); // Print the error if one occurred
console.log('statusCode:', response && response.statusCode); // Print the response status code if a response was received
console.log('body:', body); // Print the HTML for the Google homepage.
});

结论

从客户端进行HTTP调用在十年前可不是一件容易的事。前端开发人员不得不依赖于难以使用和实现的XMLHttpRequest。现代的库和HTTP客户端使得用户交互、动画、异步文件上传等前端功能变得更加简单。 我个人最喜欢的是Axios,因为我觉得它更易读更赏心悦目。你也可以忠于Fetch,因为它文档化良好且有标准化的解决方案。 你个人最喜欢的AJAX库是哪个? 欢迎各位分享你的看法。

  • 译文链接:http://www.codeceo.com/article/5-javascript-ajax-libs.html
  • 英文原文:Top JavaScript Libraries for Making AJAX Calls
  • 翻译作者:码农网 – 小峰

JavaScript

简评:一开始 JavaScript 只是为网页增添一些实时动画效果,现在 JS 已经能做到前后端通吃了,而且还是年度流行语言。本文分享几则 JS 小窍门,可以让你事半功倍 ~

1. 删除数组尾部元素

一个简单方法就是改变数组的length值:

1
2
3
4
5
6
7
8
const arr = [11, 22, 33, 44, 55, 66];
// truncanting
arr.length = 3;
console.log(arr); //=> [11, 22, 33]
// clearing
arr.length = 0;
console.log(arr); //=> []
console.log(arr[2]); //=> undefined

2. 使用对象解构(object destructuring)来模拟命名参数

如果需要将一系列可选项作为参数传入函数,你很可能会使用对象(Object)来定义配置(Config)。

1
2
3
4
5
6
7
doSomething({ foo: 'Hello', bar: 'Hey!', baz: 42 });
function doSomething(config) {
const foo = config.foo !== undefined ? config.foo : 'Hi';
const bar = config.bar !== undefined ? config.bar : 'Yo!';
const baz = config.baz !== undefined ? config.baz : 13;
// ...
}

不过这是一个比较老的方法了,它模拟了 JavaScript 中的命名参数。 在 ES 2015 中,你可以直接使用对象解构:

1
2
3
function doSomething({ foo = 'Hi', bar = 'Yo!', baz = 13 }) {
// ...
}

让参数可选也很简单:

1
2
3
function doSomething({ foo = 'Hi', bar = 'Yo!', baz = 13 } = {}) {
// ...
}

3. 使用对象解构来处理数组

可以使用对象解构的语法来获取数组的元素:

1
2
const csvFileLine = '1997,John Doe,US,john@doe.com,New York';
const { 2: country, 4: state } = csvFileLine.split(',');

4. 在 Switch 语句中使用范围值

可以这样写满足范围值的语句:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
function getWaterState(tempInCelsius) {
let state;

switch (true) {
case (tempInCelsius <= 0):
state = 'Solid';
break;
case (tempInCelsius > 0 && tempInCelsius < 100):
state = 'Liquid';
break;
default:
state = 'Gas';
}
return state;
}

5. await 多个 async 函数

在使用 async/await 的时候,可以使用 Promise.all 来 await 多个 async 函数

1
await Promise.all([anAsyncCall(), thisIsAlsoAsync(), oneMore()])

6. 创建 Pure objects

你可以创建一个 100% pure object,它不从Object中继承任何属性或则方法(比如constructor, toString()等)

1
2
3
4
5
const pureObject = Object.create(null);
console.log(pureObject); //=> {}
console.log(pureObject.constructor); //=> undefined
console.log(pureObject.toString); //=> undefined
console.log(pureObject.hasOwnProperty); //=> undefined

7. 格式化 JSON 代码

JSON.stringify除了可以将一个对象字符化,还可以格式化输出 JSON 对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
const obj = { 
foo: { bar: [11, 22, 33, 44], baz: { bing: true, boom: 'Hello' } }
};
// The third parameter is the number of spaces used to
// beautify the JSON output.
JSON.stringify(obj, null, 4);
// =>"{
// => "foo": {
// => "bar": [
// => 11,
// => 22,
// => 33,
// => 44
// => ],
// => "baz": {
// => "bing": true,
// => "boom": "Hello"
// => }
// => }
// =>}"

8. 从数组中移除重复元素

通过使用集合语法和 Spread 操作,可以很容易将重复的元素移除:

1
2
3
const removeDuplicateItems = arr => [...new Set(arr)];
removeDuplicateItems([42, 'foo', 42, 'foo', true, true]);
//=> [42, "foo", true]

9. 平铺多维数组

使用 Spread 操作平铺嵌套多维数组:

1
2
const arr = [11, [22, 33], [44, 55], 66];
const flatArr = [].concat(...arr); //=> [11, 22, 33, 44, 55, 66]

不过上面的方法仅适用于二维数组,但是通过递归,就可以平铺任意维度的嵌套数组了:

1
2
3
4
5
6
7
8
9
function flattenArray(arr) {
const flattened = [].concat(...arr);
return flattened.some(item => Array.isArray(item)) ?
flattenArray(flattened) : flattened;
}

const arr = [11, [22, 33], [44, [55, 66, [77, [88]], 99]]];
const flatArr = flattenArray(arr);
//=> [11, 22, 33, 44, 55, 66, 77, 88, 99]

希望这些小技巧能帮助你写好 JavaScript ~ 原文:https://zhuanlan.zhihu.com/p/37493249

技术杂谈

现代人都普遍比较焦虑,越来越多的人感到生活压力很大,在一二线城市不少白领人士更是已是患上“知识焦虑症”:这年头知识信息迭代太快,学习跟不上,别人懂的自己都不懂,总感觉自己欠缺的很多,没有技术和专长不知未来靠什么生存,担心自己长期落后他人从而被社会淘汰,从而产生了一种对未来不确定的心理恐惧。 于是,他们就急于渴求,希望能在短时间内学习大量知识希望从根本上解决自己的实际问题,拼命利用碎片化时间学习补充欠缺知识,不断完善自己的知识体系。这时知识付费的出现,正好满足了他们这些刚性需求。 再加上2018年前以逻辑思维为主一批内容供应商到处鼓吹和贩卖知识焦虑,在这种风气影响下连身边的很多小伙伴都购买了大量知识付费产品,但一年下来却发现这些知识根本没有学会几个,内容良莠不齐,服务跟不上,就算能坚持学完下来还是什么都不会,焦虑依然存在 。甚至更多人觉得其实知识付费就是一场骗局,从本质上来说知识付费并没有解决任何的问题,表面上只是缓解了一些焦虑,在短时间内让一些人自我感觉良好,实则上只是自欺欺人而已。 于是,一些感觉被欺骗的用户纷纷发声,对某些知识付费大号和机构更是愤怒抨击,在这些负面影响下这两年知识付费其实已逐渐降温并遭遇爆冷,甚至还有一些负面声音在说: 在线知识付费的寒冬是不是要来临了? 其实不然,纵观当下市场发展态势知识付费的前景仍然是广阔的,竞争激烈程度仍方兴未艾,当人们对知识的盲目消费退烧后,知识付费更多的是回归服务价值, 核心需求有两方面 : 一方面是为了提升欠缺的知识让自己具有更多的市场竞争力,另一方面也希望自己花钱买的知识付费产品是一些真正有帮助的东西,可帮自己迎来一个不错的未来。所以,知识付费的下一阶段必然聚焦于如何让学习用户获得真正有效的学习效果。 那么,知识付费下半场风口到底会吹去哪? 好学豚认为这一领域的大方向以后的发展趋势大致有如下特征:

趋势一:内容下沉,回归有价值的真实内容

1、职场技能

在知识付费领域和在整个教育市场体系里,职场技能都是最刚需的内容板块,从最早的电算会计化到后来的英语类培训,再到如今一些以工具为代表的设计、办公技能、IT编程等等培训,无一不彰显着其旺盛的生命力。 究其根本原因,这是因为它能够切实解决职场人士的实际需求,所以职场技能内容才会一直火爆,繁荣至今仍在蓬勃发展。

2、知识拓展

知识拓展是近年来兴起的版块内容,也是互联网上传播特别广泛的内容。以得到为代表,邀请行业细分领域的专业人士,按照标准的生产流程来生产较高质量的内容,帮助拓广知识的视野从而实现专家指路的效果。不容忽视的是,知识拓展的内容从今天来看存在较大的局限,很难解决用户的实际问题,学习效果也很难得到保证;如何打磨出更加直击用户痛点的产品,需要更多的探索和尝试。

3、兴趣爱好

在线教育领域,兴趣爱好的内容已经有了长足发展。用户的痛点正在逐渐从追求高大上、财务自由这些虚伪的概念转型到享受生活:提 升生活趣味让自己活得更舒服。兴趣爱好内容之所以能生命力如此旺盛,最大因素要得益于其以兴趣为导向,学习者本身并不会有太高的学习结果诉求,更多的是在学习之中获得的乐趣以及对授课老师的认同。

趋势二:后续服务提升,注重全流程效果

今后知识付费需要做好三个关键点的平衡:碎片化学习、学习规模和学习效果,这三者缺一不可。根据业内行家的实践和推断,下一阶段知识付费的标配服务模式将会是1+1+N模式,能较好地实现以上三个关键点的平衡。 第一个“1”代表的是标准化的课程: 这个课程将会以“图文”、“视频”或“音频”形式进行展现,让学习者完成自学。这个“1”满足了碎片化学习的随时随地性,给予了学习者最大限度的自由度,同时也满足了由于学习规模日益扩大而带来的各种问题。 第二个“1”代表的是在线训练营: 就是把线下的集中学习模式搬到线上,开展一段时间的在线集中训练,通过学习流程、学习氛围、学习评估的三位一体运作,从而使学习效果得以达成。总体做法是把所有参与训练营的学员,分成不同的小组,然后配定相应老师。每个学员在学习过程中都需要完成相应作业,然后交给老师进行批改和点评。整个训练营阶段会有实战练习,根据学习者的自身情况或使用真实的案例来进行实战,进而帮助学习者实现学以致用。同时,老师需要对每个学习者进行阶段性评分,在学习完成时要进行总体评估;老师还需要针对小组学习效果进行展示和相应氛围的营造。 最后一个“N”则代表通过科技的力量,实现多种教学辅助手段 :比如老师和学员之间的交互,老师批量布置和批改作业,对学员进行评分和评估,给积极学习者一些奖励等等,所有这些辅助手段,将会让老师和学员之间的交互更紧密,让学习效率更高、让学习流程更完整、学习模式更人性,从而最终达到提升学习效果的目的。

趋势三:更多垂直领域的小KOL将通过工具类平台输出产品

垂直领域的小KOL,他们标签清晰、价值点明确,用户深度认可,反倒更容易突围,甚至可以脱离平台,通过好学豚这类工具就可以完成知识店铺的搭建。而且因为他们有很强的用户沉淀能力,所以也更有动力参与。长期来看,小KOL通过线上虚拟产品输出知识将会成为一个新的趋势。

趋势四:一线城市受众有限,二、三线城市女性用户价值开始受到重视

一线城市对于知识付费产品的承载能力是有限的,据观察主流付费用户都不是一线白领,而是二三线城市的宝妈。她们更愿意在知识上付钱,也愿意分享课程,赚取一定分成。 互联网独角兽的发展规律一再地证明二三线城市的女性是主力消费群体,知识付费也不会逃离这个规律,现在很多母婴类课程、女性个人提升课程、陪伴式励志课程、情商人际关系类课程销量都很不错。这是一个巨大的市场空窗,目前市场上的多数知识付费平台还忽视了二三线城市的用户,电商平台和垂直大号也还没有真正介入这一行业,这个空窗很有可能下一家知识付费独角兽企业崛起的机会。 针对以上趋势,好学豚知识付费平台也正在进行多方面的尝试,希望能把握住这些新的市场机会迎来爆发性增长,对于当下的知识付费从业者来说既是一个巨大的挑战,也是突围而出成为新独角兽企业的机会。 原文:https://www.iyiou.com/p/104850.html

技术杂谈

首先,这篇文章不是一个广告。 但你可能已经要被这个时代无处不在的洗脑广告逼疯了。 大街小巷贴满的纸皮广告、商场和电梯里循环播放的电子屏广告、电脑上避不开关不掉停不了的网页广告…… 某招聘软件和某旅拍公司的循环怒吼式视频让人生理性地记住了它,但心理上可能想把相关人员关电梯里让它们把这条广告看一万遍。 ▲ 图片来自:「伯爵旅拍」广告截图 广告的形式不断在变化,从广播、平面、视频,到 H5、直播,部分广告会以新颖的形式和优质的内容取胜,但人们看广告一直都是被动接受的过程。 上周蜘蛛侠上映,索尼在 Snapchat 上 推出了 AR 活动宣传 ,为了贴合「英雄远征」的主题,索尼让蜘蛛侠「出现」在世界各地的地标处,比如纽约的熨斗大厦、伦敦的白金汉宫、巴黎的艾菲尔铁塔,只要你将自拍镜头对准建筑,就可以看到蜘蛛侠在屏幕上摆动。 ▲图片来自:mobilemarketingmagazine 它让人们愿意看蜘蛛侠的广告,同时也让广告成了一种主动参与的过程。 接下来要讲的,就是未来这一种我们会主动点开的——VR 广告。

当广告变成了一种「真实」的体验

我们看现在的广告,有一种潜意识默认的原则,就是注意力只给它们 3 秒钟。 但现在的 VR 广告,是给你无限的时间,让你自己去体验。 AR 火起来,还是被 2015 年 Snapchat 的搞怪 AR 滤镜,以及 2016 年的神奇宝贝 GO 带动,这也改变了市场营销对 AR 的看法,让 AR 开始在广告界生根发芽。 宜家是首批尝试购买 AR 技术并以此宣传的公司之一。 在 IKEA Place app 中 ,人们可以看到新款家具实际摆放在家里的样子,以判断它们是不是有足够空间布局放置、颜色风格是否和周围环境搭调,这可以帮宜家提高客户满意度以及降低产品退回率。 随后苹果发布了 ARkit 技术,Google、Facebook、亚马逊等大公司也在 2017 年和 2018 年期间发布了自己 AR 软件开发套件,以支持日后 AR 技术的发展。 Facebook 去年就为广告商提供了 展示产品的新方式 ,让人们在新闻流中看到品牌广告时,能够通过前置摄像头对比自己戴上太阳镜等配饰、甚至穿各种衣服的样子。现在 Facebook 也一直在通过各个平台包括 Instagram 扩大购物范围和增值产品。 除了家居服饰,美容时尚等行业也开始尝试利用 AR 营销,主要是为了弥补线上和线下的差距。 两周前,人们已经能在 YouTube 上一边看美妆博主的化妆教程,一边在分屏之下跟着博主一起涂口红试色,这个名为 AR Beauty Try-On 的功能 由 Google 推出,M・A・C 是第一个跟上这项 AR 广告的品牌。测试结果发现,人们愿意花费超过 80 秒的时间去体验虚拟唇膏色调。 甚至当你逛淘宝店,在前几周 天猫旗舰店升级的 2.0 版本,能直接让你像逛线下实体店一样逛线上 3D 商店、参观漫游,每家店铺展示内容也因人而异。 而且,你还可以实地进入 AR 广告之中。 在汽车行业,宝马、保时捷、丰田等汽车品牌都成为了 AR 广告的追随者。 丰田上个月给 2020 年卡罗拉 推出了 AR 移动广告 ,人们可以 360 度全方位观看车内视图和功能,以及固定在一个地方的 3D 数字模型,甚至还可以在车内行走。这能让购买者更简单地了解车辆的技术特性,也有助于在购买车辆前对其预先认证。 这种自然而直观的方式,不仅让人们和品牌建立起更真实的关系,与以往广告最大的不同就是,人们还能随时参与、持续互动,并响应内容。

我们可以拿回看广告的主动权

现在,我们自己可以掌控广告。 目前我们 能看到的 AR 广告 ,主要包括被赞助的拍照滤镜镜头、应用软件和游戏内的 AR 广告单元,信息流内的 AR 广告单元等。 之前是广告「邀请」我们看,没有任何协商。但现在我们「侵入」广告,去满足自己的好奇心。广告变成了一个工具,我们通过它与我们喜欢的品牌获得联系。 这种形式现在也让 AR 广告成为当今市场上破坏性最小的广告单元之一。 ▲ 图片来自:unsplash 另外,AR 广告已经不再是单独的一个内容,而是进入我们的真实生活,或者进入其它我们沉浸的内容之中——广告本身就是商品的展示位,不会再有其它如美化特效、夸张视觉等因素插入和干扰。 而且这些 AR 广告最初打开的阀门,就掌握在消费者手上。 因为 AR 广告现在都需要申请对其相机/设备的访问,在非相机优先的应用中,也需要申请特定权限,因此你完全可以选择你需要的内容,并与之开始进一步互动。 ▲ 图片来自: Cyber Infrastructure 可以说,AR 就是有史以来最强大的故事叙述媒体。它的互动带来的「响应式特色」,就是它最大的优势。 Unity 技术的 AR / VR 广告创新 负责人 Tony Parisi 说 : 响应性 AR 广告是一种更加友好,不那么令人生畏的方法,这些广告能够提高客户的选择率,同时通过控制权来提高用户的舒适度。 尽管 AR 广告现在还不足以吸引大多数用户,人们似乎更觉得这只是消费者的一种自我意淫。 但实际上幸运的是,现在它背后有一批最大的科技公司在支持和推动,这就让更多设计师有机会去创造更好的 AR 广告环境,更多品牌有空间去施放更大的营销活动。 Google、苹果、Facebook 这样的大平台仍然主导着 AR 领域及其营销的发展。这些科技公司还和零售商 组成了一个小组 ,为用于增强现实购物的 3D 图像创建一套通用标准。 ▲ Google 推出名为 Swirl 的沉浸式显示,消费者可以 360 度查看、旋转、放大、缩小商品 在这个背景之下,市场研究公司 Markets and Markets 的数据 预计,到明年 AR 将拥有 10 亿用户,到 2022 年将达到 22 亿美元的广告支出。 AR 广告进入我们的生活将会更加快速,而我们掌握的主动权也会越来越多,正如以色列最大的互联网公司 IronSource 首席设计官 Dan Greenberg 所认为的 : 我们不断研究如何在广告中为用户提供尽可能多的选择的方法。因为给用户提供更多控制权,才是创建真正个性化移动体验的关键。

AR 会是下一个广告形态

数字广告总体上正朝着更丰富、更身临其境、更多选择的方向发展,消费者正在被置于互动体验的中心。 根据 Gartner 的估计 ,随着 5G 高速移动服务的推出,明年它将推动 AR 购物增长到 1 亿消费者。 ▲ 图片来自:unsplash 因为在高速运行的网络下,开发者不仅能够创造更高质量的 3D 可视化技术,消费者也能获得更多形式的沉浸式体验,品牌也能将其购物平台更多扩展到商店和传统网站之外的移动设备上,而且广告也不会再只限于移动设备的小屏幕。 还可以预见的是,5G 网络之下数据信息密度也会迅速加大,除了文本,还有图像、视频,人们接受的购物信息无疑更广、更深、更繁杂,而 AR 能够降低广告的感知成本,让人们消费数字内容将更简便和直观。 ▲ 图片来自:unsplash 但现在 AR 广告还未普及的主要问题,就在于它的成本和技术。 比起其他广告形式来说,其实它的投入成本并不低。Digiday 指出 单一的广告体验 可能需要花费 5,000 到 30,000 美元甚至更多才能正常开发,投资回报率也很难衡量。 而近阶段虽然 AR 技术发展很快,但 5G 手机还刚推出第一批,5G 网络也并未稳定普及,这也是影响 AR 广告现在扩大规模的关键因素——没有与之匹配的设备。另外,比起其它开发多年的其它形式的广告,AR 广告迭代和优化也还不太灵活,并非广告商们信手就可捏来。 ▲ 图片来自:unsplash AR 热潮刚刚开始真正起飞,我们现在看到的只是关于 AR 能带来什么以及它能做些什么的一瞥。不过苹果 2017 年推出 ARKit 时,首席执行官蒂姆・库克在 财报电话会议上就指出 AR 将成为「主流」: 虽然我们现在还只触及冰山一角,但它将永久改变我们使用技术的方式。 而这个未来正在靠近。Digi-Capital 预计在未来五年内 AR 广告的市场价值将达到 830 亿美元。而且下一代移动设备,还会为我们带来更多新的可能性。 折叠手机的柔性屏幕将能让 AR 广告拥有更多形式;内置投影仪的手机,能让 AR 广告用更大的位置呈现,当广告变成了一种看电影的方式,这对广告商也意味着有更多的空间来宣传。 ▲ 图片来自: satzuma 但无论何种新的形式,接下来,当我们沉迷于自己所选的 AR 广告体验中无法自拔,会不会更加停不下来「买买买」呢? 我开始觉得这是一篇关于 AR 的沉浸式广告了。 原文:https://www.ifanr.com/1230440