不错，可惜 app 经验不多

接口自动化发展至今，已经是非常成熟的东西，接口工具 (如 soapui，apifox)，代码框架（如 pytest），带界面 + 关键字驱动的（如 robotframework），或者 web 平台 (学习可以，大部分都是为爱发电，能否持续维护包括社区热度，问题修复等不好保证)，推荐先代码实现，这样会对整体实现有个清晰认知。

以 python 为例，主流就是对 pytest+requests 的封装，pytest 是实现自动化的核心，requests 是实现接口请求的核心。

前期你先别想那么多，什么这那的，行动起来更重要，先了解下基本构成，提前熟悉一些概念和名词，然后按照基本的例子找一个业务模块写就是了，期间你自然而然的会遇到很多问题，然后针对性的去找解决方案。

例如：需要往数据库插入数据或者执行后查询数据库数据的变更是否正确，就得请求数据库，例如使用 pymysql 模块使用多了，就会发现，总是在写重复的连接代码，初始化代码，包括对查询结果为空、一条或多条的的判定，你就会想到根据实际情况自己做二次封装，同理，有使用诸如 redis 缓存，apollo 配置，消息中间件的同理。
例如：你想有个不错的执行结果的报告，搜索后大概率会推荐你 allure-pytest、pytest-html。
例如：你想有一些前置、后置的操作，加日志打印等需求，搜索后会告诉你使用 fixture，通过对 fixture 的学习，了解他的作用域和实际用法。
例如：你想有在单个用例里实现多重断言，即使第一个断言失败，也继续后面的断言，那就会接触到 pytest-assume 或是 pytest-expect。
例如：写多了以后你觉得执行速度太慢，又会想多线程或者多进程跑，经过一番搜索，推荐你 pytest-xdist（多进程）、pytest-parallel（多进程和多线程），然后又会遇到诸如仅登录一次这样的需求，经过一番搜索，解决方案又回到了 fixture 这边。
例如：让自动化定时自动执行并发送结果到企微/钉钉/飞书灯，搜索结果大概率会推荐你将代码跟 jenkins 做持续集成，发送结果这个找对应的聊天工具的官方 api，基本都有。

写久了，你看着代码就会觉得这不顺眼那不顺眼，会想着各种优化框架，如代码精简，提取公共类，按业务功能分层，包括用例数据管理，使用配置文件统一管理配置信息，代码目录结构优化等等。

楼上提到的 apifox 和 jmeter 也可以做接口自动化测试，但像 jmeter 主要还是测性能用的多，拿来做接口测试大材小用了，你想扩展也比较麻烦（不知道 Java 功底怎么样）。而像 apifox 本身拿来测单接口、管理接口是很不错的（比 postman 好用），官方也提供了做接口自动化的范例，但也有一点学习成本，有一些自己的语法规则，既然都是学习，学 python+pytest 一步到位好了，当然也看具体情况，如果规模小，接口数量少，且复杂度没有那么高，那使用 apifox 之类也挺好的，写得快，协同维护也方便。

口罩之后的那两年尽管待遇突飞猛进，但面向市场，自身并没有太多显著的提升，以至于现在处于不上不下的状态，想再去突破自己又始终觉得年龄与市场需求不匹配，现在出去面试就面临了以上许多场景，在经历了几次失败的面试后反思了不少才悟透，只恨没有早日看到大佬的文章，说的太全面了，全是干货

想了半天，越想越复杂，当 n 比较大的时候，且已有数字可以横着或者竖着或者斜着把这个方形切割。
那么 n<2g
那么 n>2g 的时候，情况就比较复杂了，截面产生后，落点只能去往截后数字多的那块区域，但进入这里面找落点还得遵循规则，还可以再产生截面。。。
单纯的 9 宫格，大不了可以写死，而想要写一个通用性的方法，托大了。
先留着，想到方案再接上。

我再想想

已修复
在过滤重复值的时候，判断下一跳，没有把前一跳作为参数传到 available_nex() 方法去，一直用的初始的 first_num。

讲下思路

假设给出的列表都是规范的 A*A 的格式，如 1-9 三行行列，1-16 四行四列，那么大致可以把数字分为三类 (g 为长度开平方，因为前提条件，g 必定为自然数)：

• 固定的角落，有四个数值，左上：1,右下：g, 左下：1+g*(g-1), 右上: g

  • 左上-1，右下 +1 超出边界
  • 左下 +g，右上-g 超出边界

• 四边除角落外的值，这类值，因为数值间的关系上下对称，左右对称，是可以遍历两次得到的

  • +g 或者-g 超出边界，那肯定是第一或者最后一行的数字了，反之则是第一或最后一列的数字
  • 值小于 g（也就是第一行最后一个数字），那肯定是第一行的数了，反之是最后一行的数
  • 值如果刚好是 g 的倍数关系，那肯定是在右侧了，反之则是左侧边界

• 剩下的就是处于中间的值

而以上三种类型，可以写三个方法定义，每一种都有特定的规律来取值，这里没说不能斜着，因此我将斜着临近的数也算进去了。

