## 查询字符串与 JSON 互转

在发送 HTTP 请求的时候，要模拟一个登录请求的包，而抓到得包如下

```http
POST https://xxx.xxx.com/xxx/login HTTP/1.1
Host: xxx.xxx.com
Connection: keep-alive
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.25 Safari/537.36 Core/1.70.3775.400 QQBrowser/10.6.4208.400
Accept:text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
Content-Type: application/x-www-form-urlencoded

username=kuizuo&password=a12345678
```

但是我要模拟这样的请求就要写成如下方式

```javascript
let url = 'https://xxx.xxx.com/xxx/login'
let username = 'kuizuo'
let password = 'a12345678'

let data = 'username=' + username + '&password=' + password
// or
// let data = `username=${username}&password=${password}`

axios.post(url, data).then(function (res) {
  console.log(res.data)
})
```

像这种 `username=kuizuo&password=a12345678`就称之为查询字符串。显而易见，如果涉及到的参数一多修改显得十分不可靠（**极易改错**）。

所以一般的做法都是将 data 用 js 对象或者用 json 格式表示，像下面这样

```javascript
let username = 'kuizuo'
let password = 'a12345678'
let data = {
  username: username,
  password: password,
}
```

不过请求头是`Content-Type: application/x-www-form-urlencoded`，那么就需要使用工具将其转化为查询字符串了。比方说 node 中自带的 [querystring](http://nodejs.cn/api/querystring.html) 库。

### querystring

```javascript
const qs = require('querystring')

let obj = {
  username: 'kuizuo',
  password: 'a12345678',
}
let data = qs.stringify(obj)
// username=kuizuo&password=a12345678
```

```javascript
const qs = require('querystring')

let data = 'username=kuizuo&password=a12345678'
let json = qs.parse(data)
// { username: 'kuizuo', password: 'a12345678' }
```

### 使用正则与 array.reduce

除了借用 querystring 库之外，实际还可以通过正则匹配与`array.reduce()`，将查询字符串 js 对象。这里就放一下对应的代码：

```javascript
function qs2Json(str) {
  return (str.match(/([^=&]+)(=([^&]*))/g) || []).reduce((a, val) => ((a[val.slice(0, val.indexOf('='))] = val.slice(val.indexOf('=') + 1)), a), {})
}
```

js 对象转查询字符串就相对简单许多了，只需要对 js 对象遍历，然后使用使用&拼接即可。具体转化代码

```javascript
function json2Qs(obj) {
  return Object.keys(obj)
    .map((key) => {
      return key + '=' + obj[key]
    })
    .join('&')
}
```

不过这里遍历的时候还可以添加一些判断的，比如`if (obj[key] === undefined) return ''`，如果键值未定义就返回空字符串，或者清除数组一些为空字符串或 null 等值，这里我就不做过多判断了。

至于要转成 json 格式字符串还是解析 通过`JSON.stringify` 与 `JSON.parse`即可，这里就不在演示了。

最终两者的执行效果

```javascript
let obj = qs2Json('username=kuizuo&password=a12345678')
// {username: "kuizuo", password: "a12345678"}

let param = json2Qs({ username: 'kuizuo', password: 'a12345678' })
// username=kuizuo&password=a12345678
```

### URLSearchParams

除了 querystring，实际上还有一个更好的库 [URLSearchParams](http://nodejs.cn/api/url.html#class-urlsearchparams)，具体的使用如下

```javascript
const params = new URLSearchParams({
  user: 'abc',
  query: 'xyz',
})
console.log(params.toString())
// 'user=abc&query=xyz'
```

```javascript
let params = new URLSearchParams('user=abc&query=xyz')
let json = {}
for (const [key, value] of newSearchParams) {
  json[key] = value
}
console.log(json)
// { user: 'abc', query: 'xyz' }
```

关于`URLSearchParams`更多的可以去官方查看，主要是针对 url 的一个操作，不过我个人更倾向于使用`querystring`，主要原因还是`URLSearchParams`对中文使用的是 js 中的`encodeURIComponent`与`decodeURIComponent`，也就是`UTF8`编码，如果是`GBK`编码就会编码错误。而`querystring`可以指定编码（针对 gbk 的 url 编解码有个[gbk-nice](https://www.npmjs.com/package/gbk-nice)的库 也就是 gbk 版的`encodeURIComponent`）

## Cookie 与 JSON 互转

除了查询字符串需要互转，cookie 数据也可能需要互转。

```javascript
Cookie: _uuid=E4842E42-D3DC-2425-C598-231821AB344B39943infoc; buvid3=C844F66D-EC25-4712-8FF3-A0B65DF172C6155806infoc; sid=cvzaog1s; DedeUserID=35745471; DedeUserID__ckMd5=24ac8c69051043f3; SESSDATA=fc469231%2C1608969153%2C1bd79*61;
```

要转化为下面的方式

```json
{
  "_uuid": "E4842E42-D3DC-2425-C598-231821AB344B39943infoc",
  "buvid3": "C844F66D-EC25-4712-8FF3-A0B65DF172C6155806infoc",
  "sid": "cvzaog1s",
  "DedeUserID": "35745471",
  "DedeUserID__ckMd5": "24ac8c69051043f3",
  "SESSDATA": "fc469231%2C1608969153%2C1bd79*61"
}
```

主要是修改 qs2Json 与 json2Qs 这两个方法，放上对应的 js 代码。

```javascript
function cookies2Obj(cookies) {
  return cookies.split('; ').reduce((a, val) => ((a[val.slice(0, val.indexOf('=')).trim()] = val.slice(val.indexOf('=') + 1).trim()), a), {})
}

function obj2Cookies(obj) {
  return Object.keys(obj)
    .map((key) => {
      return key + '=' + obj[key]
    })
    .join('; ')
}
```

效果就请读者自行尝试了。

查询字符串与JSON互转

[模块 cv2 的用法 - 陨落&新生 - 博客园 (cnblogs.com)](https://www.cnblogs.com/shizhengwen/p/8719062.html)

[Python-OpenCV 基本操作 cv2 - 菜鸟程序猿\_python - 博客园 (cnblogs.com)](https://www.cnblogs.com/zlel/p/9267629.html)

## 常用方法

### 读取图像

cv2.imread(filepath,flags)

- filepath：要读入图片的完整路径

- flags：读入图片的标志

- - cv2.IMREAD_COLOR：默认参数(3)，读入一副彩色图片，忽略 alpha 通道
  - cv2.IMREAD_GRAYSCALE：读入灰度图片
  - cv2.IMREAD_UNCHANGED：顾名思义，读入完整图片，包括 alpha 通道

### 写入图像

cv2.imwrite(filepath, img, flags)

- filepath: 要保存图像的文件名
- img: 要保存的图像
- flags: 可选的第三个参数，它针对特定的格式：对于 JPEG，其表示的是图像的质量，用 0 - 100 的整数表示，默认 95;对于 png ,第三个参数表示的是压缩级别。默认为 3.

cv2.IMWRITE_JPEG_QUALITY 类型为 long ,必须转换成 int

cv2.IMWRITE_PNG_COMPRESSION, 从 0 到 9 压缩级别越高图像越小。

```python
cv2.imwrite('1.png',img, [int(cv2.IMWRITE_JPEG_QUALITY), 95])
cv2.imwrite('1.png',img, [int(cv2.IMWRITE_PNG_COMPRESSION), 9])
```

### 显示图像

演示代码如下

```python
import cv2

img = cv2.imread('temp.jpg')
cv2.imwrite('save.jpg', img)
cv2.imshow('img', img)
cv2.waitKey(0)
cv2.destroyAllWindow()
```

### img 的一些属性

```python
img.shape # (1200, 1920, 3) 宽、高、通道数
img.size # 像素个数
img.dtype # uint8
```

### 颜色转化

由于 cv2 得到的图片是 BGR 格式，而非传统的 RGB 格式，因此需要进行转化。

有以下三种方法

```python
im_bgr = cv2.imread('temp.jpg')

im_rgb = im_bgr[:, :, [2, 1, 0]]
im_rgb = im_bgr[:, :, ::-1]
im_rgb = cv2.cvtColor(im_bgr, cv2.COLOR_BGR2RGB)
```

还有一些颜色空间转化

```python
#彩色图像转为灰度图像
img2 = cv2.cvtColor(img,cv2.COLOR_RGB2GRAY)
#灰度图像转为彩色图像
img3 = cv2.cvtColor(img,cv2.COLOR_GRAY2RGB)
# cv2.COLOR_X2Y，其中X,Y = RGB, BGR, GRAY, HSV, YCrCb, XYZ, Lab, Luv, HLS
```

### cv 图片对象与二进制图片转化

```python
def bytes2cv(im):
    return cv2.imdecode(np.array(bytearray(im), dtype='uint8'), cv2.IMREAD_UNCHANGED)

def cv2bytes(im):
    return np.array(cv2.imencode('.png', im)[1]).tobytes()
```

### 添加边框

```python
import cv2

poses = [[111, 46, 151, 86], [177, 46, 212, 80],
         [246, 89, 286, 128], [240, 18, 280, 56]]

img = cv2.imread("1.jpg")

for box in poses:
    x1, y1, x2, y2 = box
    img = cv2.rectangle(img, (x1, y1), (x2, y2), color=(0, 0, 255), thickness=2)

cv2.imwrite("result.jpg", img)
```

![result](https://img.kuizuo.cn/result.png)

### 添加文本

```python
import cv2

img = cv2.imread('temp.jpg')
# 图片对象、文本、像素、字体、字体大小、颜色、字体粗细
img_text = cv2.putText(img, "kuizuo", (50, 50),
                    cv2.FONT_HERSHEY_DUPLEX, 5.5, (35, 175, 255), 2)
cv2.imwrite("result.jpg", img_text)
```

效果如下

![image-20220306203918438](https://img.kuizuo.cn/image-20220306203918438.png)

### 图片缩放

```python
import cv2

img = cv2.imread("1.png")
cv2.imshow("img", img)

img1 = cv2.resize(img, (200, 100))

cv2.imshow("img1", img1)

cv2.waitKey()
```

Python中的cv2使用

最近临时写了个 python 爬虫的例子（核心代码不开源），总结下这次编写过程中的一些相关知识点与注意事项，以一个用 nodejs 写爬虫的开发者的角度去看待与比对。



## 编码

在抓包与协议复现的时候，出现中文以及特殊符号免不了 url 编码，python 的编码可以使用内置库 urllib，同时也能指定编码格式。

gbk 编码中文是占 2 个字节，utf8 编码中文占 3 个字节

### url 编码

```python
from urllib.parse import urlencode, parse_qs, quote, unquote

quote("愧怍", encoding="gbk")
# %C0%A2%E2%F4
```

quot 还有一个 safe 参数，可以指定那个字符不进行 url 编码

```python
quote("?", safe=";/?:@&=+$,", encoding="utf8")
# ? 加了safe
# %3F 不加safe
```

解码操作与编码同理

```python
unquote("%C0%A2%E2%F4", encoding="gbk")
# 愧怍
```

如果编码格式错误，比如 gbk 编码用 utf8 解码将会变成不可见字符 ����，而用 utf8 编码用 gbk 解码，存在一个字节差，会输出成其他字符串，比如 `你好` 就会变成 `浣犲ソ`，代码 `unquote(quote("你好",encoding='utf8'), encoding="gbk")`

### URL 查询字符串

如果想构造一个 `a=1&b=2`的 url 查询字符串，使用文本拼接很不现实。urllib 提供 urlencode 与 parse_qs 可以在查询字符串与字典中切换

```python
urlencode({
    "username": '愧怍',
    "password": 'a123456'
})
# username=%E6%84%A7%E6%80%8D&password=a123456
```

也有 encoding 与 safe 参数，配置同 quote，就不演示了。

```python
parse_qs('a=1&a=2&b=2')
# {'a': ['1', '2'], 'b': ['3']}
```

将查询字符串转为 python 字典的话，值都是列表（应该是考虑可能会多个相同参数才这么设计）

小提一下，nodejs 中有个 querystring，方法 parse 与 stringify 与效果同理。

## 解构赋值

```python
a,b = [1,2]
print(a,b)

user = {
    "username": "kuizuo",
    "password": "a123456"
}
username, password = user.values()
print(username, password)

print(user.keys())
# dict_keys(['username', 'password'])
print(user.values())
# dict_values(['kuizuo', 'a123456'])
```

解构赋值没什么好说的，和 js 类似，只不过对字典的解构赋值的话，要取值则要调用 values()，取 key 的话默认不填，但是也可以调用 keys()

## 模板字符串

```python
user = 'kuizuo'
print(f'username: {user} age: {20+1}')
# username: kuizuo age: 21
```

同样{}中可以编写表达式，与 js 的模板字符串类似

如果是 python3.6 之前的话,则是用使用 string.format 方法（不常用，也不好用）

```python
"username: {} age: {}".format("愧怍", 18)
```

而 js 中的模板字符串则是使用反引号`和${}，像下面这样

```javascript
user = 'kuizuo'
console.log(`username: ${user} age: ${20+1}`)
# username: kuizuo age: 21
```

## 字典

python 的字典与 js 的对象有些许相像，个人总体感觉没有 js 的对象灵活，演示如下

```python
user = { 'username':'kuizuo','password':'a123456' }
print(user['username'])
```

想要获取字典中的值，就需要写成`user['username']`，如果习惯了 js 的写法（比如我），就会习惯的写成`user.username`，这在 python 中将会报错，`AttributeError: 'dict' object has no attribute 'username'`，并且字典的 key 还需要使用引号进行包裹，如果是 js 的话，代码如下

```javascript
user = { username: 'kuizuo', password:'a123456'
console.log(user.username)
```

如果想在 key 中包裹引号也是可以的，省略引号相当于代码简洁，同时取值也可以像 python 中的`user['username']`来进行取值，相对灵活。

假设我想取 user 的 age 属性，但是 user 没有 age 属性，python 则是直接报错`KeyError: 'age'`，可以使用`user.get('age',20)`，如果没有 age 属性，则默认 20。而 js 是不会报错，则是会返回`undefiend`，如果想要默认值的话可以像这样，`user.age || 20`。毕竟 js 调用类的方法属性都是可以直接 `对象.属性` `对象.方法`，而 python 中是 `对象["属性"]` `对象.方法`，只能说各有各的优劣吧 。

不过 js 不确定是否有该属性的话，可以使用`?.`，比方`user?.age`，这样返回的`null`，而不是`undefiend`。

:::note 易错小结：获取字典属性使用 `字典['属性值']` 获取，key 需用引号包裹

:::

## 类

在写爬虫时，我都会将其封装成类，把一些核心的方法封装成类方法，比如登录，获取图片验证码等等

```python
class Demo():

    def __init__(self, user):
        self.user = user

    def get_img_code(self):
        pass

    def login(self):
        pass

    def get_xxx(self):
        pass
```

同样的，像 requests 的 session 也会将其封装在类属性下，但是我一开始的写法是

```python
class Demo():
    session = requests.Session()

    def __init__(self, user):
        self.user = user

```

导致我创建多个实例时

```python
demo1 = Demo()
demo2 = Demo()
```

demo1 与 demo2 的的 session 是相等的，经过百度，了解到这样定义的类属性相当于是共有属性，每个实例下获取到的都是同一个 session，如果将 session 放置在`__init__`下，每个实例的 session 就不相同

```python
class Demo():
    def __init__(self, user):
        self.session = requests.Session()
        self.user = user
```

其中 `__init__`相当于 js 中的 constructor，也就是构造函数了。

不过 python 的方法第一个参数都要是 self，像 js 或者 java 等一些面向对象的语言，不用特意声明 this，就可以直接使用 this 来调用自身属性与方法。而 python 则需要显式的声明 self。

[Python 为什么要保留显式的 self ？ - 知乎 (zhihu.com)](https://zhuanlan.zhihu.com/p/84546388)

:::note 易错小结：类共有属性与实例属性区别

:::

## 线程

python3 中线程操作可以使用 threading

```python
import threading

def func(name, sec):
    print('---开始---', name, '时间', ctime())
    sleep(sec)
    print('***结束***', name, '时间', ctime())

# 创建 Thread 实例
t1 = Thread(target=func, args=('第一个线程', 1))
t2 = Thread(target=func, args=('第二个线程', 2))

# 启动线程运行
t1.start()
t2.start()

# 等待所有线程执行完毕
t1.join()  # join() 等待线程终止，要不然一直挂起
t2.join()
```

### 多线程

如果要实现多线程的话，需要将 Thread 实例（线程句柄），保存到列表中，然后调用 join

```python
l = []

for i in range(10):  # 开启10个线程
    t = threading.Thread(target=func, args=('第'+str(i)+'个线程', i))
    t.start()
    l.append(t)

# 等待线程运行结束
for i in l:
    i.join()
```

### 锁

说到多线程，怎么可能不提到锁呢。

```python
import threading
from time import sleep

def func():
    global num
    sleep(1)
    lock.acquire() # 获取锁
    num = num+1
    print(num)
    lock.release() # 释放锁


lock = threading.Lock()
num = 0

for i in range(10):
    t = threading.Thread(target=func, args=())
    t.start()

```

获取与释放锁的操作可以使用 with 关键字来操作

```python
with lock:
	num = num+1
	print(num)
```

## 时间

### 计算两者时间间隔

```python
duringtime =  datetime.datetime.strptime('2022-03-02 16:16:16', "%Y-%m-%d %H:%M:%S") - datetime.datetime.now()
seconds = duringtime.seconds
```

### 定时任务

[8 种 Python 定时任务的解决方案 - 知乎 (zhihu.com)](https://zhuanlan.zhihu.com/p/410388979)

## http 请求库

python 较为知名的 http 请求库无非就是 requests 了，但是 requests 不支持异步，在某些情况下，就只能等待上条请求结束，而异步请求则可以在发起一次请求后，在等待网站返回结果的时间里，可以继续发送更多请求。

此外还有 aiohttp、httpx，由于 httpx 又可以发送同步，也可以发送异步请求，号称新下一代网络请求库，并且基本与 requests 的代码重合度高，只需要改点对应关键词即可，这里所使用的时 httpx，并着重针对两者的区别进行测试。

### cookies

在 requests 中想要在下次使用上次响应中返回 cookies 十分简单，只需要设置实例化一个 session，然后使用 session 来发送后续的请求。在 requests 中是`session = requests.Session()`，而 httpx 则是`client = httpx.Client()`来代替

不过 httpx 则是有同步客户端与异步客户端，下面就是异步请求对的演示代码

```python
import asyncio
import httpx

async def main():
    async with httpx.AsyncClient() as client:  # 创建一个异步client
        r = await client.get('https://www.example.com/')
        print(r)

if __name__ == '__main__':
    asyncio.run(main())
```

获取请求的 cookies 也比较简单

request

```python
cookies_dict = requests.utils.dict_from_cookiejar(session.cookies)
```

httpx

```python
cookies_dict = dict(self.client.cookies)
```

### 协议头

在 http 请求中，少不了协议头的检测，比如说 Referer 检测来源链接是否符合要求，Content-Type 的请求体格式等等。但是如果在每条请求下都添加 headers 就略显代码繁杂，而且像很多公用的协议头 Origin，User-Agent 在全部的请求都是不变的，就可以使用`client.headers.update`设置成全局的协议头

```python
client.headers.update({
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/98.0.4758.102 Safari/537.36 Edg/98.0.1108.62",
})
```

如果不设置的话，默认全局协议头如下

```python
Headers({'host': 'example.com', 'accept': '*/*', 'accept-encoding': 'gzip, deflate', 'connection': 'keep-alive', 'user-agent': 'python-httpx/0.22.0'})
```

### post 请求

post 请求主要有两种格式一个是查询字符串 `a=1&b=2`，另一个是 json 格式 `{"a": 1, "b": 2}`，下面为代码演示

查询字符串

```python
import httpx
data = {
    "username": "kuizuo",
    "password": "a123456"
}

httpx.post(
    url='http://example.com', data=data)
# 请求体 username=kuizuo&password=a123456
```

json

```python
import httpx
data = {
    "username": "kuizuo",
    "password": "a123456"
}

httpx.post(
    url='http://example.com', json=data)
# 请求体 {"username": "kuizuo", "password": "a123456"}
```

请求库将会自动将根据你所传入的字典，转成对应的格式，同时会携带对应`Content-Type`协议头`Content-Type: application/x-www-form-urlencoded` 与 `Content-Type: application/json`。所以就不需要使用

:::warning 要注意一点的时，如果 data 不是字典，而是字符串 `a=1&b=2` ，那么请求时不会携带`Content-Type`，如果网站有对`Content-Type`的判断的话，那么这次的请求很有可能报错。

:::

:::note 易错小结：请求库默认使用 utf8 编码，如果想要发送 gbk 编码的话，就需要使用 urlencode，然后设置对应的协议头。（相对还是比较麻烦的，暂时没找到比较有效的方法）

:::

### 重定向

requests 默认情况下是允许重定向请求的，而 httpx 则是默认不允许重定向，所以，如果项目中涉及到重定向的请求的话，是需要改点代码

如果要禁止重定向设置为 False，允许则为 True

requests 的参数是`allow_redirects`，而 httpx 则是`follow_redirects`，如果想要在 httpx 设置允许重定向的话，可以在 client 中设置，之后的请求都将进行重定向

```python
client.follow_redirects = True
```

不过在正常协议复现的情况下，是不建议允许重定向的，因为有可能重定向的那个请求有必要关键参数可能会在后续中使用到，而重定向就会直接跳过。

:::note 易错小结：requests 是 allow_redirects，httpx 是 follow_redirects

:::

### 拦截器(hook)

http 拦截器主要用途在请求时附带一些参数（比方说 post 请求对 body 进行加密，添加 authorization 协议头），在返回响应的时候作何处理（如请求重试，ip 异常更换 ip，对响应结果进行统一处理）

在 node 的请求库 axios 中的叫拦截器，而在 requests 中则是叫 hook，httpx 则是 event_hooks，下面对两者拦截器进行简单演示

requests

```python
import requests

def log_response(r, *args, **kwargs):
    request = r.request
    print(
        f"Response event hook: {request.method} {request.url} - Status {r.status_code}")


requests.get(url='http://example.com',
                 hooks=dict(response=[log_response]))
```

httpx

```python
import httpx

def log_request(request):
    print(
        f"Request event hook: {request.method} {request.url} - Waiting for response")


def log_response(response):
    request = response.request
    print(
        f"Response event hook: {request.method} {request.url} - Status {response.status_code}")


client = httpx.Client(
    event_hooks={'request': [log_request], 'response': [log_response]})

r = client.get(
    url='http://example.com')
```

requests 只支持响应后处理，还不支持请求发送前处理，而 httpx 则是都支持，所以更推荐使用 httpx。

## OCR

python 有一个 ocr 的识别库 [ddddocr](https://github.com/sml2h3/ddddocr)

主要是用于识别验证码，不过前提环境要求 python，通过`pip install ddddocr`进行安装，具体演示代码在官网文档上也有，这里就不做演示了。

还有一个搭建 api 服务的 [sml2h3/ocr_api_server: 使用 ddddocr 的最简 api 搭建项目，支持 docker (github.com)](https://github.com/sml2h3/ocr_api_server)

## 总结

主要是这个爬虫项目中所使用到了 OCR 识别验证码，加上太久没有编写 python 爬虫的项目，就打算编写一个 demo 例子，顺带巩固下 python 的一些语法特性。整体体验其实与 node 相差不大，但是 python 对异步的支持不如 js 的异步，并且 js 编写 json 数据更加灵活，最主要是 node 的三大特性**单线程、非阻塞 I/O、事件驱动**，如果不是特殊必要，我都会首选 node 的 axios 库来进行编写 http 请求。

Python爬虫总结

说实话，貌似有一年没写过啥脚本类的代码了

之前针对加密视频播放编写了一个自动答题的脚本（使用易语言 大漠插件所编写的）

![image-20220207045652164](https://img.kuizuo.cn/20220207045652.png)

还有商户自动话术回复的（也是易语言+大漠插件）

![image-20220207050011838](https://img.kuizuo.cn/20220207050011.png)

还有使用 autojs 所编写的一个针对安卓端钉钉的自动签到

![image-20220207045811771](https://img.kuizuo.cn/20220207045811.png)

还有一个某宝领喵币类的，这里就不放截图了

甚至是一些网页类的脚本，例如油猴，Chrome 拓展之类的，都可以算作是脚本开发。

通常对这类代码称 RPA(机器人流程自动化)，不过自从玩了网络协议后，貌似就没在怎么碰过自动化操作脚本类的东西了（协议 脱机是真香，并且效率还高，不过需要一定的逆向能力），但对于一些需要自动化的东西，就只能靠脚本了。

## 使用

pyautogui 无就是一个 python 版的针对 windows 的 API 的封装操作，而这类操作主要功能就是找到窗口，找到鼠标位置，控制鼠标点击移动，还有键盘信息输入，进行一系列流程控制来达到想要的目的。所以必然会提供相关的 API 供调用，这里有一篇文章 [PyAutoGUI 超全介绍|基于 python 的自动化控制|工作自动化](https://www.zhaoyabo.com/?p=7033#i-15) 就不做 api 的介绍了。

## 例子

就简单写一个打开微信窗口并自动寻找关键人物头像发送你好的例子，顺便来说明下编写一个自动化脚本的各个流程。

### 第一步：寻找窗口

如果要写一个自动化脚本，首先范围是一定要确认好，这样能避免不必要的区域搜索以及效率的提升，在这里例子的范围就是整个微信窗口，通过一些窗口检测工具（这里使用精易编程助手），可以得到窗口标题与窗口类名，用于定位窗口（**窗口句柄**）。

![image-20220218065420228](https://img.kuizuo.cn/20220218065420.png)

可以通过如下代码获取窗口句柄

```python
def findWindow():
    windows = pyautogui.getWindowsWithTitle('微信')
    if len(windows) == 0:
        raise Exception("微信窗口未找到")
    return windows[0]


wxWindow = findWindow()
wxWindow.activate() # 激活窗口,将窗口最前化
```

### 第二步：找图点击

要找到对应联系人，就需要找到该联系人的相关特征，例如头像、昵称，这里就以头像作为演示。

既然要以头像作为特征，那么就需要提前将头像保存起来，然后利用 api 找到图片所在的坐标

```python
def clickAvatar():
    try:
        location = pyautogui.locateOnScreen('avatar.png')
        print(location)  # Box(left=293, top=402, width=40, height=40)
        pyautogui.click(location)
        # pyautogui.click('avatar.png') # 坐标用不到的话，可使用该命令 识图+点击
    except:
        print('头像未找到')
```

要注意的是：头像最好截取的完整（小而准），因为要完全匹配（所有像素及分辨率）。

### 第三步：输入内容

经过上面两步操作，就可以正常打开对应联系人与其聊天，现在就需要将内容输入到聊天框，然后和第二步一样找到发送按钮并点击。

```python
import pyperclip


def paste(content):
    pyperclip.copy(content)
    pyautogui.hotkey('ctrl', 'v')


content = u'你好'
paste(content)
```

由于我们要输入的内容是包含中文的，而在一般键盘指令是无法直接输入中文，所以需要变通一下，将所需要输入的内置剪辑版，然后使用组合键 ctrl + V 粘贴至窗口，具体代码如上演示（需要引入 pyperclip）

然后同第二步，找到发送按钮，并点击

```python
def clickSend():
     pyautogui.click('send.png')
```

### 完整代码

```python
import pyperclip
import pyautogui

pyautogui.PAUSE = 1 # 调用在执行动作后暂停的秒数，只能在执行一些pyautogui动作后才能使用，建议用time.sleep

def findWindow():
    windows = pyautogui.getWindowsWithTitle('微信')
    if len(windows) == 0:
        raise Exception("微信窗口未找到")
    return windows[0]


def clickAvatar():
    try:
        location = pyautogui.locateOnScreen('avatar.png')
        print(location) # Box(left=293, top=402, width=40, height=40)
        pyautogui.click(location)
        # pyautogui.click('avatar.png')  # 坐标用不到的话，可使用该命令
    except:
        print('头像未找到')

def clickSend():
     pyautogui.click('send.png')


def paste(content):
    pyperclip.copy(content)
    pyautogui.hotkey('ctrl', 'v')


if __name__ == '__main__':
    wxWindow = findWindow()
    wxWindow.activate()  # 激活窗口,将窗口最前化
    clickAvatar()

    content = '你好'
    paste(content)

    clickSend()
```

## 演示效果

![wxauto](https://img.kuizuo.cn/wxauto.gif)

## 体验感受

不过还有很多地方需要改进，例如多个微信窗口的情况下呢，针对窗口的操作更推荐使用 win32gui，其次在找图的时候，使用的是全屏找图，但都已经找到图片所在的区域是微信窗口的大小，可以将范围搜下，以便搜到更快。

上面也仅仅只是一个简单的例子，事实上自动化所需要考虑的东西挺多的，比方我当时编写的视频自动答题的，就需要定时（1 秒）监控是否弹出答题窗口，然后判断题目内容，从现有题库中获取题库。而不是像上面这个看似毫无意义，实际也确实毫无意义，但如果对其加强，比方说判断微信图标是否闪烁（有人发消息），然后对对方的聊天内容进行判断是否有关键词进行回复，事实上就能做一个简单的机器人客服聊天了（对于一些平台不支持自动回复的话，自动化脚本有显得很有用了）。不过具体使用场景还需要另行考虑，本文所展示的例子看看就行了。

不过整体体验下来，该说不说，比易语言好太多了，如果再让我写 window 窗口自动化操作的话，我肯定毫不犹豫的选择 python 来编写。

pyautogui自动化操作脚本

在学习安卓逆向的时候，遇到一个 APP，服务端检测请求的 SSL 证书，需要提交 SSL 证书上去才能正常发送请求。而在开启抓包和协议复现的时候，请求是能正常发出去，但是服务器会返回 400 错误。于是便有了这篇文章来记录下。



## 说明

由于是服务端效验客户端发送的证书，所以使用代理服务器（FD，Charles 等）抓包是会替换本地证书，当服务器效验客户端发送的证书与服务器内的证书不一致，那么就直接返回 400 错误，实际上请求还是能够发送出去，只是被服务器给拒绝了。俗称**双向认证**

所以解决办法就是在请求的时候，将正确的证书也一同发送过去，这样服务端效验时就会将正常的响应结果返回给客户端，也就是**配置自定义证书**。

### 例子

APP 例子：隐约

具体如何拉取证书，就是安卓逆向相关的部分了，这里我也只提供证书文件，不提供 app。

贴上下载地址及密码

证书: https://img.kuizuo.cn/cert.p12

密码: `xinghekeji888.x`

### 证书转化

[证书格式转换 (myssl.com)](https://myssl.com/cert_convert.html)

[SSL 在线工具-在线证书格式转换-证书在线合并-p12、pfx、jks 证书在线合成解析-SSLeye 官网](https://www.ssleye.com/ssltool/jks_pkcs12.html)

也可使用 OpenSSL 工具来进行转化证书

## HTTP 发送请求

### node 的 axios

```javascript
const axios = require('axios').default
const fs = require('fs')
const https = require('https')

axios
  .post(
    `https://app.yyueapp.com/api/passLogin`,
    {
      mobile: '15212345678',
      password: 'a123456',
    },
    {
      httpsAgent: new https.Agent({
        cert: fs.readFileSync('./cert.cer'),
        key: fs.readFileSync('./cert.key'),
        // pfx: fs.readFileSync('./cert.p12'),
        // passphrase: 'xinghekeji888.x,
      }),
    },
  )
  .then((res) => {
    console.log(res.data)
  })
  .catch((error) => {
    console.log(error.response.data)
  })
```

如果没有配置 httpsAgent，也就是没有配置证书，那么返回 400 错误 `400 No required SSL certificate was sent`。

配置成功将会得到正确的响应结果

```javascript
{ code: 998, msg: '系统维护中...', data: null }
```

### python 的 requests

requests 不支持 p12 格式的证书，所以需要使用其他的证书格式，如下

```python
import requests

r = requests.post('https://app.yyueapp.com/api/passLogin', data={
                  'mobile': '15212345678', 'password': 'a123456'}, cert=('./cert.cer', './cert.key'))
print(r.status_code)
print(r.text)
```