当在一个py文件中编写的代码有很多，运行py文件的时候能够全部执行。需要将不同功能的代码封装到函数中进行维护。

定义函数的基本语法

  1. def func_name():
  2.     pass
  1. def run_monkey():
  2.     print("运行monkey 命令")
  4. # 调用函数
  5. run_monkey()

定义函数之后，一定要调用才能被执行。

  1. def run_monkey():
  2.     print("运行monkey 命令")
  4. def run_install():
  5.     print("运行安装卸载测试")
  6. # 调用函数
  7. run_install()

函数的参数

定义的函数可以传递不同的参数，目的让函数的功能更加灵活

  1. # device,package_name,count 定义不同的参数
  2. def run_monkey(device,package_name,count):
  3.     # 在代码中引用参数名，参数名与定义的时候要保持一致
  4.     monkey_cmd = f'adb -s {device} shell monkey -p {package_name} -vv {count}'
  5.     print(monkey_cmd)
  7. def run_install():
  8.     print("运行安装卸载测试")
  9. # 调用函数 如果函数中定义的有参数，必须要传递参数
  10. run_monkey("127.0.0.1:62001","org.cnodejs.android.md", 1000) # 传递给对应的参数
  11. run_monkey("127.0.0.1:62001","org.cnodejs.android.md", 2000)

函数参数的默认值

在执行测试脚本的时候，我们一般设置运行的次数为1000，那么可以在定义函数的时候使用默认值的方式来设置。

  1. # device,package_name,count 不同参数 设置count的默认值为1000
  2. def run_monkey(device,package_name,count=1000):
  3.     monkey_cmd = f'adb -s {device} shell monkey -p {package_name} -vv {count}'
  4.     print(monkey_cmd)
  6. def run_install():
  7.     print("运行安装卸载测试")
  8. # 调用函数 如果函数中定义的有参数，必须要传递参数
  9. run_monkey("127.0.0.1:62001","org.cnodejs.android.md") #count值不传，使用默认值
  10. run_monkey("127.0.0.1:62001","org.cnodejs.android.md", 2000) # count参数传参，回覆盖默认值

如果有默认值： 默认值的参数位置放在定义的最后。
比如上述代码，count存放的位置是在 最后位置。

函数的返回值

  1. import os
  3. def get_devices():
  4.     # 定义空的list
  5.     devices = []
  6.     # 获取设备串号 执行命令 adb devices 将打印输出的内容放到文件中
  7.     os.system('adb devices > devices.txt')
  8.     # 从 devices.txt 文件中获取内容
  9.     with open('./devices.txt',mode='r',encoding='utf8') as file:
  10.         # 获取到多行内容，数据类型为list ['List of devices attached\n', '127.0.0.1:62001\tdevice\n', '127.0.0.1:62025\tdevice\n', '127.0.0.1:62026\tdevice\n', '\n']
  11.         lines = file.readlines()
  12.         # 循环list
  13.         for line in lines:
  14.             # 拿到每一行内容，经过大量观察分析， 如果字符串中包含  \tdevice 字符串说明 里面含有 device的设备串号
  15.             if "\tdevice" in line:
  16.                 print(line, type(line)) # 127.0.0.1:62001    device
  17.                 # 从字符串中提取 127.0.0.1:62001
  18.                 # 1. 先将 \tdevice\n 替换为空字符串 ""
  19.                 device_id = line.replace("\tdevice\n","")
  20.                 print(f'处理之后的设备串号：{device_id}')
  21.                 # 将处理之后的设备串号 存到 devices 列表
  22.                 devices.append(device_id)
  24.         # 将获取到的所有的devices信息返回出去，
  25.         return devices
  29. # 因为 get_devices() 函数有返回值， devices_list 的就是 函数返回的值
  30. devices_list = get_devices()
  31. print(devices_list)

return 关键字可以将函数内部计算的结果返回出来。
加返回值一般原则：

  1. 如果这个函数运行的结果在其它函数中有需要可以添加返回，
  2. 一般返回结果是之前学习过的基本数据类型
    1. 数字，字符串，列表，元组，集合，字典，bool