实现代码（基于 python3.6）

# coding:utf8
# author: ryan
import random
from math import sqrt
list_a = [1,2,3,4,5,6,7,8,9]
L = len(list_a)
# 每一行个数
g = int(sqrt(L) )
 # 四个角
corner_list = [1,g,1+2*g,L]
# 除角落外的边界数字
middle_list = []
for i in range(2,g):
    # 首行
    middle_list.append(i)
    # 末行
    middle_list.append(i+2*g)
for i in range(1+g,1+2*g,g):
    # 左侧
    middle_list.append(i)
    # 右侧
    middle_list.append(i+g-1)

# 角落数字推算下一个数
def corner_make_nextnum(x):
    temp_list =[]
    # 边角数字固定只有四个，分两种, 1 和最大值 (也就是L))往前-1或者往后+1，不在1到L之间间，是一类。 另外两个是另一类
    if x-1 not in list_a or x+1 not in list_a:
        # 1 和 len, x-1不在list_a里，是左上角，反之是右下角
        if x-1 not in list_a:
            # 左上角，符合数字，右，下，右下
            x_right = x + 1
            x_down = x + g
            x_right_down = x + g + 1
            temp_list.append(x_right)
            temp_list.append(x_down)
            temp_list.append(x_right_down)
        else:
            # 右下角，符合数字，左，上，左上
            x_left = x - 1
            x_up = x - g
            x_left_up = x - g - 1
            temp_list.append(x_left)
            temp_list.append(x_up)
            temp_list.append(x_left_up)
    else:
        # 如果x-g还在list_a里，是左下角，反之是右上角
        if x-g in list_a:
            # 左下角，符合数字：上，右上，右
            x_up = x - g
            x_right_down = x - g + 1
            x_right = x + 1
            temp_list.append(x_up)
            temp_list.append(x_right_down)
            temp_list.append(x_right)
        else:
            # 右上角，符合数字：左，左下，下
            x_left = x - 1
            x_left_down = x + g - 1
            x_down = x + g
            temp_list.append(x_left)
            temp_list.append(x_left_down)
            temp_list.append(x_down)
    next_num = random.choice(temp_list)
    return next_num

# 每行中间数推算下一个数
def line_without_corner(x):
    temp_list = []
    # 如果+g，-g不在list_a中，那就是横向的
    if x+g not in list_a or x-g not in list_a:
        x_left = x - 1
        x_right = x + 1
        # 如果x比g小，那说明是第一行的，反之是最后一行的
        if x < g:
            # 第一行符合数字为左，右，下，临近的左下，右下
            x_down = x + g
            x_left_down = x + g - 1
            x_right_down = x + g + 1
            temp_list.append(x_down)
            temp_list.append(x_left_down)
            temp_list.append(x_right_down)
        else:
            # 最后一行符合数字为左，右，上，临近的左上，右上
            x_up= x - g
            x_left_up = x - g - 1
            x_right_up = x - g + 1
            temp_list.append(x_up)
            temp_list.append(x_left_up)
            temp_list.append(x_right_up)
        temp_list.append(x_left)
        temp_list.append(x_right)
     # 纵向的,且如果是g的倍数，则表示是在右侧边界，若不是则表示在左侧边界
    else:
        # 自然数，横竖个数相同的这种排列，上下相差始终为g
        x_up = x - g
        x_down = x + g
        # 右侧边界，可以除了上下还有临近的左侧，左上，左下
        if x%g == 0:
            x_left = x - 1
            x_left_up = x - g - 1
            x_left_dwwn = x + g - 1
            temp_list.append(x_left)
            temp_list.append(x_left_up)
            temp_list.append(x_left_dwwn)
        # 左侧边界，可以除了上下还有右临近的右侧，右上，右下
        else:
            x_right = x + 1
            x_right_up = x - g + 1
            x_right_dwwn = x + g + 1
            temp_list.append(x_right)
            temp_list.append(x_right_up)
            temp_list.append(x_right_dwwn)
        temp_list.append(x_up)
        temp_list.append(x_down)
    next_num = random.choice(temp_list)
    return next_num

# 中间的数字推算下一个数，上，下，左，右，左上，左下，右上，右上，固定有8个
def middle_make_nextnum(x):
    temp_list = [x-1, x+1, x-g, x+g, x-g-1, x-g+1, x+g-1, x+g+1]
    next_num = random.choice(temp_list)
    return next_num

# 根据已有数字推测下一可能数字
def available_next(x):
    if x in corner_list:
        next_number = corner_make_nextnum(x)
    elif x in middle_list:
        next_number = line_without_corner(x)
    else: 
        next_number = middle_make_nextnum(x)
    return next_number

def random_make_num(n):
    first_num = random.choice(list_a)
    passwd_list = [first_num]
    i = 1
    while i < n:
        next_num = available_next(first_num)
        # 过滤重复值
        if next_num in passwd_list:
            pass
        else:
            passwd_list.append(next_num)
            first_num = next_num
            i+=1
    return passwd_list

if __name__ == "__main__":
    passwd_list = random_make_num(4)
    print(passwd_list)