pyppeteer 模拟人工滑动验证（二）

根据上篇pyppeteer 模拟人工滑动验证(一)

我们现在继续模拟人工滑动验证。
请先看了上篇（pyppeteer 模拟人工滑动验证(一)）的基础介绍，再看当前篇

一、模拟的思路

人工滑动的速度肯定是在变化的，大部分是先加速滑动，然后再减速，我们要模拟的也就是这样的轨迹。

二、如何控制滑动的速度

根据 pyppeteer 提供的API page.mouse.move()唯一可以控制速度变化的就是steps, 源码如下：

    async def move(self, x: float, y: float, options: dict = None,
                   **kwargs: Any) -> None:
        """Move mouse cursor (dispatches a ``mousemove`` event).

        Options can accepts ``steps`` (int) field. If this ``steps`` option
        specified, Sends intermediate ``mousemove`` events. Defaults to 1.
        """
        options = merge_dict(options, kwargs)
        fromX = self._x
        fromY = self._y
        self._x = x
        self._y = y
        steps = options.get('steps', 1)
        for i in range(1, steps + 1):
            x = round(fromX + (self._x - fromX) * (i / steps))
            y = round(fromY + (self._y - fromY) * (i / steps))
            await self._client.send('Input.dispatchMouseEvent', {
                'type': 'mouseMoved',
                'button': self._button,
                'x': x,
                'y': y,
                'modifiers': self._keyboard._modifiers,
            })

大概看一下可以知道，steps是将我们传入的距离分成 ‘steps’ 段来执行，steps越大 则 越耗时，滑动越慢，在这里使用 steps 来控制滑动速度是很麻烦的，不如换一种思路，将steps固定，都是1，也就是滑动一次的时间固定下来。那么在时间固定的情况下，改变每次滑动的距离就可以实现变速滑动

三、如何滑动指定的距离

通过调用page.mouse.move()，可以移动到指定的 x , y，要实现相对移动，则需要知道相对坐标点，也就是传入 start_x + space_x, start_y + space_y
start_x , start_y 是滑块的坐标，但是 pyppeteer 好像没有提供这样的方法。
再次观察move() 的源码， 中间有一段 fromX = self._x ； fromY = self._y
这个 self是指鼠标 Mouse 对象，self._x 不就是当前的横坐标吗（调用hover(slide_id)后，我们已经聚焦到滑块上，也就是把鼠标放在滑块上了）。

start_x = page.mouse._x
await page.mouse.move(start_x + space_x, 0) # space_x 就是我们想要控制移动的距离。

四、如何从滑动的距离中切出来一块块的变速长度

根据 二、三，我们已经有大概的思路了，假如我们要滑动 300 像素，可以把300 的长度分成 10 段左右，前 7 段的长度在递增，后三段的长度在递减。然后在每一段上执行 page.mouse.move() 函数。
这里我们可以做一个等差数列生成器（或者等比数列），它应该有两个特点。
1）数列是先递增，再递减的
2）每次生成的数列应该是随机的（不可能一直使用同一个轨迹）。

具体怎么实现每个人都有自己的想法，这里我借助 numpy 第三方库，以及random标准库完成了一个实现。大概思路如下：
1）先依赖 numpy 生成一个标准的等差数列，计算出数列的差值 origin_space。
2）数列的第一位不变，但是后面不是加上标准 origin_space,而是origin_space 上下浮动 10% ，以实现每次都是随机的。

import numpy, random


def random_linspace(num, length):
  '''辅助函数
    传入要分成的几段 -> num ；长度 -> length, 生成一个递增的、随机的、不严格等差数列
  '''
    # 数列的起始值 、 结束值。 这里以平均值的 0.5 作为起始值，平均值的 1.5倍作为结束值。
    start, end = 0.5 * (length / num), 1.5 * (length / num)
    # 借助三方库生成一个标准的等差数列，主要是得出标准等差 space
    origin_list = numpy.linspace(start, end, num)
    space = origin_list[2] - origin_list[1]
    # 在标准等差的基础上，设置上下浮动的大小，（上下浮动10%）
    min_random, max_random = -(space / 10), space / 10
    result = []
    # 等差数列的初始值不变，就是我们设置的start
    value = start
    # 将等差数列添加到 list
    result.append(value)
    # 初始值已经添加，循环的次数 减一
    for i in range(num - 1):
        # 浮动的等差值 space
        random_space = space + random.uniform(min_random, max_random)
        value += random_space
        result.append(value)
    return result


def slide_list(total_length):
    '''等差数列生成器，根据传入的长度，生成一个随机的，先递增后递减，不严格的等差数列'''
    # 具体分成几段是随机的
    total_num = random.randint(10, 15)

    # 中间的拐点是随机的
    mid = total_num - random.randint(3, 5)

    # 第一段、第二段的分段数
    first_num, second_num = mid, total_num - mid

    # 第一段、第二段的长度，根据总长度，按比例分成
    first_length, second_length = total_length * (first_num / total_num), total_length * (second_num / total_num)

    # 调用上面的辅助函数，生成两个随机等差数列
    first_result = random_linspace(first_num, first_length)
    second_result = random_linspace(second_num, second_length)

    # 第二段等差数列进行逆序排序
    slide_result = first_result + second_result[::-1]

    # 由于随机性，判断一下总长度是否满足，不满足的再补上一段
    if sum(slide_result) < total_length:
        slide_result.append(total_length - sum(slide_result))
    return slide_result

async def slide_move(page, slide_id)
    await page_or_iframe.hover(slide_id)
    await page.mouse.down()
    slides = slide_list(300)
    x = page.mouse._x
    for distance in slides:
        x += distance
        await page.mouse.move(x, 0, )
    await page.mouse.up()

==================================================================
后续更新
有看到别人的实现滑动轨迹列表的实现，这里也记录一下。
思路是相同的，在时间不变的情况下滑动的每一段长度在不停的变化
这里运用了一些物理知识来做轨迹可能

def slide_list(total_length):
    '''
    拿到移动轨迹，模仿人的滑动行为，先匀加速后匀减速
    匀变速运动基本公式：
    ①v=v0+at
    ②s=v0t+½at²
    ③v²-v0²=2as
    :param total_length: 需要移动的距离
    :return: 每段移动的距离列表
    '''
    #初速度
    v=0
    #单位时间为0.3s来统计轨迹，轨迹即0.3内的位移
    t=1
    #位移/轨迹列表，列表内的一个元素代表一个T时间单位的位移,t越大，每次移动的距离越大
    slide_result =[]
    #当前的位移
    current=0
    #到达mid值开始减速
    mid=total_length*4/5
 
    while current < total_length:
        if current < mid:
            # 加速度越小，单位时间的位移越小,模拟的轨迹就越多越详细
            a= 2
        else:
            a=-3
        #初速度
        v0=v
        #0.2秒时间内的位移
        s=v0*t+0.5*a*(t**2)
        #当前的位置
        current+=s
        #添加到轨迹列表
        slide_result.append(round(s))
 
        #速度已经达到v,该速度作为下次的初速度
        v=v0+a*t
    return slide_result

我们输入一个距离 total_length = 300，得到以下列表：
[1, 4, 7, 10, 13, 16, 19, 22, 24, 27, 30, 33, 36, 35, 31]
这是因为当初速度为零时，同一间隔的时间 T 内，s 的距离成等差数列。
这个结果也和我们想要生成等差数列轨迹路线效果相同。
注：如果你采用后面的这个方法，也要采用一些随机函数。

pyppeteer文档 https://miyakogi.github.io/pyppeteer/reference.html#mouse-class