自动化运行monkey或者安装卸载

  1. import os
  3. def get_devices():
  4.     # 定义空的list
  5.     devices = []
  6.     # 获取设备串号 执行命令 adb devices 将打印输出的内容放到文件中
  7.     os.system('adb devices > devices.txt')
  8.     # 从 devices.txt 文件中获取内容
  9.     with open('./devices.txt',mode='r',encoding='utf8') as file:
  10.         # 获取到多行内容，数据类型为list ['List of devices attached\n', '127.0.0.1:62001\tdevice\n', '127.0.0.1:62025\tdevice\n', '127.0.0.1:62026\tdevice\n', '\n']
  11.         lines = file.readlines()
  12.         # 循环list
  13.         for line in lines:
  14.             # 拿到每一行内容，经过大量观察分析， 如果字符串中包含  \tdevice 字符串说明 里面含有 device的设备串号
  15.             if "\tdevice" in line:
  16.                 # print(line, type(line)) # 127.0.0.1:62001    device
  17.                 # 从字符串中提取 127.0.0.1:62001
  18.                 # 1. 先将 \tdevice\n 替换为空字符串 ""
  19.                 device_id = line.replace("\tdevice\n","")
  20.                 # print(f'处理之后的设备串号：{device_id}')
  21.                 # 将处理之后的设备串号 存到 devices 列表
  22.                 devices.append(device_id)
  24.         # 将获取到的所有的devices信息返回出去，
  25.         return devices
  27. # device,package_name,count 不同参数 设置count的默认值为1000
  28. def run_monkey(device,package_name,count=1000):
  29.     monkey_cmd = f'adb -s {device} shell monkey -p {package_name} -vv {count}'
  30.     print(monkey_cmd)
  32. def run_install():
  33.     print("运行安装卸载测试")
  35. # 因为 get_devices() 函数有返回值， devices_list 的就是 函数返回的值
  36. # 1. 获取所有的设备
  37. devices_list = get_devices()
  39. option = input('支持如下自动化测试：\n1.执行monkey测试\n2.安装卸载测试\n请选择测试类型[1,2]：')
  40. if option == "1":
  41.     package = input("请输入运行包名:")
  42.     count = input("请输入运行次数（按下Enter 使用默认值1000）：")
  44.     for device in devices_list:
  45.         if count=="":
  46.             run_monkey(device,package)
  47.         else:
  48.             run_monkey(device,package,count)
  49. elif option == "2":
  50.     run_install()
  51. else:
  52.     print('输入参数有误。拜拜！')
  55. # 调用函数 如果函数中定义的有参数，必须要传递参数
  56. # run_monkey("127.0.0.1:62001","org.cnodejs.android.md") #count值不传，使用默认值
  57. # run_monkey("127.0.0.1:62001","org.cnodejs.android.md", 2000) # count参数传参，回覆盖默认值

最终代码

  1. import os
  3. def get_logs_dir():
  4.     """
  5.     获取项目的logs目录的绝对路径
  6.     :return:
  7.     """
  8.     # 文件的绝对路径
  9.     abspath = os.path.abspath(__file__)
  10.     # 文件的根目录
  11.     root_dir = os.path.dirname(abspath)
  12.     logs_dir = os.path.join(root_dir,'logs')
  13.     # 如果不存在
  14.     if not os.path.exists(logs_dir):
  15.         os.mkdir(logs_dir)
  16.     return logs_dir
  18. def get_devices():
  19.     # 定义空的list
  20.     devices = []
  21.     # 获取设备串号 执行命令 adb devices 将打印输出的内容放到文件中
  22.     os.system('adb devices > devices.txt')
  23.     # 从 devices.txt 文件中获取内容
  24.     with open('./devices.txt',mode='r',encoding='utf8') as file:
  25.         # 获取到多行内容，数据类型为list ['List of devices attached\n', '127.0.0.1:62001\tdevice\n', '127.0.0.1:62025\tdevice\n', '127.0.0.1:62026\tdevice\n', '\n']
  26.         lines = file.readlines()
  27.         # 循环list
  28.         for line in lines:
  29.             # 拿到每一行内容，经过大量观察分析， 如果字符串中包含  \tdevice 字符串说明 里面含有 device的设备串号
  30.             if "\tdevice" in line:
  31.                 # print(line, type(line)) # 127.0.0.1:62001    device
  32.                 # 从字符串中提取 127.0.0.1:62001
  33.                 # 1. 先将 \tdevice\n 替换为空字符串 ""
  34.                 device_id = line.replace("\tdevice\n","")
  35.                 # print(f'处理之后的设备串号：{device_id}')
  36.                 # 将处理之后的设备串号 存到 devices 列表
  37.                 devices.append(device_id)
  39.         # 将获取到的所有的devices信息返回出去，
  40.         return devices
  44. # device,package_name,count 不同参数 设置count的默认值为1000
  45. def run_monkey(device,package_name,count=1000):
  46.     # 创建monkey的日志目录
  47.     logs_dir = get_logs_dir()
  48.     monkey_dir = os.path.join(logs_dir,'monkey_log')
  49.     # 如果不存在monkey日志目录
  50.     if not os.path.exists(monkey_dir):
  51.         # 创建monkey目录
  52.         os.mkdir(monkey_dir)
  53.     #针对不同的设备串号 生成对应文件名
  54.     device_file = device.replace(":","_")
  55.     # 生成日志文件的路径，日志文件放在monkey 日志文件夹下
  56.     log_file = os.path.join(monkey_dir,f'{device_file}.log')
  57.     monkey_cmd = f'adb -s {device} shell monkey -p {package_name} -vv {count} > {log_file}'
  58.     os.system(monkey_cmd)
  59.     print(f'运行设备{device}完毕，生成对应日志文件{log_file}')
  61. def run_install(device,package_name):
  62.     """
  63.     运行安装卸载测试
  64.     1. 先把原来安装好的包卸载
  65.     2. 安装apk
  66.     :param device: 设备串号
  67.     :param package_name:  包名
  68.     :return:
  69.     """
  70.     # 创建安装卸载的日志目录
  71.     logs_dir = get_logs_dir()
  72.     # 定义安装卸载日志目录
  73.     install_dir = os.path.join(logs_dir,'install_log')
  74.     # 创建目录
  75.     if not  os.path.exists(install_dir):
  76.         os.mkdir(install_dir)
  77.     # 定义日志文件名
  78.     device_id = device.replace(":","_")
  79.     # 安装日志
  80.     install_log_path = os.path.join(install_dir,f'{device_id}_install.log')
  81.     # 卸载日志
  82.     uninstall_log_path = os.path.join(install_dir,f'{device_id}_uninstall.log')
  83.     uninstall_cmd = f"adb -s {device} shell pm uninstall {package_name} > {uninstall_log_path}"
  84.     # 执行卸载命令
  85.     os.system(uninstall_cmd)
  86.     print(f"卸载完成，生成对应的日志文件：{uninstall_log_path}")
  87.     apkfile = os.path.join(os.path.abspath(__file__),'../apks/app-release.apk')
  88.     # 执行安装命令
  89.     install_cmd=f'adb -s {device} install {apkfile} > {install_log_path}'
  90.     os.system(install_cmd)
  91.     print(f"安装完成，生成对应的日志文件：{install_log_path}")
  92. # 因为 get_devices() 函数有返回值， devices_list 的就是 函数返回的值
  93. # 1. 获取所有的设备
  94. devices_list = get_devices()
  96. option = input('支持如下自动化测试：\n1.执行monkey测试\n2.安装卸载测试\n请选择测试类型[1,2]：')
  97. if option == "1":
  98.     package = input("请输入运行包名:")
  99.     count = input("请输入运行次数（按下Enter 使用默认值1000）：")
  101.     for device in devices_list:
  102.         if count=="":
  103.             run_monkey(device,package)
  104.         else:
  105.             run_monkey(device,package,count)
  106. elif option == "2":
  107.     package = input("请输入运行包名:")
  108.     for device in devices_list:
  109.         run_install(device,package)
  110. else:
  111.     print('输入参数有误。拜拜！')

git仓库地址 https://gitee.com/imzack/adb_atuo.git

扩展：接口自动化测试框架
https://www.bilibili.com/video/BV1kz4y1f7Cm/