selenium实现web自动化测试

Web自动化测试

课程大纲

序号	章节	知识点
1	第一章 Web自动化入门	1.认识自动化及自动化测试 2.自动化测试工具选择 3.环境搭建
2	第二章 Selenium-API	1.元素定位方式 2.元素和浏览器的操作方法 3.鼠标和键盘操作 4.元素等待 5.HTML特殊元素处理 6.窗口截图 7.验证码处理
3	第三章 Pytest框架	1.Pytest基本使用
4	第四章 PO模式	1.方法封装 2.PO模式介绍 3.PO模式实战
5	第五章 数据驱动	1.JSON读写 2.数据驱动介绍 3.数据驱动实战
6	第六章 日志收集	1.日志相关概念 2.日志的基本方法 3.日志的高级方法

第一章 Web自动化入门

1 自动化

1.1 概念

由机器设备代替人工自动完成指定目标的过程

1.2 优点

• 减少人工劳动力

• 提高工作效率

• 产品规格统一标准

• 规模化(批量生产)

• 安全

2 自动化测试

2.1 概念

用程序代替人工去执行测试的过程

软件测试: 对程序进行操作，以发现程序错误，并验证其是否满足需求的过程

2.2 应用场景

• 解决-回归测试

  回归测试：项目在发新版本之后对项目之前的功能进行验证

• 解决-压力测试

  压力测试：可以理解多用户同时去操作软件，统计软件服务器处理多用户请求的能力

• 解决-兼容性测试

  兼容性测试：不同浏览器（IE、Firefox、Chrome）等等，执行的用例都是同一条，只是浏览器不同

• 解决-冒烟测试

  冒烟测试：针对最基本的功能或者流程进行的测试

• 提高测试效率，保证产品质量

2.3 正确认识（存在即合理）

优点

• 较少的时间内运行更多的测试用例
• 自动化脚本可重复运行
• 减少人为的错误
• 克服手工测试的局限性

误区

• 自动化测试可以完全替代手工测试
• 自动化测试一定比手工测试厉害
• 自动化测试可以发掘更多的BUG （自动化脚本执行的用例一般都是重复的，操作都是一致的）
• 自动化测试适用于所有功能

2.4 分类

• Web-自动化测试 (本阶段学习)
• 移动-自动化测试
• 接口-自动化测试
• 桌面自动化 （桌面层次的自动化）
• 单元测试-自动化测试
• web自动化/移动自动化测试都属于UI自动化

3 Web自动化测试

概念

用程序代替人工去执行Web测试的过程

什么是接口自动化测试？

什么是移动自动化测试？

什么样的项目适合做Web自动化测试

• 需求变动不频繁 （如果需求变动频繁，脚本代码需要变动，将会浪费大量时间精力）
• 项目周期长 （如果周期过短，整个测试流程的时间有限，优先完成功能测试，编写脚本太费时间）
• 项目需要回归测试

Web自动化测试什么时候开始

手工测试结束后 （为什么是手工测试结束?）

web自动化测试的场景多为回归测试

Web自动化测试所属分类

属于功能测试 (黑盒)

我们编写了自动化的脚本进行测试为什么不属于白盒或者灰盒？

我们编写的自动化脚本本身不属于程序内部的代码

4 Selenium

4.1 Web自动化工具简介

主流工具

• QTP

  一个商业化的功能测试工具, 收费, 支持web/ 桌面自动化测试

• Selenium（重点）

  一个开源的web自动化测试工具, 主要做功能测试（开源）

• Robot framework

  一个基于python可扩展的关键字驱动的自动化测试框架（运用较少）

  什么是关键字驱动？

  什么是驱动？

Selenium特点

• 开源软件：源代码开放可以根据需要来增加工具的某些功能
• 跨平台：linux、windows、mac
• 支持多种浏览器：Firefox、Chrome、IE、Edge、Opera、Safari等
• 支持多种语言：Python、Java、C#、JavaScript、Ruby、PHP等
• 成熟稳定：目前已经被google、百度、腾讯等公司广泛使用
• 功能强大：能够实现类似商业工具的大部分功能，因为开源性，可实现定制化功能（二次开发）

4.2 环境搭建

4.2.1 搭建步骤

基于python搭建环境:

1. python 开发环境 (python v3.x)

2. 安装 selenium 包

3. 安装浏览器

4. 安装浏览器驱动

   保证能够用程序驱动浏览器, 实现自动化测试

为什么我们是基于python搭建的，能基于其他语言进行环境搭建吗？

4.2.2 安装selenium包

安装

pip install selenium

验证

pip list
# 或者
pip show selenium

卸载

pip uninstall selenium

离线安装

• 把下载好的selenium包放到 D:\python\Lib\site-packages\ 下
• 命令行, 进入到~\python\Lib\site-packages\selenium-3.141.0
• 执行 python setup.py install

4.2.3 安装浏览器驱动

驱动下载

• Chrome

  下载地址: http://chromedriver.storage.googleapis.com/index.html

  镜像地址: http://npm.taobao.org/mirrors/chromedriver/

  浏览器下载地址: https://www.chromedownloads.net/

• Firefox

  下载地址: https://github.com/mozilla/geckodriver/releases

• Edge（ie浏览器的改进版）

  下载地址: https://developer.microsoft.com/en-us/microsoft-edge/tools/webdriver/

安装步骤

1. 下载浏览器驱动

   各个驱动下载地址： http://www.seleniumhq.org/download/

   浏览器的版本和驱动版本要一致

2. 把驱动文件所在目录添加到Path环境变量中

   或者直接放到Python安装目录，因为Python已添加到Path中

4.3 入门示例

4.3.1 需求

通过程序启动浏览器，并打开百度首页，暂停3秒，关闭浏览器

4.3.2 实现步骤

1.导包
2.创建浏览器驱动对象
3.打开百度首页
4.暂停3秒
5.关闭驱动对象

4.3.3 示例代码

# 1.导包
import time
from selenium import webdriver

# 2.创建浏览器驱动对象
driver = webdriver.Chrome()

# 3.打开百度首页
driver.get("http://www.baidu.com")

# 4.暂停3秒
time.sleep(3)

# 5.关闭驱动对象
driver.quit()

第二章 Selenium-API

1 元素定位基础

1.1 为什么进行元素定位

让程序操作指定元素，就必须先找到此元素

什么是元素？

HTML网页实际上就是由许多的HTML元素构成的文本文件，并且任何网页浏览器都可以直接运行HTML文件。所以可以这样说，HTML元素就是构成HTML文件的基本对象，HTML元素可以说是一个统称而已。HTML元素就是通过使用HTML标签进行定义的。

什么是标签？

标签就是、、

等被尖括号“<”和“>”包起来的对象，绝大部分的标签都是成对出现的，如 、。

标签就是用来标记HTML元素的。位于起始标签和结束标签之间的文本就是HTML元素的内容。

什么是属性？

为HTML元素提供各种附加信息的就是HTML属性，它总是以"属性名=属性值"这种名值对的形式出现，而且属性总是在HTML元素的开始标签中进行定义。

1.2 如何进行元素定位

元素定位就是通过元素的信息或元素层级结构来定位元素的

html页面由标签构成，标签的基本格式如下：
	<标签名 属性名1="属性值1" 属性名2="属性值2">文本
示例：
    
    

    	我的购物车
    

思考：如何快速的查看一个元素的相关信息？

1.3 浏览器开发者工具

概念

浏览器开发者工具就是给专业的web应用和网站开发人员使用的工具。包含了对HTML查看和编辑、Javascript控制台、网络状况监视等功能，是开发JavaScript、CSS、HTML和Ajax的得力助手

作用

定位元素, 查看元素信息

使用

需求:

使用浏览器开发者工具, 查看百度输入框的相关信息

• 安装: 无需安装
• 启动: 快捷键一般都是F12
• 使用方式
  • 方式一: 在要查看的元素上点击右键选择 ‘查看元素’(Firefox) 或者 ‘检查’(Chrome)
  • 方式二: 先打开浏览器开发者工具, 点击选择元素的图标, 移动鼠标到要查看的元素, 然后点击

1.4 元素定位方式

1.4.1 总体介绍

Selenium提供了八种定位元素方式
1. id
2. name
3. class_name
4. tag_name
5. link_text
6. partial_link_text
7. XPath
8. CSS

id、name、class_name：为元素属性定位
tag_name：为元素标签名称
link_text、partial_link_text：为超链接定位(a标签)
XPath：为元素路径定位
CSS：为CSS选择器定位

1.4.2 id定位

说明：id定位就是通过元素的id属性来定位元素，HTML规定id属性在整个HTML文档中必须是唯一的；
前提：元素有id属性
但是id唯一不是硬性要求，一般情况id都是唯一的

方法

element = driver.find_element_by_id(id)

案例

案例演示环境说明：
受限于网络速度的影响，我们案例采用本地的html页面来演示。这样可以提高学习效率和脚本执行速率

需求：打开注册A.html页面，完成以下操作
1.使用id定位，输入用户名：admin
2.使用id定位，输入密码：123456
3.3秒后关闭浏览器窗口

实现步骤分析:
1. 导入selenium包 --> from selenium import webdriver
2. 导入time包 --> import time
3. 实例化浏览器驱动对象 --> driver = webdriver.Firefox()
4. 打开注册A.html --> driver.get(url)
5. 调用id定位方法 --> element = driver.find_element_by_id("")
6. 使用send_keys()方法输入内容 --> element.send_keys("admin")
7. 暂停3秒 --> time.sleep(3)
8. 关闭浏览器驱动对象 --> driver.quit()

说明：为了更好的学习体验，我们先暂时使用下send_keys()方法来输入内容

代码:

# 1.导包
import time
from selenium import webdriver

# 2.创建浏览器驱动对象
driver = webdriver.Chrome()

# 3.业务操作
driver.get("C:\\Users\\Administrator.USER-20190219YL\\Desktop\\pagetest\\注册A.html")
driver.find_element_by_id("userA").send_keys("admin")
driver.find_element_by_id("passwordA").send_keys("123456")

# 4.暂停3秒
time.sleep(3)

# 5.关闭驱动对象
driver.quit()

1.4.3 name定位

说明：name定位就是根据元素name属性来定位。HTML文档中name的属性值是可以重复的。
前提：元素有name属性

方法

element = driver.find_element_by_name(name)

案例

需求：打开注册A.html页面，完成以下操作
1.使用name定位，输入用户名：admin
2.使用name定位，输入密码：123456
3.3秒后关闭浏览器窗口

代码:

# 1.导包
import time
from selenium import webdriver

# 2.创建浏览器驱动对象
driver = webdriver.Chrome()

# 3.业务操作
driver.get("C:\\Users\\Administrator.USER-20190219YL\\Desktop\\pagetest\\注册A.html")
driver.find_element_by_name("userA").send_keys("admin")
driver.find_element_by_name("passwordA").send_keys("123456")

# 4.暂停3秒
time.sleep(3)

# 5.关闭驱动对象
driver.quit()

1.4.4 class_name定位

说明：class_name定位就是根据元素class属性值来定位元素。HTML通过使用class来定义元素的样式
前提：元素有class属性
注意：如果class有多个属性值，只能使用其中的一个

方法

element = driver.find_element_by_class_name(class_name)

案例

需求：打开注册A.html页面，完成以下操作
1.通过class_name定位电话号码A，并输入：13122223333
2.通过class_name定位电子邮箱A，并输入：[email protected]
3.3秒后关闭浏览器窗口

代码:

# 1.导包
import time
from selenium import webdriver

# 2.创建浏览器驱动对象
driver = webdriver.Chrome()

# 3.业务操作
driver.get("C:\\Users\\Administrator.USER-20190219YL\\Desktop\\pagetest\\注册A.html")
driver.find_element_by_class_name("telA").send_keys("13122223333")
driver.find_element_by_class_name("emailA").send_keys("[email protected]")

# 4.暂停3秒
time.sleep(3)

# 5.关闭驱动对象
driver.quit()

1.4.5 tag_name定位

说明：tag_name定位就是通过标签名来定位；
HTML本质就是由不同的tag组成，每一种标签一般在页面中会存在多个，所以不方便进行精确定位，一般很少使用

方法

element = driver.find_element_by_tag_name(tag_name)
# 如果存在多个相同标签，则返回符合条件的第一个标签
# 如何获取第二个元素？后面会讲到

案例

需求：打开注册A.html页面，完成以下操作
1.使用tag_name定位用户名输入框，并输入：admin
2.3秒后关闭浏览器窗口

代码:

# 1.导包
import time
from selenium import webdriver

# 2.创建浏览器驱动对象
driver = webdriver.Chrome()

# 3.业务操作
driver.get("C:\\Users\\Administrator.USER-20190219YL\\Desktop\\pagetest\\注册A.html")
driver.find_element_by_tag_name("input").send_keys("admin")

# 4.暂停3秒
time.sleep(3)

# 5.关闭驱动对象
driver.quit()

1.4.6 link_text定位

说明：link_text定位是专门用来定位超链接元素(标签)，并且是通过超链接的文本内容来定位元素

方法

element = driver.find_element_by_link_text(link_text)
# link_text：为超链接的全部文本内容

案例

需求：打开注册A.html页面，完成以下操作
1.使用link_text定位(访问 新浪 网站)超链接，并点击
2.3秒后关闭浏览器窗口

代码:

# 1.导包
import time
from selenium import webdriver

# 2.创建浏览器驱动对象
driver = webdriver.Chrome()

# 3.业务操作
driver.get("C:\\Users\\Administrator.USER-20190219YL\\Desktop\\pagetest\\注册A.html")
driver.find_element_by_link_text("访问 新浪 网站").click()

# 4.暂停3秒
time.sleep(3)

# 5.关闭驱动对象
driver.quit()

1.4.7 partial_link_text定位

说明：partial_link_text定位是对link_text定位的补充，link_text使用全部文本内容匹配元素，而partial_link_text可以使用局部来匹配元素，也可以使用全部文本内容匹配元素

方法

element = driver.find_element_by_partial_link_text(partial_link_text)
# partial_link_text：可以传入a标签局部文本-能表达唯一性

案例

需求：打开注册A.html页面，完成以下操作
1.使用partial_link_text定位(访问 新浪 网站)超链接，并点击
2.3秒后关闭浏览器窗口

代码:

# 1.导包
import time
from selenium import webdriver

# 2.创建浏览器驱动对象
driver = webdriver.Chrome()

# 3.业务操作
driver.get("C:\\Users\\Administrator.USER-20190219YL\\Desktop\\pagetest\\注册A.html")
driver.find_element_by_partial_link_text("访问").click()

# 4.暂停3秒
time.sleep(3)

# 5.关闭驱动对象
driver.quit()

1.5 定位一组元素

使用上述方法的时候, 发现有一些类似的方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TRn7ywk1-1609329063534)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20201222143040129.png)]

方法

elements = driver.find_elements_by_xxx("xxxxxx")
作用：
    1. 查找定位所有符合条件的元素
    2. 返回值是一个列表
说明：列表数据格式的读取需要指定下标(下标从0开始)
思考：如果定位一组列表没定位到，会报错吗？

案例

需求：打开注册A.html页面，完成以下操作
1.使用tag_name定位密码输入框(第二个input标签)，并输入：123456
2.3秒后关闭浏览器窗口

代码:

# 1.导包
import time
from selenium import webdriver

# 2.创建浏览器驱动对象
driver = webdriver.Chrome()

# 3.业务操作
driver.get("C:\\Users\\Administrator.USER-20190219YL\\Desktop\\pagetest\\注册A.html")
#elements = driver.find_elements_by_tag_name("input")
#elements[1].send_keys("123456")
driver.find_elements_by_tag_name("input")[1].send_keys("123456")

# 4.暂停3秒
time.sleep(3)

# 5.关闭驱动对象
driver.quit()

2 元素定位-XPath/CSS

2.1 总体介绍

为什么要学习XPath/CSS定位

1. 如果要定位的元素没有id、name、class属性，该如何进行定位？
2. 如果通过name、class、tag_name无法定位到唯一的元素，该如何进行定位？
示例：
	

2.2 XPath定位

2.2.1 什么是XPath

跟之前学接口测试jmeter中的xpath提取器有什么区别？

1. XPath即为XML Path的简称，它是一门在 XML 文档中查找元素信息的语言
2. HTML可以看做是XML的一种实现，所以Selenium用户可以使用这种强大的语言在Web应用中定位元素

XML：一种标记语言，用于数据的存储和传递。 后缀.xml结尾


    
        3
        3
        3
        等边三角形
    
    
        4
        4
        5
        等腰三角形
    

XPath之所以强大, 是因为它有非常灵活的定位方式

2.2.2 XPath定位方式

2.2.2.1 总体介绍

四种定位方式

1. 路径-定位
2. 利用元素属性-定位
3. 属性与逻辑结合-定位
4. 层级与属性结合-定位

方法

element = driver.find_element_by_xpath(xpath)

2.2.2.2 路径

绝对路径：从最外层元素到指定元素之间所有经过元素层级的路径

1. 绝对路径以/html根节点开始，使用/来分隔元素层级
   如：/html/body/div/fieldset/p[1]/input
2. 绝对路径对页面结构要求比较严格，不建议使用

相对路径：匹配任意层级的元素，不限制元素的位置

1. 相对路径以//开始

2. 格式：//input 或者 //*

   如：//input[@id=‘passwordA’] #找input标签，并且查找id是passwordA的元素

   如果是//*input[@id=‘passwordA’] #找所有的标签，并且查找id是passwordA的元素

练习

需求：打开注册A.html页面，完成以下操作
1.使用绝对路径定位用户名输入框，并输入：admin
2.暂停2秒
3.使用相对路径定位密码输入框，并输入：123

核心代码:

driver.find_element_by_xpath("/html/body/div/fieldset/form/p[1]/input").send_keys("admin")
time.sleep(2)
driver.find_element_by_xpath("//*[@id='passwordA']").send_keys("123")

2.2.2.3 利用元素属性

说明：通过使用元素的属性信息来定位元素
格式：//input[@id='userA'] 或者 //*[@id='userA']
//input[@id='userA'] 是你知道他的层级是input标签，而且你也知道他的id是userA
//*[@id='userA'] 是你不知道他是哪个层级的标签，*代表全部，但是你知道他的id是userA

练习

需求：打开注册A.html页面，完成以下操作
利用元素的属性信息精确定位用户名输入框，并输入：admin

2.2.2.4 属性与逻辑结合

说明：解决元素之间个相同属性重名问题
格式：//*[@name='tel' and @class='tel']

练习

需求：打开注册A.html页面，完成以下操作
使用属性与逻辑结合定位策略，在密码对应的输入框里输入：123

核心代码:

driver.find_element_by_xpath("//*[@type='password' and @id='passwordA']").send_keys("123")

2.2.2.5 层级与属性结合

说明：如果通过元素自身的信息不方便直接定位到该元素，则可以先定位到其父级元素，然后再找到该元素
格式：//*[@id='p1']/input

练习

需求：打开注册A.html页面，完成以下操作
使用层级与属性结合定位策略，在test1对应的输入框里输入：test1

核心代码:

driver.find_element_by_xpath("//*[@id='p1']/input").send_keys("test1")

2.2.2.6 XPath扩展

//*[text()="xxx"] 文本内容是xxx的元素
//*[contains(@attribute,'xxx')] 属性中含有xxx的元素    #attribute是属性名
//*[starts-with(@attribute,'xxx')] 属性以xxx开头的元素

举例:

driver.find_element_by_xpath("//*[text()='访问 新浪 网站']").click()
driver.find_element_by_xpath("//*[contains(@placeholder,'用户名')]").send_keys('admin')
driver.find_element_by_xpath("//*[starts-with(@placeholder,'请输入密')]").send_keys('123')

2.3 CSS定位

前端三件宝：html，js，css

html管理布局，js做效果，css做样式

如：html告诉你一个人应该有什么器官，js告诉你一个人能做哪些行为动作，css表示一个人长什么样

如：你想去定义一只手长啥样，你需要先定位到哪只手，才能去定义他的样式

css选择器，是css提供的一种定位方式。

2.3.1 什么是CSS

1. CSS（Cascading Style Sheets）是一种语言，它用来描述HTML元素的显示样式
2. 在CSS中，选择器是一种模式，用于选择需要添加样式的元素
3. 在Selenium中也可以使用这种选择器来定位元素

提示：
1. 在selenium中推荐使用CSS定位，因为它比XPath定位速度要快
2. css选择器语法非常强大，在这里我们只学习在测试中常用的几个

2.3.2 CSS定位方式

2.3.2.1 总体介绍

常用定位方式

1. id选择器
2. class选择器
3. 元素选择器
4. 属性选择器
5. 层级选择器

方法

element = driver.find_element_by_css_selector(css_selector)

2.3.2.2 id选择器

说明：根据元素id属性来选择
格式：#id
例如：#userA <选择id属性值为userA的元素>

练习

需求：打开注册A.html页面，完成以下操作
使用CSS定位方式中id选择器定位用户名输入框，并输入：admin

核心代码:

driver.find_element_by_css_selector("#userA").send_keys("admin")

2.3.2.3 class选择器

说明：根据元素class属性来选择
格式：.class
例如：.telA <选择class属性值为telA的所有元素>

练习

需求：打开注册A.html页面，完成以下操作
使用CSS定位方式中class选择器定位电话号码输入框，并输入：13100000000

核心代码:

driver.find_element_by_css_selector(".telA").send_keys("123456")

2.3.2.4 元素选择器

说明：根据元素的标签名选择
格式：element
例如：input <选择所有input元素>

练习

需求：打开注册A.html页面，完成以下操作
使用CSS定位方式中元素选择器定位注册按钮，并点击

核心代码:

driver.find_element_by_css_selector("button").click()

2.3.2.5 属性选择器

说明：根据元素的属性名和值来选择
格式：[attribute=value] element[attribute=value]
例如：[type="password"] <选择type属性值为password的元素>

练习

需求：打开注册A.html页面，完成以下操作
使用CSS定位方式中属性选择器定位密码输入框，并输入：123456

核心代码:

driver.find_element_by_css_selector("[type='password']").send_keys("123456")

2.3.2.6 层级选择器

说明：根据元素的父子关系来选择
格式1：element1>element2 通过element1来定位element2，并且element2必须为element1的直接子元素
例如1：p[id='p1']>input <定位指定p元素下的直接子元素input>
格式2：element1 element2 通过element1来定位element2，并且element2为element1的后代元素
例如2：p[id='p1'] input <定位指定p元素下的后代元素input>

练习

需求：打开注册A.html页面，完成以下操作
使用CSS定位方式中的层级选择器定位用户名输入框，并输入：admin

核心代码:

#driver.find_element_by_css_selector("p[id='pa']>input").send_keys("admin")
driver.find_element_by_css_selector("div[class='zc'] input").send_keys("admin")

2.3.2.7 CSS扩展

input[type^='p'] type属性以p字母开头的元素
input[type$='d'] type属性以d字母结束的元素
input[type*='w'] type属性包含w字母的元素

举例:

# 输入用户名
# driver.find_element_by_css_selector("input[type^='t']").send_keys("admin")
driver.find_element_by_css_selector("input[id^='u']").send_keys("admin")
driver.find_element_by_css_selector("input[type$='t']").send_keys("admin")
driver.find_element_by_css_selector("input[type*='ex']").send_keys("admin")

2.4 XPath和CSS对比

定位方式	XPath	CSS
元素名	//input	input
id	//*[@id=‘userA’]	#userA
class	//*[@class=‘telA’]	.telA
属性	1. //[starts-with(@attribute,‘x’)] 2. //[text()=“x”] 3. //*[contains(@attribute,‘x’)]	1. input[type^=‘x’] 2. input[type$=‘x’] 3. input[type*=‘x’]

3 元素定位总结

3.1 元素定位分类汇总

1. id、name、class_name：为元素属性定位
2. tag_name：为元素标签名称
3. link_text、partial_link_text：为超链接定位(a标签)
4. XPath：为元素路径定位
5. CSS：为CSS选择器定位

3.2 另一种写法

3.2.1 方法介绍

方法

方法：find_element(by=By.ID, value=None)
备注：需要两个参数，第一个参数为定位的类型由By提供，第二个参数为定位的具体方式
导包：from selenium.webdriver.common.by import By

示例

1. driver.find_element(By.CSS_SELECTOR, '#emailA').send_keys("[email protected]")
2. driver.find_element(By.XPATH, '//*[@id="emailA"]').send_keys('[email protected]')
3. driver.find_element(By.ID, "userA").send_keys("admin")
4. driver.find_element(By.NAME, "passwordA").send_keys("123456")
5. driver.find_element(By.CLASS_NAME, "telA").send_keys("13111111111")
6. driver.find_element(By.TAG_NAME, 'input').send_keys("123")
7. driver.find_element(By.LINK_TEXT, '访问 新浪 网站').click()
8. driver.find_element(By.PARTIAL_LINK_TEXT, '访问').click()

3.2.2 区别

    def find_element_by_id(self, id_):
        """Finds an element by id.

        :Args:
         - id\_ - The id of the element to be found.

        :Returns:
         - WebElement - the element if it was found

        :Raises:
         - NoSuchElementException - if the element wasn't found

        :Usage:
            element = driver.find_element_by_id('foo')
        """
        return self.find_element(by=By.ID, value=id_)

4 元素操作

4.1 应用场景

1. 需要让脚本模拟用户给指定元素输入值
2. 需要让脚本模拟人为删除元素的内容
3. 需要让脚本模拟点击操作

4.2 方法

1. click() 单击元素
2. send_keys(value) 模拟输入
3. clear() 清除文本

4.3 案例

需求

需求：打开注册A页面，完成以下操作
1.通过脚本执行输入用户名：admin；密码：123456；电话号码：18611111111；电子邮件：[email protected]
2.间隔3秒，修改电话号码为：18600000000
3.间隔3秒，点击‘注册’按钮
4.间隔3秒，关闭浏览器
ps: 元素定位方法不限

操作难点分析

1. 修改电话号码，先清除再输入新的号码； 清除 --> clear()
2. 点击按钮 --> click()

5 浏览器操作

5.1 应用场景

脚本启动浏览器窗口大小默认不是全屏？
如何刷新页面？

怎样解决这些问题?

5.2 方法

1. maximize_window() 				最大化浏览器窗口 --> 模拟浏览器最大化按钮
2. set_window_size(width, height) 	设置浏览器窗口大小 --> 设置浏览器宽、高(像素点)
3. set_window_position(x, y) 		设置浏览器窗口位置 --> 设置浏览器位置
4. back() 							后退 --> 模拟浏览器后退按钮
5. forward() 						前进 --> 模拟浏览器前进按钮
6. refresh() 						刷新 --> 模拟浏览器F5刷新
7. close() 							关闭当前窗口 --> 模拟点击浏览器关闭按钮
8. quit() 							关闭浏览器驱动对象 --> 关闭所有程序启动的窗口
9. title 							获取页面title
10. current_url 					获取当前页面URL

close关闭与quit关闭有什么区别？

close关闭的是当前页面，但是浏览器驱动还在，会造成内存泄露，最终导致内存溢出

quit关闭的是当前浏览器驱动

5.3 示例

# 最大化浏览器
driver.maximize_window()
# 刷新
driver.refresh()
# 后退
driver.back()
# 前进
driver.forward()
# 设置浏览器大小
driver.set_window_size(300,300)
# 设置浏览器位置
driver.set_window_position(300,200)
# 关闭浏览器单个窗口
driver.close()
# 关闭浏览器所有窗口
driver.quit()
# 获取title
title = driver.title
# 获取当前页面url
url = driver.current_url

6 获取元素信息

应用场景

1. 如何获取元素的文本？
2. 如何获取元素属性值？
3. 如何让程序判断元素是否为可见状态？

6.2 常用方法

1. size 				返回元素大小
2. text 				获取元素的文本
3. get_attribute("xxx") 获取属性值，传递的参数为元素的属性名
4. is_displayed() 		判断元素是否可见
5. is_enabled() 		判断元素是否可用
6. is_selected() 		判断元素是否选中，用来检查复选框或单选按钮是否被选中

提示：
	size、text：为属性，调用时无括号；如：xxx.size

is_displayed() 和is_enabled() 扩展

面试题：如果你定位不到一个元素，请问怎么去排查？

6.3 案例

需求：使用‘注册A.html’页面，完成以下操作：
1.获取用户名输入框的大小
2.获取页面上第一个超链接的文本内容
3.获取页面上第一个超链接的地址
4.判断页面中的span标签是否可见
5.判断页面中取消按钮是否可用
6.判断页面中'旅游'对应的复选框是否为选中的状态

代码:

# 1.获取用户名输入框的大小
print(driver.find_element_by_tag_name("a").size)
# 2.获取页面上第一个超链接的文本内容
print(driver.find_element_by_tag_name("a").text)
# 3.获取页面上第一个超链接的地址
print(driver.find_element_by_tag_name("a").get_attribute("href"))
# 4.判断页面中的span标签是否可见
print(driver.find_element_by_tag_name("span").is_displayed())
# 5.判断页面中取消按钮是否可用
print(driver.find_element_by_id("cancelA").is_enabled())
# 6.判断页面中'旅游'对应的复选框是否为选中的状态
print(driver.find_element_by_id("lyA").is_selected())

7 鼠标操作

7.1 什么是鼠标操作

点击、右击、双击、悬停、拖拽等

7.2 应用场景

现在Web产品中存在丰富的鼠标交互方式，作为一个Web自动化测试框架，需要应对这些鼠标操作的应用场景

7.3 常用方法

说明：在Selenium中将操作鼠标的方法封装在ActionChains类中

实例化对象：
action = ActionChains(driver)

方法：
1. context_click(element) 			右击 --> 模拟鼠标右键点击效果
2. double_click(element) 			双击 --> 模拟鼠标双击效果
3. drag_and_drop(source, target) 	拖动 --> 模拟鼠标拖动效果
4. move_to_element(element) 		悬停 --> 模拟鼠标悬停效果
5. perform() 						执行 --> 此方法用来执行以上所有鼠标操作

为了更好的学习其他方法，我们先学习perform()执行方法,因为所有的方法都需要执行才能生效

7.4 鼠标执行-perform()

说明：在ActionChains类中所有提供的鼠标事件方法，在调用的时候所有的行为都存储在ActionChains对象中, 而perform()方法就是真正去执行所有的鼠标事件

强调：必须调用perform()方法才能执行鼠标事件

7.5 鼠标右键-context_click()

说明：
对于点击鼠标右键，如果弹出的是浏览器默认的菜单，Selenium没有提供操作菜单选项的方法；
如果是自定义的右键菜单，则可以通过元素定位来操作菜单中的选项

练习

需求：打开注册页面A，在用户名文本框上点击鼠标右键

关键点分析

1. 导包：from selenium.webdriver.common.action_chains import ActionChains
2. 实例化ActionChains对象：action = ActionChains(driver)
3. 调用右键方法：action.context_click(element)
4. 执行：action.perform()

核心代码:

element = driver.find_element_by_id("userA")
action = ActionChains(driver).context_click(element)
action.perform()

7.6 鼠标双击-double_click()

说明：模拟双击鼠标左键操作

练习

需求：打开注册页面A，输入用户名admin，暂停3秒钟后，双击鼠标左键，选中admin

核心代码:

element = driver.find_element_by_id("userA")
element.send_keys("admin")
time.sleep(3)
ActionChains(driver).double_click(element).perform()

7.7 鼠标拖动-drag_and_drop()

说明：模拟鼠标拖动动作，选定拖动源元素释放到目标元素

关键点分析

1. 源元素 		 source = driver.find_element_by_id(xxx)
2. 目标元素 	target = driver.find_element_by_id(xxx)
3. 调用方法 	action.drag_and_drop(source, target).perform()

练习

需求：打开‘drag.html’页面，把红色方框拖拽到蓝色方框上

核心代码:

source = driver.find_element_by_id("div1")
target = driver.find_element_by_id("div2")
ActionChains(driver).drag_and_drop(source, target).perform()

7.8 鼠标悬停-move_to_element()

说明: 模拟鼠标悬停在指定的的元素上

练习

需求：打开注册页面A，模拟鼠标悬停在‘注册’按钮上

核心代码:

element = driver.find_element_by_xpath("/html/body/div/fieldset/form/p[5]/button")
ActionChains(driver).move_to_element(element).perform()

扩展：

鼠标操作ActionChains可进行链式调用，单击后可继续调用双击继续调用右键，可执行一连串操作

8 键盘操作

8.1 应用场景

思考:

如何实现复制/ 粘贴的操作?

说明：
1. 模拟键盘上一些按键或者组合键的输入 如：Ctrl+C 、Ctrl+V；
2. Selenium中把键盘的按键都封装在Keys类中

8.2 常用操作

导包：from selenium.webdriver.common.keys import Keys

1. send_keys(Keys.BACK_SPACE) 	删除键(BackSpace)
2. send_keys(Keys.SPACE) 		空格键(Space)
3. send_keys(Keys.TAB) 			制表键(Tab)
4. send_keys(Keys.ESCAPE) 		回退键(Esc)
5. send_keys(Keys.ENTER) 		回车键(Enter)
6. send_keys(Keys.CONTROL,'a') 	全选(Ctrl+A)
7. send_keys(Keys.CONTROL,'c') 	复制(Ctrl+C)

提示：以上方法就不一个一个讲解了，因为调用方法都一样

8.3 案例

需求：打开注册A页面，完成以下操作
1. 输入用户名：admin1，暂停2秒，删除1
2. 全选用户名：admin，暂停2秒
3. 复制用户名：admin，暂停2秒
4. 粘贴到密码框

8.4 案例代码

# 定位用户名
element = driver.find_element_by_id("userA")
# 输入用户名
element.send_keys("admin1")
# 删除1
element.send_keys(Keys.BACK_SPACE)
# 全选
element.send_keys(Keys.CONTROL, 'a')
# 复制
element.send_keys(Keys.CONTROL, 'c')
# 粘贴
driver.find_element_by_id('passwordA').send_keys(Keys.CONTROL, 'v')

9 元素等待

9.1 概念

定位页面元素时如果未找到，在指定时间内一直等待的过程

元素等待一共分为两种类型

1. 隐式等待
2. 显式等待

9.2 应用场景

由于一些原因，我们想找的元素并没有立刻出来，此时如果直接定位会报错，场景如下：

1. 网络速度慢
2. 服务器处理请求速度慢
3. 硬件配置原因

是否定位每个元素都应该需要元素等待?

9.3 隐式等待

方法

# 隐式等待为全局设置（只需要设置一次，就会作用于所有元素）
# 参数：
# 	timeout：超时的时长，单位：秒
driver.implicitly_wait(timeout)

案例

需求：打开注册A页面，完成以下操作
使用隐式等待定位用户名输入框，如果元素存在，就输入admin

注意点

单个元素定位超时会报 NoSuchElementException异常

9.4 显式等待

在Selenium中把显式等待的相关方法封装在 WebDriverWait 类中

方法

# 显式等待，为定位不同元素的超时时间设置不同的值

1. 导包 from selenium.webdriver.support.wait import WebDriverWait
2. WebDriverWait(driver, timeout, poll_frequency=0.5)
    1). driver：浏览器驱动对象
    2). timeout：超时的时长，单位：秒
    3). poll_frequency：检测间隔时间，默认为0.5秒
3. 调用方法 until(method)：直到...时
    1). method：函数名称，该函数用来实现对元素的定位
    2). 一般使用匿名函数来实现：lambda x: x.find_element_by_id("userA")

如:ele = WebDriverWait(driver, 10, 1).until(lambda x: x.find_element_by_id("userA"))

一般函数的定义：

def test():
	print("test")
#调用方式
test()

匿名函数：

test = lambda x , y : x+y
#调用
test(1,2)
#结果为3
print(test(1,2))

案例

需求：打开注册A页面，完成以下操作
使用显示等待定位用户名输入框，如果元素存在，就输入admin

注意点

单个元素定位超时会报 TimeoutException异常

9.5 隐式和显式区别

1. 作用域：隐式为全局元素，显式等待为单个元素有效
2. 使用方法：隐式等待直接通过驱动对象调用，而显式等待方法封装在WebDriverWait类中
3. 达到最大超时时长后抛出的异常不同：隐式为NoSuchElementException，显式等待为TimeoutException

10 下拉框/弹出框/滚动条操作

10.1 下拉框

10.1.1 方法一

案例

需求：使用‘注册A.html’页面，完成对城市的下拉框的操作
1.选择‘广州’
2.暂停2秒，选择‘上海’
3.暂停2秒，选择‘北京’

核心代码

driver.find_element_by_xpath("//*[@id='selectA']/option[3]").click()
time.sleep(2)
driver.find_element_by_xpath("//*[@id='selectA']/option[2]").click()
time.sleep(2)
driver.find_element_by_xpath("//*[@id='selectA']/option[1]").click()

说明: 下拉框就是 HTML 中的 元素

思路: 先定位到操作的 option 元素, 然后执行点击操作

问题: 操作起来比较繁琐

10.1.2 方法二

Select类

说明：Select类是Selenium为操作select标签特殊封装的

实例化对象：
	select = Select(element)
		element: 标签对应的元素，通过元素定位方式获取
			例如：driver.find_element_by_id("selectA")

操作方法：
1. select_by_index(index) 		--> 根据option索引来定位，从0开始
2. select_by_value(value) 		--> 根据option属性 value值来定位
3. select_by_visible_text(text) --> 根据option显示文本来定位
 
  
Select类实现步骤分析
 
  
1. 导包 Select类 --> from selenium.webdriver.support.select import Select
2. 实例化Select类 select = Select(driver.find_element_by_id("selectA"))
3. 调用方法：select.select_by_index(index)
 
  
案例核心代码
 
  
select = Select(driver.find_element_by_xpath("//*[@id='selectA']"))
select.select_by_index(2)
time.sleep(2)
select.select_by_index(1)
time.sleep(2)
select.select_by_index(0)
 
  
10.2 弹出框
 
  
10.2.1 分类
 
  
网页中常用的弹出框有三种
1. alert 	警告框
2. confirm 	确认框
3. prompt 	提示框
 
  
10.2.2 案例
 
  
需求：打开注册A.html页面，完成以下操作：
1.点击 alert 按钮
2.输入用户名：admin
 
  
 
   
错误代码:
 
   
driver.find_element_by_xpath("//*[@id='alerta']").click()
driver.find_element_by_id("userA").send_keys("admin")
 
  
 
  
思考
 
  
按钮被点击后弹出警告框，而接下来输入用户名的语句没有生效
1. 什么问题导致的？
2. 如何处理警告框？
 
  
10.2.3 方法
 
  
说明：Selenium中对处理弹出框的操作，有专用的处理方法；并且处理的方法都一样
1. 获取弹出框对象
	alert = driver.switch_to.alert
2. 调用
    alert.text 		--> 返回alert/confirm/prompt中的文字信息
    alert.accept() 	--> 接受对话框选项
    alert.dismiss() --> 取消对话框选项
 
  
10.2.4 示例代码
 
  
核心代码
 
  
driver.find_element_by_xpath("//*[@id='alerta']").click()
time.sleep(2)
alert = driver.switch_to.alert
time.sleep(2)
print(alert.text)
time.sleep(2)
alert.accept()
time.sleep(2)
driver.find_element_by_id("userA").send_keys("admin")
 
  
10.3 滚动条
 
  
10.3.1 应用场景
 
  
1. 在HTML页面中，由于前端技术框架的原因，页面元素为动态显示，元素根据滚动条的下拉而被加载
2. 页面注册同意条款，需要滚动条到最底层，才能点击同意
 
  
10.3.2 实现方式
 
  
 
   
说明：
 
   
selenium中没有提供操作滚动条的方法，但是它提供了可执行JavaScript脚本的方法，所以我们可以通过JavaScript脚本来达到操作滚动条的目的
 
  
 
  
1. 设置JavaScript脚本控制滚动条
	js = "window.scrollTo(0,1000)"
		(0:左边距；1000：上边距；单位像素)
2. selenium调用执行JavaScript脚本的方法
	driver.execute_script(js)
 
  
 
   
JavaScript是一种被广泛用于Web前端开发的脚本语言 ,常用来为网页添加动态功能（弹窗，点击事件…），JavaScript提供了页面对象获取和操作功能。
 
  
 
  
实现方式一：
编写js脚本 定位用户名输入框，并且输入admin
js = "document.getElementById('userA').value='admin'"
#执行js脚本
driver.execute_script(js)

#实现方式二：
#编写js定位元素并且返回定位到的元素
js = "return document.getElementById('userA')"
#将定位到的元素赋予el这个变量
el = driver.execute_script(js)
#输入admin
el.send_keys('admin')
 
  
如何去开发者工具调试js语句？
 
  
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SzWlNqtB-1609329063538)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20201230150516102.png)]
 
  
10.3.3 案例
 
  
需求：打开注册页面A，暂停2秒后，滚动条拉到最底层
 
  
示例代码
 
  
js1 = "window.scrollTo(0,10000)"	# 最底部
js2 = "window.scrollTo(0,0)"		# 最顶部
time.sleep(2)
driver.execute_script(js1)
time.sleep(2)
driver.execute_script(js2)
 
  
11 frame切换
 
  
11.1 概念
 
  
frame：HTML页面中的一种框架，主要作用是在当前页面中指定区域显示另一页面元素；
形式一：[了解]
    
        
        
    
形式二：
	
 
  
11.2 案例
 
  
需求：打开‘注册实例.html’页面，完成以下操作
1. 填写主页面的注册信息
2. 填写注册页面A中的注册信息
3. 填写注册页面B中的注册信息
 
  
 
   
问题:
 
   
当前页面内无法定位注册页面A和注册页面B
 
  
 
  
11.3 方法
 
  
说明：在Selenium中封装了如何切换frame框架的方法

步骤：
    1. driver.switch_to.frame(frame_reference) 	--> 切换到指定frame的方法
            frame_reference：可以为frame框架的name、id或者定位到的frame元素
    2. driver.switch_to.default_content() 		--> 恢复默认页面方法
            在frame中操作其他页面，必须先回到默认页面，才能进一步操作
 
  
 
   
解决方案:
 
   
 
    
完成主页面注册信息；
 
    
调用frame切换方法(switch_to.frame(“myframe1”))切换到注册用户A框架中
 
    
调用恢复默认页面方法(switch_to.default_content())
 
    
调用frame切换方法(switch_to.frame(“myframe2”))切换到注册用户B框架中
 
   
 
  
 
  
11.4 示例代码
 
  
driver.find_element_by_id("userA").send_keys("admin")
# driver.switch_to.frame(driver.find_element_by_id("idframe1"))
# driver.switch_to.frame("idframe1")
driver.switch_to.frame("myframe1")
driver.find_element_by_id("userA").send_keys("adminA")
driver.switch_to.default_content()
driver.switch_to.frame("myframe2")
driver.find_element_by_id("userA").send_keys("adminB")
 
  
12 多窗口切换
 
  
12.1 概念
 
  
什么是窗口?
 
  
为什么要切换窗口?
 
  
 
   
在HTML页面中，当点击超链接或者按钮时，有的会在新的窗口打开页面
 
  
 
  
12.2 案例
 
  
需求：打开注册页面A
1. 新窗口打开新浪
2. 在新浪搜索框输入'新浪搜索'
3. 在注册页输入用户名admin
 
  
12.3 方法
 
  
说明：在Selenium中封装了获取当前窗口句柄、获取所有窗口句柄和切换到指定句柄窗口的方法
句柄：英文handle，窗口的唯一识别码
方法：
    1. driver.current_window_handle 	--> 获取当前窗口句柄
    2. driver.window_handles 			--> 获取所有窗口句柄
    3. driver.switch_to.window(handle) 	--> 切换指定句柄窗口
 
  
 
   
解决方案:
 
   
 
    
打开注册A页面
 
    
获取当前窗口句柄
 
    
在注册A页面点击 “访问 新浪 网站”
 
    
获取所有窗口句柄
 
    
根据句柄, 切换到新浪窗口
 
    
对输入框进行输入
 
    
切换回原窗口, 即注册A窗口
 
    
输入用户名 admin
 
   
 
   
注意: 新浪页面加载慢, 可能需要用到元素等待
 
  
 
  
12.4 示例代码
 
  
driver.implicitly_wait(10)
print("切换前窗口句柄:", driver.current_window_handle)
driver.find_element_by_id("fw").click()
handles = driver.window_handles
print("所有窗口句柄:", handles)
driver.switch_to.window(handles[1])
print("切换后窗口句柄:", driver.current_window_handle)
driver.find_element_by_class_name("inp-txt").clear()
driver.find_element_by_class_name("inp-txt").send_keys("1111111111111")
time.sleep(3)
driver.switch_to.window(handles[0])
print("切换回原窗口句柄:", driver.current_window_handle)
driver.find_element_by_id("userA").send_keys("admin")
 
  
13 窗口截图
 
  
13.1 概念
 
  
什么是窗口截图?
 
  
把当前操作的页面，截图保存到指定位置
 
  
为什么要窗口截图?
 
  
自动化脚本是由程序去执行的，因此有时候打印的错误信息并不是十分明确
 
  
如果在执行出错的时候对当前窗口截图保存，那么通过图片就可以非常直观地看到出错的原因
 
  
13.2 方法
 
  
说明：在Selenium中，提供了截图方法，我们只需要调用即可

方法：
	driver.get_screenshot_as_file(imgpath)
		imgpath：图片保存路径
 
  
13.3 案例
 
  
需求：打开‘注册A.html’页面，完成以下操作
1. 填写注册信息
2. 截图保存
 
  
 
   
核心代码:
 
   
driver.find_element_by_id("userA").send_keys("admin")
# 需提前创建 png 目录
driver.get_screenshot_as_file("./png/123.png")

ps:filepath = "./img/test_{}.png".format(time.strftime("%Y%m%d%H%M%S"))
 
  
 
  
14 验证码处理
 
  
14.1 概念
 
  
什么是验证码?
 
  
一种随机生成的信息（数字、字母、汉字、图片、算术题）等为了防止恶意的请求行为，增加应用的安全性
 
  
为什么要学习验证码?
 
  
在Web应用中，大部分系统在用户登录注册的时候都要求输入验证码，而我们在设计自动化测试脚本的时候，就需要面临处理验证码的问题
 
  
14.2 常用方法
 
  
说明：Selenium中并没有对验证码处理的方法，在这里我们介绍一下针对验证码的几种常用处理方式

方式：
    1. 去掉验证码
    	(测试环境下-采用)
    2. 设置万能验证码
    	(生产环境和测试环境下-采用)
    3. 验证码识别技术
    	(通过Python-tesseract来识别图片类型验证码；识别率很难达到100%)
    4. 记录cookie
    	(通过记录cookie进行跳过登录)
 
  
PS
 
  
1. 去掉验证码、设置万能验证码：都是开发来完成，我们在这里不做讲解
2. 验证码识别技术：成功率不高，验证码种类繁多，不太适合
3. 记录cookie：比较实用，我们对它进行下讲解
 
  
14.3 cookie
 
  
14.3.1 概念
 
  
1. Cookie是由Web服务器生成的，并且保存在用户浏览器上的小文本文件，它可以包含用户相关的信息
2. Cookie数据格式：键值对组成（python中的字典）
3. Cookie产生：客户端请求服务器，如果服务器需要记录该用户状态，就向客户端浏览器颁发一个Cookie数据
4. Cookie使用：当浏览器再次请求该网站时，浏览器把请求的数据和Cookie数据一同提交给服务器，服务器检查该	 Cookie，以此来辨认用户状态
 
  
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-liiZ3JXN-1609329063540)(.\Web自动化测试.assets\image-20200104103932686.png)]
 
  
14.3.2 应用场景
 
  
1. 实现会话跟踪，记录用户登录状态
2. 实现记住密码和自动登录的功能
3. 用户未登录的状态下，记录购物车中的商品
 
  
14.4 selenium操作cookie
 
  
14.4.1 方法
 
  
说明：Selenium中对cookie操作提供相应的方法

方法：
    1. get_cookie(name) 		--> 获取指定cookie
    		name:为cookie的名称
    2. get_cookies() 			--> 获取本网站所有本地cookies
    3. add_cookie(cookie_dict) 	--> 添加cookie
    		cookie_dict：一个字典对象，必选的键包括："name" and "value"
 
  
14.4.2 案例
 
  
需求：使用cookie实现跳过登录
1. 手动登录百度，获取cookie
2. 使用获取到的cookie，达到登录目的，然后就可以执行登录之后的操作
 
  
14.4.3 实现步骤分析
 
  
BDUSS是登录百度后的唯一身份凭证(*.baidu.com)，拿到BDUSS就等于拿到帐号的控制权，通行贴吧、知道、百科、文库、空间、百度云等百度主要产品。

1. 登录baidu，登录成功后抓取 (BDUSS)
2. 使用add_cookie()方法，添加 (BDUSS)键和值
3. 调用刷新方法 driver.refresh()
 
  
14.4.4 示例代码
 
  
from selenium import webdriver
import time

driver = webdriver.Chrome()

driver.get("http://www.baidu.com")
driver.add_cookie({'name': 'BDUSS', 'value': '根据实际填写'})
time.sleep(3)
driver.refresh()

time.sleep(3)
driver.quit()
 
  
第三章 Pytest框架
 
  
1 总体介绍
 
  
1.1 什么是框架
 
  
说明：
1. 框架英文单词framework
2. 为解决一类事情的功能集合
 
  
1.2 什么是Pytest框架
 
  
Pytest框架 是一个第三方单元测试框架，用它来做单元测试
 
  
 
   
UnitTest 是Python自带的一个单元测试框架
 
  
 
  
1.3 为什么使用Pytest
 
  
1. 能够组织多个用例去执行
2. 提供丰富的断言方法
3. 能够生成测试报告
 
  
2 基本使用
 
  
2.1 安装
 
  
安装
 
  
pip install pytest
# pip install pytest==3.10
 
  
 
   
推荐安装 3.10 的版本, 兼容性较好
 
  
 
  
校验
 
  
 
   
进入命令行
 
   
输入命令 pytest --version 会展示当前已安装的版本
 
  
 
  
2.2 运行方式
 
  
2.2.1 方式介绍
 
  
方式1. 命令行模式【建议】
方式2. 主函数模式
 
  
2.2.2 代码准备
 
  
test_login.py
 
  
class TestLogin:

    def test_a(self):   # test开头的测试函数
        print("----->test_a")

    def test_b(self):
        print("----->test-b")
 
  
2.2.3 命令行运行
 
  
命令行中执行:
pytest -s test_login.py
 
  
 
   
-s 表示支持控制台打印，如果不加，print 不会出现任何内容
 
  
 
  
2.2.4 主函数运行
 
  
在 test_login.py 文件中增加主函数:
# 需要先导入包： import pytest
if __name__ == '__main__':
    pytest.main(["-s", "test_login.py"])
 
  
2.2.5 运行结果
 
  
test_login.py ----->test_a
.----->test_b
F
 
  
 
   
. 表示成功
 
   
F 表示失败
 
  
 
  
2.3 断言
 
  
2.3.1 什么是断言
 
  
让程序代替人为判断测试程序执行结果是否符合预期结果的过程
 
  
2.3.2 为什么学习断言
 
  
自动化脚本在执行的时候一般都是无人值守状态，我们不知道执行结果是否符合预期结果，所以我们需要让程序代替人为检测程序执行的结果是否符合预期结果，这就需要使用断言
 
  
2.3.3 断言方法
 
  
assert xx		-->判断xx为真
assert not xx	-->判断xx不为真
assert a in b	-->判断b包含a
assert a == b	-->判断a等于b
assert a != b	-->判断a不等于b
 
  
 
   
对比UinitTest的断言:
  
  
 
  
2.3.4 案例
 
  
需求：
1. 写一个计算加法的函数, 要求可以输入两个参数
2. 写两个测试脚本, 测试加法计算结果, 一个断言成功, 另一个断言失败
3. 运行并查看结果
 
  
2.3.4 示例代码
 
  
test_demo.py
 
  
def add(x, y):
    return x + y


class TestDemo:

    def test_a(self):
        assert 2 == add(1, 1)

    def test_b(self):
        assert 4 == add(2, 1)
 
  
3 setup和teardown
 
  
3.1 应用场景
 
  
pytest 在运行自动化脚本的前后会执行两个特殊的方法，分别是“前置” 和“后置”方法。
在执行脚本前会执行“前置”方法，在执行脚本后会执行 “后置”方法。
有了这两个方法，我们可以在“前置”方法中获取驱动对象，在“后置”方法中关闭驱动对象。
 
  
3.2 概念和方法
 
  
1. 初始化(前置处理):
	def setup(self) 	--> 首先自动执行
2. 销毁(后置处理):
	def teardown(self) 	--> 最后自动执行
3. 运行于测试方法的始末，即：运行一次测试方法就会运行一次setUp和tearDown
 
  
3.3 案例
 
  
需求：在一个测试类中定义多个测试方法，查看每个测试方法执行完所花费的时长
 
  
3.4 示例代码
 
  
test_demo.py
 
  
import time

def add(x, y):
    return x + y

class TestDemo:

    def setup(self):
        print("start-time:", time.time())

    def teardown(self):
        print("end-time:", time.time())

    def test_a(self):
        assert 2 == add(1, 1)

    def test_b(self):
        assert 3 == add(2, 1)
 
  
4 配置文件
 
  
4.1 应用场景
 
  
使用配置文件, 可以通过配置项来选择执行哪些目录下的哪些测试模块。
 
  
4.2 用法
 
  
步骤:
1. 项目下新建 scripts 模块
2. 将测试脚本文件放到 scripts 中
3. pytest 的配置文件放在自动化项目目录下
4. 名称为 pytest.ini
5. 第一行内容为 [pytest] , 后面写具体的配置参数
6. 命令行运行时会使用该配置文件中的配置
 
  
4.3 示例
 
  
 
   
可以直接拿来复制粘贴
 
  
 
  
[pytest]
addopts = -s
testpaths = ./scripts
python_files = test_*.py
python_classes = Test*
python_functions = test_*
 
  
 
   
addopts = -s
 
   
表示命令行参数
 
   
testpaths，python_files，python_classes，python_functions
 
   
表示执行 scripts 文件夹下的 test_ 开头 .py 结尾的文件下的 Test 开头的类下的 test_开头的函数
 
  
 
  
4.4 注意点
 
  
1. 配置文件是否已经正确的加载？
   - 通过控制台的 inifile 进行查看
2. windows中可能出现 “gbk” 错误？
   - 删除 ini 文件中的所有中文
3. 在工作中这个文件也需要复制粘贴？
   - 是的，一个项目只会用一次，只需理解，会修改即可
 
  
5 测试报告插件
 
  
5.1 应用场景
 
  
自动化测试脚本最终执行是通过还是不通过，需要通过测试报告进行体现
 
  
5.2 安装
 
  
使用命令 pip install pytest-html 进行安装
 
  
 
   
install pytest-html==1.21.1 在最新的2.0上有错误
 
  
 
  
5.3 使用
 
  
在配置文件中的命令行参数中增加 --html=用户路径/report.html
 
  
 
   
示例: pytest.ini 中
 
   
addopts = -s --html=report/report.html
 
  
 
  
5.4 生成报告
 
  
步骤:
1. 命令行输入 pytest 运行脚本
2. 在项目目录下会对一个 report 文件夹，里面有个 report.html 即为测试报告
 
  
6 数据参数化
 
  
6.1 应用场景
 
  
登录功能都是输入用户名，输入密码，点击登录。但登录的用户名和密码如果想测试多个值时, 数据参数化可以使代码更整洁, 可读性更好
 
  
6.2 方法
 
  
# 数据参数化 
# 参数： 
# 	argnames：参数名 
# 	argvalues：参数对应值，类型必须为可迭代类型，一般使用list @pytest.mark.parametrize(argnames, argvalues)
 
  
6.3 使用
 
  
在需要参数化的测试脚本之上加上装饰器 @pytest.mark.parametrize(argnames, argvalues)
 
  
6.4 案例准备
 
  
# 要求:
# 不使用数据参数化的情况下, 写两个函数, 分别打印用户名 zhangsan 和 lisi
 
  
    def test_a(self):
        print("zhangsan")
        
    def test_b(self):
        print("lisi")
 
  
6.5 单一参数
 
  
示例
 
  
# 要求:
# 使用单一参数的数据参数化, 修改上面的代码
 
  
    @pytest.mark.parametrize("name", ["zhangsan", "lisi"])
    def test_a(self, name):
        print(name)
 
  
结果
 
  
scripts\test_login.py zhangsan
.lisi
.
 
  
6.6 多个参数
 
  
示例
 
  
# 要求:
# 使用多个参数的数据参数化, 分别打印2组账号和密码: zhangsan / 111111 和 lisi / 222222
 
  
    @pytest.mark.parametrize(("username", "password"), [("zhangsan","111111"), ("lisi","222222")])
    def test_a(self, username, password):
        print(username + "---" + password)
 
  
结果
 
  
scripts\test_login.py zhangsan---111111
.lisi---222222
.
 
  
6.7 推荐用法
 
  
示例
 
  
# 要求:
# 使用扩展, 增加数据可读性, 使用字典作为参数列表中的每个元素, 修改上面得案例
 
  
    @pytest.mark.parametrize("params", [{"username": "zhangsan","password": "111"},{"username": "lisi","password": "222"}])
    def test_a(self, params):
        print(params)
 
  
结果
 
  
scripts\test_login.py {'username': 'zhangsan', 'password': '111'}
.{'username': 'lisi', 'password': '222'}
.
 
  
第四章 PO模式
 
  
学习路线
 
  
 
   
V1: 不使用任何设计模式和单元测试框 （面向过程式）
 
   
V2: 使用 Pytest 管理用例
 
   
V3: 使用方法封装的思想, 对代码进行优化
 
   
V4: 采用PO模式的分层思想对代码进行拆分, 分离page
 
   
V5: 对PO分层之后的代码继续优化, 分离page中的元素和操作
 
   
V6: PO模式深入封装, 把共同操作提取封装
 
  
 
  
1 无模式
 
  
1.1 案例说明
 
  
对TPshop项目的登录模块进行自动化测试
 
  
 
   
提示：登录模块包含了很多测试用例，比如：账号不存在、密码错误、验证码错误、登录成功等等
 为了节省时间我们只选取几个有代表性的用例来演示
 
  
 
  
1.2 选择测试用例
 
  
 
   
账号不存在 
    
 
     
点击首页的 ‘登录’ 链接，进入登录页面
 
     
输入一个不存在的用户名
 
     
输入密码
 
     
输入验证码
 
     
点击登录按钮
 
     
获取错误提示信息
 
    
 
 
   
密码错误 
    
 
     
点击首页的 ‘登录’ 链接，进入登录页面
 
     
输入用户名
 
     
输入一个错误的密码
 
     
输入验证码
 
     
点击登录按钮
 
     
获取错误提示信息
 
    
 
 
  
 
  
1.3 v1版本
 
  
1.3.1 总体介绍
 
  
 
   
不使用任何设计模式和单元测试框架
 
   
每个文件里编写一个用例，完全的面向过程的编程方式
 
  
 
  
1.3.2 示例代码
 
  
 
   
 
登录功能, 账号不存在, test_login_account_not_exist.py
 
# 账号不存在
import time
from selenium import webdriver

# 实例化浏览器驱动
driver = webdriver.Chrome()
driver.maximize_window()
driver.implicitly_wait(10)
driver.get('http://localhost/')

# 1. 点击首页的‘登录’链接，进入登录页面
driver.find_element_by_class_name('red').click()
# 2. 输入一个不存在的用户名
driver.find_element_by_id('username').send_keys('17100000000')
# 3. 输入密码
driver.find_element_by_id('password').send_keys('123456')
# 4. 输入验证码
driver.find_element_by_id('verify_code').send_keys('8888')
# 5. 点击登录按钮
driver.find_element_by_name('sbtbutton').click()
# 6. 获取错误提示信息
# msg = driver.find_element_by_css_selector('.layui-layer-content').text
msg = driver.find_element_by_xpath("//*[@id='layui-layer1']/div[2]").text
print(msg)

# 关闭浏览器
time.sleep(5)
driver.quit()
 
 
   
 
登录功能, 密码错误, test_login_password_error.py
 
# 密码错误
import time
from selenium import webdriver

# 实例化浏览器驱动
driver = webdriver.Chrome()
driver.maximize_window()
driver.implicitly_wait(10)
driver.get('http://localhost/')

# 1. 点击首页的‘登录’链接，进入登录页面
driver.find_element_by_class_name('red').click()
# 2. 输入一个已存在的用户名
driver.find_element_by_id('username').send_keys('17150312012')
# 3. 输入错误密码
driver.find_element_by_id('password').send_keys('error')
# 4. 输入验证码
driver.find_element_by_id('verify_code').send_keys('8888')
# 5. 点击登录按钮
driver.find_element_by_name('sbtbutton').click()
# 6. 获取错误提示信息
msg = driver.find_element_by_css_selector('.layui-layer-content').text
print(msg)

# 关闭浏览器
time.sleep(5)
driver.quit()
 
 
  
 
  
1.3.3 存在的问题
 
  
 
   
一条测试用例对应一个文件，用例较多时不方便管理维护
 
   
代码高度冗余
 
  
 
  
1.4 v2版本
 
  
1.4.1 总体介绍
 
  
引入Pytest管理用例, 并断言用例的执行结果
 
  
好处
 
  
 
   
方便组织、管理多个测试用例
 
   
提供了丰富的断言方法
 
   
方便生成测试报告
 
   
减少了代码冗余
 
  
 
  
1.4.2 示例代码
 
  
# 1.导包
import time
from selenium import webdriver


# 2.定义测试类
class TestLogin:

    def setup(self):
        self.driver = webdriver.Chrome()
        self.driver.maximize_window()
        self.driver.implicitly_wait(10)
        self.driver.get('http://localhost/')

    def teardown(self):
        # 关闭浏览器
        time.sleep(5)
        self.driver.quit()

    # 定义账户不存在测试方法
    def test_login_accout_not_exist(self):
        # 1. 点击首页的‘登录’链接，进入登录页面
        self.driver.find_element_by_class_name('red').click()
        # 2. 输入一个不存在的用户名
        self.driver.find_element_by_id('username').send_keys('17100000000')
        # 3. 输入密码
        self.driver.find_element_by_id('password').send_keys('123456')
        # 4. 输入验证码
        self.driver.find_element_by_id('verify_code').send_keys('8888')
        # 5. 点击登录按钮
        self.driver.find_element_by_name('sbtbutton').click()
        # 6. 获取错误提示信息
        msg = self.driver.find_element_by_css_selector('.layui-layer-content').text
        print(msg)
        # 断言
        assert "账号不存在!" == msg

    # 定义密码错误的测试
    def test_login_password_error(self):
        # 1. 点击首页的‘登录’链接，进入登录页面
        self.driver.find_element_by_class_name('red').click()
        # 2. 输入一个已存在的用户名
        self.driver.find_element_by_id('username').send_keys('17150312012')
        # 3. 输入错误密码
        self.driver.find_element_by_id('password').send_keys('error')
        # 4. 输入验证码
        self.driver.find_element_by_id('verify_code').send_keys('8888')
        # 5. 点击登录按钮
        self.driver.find_element_by_name('sbtbutton').click()
        # 6. 获取错误提示信息
        msg = self.driver.find_element_by_css_selector('.layui-layer-content').text
        print(msg)
        # 断言
        assert "密码错误!" == msg
 
  
1.4.3 存在的问题
 
  
代码冗余
 
  
#获取驱动的代码冗余，如果有多个test文件，则需要多次重复编写创建驱动
 
  
2 方法封装
 
  
2.1 封装方法
 
  
概念
 
  
是将一些有共性的或多次被使用的代码提取到一个方法中，供其他地方调用
 
  
好处
 
  
 
   
避免代码冗余
 
   
容易维护
 
   
隐藏代码实现的细节
 
  
 
  
目的
 
  
用最少的代码实现最多的功能
 
  
2.2 v3版本
 
  
2.2.1 总体介绍
 
  
使用方法封装的思想，对代码进行优化
 
  
2.2.2 封装驱动
 
  
 
   
定义获取驱动对象的工具类
 
  
 
  
utils.py
 
  
# 获取/关闭浏览器驱动的类
from selenium import webdriver


class DriverUtils:
    __driver = None

    # 获取浏览器驱动
    @classmethod
    def get_driver(cls):
        if cls.__driver is None:
            cls.__driver = webdriver.Chrome()
            cls.__driver.maximize_window()
            cls.__driver.implicitly_wait(10)
        return cls.__driver

    # 关闭浏览器驱动
    @classmethod
    def quit_driver(cls):
        if cls.__driver is not None:
            cls.__driver.quit()
            cls.__driver = None
 
  
test_login.py
 
  
# 1.导包
import time
from selenium import webdriver
from utils import DriverUtils

# 2.定义测试类
class TestLogin:

    def setup(self):
        self.driver = DriverUtils.get_driver()
        self.driver.get('http://localhost/')

    def teardown(self):
        DriverUtils.quit_driver()

    # 定义账户不存在测试方法
    def test_login_accout_not_exist(self):
        # 1. 点击首页的‘登录’链接，进入登录页面
        self.driver.find_element_by_class_name('red').click()
        # 2. 输入一个不存在的用户名
        self.driver.find_element_by_id('username').send_keys('17100000000')
        # 3. 输入密码
        self.driver.find_element_by_id('password').send_keys('123456')
        # 4. 输入验证码
        self.driver.find_element_by_id('verify_code').send_keys('8888')
        # 5. 点击登录按钮
        self.driver.find_element_by_name('sbtbutton').click()
        # 6. 获取错误提示信息
        msg = self.driver.find_element_by_css_selector('.layui-layer-content').text
        print(msg)
        # 断言
        assert "账号不存在!" == msg

    # 定义密码错误的测试
    def test_login_password_error(self):
        # 1. 点击首页的‘登录’链接，进入登录页面
        self.driver.find_element_by_class_name('red').click()
        # 2. 输入一个已存在的用户名
        self.driver.find_element_by_id('username').send_keys('17150312012')
        # 3. 输入错误密码
        self.driver.find_element_by_id('password').send_keys('error')
        # 4. 输入验证码
        self.driver.find_element_by_id('verify_code').send_keys('8888')
        # 5. 点击登录按钮
        self.driver.find_element_by_name('sbtbutton').click()
        # 6. 获取错误提示信息
        msg = self.driver.find_element_by_css_selector('.layui-layer-content').text
        print(msg)
        # 断言
        assert "密码错误!" == msg
 
  
2.2.3 存在的问题
 
  
代码冗余
 
  
3 PO模式介绍
 
  
3.1 思考
 
  
在做UI自动化时定位元素特别依赖页面，一旦页面发生变更就不得不跟着去修改定位元素的代码
 
  
 
   
举例:
 
   
假设要对一个元素进行点击操作，而且会经常用到，那么你就可能会编写多处如下代码
 
   
driver.find_element_by_id("login-btn").click()
 
  
 
  
存在的问题
 
  
 
   
如果开发人员修改了这个元素的id，这时候你就不得不修改所有对应的代码
 
   
存在大量冗余代码
 
  
 
  
 
   
如何解决呢?
 
  
 
  
3.2 PO模式概念（一个页面一个对象）
 
  
PO是Page Object的缩写，PO模式是自动化测试项目开发实践的最佳设计模式之一
 
  
 
   
核心思想:
 
   
 
    
通过对界面元素的封装减少冗余代码，同时在后期维护中，若元素定位发生变化， 只需要调整页面元素封装的代码，提高测试用例的可维护性、可读性
 
    
页面和测试脚本分离
 
   
 
  
 
  
3.3 PO模式分层
 
  
分层机制，让不同层去做不同类型的事情，让代码结构清晰，增加复用性
 
  
主要有以下几种分层方式
 
  
 
   
 
两层： 对象操作层+业务数据层
 
    
 
     
 
      
对象操作层: 封装页面信息, 包括元素以及对元素的操作 
       
 
        
对象操作层中，页面的元素是对象，点击输入等行为是操作
 
       
 
 
      
业务数据层: 封装多操作组合的业务以及测试数据 
       
 
        
业务数据层中，test脚本中执行的是业务流程只需要关注业务，并且测试数据也是在此层传入
 
       
 
 
     
 
    
 
 
   
 
三层：对象库层+操作层+业务数据层
 
    
 
     
 
      
对象层：封装页面元素的定位方法
 
      
操作层：封装对元素的操作 （点击输入等）
 
      
业务数据层：将一个或多个操作组合起来完成一个业务功能。比如登录：需要输入帐号、密码、点击登录三个操作，以及操作所需要的数据
 
     
 
    
 
 
   
 
四层：对象库层+操作层+业务层+数据层
 
 
  
 
  
3.4 PO模式的优点
 
  
 
   
引入PO模式前 
    
 
     
存在大量冗余代码
 
     
业务流程不清晰
 
     
后期维护成本大
 
    
 
 
   
引入PO模式后 
    
 
     
减少冗余代码
 
     
业务代码和测试代码被分开，降低耦合性
 
     
维护成本低
 
    
 
 
  
 
  
4 PO模式实践
 
  
4.1 v4版本
 
  
4.1.1 总体介绍
 
  
采用PO模式的分层思想对代码进行拆分
 
  
4.2.2 PO封装
 
  
 
   
 
对登录页面进行封装
 
    
 
     
LoginPage
 
    
 
 
   
 
编写测试用例
 
    
 
     
TestLogin
 
    
 
 
  
 
  
4.2.3 示例代码
 
  
结构
 
  
- utils
  -- utils.py
- page
  -- login_page.py
- scripts
  -- test_login.py
- pytest.ini
 
  
核心代码
 
  
utils.py
 
  
class DriverUtils:
    __driver = None

    # 获取浏览器驱动
    @classmethod
    def get_driver(cls):
        if cls.__driver is None:
            cls.__driver = webdriver.Chrome()
            cls.__driver.maximize_window()
            cls.__driver.implicitly_wait(10)
        return cls.__driver

    # 关闭浏览器驱动
    @classmethod
    def quit_driver(cls):
        if cls.__driver is not None:
            cls.__driver.quit()
            cls.__driver = None
 
  
login_page.py
 
  
class LoginPage:

    def __init__(self, driver):
        self.driver = driver

    # 1. 点击首页的‘登录’链接，进入登录页面
    def click_login_link(self):
        return self.driver.find_element_by_class_name('red').click()

    # 2. 输入一个不存在的用户名
    def input_username(self, username):
        return self.driver.find_element_by_id('username').send_keys(username)

    # 3. 输入密码
    def input_password(self, password):
        return self.driver.find_element_by_id('password').send_keys(password)

    # 4. 输入验证码
    def input_verify_code(self, code):
        return self.driver.find_element_by_id('verify_code').send_keys(code)

    # 5. 点击登录按钮
    def click_login_btn(self):
        return self.driver.find_element_by_name('sbtbutton').click()

    # 6. 获取错误提示信息
    def get_msg(self):
        msg = self.driver.find_element_by_css_selector('.layui-layer-content').text
        return msg
 
  
test_login.py
 
  
import time
from page.login_page import LoginPage
from utils.utils import DriverUtils


class TestLogin:

    def setup(self):
        self.driver = DriverUtils.get_driver()
        self.login_page = LoginPage(self.driver)
        self.driver.get('http://localhost/')

    def teardown(self):
        time.sleep(3)
        DriverUtils.quit_driver()

    # 定义账户不存在测试方法
    def test_login_accout_not_exist(self):
        # 1. 点击首页的‘登录’链接，进入登录页面
        self.login_page.click_login_link()
        # 2. 输入一个不存在的用户名
        self.login_page.input_username("17100000000")
        # 3. 输入密码
        self.login_page.input_password("123456")
        # 4. 输入验证码
        self.login_page.input_verify_code("8888")
        # 5. 点击登录按钮
        self.login_page.click_login_btn()
        # 6. 获取错误提示信息
        print(self.login_page.get_msg())
        # 断言
        assert "账号不存在!" == self.login_page.get_msg()

    # 定义密码错误的测试
    def test_login_password_error(self):
        # 1. 点击首页的‘登录’链接，进入登录页面
        self.login_page.click_login_link()
        # 2. 输入一个已存在的用户名
        self.login_page.input_username("17150312012")
        # 3. 输入错误密码
        self.login_page.input_password("error")
        # 4. 输入验证码
        self.login_page.input_verify_code("8888")
        # 5. 点击登录按钮
        self.login_page.click_login_btn()
        # 6. 获取错误提示信息
        print(self.login_page.get_msg())
        # 断言
        assert "密码错误!" == self.login_page.get_msg()

 
  
pytest.ini
 
  
[pytest]
addopts = -s
testpaths = ./scripts
python_files = test_*.py
python_classes = Test*
python_functions = test_*
 
  
可以看到test脚本下方法的操作都是一致的 只是用例的数据不一样，这时候我们可以使用参数化的形式：
 
  
@pytest.mark.parametrize("params",[{},{}])
 
  
4.2 v5版本
 
  
4.2.1 总体介绍
 
  
对PO分层后的代码继续优化
 
  
4.2.2 优化内容
 
  
 
   
分离page页面中的元素和操作
 
   
优化元素定位方式
 
  
 
  
4.2.3 示例代码
 
  
只变更了 login_page.py
 
  
from selenium.webdriver.common.by import By


class LoginPage:

    # 登录链接 按钮
    login_link_btn = By.CLASS_NAME, "red"

    # 用户名 输入框
    username_input = By.ID, "username"

    # 密码 输入框
    password_input = By.ID, "password"

    # 验证码 输入框
    verify_code_input = By.ID, "verify_code"

    # 登录 按钮
    login_btn = By.NAME, "sbtbutton"

    # 提示信息
    msg_info = By.CSS_SELECTOR, ".layui-layer-content"

    def __init__(self, driver):
        self.driver = driver

    def find_el(self, feature):
        return self.driver.find_element(*feature)

    # 1. 点击首页的‘登录’链接，进入登录页面
    def click_login_link(self):
        return self.find_el(self.login_link_btn).click()
        # return self.driver.find_element(self.login_link_btn[0], self.login_link_btn[1]).click()
        # return self.driver.find_element_by_class_name('red').click()

    # 2. 输入一个不存在的用户名
    def input_username(self, username):
        return self.find_el(self.username_input).send_keys(username)
        # return self.driver.find_element_by_id('username').send_keys(username)

    # 3. 输入密码
    def input_password(self, password):
        return self.find_el(self.password_input).send_keys(password)
        # return self.driver.find_element_by_id('password').send_keys(password)

    # 4. 输入验证码
    def input_verify_code(self, code):
        return self.find_el(self.verify_code_input).send_keys(code)
        # return self.driver.find_element_by_id('verify_code').send_keys(code)

    # 5. 点击登录按钮
    def click_login_btn(self):
        return self.find_el(self.login_btn).click()
        # return self.driver.find_element_by_name('sbtbutton').click()

    # 6. 获取错误提示信息
    def get_msg(self):
        msg = self.find_el(self.msg_info).text
        # msg = self.driver.find_element_by_css_selector('.layui-layer-content').text
        return msg
 
  
5 PO模式深入封装
 
  
5.1 v6版本
 
  
5.1.1 总体介绍
 
  
把共同的方法进行封装
 
  
5.1.2 优化内容
 
  
 
   
封装操作基类 
    
 
     
封装查找元素的方法
 
     
封装基本操作方法: 点击/ 清空/ 输入 等
 
    
 
 
   
page继承操作类
 
  
 
  
5.1.3 示例代码
 
  
结构
 
  
- base
  -- base_action.py
- utils
  -- utils.py
- page
  -- login_page.py
- scripts
  -- test_login.py
- pytest.ini
 
  
代码
 
  
base_aciton.py
 
  
class BaseAction:

    def __init__(self, driver):
        self.driver = driver

    def find_el(self, feature):
        return self.driver.find_element(*feature)

    def find_els(self, feature):
        return self.driver.find_elements(*feature)

    def input(self, feature, context):
        return self.find_el(feature).send_keys(context)

    def click(self, feature):
        return self.find_el(feature).click()

    def clear(self, feature):
        return self.find_el(feature).clear

 
  
login_page.py
 
  
from selenium.webdriver.common.by import By
from base.base_action import BaseAction


class LoginPage(BaseAction):

    # 登录链接 按钮
    login_link_btn = By.CLASS_NAME, "red"

    # 用户名 输入框
    username_input = By.ID, "username"

    # 密码 输入框
    password_input = By.ID, "password"

    # 验证码 输入框
    verify_code_input = By.ID, "verify_code"

    # 登录 按钮
    login_btn = By.NAME, "sbtbutton"

    # 提示信息
    msg_info = By.CSS_SELECTOR, ".layui-layer-content"

    # 1. 点击首页的‘登录’链接，进入登录页面
    def click_login_link(self):
        return self.click(self.login_link_btn)
        # return self.find_el(self.login_link_btn).click()

    # 2. 输入一个不存在的用户名
    def input_username(self, context):
        return self.input(self.username_input, context)
        # return self.find_el(self.username_input).send_keys(username)

    # 3. 输入密码
    def input_password(self, context):
        return self.input(self.password_input, context)
        # return self.find_el(self.password_input).send_keys(password)

    # 4. 输入验证码
    def input_verify_code(self, context):
        return self.input(self.verify_code_input, context)
        # return self.find_el(self.verify_code_input).send_keys(code)

    # 5. 点击登录按钮
    def click_login_btn(self):
        return self.click(self.login_btn)
        # return self.find_el(self.login_btn).click()

    # 6. 获取错误提示信息
    def get_msg(self):
        msg = self.find_el(self.msg_info).text
        return msg
 
  
第五章 数据驱动
 
  
1 数据驱动介绍
 
  
1.1 数据驱动概念
 
  
数据驱动: 是以数据来驱动整个测试用例的执行，也就是测试数据决定测试结果
 
  
 
   
比如我们要测试加法，我们的测试数据是1和1，测试结果就是2，如果测试数据是1和2，测试结果就是3
 
  
 
  
1.2 数据驱动特点
 
  
 
   
可以把数据驱动理解为一种模式或者一种思想
 
   
数据驱动技术可以将用户把关注点放在对测试数据的构建和维护上，而不是直接维护脚本，可以利用同样的过程对不同的数据输入进行测试
 
   
数据驱动的实现要依赖参数化的技术
 
  
 
  
1.3 数据来源
 
  
 
   
直接定义在测试脚本中（简单直观，但代码和数据未实现真正的分离，不方便后期维护）
 
   
从文件读取数据，如JSON、excel、xml、txt等格式文件
 
   
从数据库中读取数据
 
  
 
  
2 JSON操作
 
  
2.1 JSON基本介绍
 
  
2.1.1 JSON概念
 
  
JSON的全称是”JavaScript Object Notation”，是JavaScript对象表示法，它是一种基于文本，独立于语言的轻量级数据交换格式
 
  
2.1.2 JSON特点
 
  
特点
 
  
 
   
JSON是纯文本
 
   
JSON具有良好的自我描述性，便于阅读和编写
 
   
JSON具有清晰的层级结构
 
   
有效地提升网络传输效率
 
  
 
  
对比XML
 
  
 
   
XML 指可扩展标记语言, XML 被设计用来传输和存储数据
 
  
 
  

	<name>tomname>
	<age>18age>
	<isMan>trueisMan>
	<school />
	<address>
		<country>中国country>
		<city>广州city>
	address>
	<numbers>2numbers>
	<numbers>4numbers>
	<numbers>6numbers>
	<numbers>8numbers>
	<like_links>
		<name>Baiduname>
		<url>http://www.baidu.comurl>
	like_links>
	<like_links>
		<name>TaoBaoname>
		<url>http://www.taobao.comurl>
	like_links>
 
  
{
	"name": "tom",
	"age": 18,
	"isMan": true,
	"school": null,
	"address": {
		"country": "中国",
		"city": "广州"
	},
	"numbers": [2, 4, 6, 8],
	"like_links": [
		{
			"name": "Baidu",
			"url": "http://www.baidu.com"
		},
		{
			"name": "TaoBao",
			"url": "http://www.taobao.com"
		}
	]
}
 
  
 
   
如果使用XML，需要读取XML文档，然后用XML DOM来遍历文档并读取值并存储在变量中
 使用JSON，只需读取JSON字符串
 
  
 
  
2.1.3 JSON语法规则
 
  
- 大括号保存对象
- 中括号保存数组
- 对象数组可以相互嵌套
- 数据采用键值对表示
- 多个数据由逗号分隔
 
  
2.1.4 JSON值
 
  
- 数字（整数或浮点数）
- 字符串（在双引号中）
- 逻辑值（true 或 false）
- 数组（在中括号中）
- 对象（在大括号中）
- null  
 
  
2.2 JSON基本操作
 
  
2.2.1 总体介绍
 
  
操作内容
 
  
 
   
python字典与JSON之间的转换
 
   
JSON文件读写
 
  
 
  
 
   
在python中想要操作 JSON, 需要先导入依赖包
 
   
import json
 
  
 
  
2.2.2 字典与JSON转换
 
  
把python字典类型转换为JSON字符串
 
  
# 定义一个字典对象
dict_str = {
    "name": "zhangsan",
    "age": 18,
    "is_man": False,
    "school": None
}
# python字典转换成json格式数据
json_str = json.dumps(dict_str)
 
  
把JSON字符串转换为python字典
 
  
# 定义一个JSON字符串
json_str = '{"name": "zhangsan", "age": 18, "is_man": false, "school": null}'

# json格式数据转换成python字典
json.loads(json_str)
 
  
2.2.3 JSON文件读写
 
  
准备数据
 
  
{
	"name": "tom",
	"age": 18,
	"isMan": true,
	"school": null,
	"address": {
		"country": "中国",
		"city": "广州"
	},
	"numbers": [2, 4, 6, 8],
	"like_links": [
		{
			"name": "Baidu",
			"url": "http://www.baidu.com"
		},
		{
			"name": "TaoBao",
			"url": "http://www.taobao.com"
		}
	]
}
 
  
读取JSON文件 + 写入JSON文件
 
  
import json

# 读json文件"data.json"
with open("data.json", "r", encoding="utf-8") as f:
    data = json.load(f)
    print(data)

# 把data2这个字典写入json文件"data2.json"
data2 = data
with open("data2.json", "w", encoding="utf-8") as f:
    json.dump(data2, f)

 
  
3 数据驱动实战一
 
  
为什么我们要把json文件的数据转换成字典呢？
 
  
如果需要读取数据，我们采用的是字典方式读取，而json数据是字符串，使用之前我们需要先转换成字典。
 
  
3.1 案例介绍
 
  
对tpshop项目的登录模块进行自动化测试, 需要使用数据驱动
 
  
 
   
为v6版本增加数据驱动
 
  
 
  
3.2 实现步骤
 
  
 
   
编写测试用例
 
   
采用PO模式的分层思想对页面进行封装
 
   
编写测试脚本
 
   
定义数据文件, 实现参数化
 
  
 
  
3.3 用例设计
 
  
账号不存在!
 
  
密码错误!
 
  
3.4 测试脚本参数化
 
  
核心代码
 
  
# 分析测试脚本参数化模板
dict1 = {"username": "17100000000", "password": "123456", "code": "8888", "msg": "账号不存在!"}
    dict2 = {"username": "17150312012", "password": "error", "code": "8888", "msg": "密码错误!"}
    @pytest.mark.parametrize("params", [dict1, dict2])
    def test_login(self, params):
        self.login_page.click_login_link()
        self.login_page.input_username(params["username"])
        self.login_page.input_password(params["password"])
        self.login_page.input_verify_code(params["code"])
        self.login_page.click_login_btn()
        print(self.login_page.get_msg())
        assert params["msg"] == self.login_page.get_msg()
 
  
3.5 数据文件
 
  
新建 ./data/login_data.json 文件
 
  
{
    "login_001_account_exist": {
        "username": "17100000000",
        "password": "123456",
        "code": "8888",
        "msg": "账号不存在!"
    },
    "login_002_password_error": {
        "username": "17150312012",
        "password": "error",
        "code": "8888",
        "msg": "密码错误!"
    }
}
 
  
3.6 数据解析函数
 
  
需要对json数据文件进行解析, 在test_login.py中, 写一个解析函数
 
  
def analyze_data():
    with open("./data/login_data.json", "r", encoding="utf-8") as f:
        list_data = []
        dict_data = json.load(f)
        for value in dict_data.values():
            list_data.append(value)
        return list_data
 
  
3.7 抽离解析函数
 
  
在base包中新建base_analyze.py文件
 
  
import json


def analyze_data(filename):
    with open("./data/" + filename, "r", encoding="utf-8") as f:
        list_data = []
        dict_data = json.load(f)
        for value in dict_data.values():
            list_data.append(value)
        return list_data
 
  
在test_login.py中进行调用, 核心代码如下
 
  
    @pytest.mark.parametrize("params", analyze_data("login_data.json"))
    def test_login(self, params):
        self.login_page.click_login_link()
        self.login_page.input_username(params["username"])
        self.login_page.input_password(params["password"])
        self.login_page.input_verify_code(params["code"])
        self.login_page.click_login_btn()
        print(self.login_page.get_msg())
        assert params["msg"] == self.login_page.get_msg()
 
  
4 数据驱动实战二
 
  
4.1 案例介绍
 
  
对网页计算器，进行加法的测试操作。通过读取数据文件中的数据来执行用例
 
  
 
   
网址: http://cal.apple886.com/
 
  
 
  
4.2 实现步骤
 
  
 
   
编写测试用例
 
   
采用PO模式的分层思想对页面进行封装
 
   
编写测试脚本
 
   
定义数据文件, 实现参数化
 
  
 
  
4.3 copy框架代码
 
  
4.4 修改page文件
 
  
4.5 抽离数字定位方法
 
  
4.6 编写测试脚本
 
  
4.7 案例代码
 
  
目录
 
  
-- base
	-- base_action.py
	-- base_analyze.py
-- data
	-- cal_data.json
-- page
	-- cal_page.py
-- scripts
	-- test_add.py
-- utils
	-- utils.py
pytest.ini
 
  
代码
 
  
base和utils包的内容基本不变, 其中base_action.py 有新增数字定位方法
 
  
    def find_ele_num(self, feature, digit):
        return self.driver.find_element(feature[0], feature[1].format(str(digit)))
 
  
data/cal_data.json
 
  
{
    "add_001_xxx": {
        "data": [1, 2],
        "result": 3
    },
    "add_001_xxxx": {
        "data": [1, 2, 3],
        "result": 6
    }
}
 
  
page/cal_page.py
 
  
from selenium.webdriver.common.by import By
from base.base_action import BaseAction


class CalPage(BaseAction):

    # 数字 按钮
    digit_btn = By.ID, "simple{}"

    # 加法 按钮
    add_btn = By.ID, "simpleAdd"

    # 等号 按钮
    eq_btn = By.ID, "simpleEqual"

    # 计算结果
    result = By.ID, "resultIpt"

    # 点击数字
    def click_digit_btn(self, num):
        return self.find_ele_num(self.digit_btn, num).click()

    # 点击加法
    def click_add_btn(self):
        return self.click(self.add_btn)

    # 点击等号
    def click_eq_btn(self):
        return self.click(self.eq_btn)

    # 获取结果
    def get_result(self):
        return self.find_el(self.result).get_attribute("value")
 
  
scripts/test_add.py
 
  
import time
import pytest
from base.base_analyze import analyze_data
from page.cal_page import CalPage
from utils.utils import DriverUtils


class TestCal:

    def setup(self):
        self.driver = DriverUtils.get_driver()
        self.cal_page = CalPage(self.driver)
        self.driver.get('http://cal.apple886.com/')

    def teardown(self):
        time.sleep(3)
        DriverUtils.quit_driver()

    @pytest.mark.parametrize("params", analyze_data("cal_data.json"))
    def test_add(self, params):
        for i in params["data"]:
            self.cal_page.click_digit_btn(i)
            self.cal_page.click_add_btn()
        self.cal_page.click_eq_btn()
        # print("---",self.cal_page.get_result())
        # print("+++",params["result"])
        assert self.cal_page.get_result() == str(params["result"])
 
  
第六章 日志收集
 
  
1 日志相关概念
 
  
1.1 日志的概念
 
  
日志就是用于记录系统运行时的信息, 对一个事件的记录, 也称为Log
 
  
1.2 日志的作用
 
  
 
   
调试程序
 
   
了解系统程序运行的情况，是否正常
 
   
系统程序运行故障分析与问题定位
 
   
用来做用户行为分析和数据统计
 
  
 
  
1.3 日志级别
 
  
 
   
思考:
 
   
是否系统记录的所有日志信息重要性都一样?
 
  
 
  
日志级别: 指日志信息的重要性
 
  
常见日志级别
 
  
 
   
 
    
 
     
日志级别
 
     
描述
 
    
 
   
 
   
 
    
 
     
DEBUG
 
     
调试级别，打印非常详细的日志信息，通常用于对代码的调试
 
    
 
    
 
     
INFO
 
     
信息级别，打印一般的日志信息，突出强调程序的运行过程
 
    
 
    
 
     
WARNING
 
     
警告级别，打印警告日志信息，表明会出现潜在错误的情形，一般不影响软件的正常使用
 
    
 
    
 
     
ERROR
 
     
错误级别，打印错误异常信息，该级别的错误可能会导致系统的一些功能无法正常使用
 
    
 
    
 
     
CRITICAL
 
     
严重错误级别，一个严重的错误，这表明系统可能无法继续运行
 
    
 
   
 
  
 
  
 
   
说明:
 
   
 
    
上面列表中的日志级别是从上到下依次升高的，即：DEBUG < INFO < WARNING < ERROR < CRITICA
 
    
当为程序指定一个日志级别后，程序会记录所有日志级别大于或等于指定日志级别的日志信息，而不是仅仅记录指定级别的日志信息
 
    
一般建议只使用DEBUG、INFO、WARNING、ERROR这四个级别
 
   
 
  
 
  
2 日志基本用法
 
  
2.1 logging
 
  
Python中有一个标准库模块logging可以直接记录日志
 
  
2.2 基本用法
 
  
import logging

logging.debug("这是一条调试信息")
logging.info("这是一条普通信息")
logging.warning("这是一条警告信息")
logging.error("这是一条错误信息")
logging.critical("这是一条严重错误信息")
 
  
 
   
说明:
 
   
logging中默认的日志级别为WARNING，程序中大于等于该级别的日志才能输出
 
  
 
  
2.3 设置日志级别
 
  
方法
 
  
logging.basicConfig(level=logging.DEBUG)
 
  
 
   
如何选择日志级别?
 
   
 
    
 
在开发环境和测试环境中，为了尽可能详细的查看程序的运行状态来保证上线后的稳定性，可以使用DEBUG或INFO级别的日志获取详细的日志信息，这是非常耗费机器性能的
 
 
    
 
在生产环境中，通常只记录程序的异常信息、错误信息等（设置成WARNING或ERROR级别），这样既可以减小服务器的I/O压力，也可以提高获取错误日志信息的效率和方便问题的排查
 
 
   
 
  
 
  
2.4 设置日志格式
 
  
默认格式
 
  
日志级别:Logger名称:日志内容
 
  
自定义格式
 
  
logging.basicConfig(format="%(levelname)s:%(name)s:%(message)s")
 
  
format参数中可能用到的格式化信息:
 
  
 
   
 
    
 
     
占位符
 
     
描述
 
    
 
   
 
   
 
    
 
     
%(name)s
 
     
Logger的名字
 
    
 
    
 
     
%(levelno)s
 
     
数字形式的日志级别
 
    
 
    
 
     
%(levelname)s
 
     
文本形式的日志级别
 
    
 
    
 
     
%(pathname)s
 
     
调用日志输出函数的模块的完整路径名，可能没有
 
    
 
    
 
     
%(filename)s
 
     
调用日志输出函数的模块的文件名
 
    
 
    
 
     
%(module)s
 
     
调用日志输出函数的模块名
 
    
 
    
 
     
%(funcName)s
 
     
调用日志输出函数的函数名
 
    
 
    
 
     
%(lineno)d
 
     
调用日志输出函数的语句所在的代码行
 
    
 
    
 
     
%(created)f
 
     
当前时间，用UNIX标准的表示时间的浮点数表示
 
    
 
    
 
     
%(relativeCreated)d
 
     
输出日志信息时的，自Logger创建以来的毫秒数
 
    
 
    
 
     
%(asctime)s
 
     
字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”
 
    
 
    
 
     
%(thread)d
 
     
线程ID。可能没有
 
    
 
    
 
     
%(threadName)s
 
     
线程名。可能没有
 
    
 
    
 
     
%(process)d
 
     
进程ID。可能没有
 
    
 
    
 
     
%(message)s
 
     
用户输出的消息
 
    
 
   
 
  
 
  
示例代码
 
  
import logging

fmt = '%(asctime)s %(levelname)s [%(name)s] [%(filename)s(%(funcName)s:%(lineno)d)] - %(message)s'
logging.basicConfig(level=logging.DEBUG, format=fmt)

logging.debug("这是一条调试信息")
logging.info("这是一条普通信息")
logging.warning("这是一条警告信息")
logging.error("这是一条错误信息")
logging.critical("这是一条严重错误信息")
 
  
2.5 日志输出到文件
 
  
默认情况下Python的logging模块将日志打印到了标准输出中（控制台）
 
  
将日志信息输出到文件的方法
 
  
logging.basicConfig(filename="a.log")
 
  
示例代码
 
  
import logging

fmt = '%(asctime)s %(levelname)s [%(name)s] [%(filename)s(%(funcName)s:%(lineno)d)] - %(message)s'
logging.basicConfig(level=logging.DEBUG, format=fmt, filename="a.log")

logging.debug("这是一条调试信息")
logging.info("这是一条普通信息")
logging.warning("这是一条警告信息")
logging.error("这是一条错误信息")
logging.critical("这是一条严重错误信息")
 
  
3 日志高级用法
 
  
3.1 总体介绍
 
  
 
   
思考:
 
   
 
    
如何将日志信息同时输出到控制台和日志文件中？
 
    
如何将不同级别的日志输出到不同的日志文件中？
 
    
如何解决日志文件过大的问题？
 
   
 
  
 
  
3.2 四大组件
 
  
3.2.1 总体介绍
 
  
logging日志模块四大组件
 
  
 
   
 
    
 
     
组件名称
 
     
类名
 
     
功能描述
 
    
 
   
 
   
 
    
 
     
日志器
 
     
Logger
 
     
提供了程序使用日志的入口
 
    
 
    
 
     
处理器
 
     
Handler
 
     
将logger创建的日志记录发送到合适的目的输出
 
    
 
    
 
     
格式器
 
     
Formatter
 
     
决定日志记录的最终输出格式
 
    
 
    
 
     
过滤器
 
     
Filter
 
     
提供了更细粒度的控制工具来决定输出哪条日志记录，丢弃哪条日志记录
 
    
 
   
 
  
 
  
 
   
logging模块就是通过这些组件来完成日志处理的
 
  
 
  
3.2.2 组件之间的关系
 
  
 
   
日志器（logger）需要通过处理器（handler）将日志信息输出到目标位置，如：文件、sys.stdout、网络等
 
   
不同的处理器（handler）可以将日志输出到不同的位置
 
   
日志器（logger）可以设置多个处理器（handler）将同一条日志记录输出到不同的位置
 
   
每个处理器（handler）都可以设置自己的格式器（formatter）实现同一条日志以不同的格式输出到不同的地方
 
   
每个处理器（handler）都可以设置自己的过滤器（filter）实现日志过滤，从而只保留感兴趣的日志
 
  
 
  
简单点说就是：
 
  
日志器（logger）是入口，真正干活儿的是处理器（handler），处理器（handler）还可以通过过滤器（filter）和格式器（formatter）对要输出的日志内容做过滤和格式化等处理操作
 
  
3.2.3 Logger类
 
  
作用
 
  
 
   
向程序暴露记录日志的方法
 
   
将日志消息传送给所有感兴趣的日志handlers
 
   
基于日志级别或Filter对象来决定要对哪些日志进行后续处理
 
  
 
  
如何创建Logger对象
 
  
logger = logging.getLogger()
logger = logging.getLogger("myLogger")
 
  
 
   
 
    
 
logging.getLogger()方法有一个可选参数name，该参数表示将要返回的日志器的名称标识
 
 
    
 
如果不提供该参数，则返回root日志器对象
 
 
    
 
若以相同的name参数值多次调用getLogger()方法，将会返回指向同一个logger对象的引用
 
 
   
 
  
 
  
Logger常用方法
 
  
 
   
 
    
 
     
方法
 
     
描述
 
    
 
   
 
   
 
    
 
     
logger.debug()
logger.info()
logger.warning()
logger.error()
logger.critical()
 
     
打印日志
 
    
 
    
 
     
logger.setLevel()
 
     
设置日志器将会处理的日志消息的最低严重级别
 
    
 
    
 
     
logger.addHandler()
 
     
为该logger对象添加一个handler对象
 
    
 
    
 
     
logger.addFilter()
 
     
为该logger对象添加一个filter对象
 
    
 
   
 
  
 
  
3.2.4 Handler类
 
  
作用
 
  
Handler对象的作用是将消息分发到handler指定的位置，比如：控制台、文件、网络、邮件等。 Logger对象可以通过addHandler()方法为自己添加多个handler对象
 
  
如何创建Handler对象
 
  
在程序中不应该直接实例化和使用Handler实例，因为Handler是一个基类，它只定义了Handler应该有的接口。 应该使用Handler实现类来创建对象，logging中内置的常用的Handler包括：
 
  
 
   
 
    
 
     
Handler
 
     
描述
 
    
 
   
 
   
 
    
 
     
logging.StreamHandler
 
     
将日志消息发送到输出到Stream，如std.out, std.err或任何file-like对象
 
    
 
    
 
     
logging.FileHandler
 
     
将日志消息发送到磁盘文件，默认情况下文件大小会无限增 长
 
    
 
    
 
     
logging.handlers.RotatingFileHandler
 
     
将日志消息发送到磁盘文件，并支持日志文件按大小切割
 
    
 
    
 
     
logging.hanlders.TimedRotatingFileHandler
 
     
将日志消息发送到磁盘文件，并支持日志文件按时间切割
 
    
 
    
 
     
logging.handlers.HTTPHandler
 
     
将日志消息以GET或POST的方式发送给一个HTTP服务器
 
    
 
    
 
     
logging.handlers.SMTPHandler
 
     
将日志消息发送给一个指定的email地址
 
    
 
   
 
  
 
  
Handler常用方法
 
  
 
   
 
    
 
     
方法
 
     
描述
 
    
 
   
 
   
 
    
 
     
handler.setLevel()
 
     
设置handler将会处理的日志消息的最低严重级别
 
    
 
    
 
     
handler.setFormatter()
 
     
为handler设置一个格式器对象
 
    
 
    
 
     
handler.addFilter()
 
     
为handler添加一个过滤器对象
 
    
 
   
 
  
 
  
3.2.5 Formatter类
 
  
作用
 
  
Formatter对象用于配置日志信息的格式
 
  
如何创建Formatter对象
 
  
formatter = logging.Formatter(fmt=None, datefmt=None, style='%') 
    fmt：指定消息格式化字符串，如果不指定该参数则默认使用message的原始值
    datefmt：指定日期格式字符串，如果不指定该参数则默认使用"%Y-%m-%d %H:%M:%S"
    style：Python 3.2新增的参数，可取值为 '%', '{'和 '$'，如果不指定该参数则默认使用'%'
 
  
3.3 案例
 
  
 
   
说明: 可读性好的日志需具备一些共性
 
   
 
    
在控制台和文件都能输出
 
    
文件输出能够按时间切割
 
   
 
  
 
  
# 1.导包
# 2.创建日志器对象 / 设置日志级别
# 3.创建输出到控制台 / 文件(按时间切割)的处理器对象
# 4.创建格式化器
# 5.将格式化器添加到处理器
# 6.添加处理器到日志器
# 7.打印日志
 
  
3.4 示例代码
 
  
# 1.导包
import logging.handlers
# 2.创建日志器对象 / 设置日志级别
logger = logging.getLogger("myLogger")
logger.setLevel(level=logging.DEBUG)
# 3.创建输出到控制台 / 文件(按时间切割)的处理器对象
ls = logging.StreamHandler()
lf = logging.handlers.TimedRotatingFileHandler(filename="test.log", when="s", backupCount=5)
# 4.创建格式化器
fmt = '%(asctime)s %(levelname)s [%(name)s] [%(filename)s(%(funcName)s:%(lineno)d)] - %(message)s'
formatter = logging.Formatter(fmt=fmt)
# 5.将格式化器添加到处理器
ls.setFormatter(formatter)
lf.setFormatter(formatter)
# 6.添加处理器到日志器
logger.addHandler(ls)
logger.addHandler(lf)
# 7.打印日志

#试验
while 1:	
    def test_log():
        try:
            assert 1==2
        except Exception as e:
            logger.debug(e)

    test_log()
 
  
第七章 项目实战
 
  
1 自动化测试流程
 
  
1.1 流程
 
  
 
   
需求分析
 
   
挑选适合做自动化测试的功能
 
   
设计测试用例
 
   
搭建自动化测试环境 [可选]
 
   
设计自动化测试项目的架构 [可选]
 
   
编写代码
 
   
执行测试用例
 
   
生成测试报告并分析结果
 
  
 
  
1.2 对比
 
  
2 项目介绍
 
  
2.1 如何介绍[复习]
 
  
四个步骤
 
  
 
   
业务特性
 
   
用户和角色
 
   
功能模块
 
   
技术栈
 
  
 
  
2.2 项目案例介绍
 
  
项目名称
 
  
TPshop开源商城系统
 
  
项目描述
 
  
TPshop是一个电子商务B2C电商平台系统，功能强大，安全便捷。适合企业及个人快速构建个性化网上商城
 
  
 
   
包含PC+IOS客户端+Adroid客户端+微商城，系统PC+后台是基于ThinkPHP MVC构架开发的跨平台开源软件，设计得非常灵活，具有模块化架构体系和丰富的功能，易于与第三方应用系统无缝集成，在设计上，包含相当全面，以模块化架构体系，让应用组合变得相当灵活，功能也相当丰富
 
  
 
  
项目架构
 
  
windows + php + apache + mysql
 
  
 
   
要求能运用画图表达
 
  
 
  
3 用例设计
 
  
3.1 编写原则
 
  
 
   
自动化测试用例一般只实现核心业务流程或者重复执行率较高的功能
 
   
自动化测试用例的选择一般以“正向”逻辑的验证为主
 
   
不是所有手工用例都可以使用自动化测试来执行
 
   
尽量减少多个用例脚本之间的依赖
 
   
自动化测试用例执行完毕之后，一般需要回归原点
 
  
 
  
3.2 编写测试用例
 
  
4 搭建框架
 
  
4.1 新建项目
 
  
项目名称: webAutoTestTPshop
 
  
4.2 创建目录结构
 
  
 
   
 
    
base 包: 存放基类, 如 base_action.py, base_analyze.py
 
    
config 包: 存放配置文件, 如 logging_config.py
 
    
data 包: 存放测试数据, 如 login_data.json
 
    
log 包/文件夹: 存放日志文件
 
    
page 包: 存放页面类
 
    
report 包/文件夹: 存放html测试报告
 
    
screenshot 包/文件夹: 存放截图
 
    
scripts 包: 存放测试脚本
 
    
utils 包: 存放工具类, 如 utils.py
 
    
pytest.ini 文件
 
   
 
  
 
  
4.3 安装依赖包
 
  
 
   
selenium
 
   
pytest
 
   
pytest-html
 
   
…
 
  
 
  
4.4 初始化代码
 
  
 
   
 
封装驱动工具类
 
    
 
     
utils包下的 utils.py
 
    
 
 
   
 
封装基类
 
    
 
     
base包下的 base_action.py 和 base_analyze.py
 
    
 
 
  
 
  
5 编写代码
 
  
5.1 抽取PO
 
  
5.1.1 定义页面对象文件
 
  
登录页: login_page.py
首页: index_page.py
个人中心页: home_page.py
商品搜索页: goods_search_page.py
商品详情页: goods_detail_page.py
购物车页: cart_page.py
下订单页: order_page.py
订单支付页: order_pay_page.py

 
  
5.1.2 编写页面对象代码
 
  
5.2 编写测试脚本
 
  
5.2.1 定义脚本文件
 
  
登录模块: test_login.py
购物车模块: test_cart.py
订单模块: test_order.py
 
  
5.2.2 使用pytest管理脚本
 
  
6 完善代码
 
  
6.1 数据驱动
 
  
6.1.1 定义数据文件
 
  
 
   
 
定义存放测试文件的目录, 如 data
 
 
   
 
分模块定义数据文件
 
login_data.py
cart_data.py
order_data.py
 
 
   
 
根据业务编写用例数据
 
 
  
 
  
6.1.2 测试数据参数化
 
  
使用 @pytest.mark.parametrize() 完成参数化
 
  
6.2 日志收集
 
  
6.2.1 日志配置
 
  
使用 logging 模块完成日志收集
 
  
示例代码
 
  
# 1.导包
import logging
import logging.handlers
import os

# BASE_PATH = os.path.dirname(os.path.abspath("__file__"))
BASE_PATH = os.path.abspath(os.path.join(os.getcwd(), ".."))


def set_log_config():
    # 2.创建日志器对象 / 设置日志级别
    logger = logging.getLogger()
    logger.setLevel(level=logging.INFO)
    # 3.创建输出到控制台 / 文件(按时间切割)的处理器对象
    ls = logging.StreamHandler()
    lf = logging.handlers.TimedRotatingFileHandler(filename="./log/tpshop.log", when="d", backupCount=5)
    # 4.创建格式化器
    fmt = '%(asctime)s %(levelname)s [%(name)s] [%(filename)s(%(funcName)s:%(lineno)d)] - %(message)s'
    formatter = logging.Formatter(fmt=fmt)
    # 5.将格式化器添加到处理器
    ls.setFormatter(formatter)
    lf.setFormatter(formatter)
    # 6.添加处理器到日志器
    logger.addHandler(ls)
    logger.addHandler(lf)

 
  
6.2.2 配置文件加载
 
  
在 utils 包下
 
  
# 在 __init__.py 中增加
from config.logging_config import set_log_config

set_log_config()
 
  
    |
 
  
| handler.addFilter() | 为handler添加一个过滤器对象 |
 
  
3.2.5 Formatter类
 
  
作用
 
  
Formatter对象用于配置日志信息的格式
 
  
如何创建Formatter对象
 
  
formatter = logging.Formatter(fmt=None, datefmt=None, style='%') 
    fmt：指定消息格式化字符串，如果不指定该参数则默认使用message的原始值
    datefmt：指定日期格式字符串，如果不指定该参数则默认使用"%Y-%m-%d %H:%M:%S"
    style：Python 3.2新增的参数，可取值为 '%', '{'和 '$'，如果不指定该参数则默认使用'%'
 
  
3.3 案例
 
  
 
   
说明: 可读性好的日志需具备一些共性
 
   
 
    
在控制台和文件都能输出
 
    
文件输出能够按时间切割
 
   
 
  
 
  
# 1.导包
# 2.创建日志器对象 / 设置日志级别
# 3.创建输出到控制台 / 文件(按时间切割)的处理器对象
# 4.创建格式化器
# 5.将格式化器添加到处理器
# 6.添加处理器到日志器
# 7.打印日志
 
  
3.4 示例代码
 
  
# 1.导包
import logging.handlers
# 2.创建日志器对象 / 设置日志级别
logger = logging.getLogger("myLogger")
logger.setLevel(level=logging.DEBUG)
# 3.创建输出到控制台 / 文件(按时间切割)的处理器对象
ls = logging.StreamHandler()
lf = logging.handlers.TimedRotatingFileHandler(filename="test.log", when="s", backupCount=5)
# 4.创建格式化器
fmt = '%(asctime)s %(levelname)s [%(name)s] [%(filename)s(%(funcName)s:%(lineno)d)] - %(message)s'
formatter = logging.Formatter(fmt=fmt)
# 5.将格式化器添加到处理器
ls.setFormatter(formatter)
lf.setFormatter(formatter)
# 6.添加处理器到日志器
logger.addHandler(ls)
logger.addHandler(lf)
# 7.打印日志

#试验
while 1:	
    def test_log():
        try:
            assert 1==2
        except Exception as e:
            logger.debug(e)

    test_log()
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    

                        
                        

                            
 
                        
                        
                        

                            

                        
                        
                        

                            

                        
                    
                
            
        
    
    

        
你可能感兴趣的:(自动化测试,Python,软件测试,selenium,web,黑盒测试)
        

            

                

                    
理解Gunicorn：Python WSGI服务器的基石
                        范范0825
ipythonlinux运维
                        
理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
                    
                    
Python数据分析与可视化实战指南
                        William数据分析
pythonpython数据
                        
在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
                    
                    
python os.environ
                        江湖偌大
python深度学习
                        
os.environ['TF_CPP_MIN_LOG_LEVEL']='0'#默认值，输出所有信息os.environ['TF_CPP_MIN_LOG_LEVEL']='1'#屏蔽通知信息（INFO）os.environ['TF_CPP_MIN_LOG_LEVEL']='2'#屏蔽通知信息和警告信息（INFO\WARNING）os.environ['TF_CPP_MIN_LOG_LEVEL']='
                    
                    
Python中os.environ基本介绍及使用方法
                        鹤冲天Pro
#Pythonpython服务器开发语言
                        
文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
                    
                    
Pyecharts数据可视化大屏：打造沉浸式数据分析体验
                        我的运维人生
信息可视化数据分析数据挖掘运维开发技术共享
                        
Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
                    
                    
Python教程：一文了解使用Python处理XPath
                        旦莫
Python进阶python开发语言
                        
目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
                    
                    
Google earth studio 简介
                        陟彼高冈yu
旅游
                        
GoogleEarthStudio是一个基于Web的动画工具，专为创作使用GoogleEarth数据的动画和视频而设计。它利用了GoogleEarth强大的三维地图和卫星影像数据库，使用户能够轻松地创建逼真的地球动画、航拍视频和动态地图可视化。网址为https://www.google.com/earth/studio/。GoogleEarthStudio是一个基于Web的动画工具，专为创作使用G
                    
                    
python os.environ_python os.environ 读取和设置环境变量
                        weixin_39605414
pythonos.environ
                        
>>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
                    
                    
PHP环境搭建详细教程
                        好看资源平台
前端php
                        
PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这
                    
                    
DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
                    
                    
使用Faiss进行高效相似度搜索
                        llzwxh888
faisspython
                        
在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss
                    
                    
python是什么意思中文-在python中%是什么意思
                        编程大乐趣

                        
Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
                    
                    
关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
                    
                    
HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
                    
                    
Day1笔记-Python简介&标识符和关键字&输入输出
                        ~在杰难逃~
Pythonpython开发语言大数据数据分析数据挖掘
                        
大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
                    
                    
python八股文面试题分享及解析(1)
                        Shawn________
python
                        
#1.'''a=1b=2不用中间变量交换a和b'''#1.a=1b=2a,b=b,aprint(a)print(b)结果：21#2.ll=[]foriinrange(3):ll.append({'num':i})print(11)结果:#[{'num':0},{'num':1},{'num':2}]#3.kk=[]a={'num':0}foriinrange(3):#0,12#可变类型，不仅仅改变
                    
                    
git - Webhook让部署自动化
                        大猪大猪

                        
我们现在有一个需求，将项目打包上传到gitlab或者github后，程序能自动部署，不用手动地去服务器中进行项目更新并运行，如何做到？这里我们可以使用gitlab与github的挂钩，挂钩的原理就是，每当我们有请求到gitlab与github服务器时，这时他俩会根据我们配置的挂钩地扯进行访问，webhook挂钩程序会一直监听着某个端口请求，一但收到他们发过来的请求，这时就知道用户有请求提交了，这时
                    
                    
每日算法&面试题，大厂特训二十八天——第二十天（树）
                        肥学
⚡算法题⚡面试题每日精进java算法数据结构
                        
目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
                    
                    
Python快速入门 —— 第三节：类与对象
                        孤华暗香
Python快速入门python开发语言
                        
第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
                    
                    
webpack图片等资源的处理
                        dmengmeng

                        
需要的loaderfile-loader（让我们可以引入这些资源文件）url-loader（其实是file-loader的二次封装）img-loader（处理图片所需要的）在没有使用任何处理图片的loader之前，比如说css中用到了背景图片，那么最后打包会报错的，因为他没办法处理图片。其实你只想能够使用图片的话。只加一个file-loader就可以，打开网页能准确看到图片。{test:/\.(p
                    
                    
pyecharts——绘制柱形图折线图
                        2224070247
信息可视化pythonjava数据可视化
                        
一、pyecharts概述自2013年6月百度EFE(ExcellentFrontEnd）数据可视化团队研发的ECharts1.0发布到GitHub网站以来，ECharts一直备受业界权威的关注并获得广泛好评，成为目前成熟且流行的数据可视化图表工具，被应用到诸多数据可视化的开发领域。Python作为数据分析领域最受欢迎的语言，也加入ECharts的使用行列，并研发出方便Python开发者使用的数据
                    
                    
Python 实现图片裁剪（附代码） | Python工具
                        剑客阿良_ALiang

                        
前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码
                    
                    
【华为OD技术面试真题 - 技术面】- python八股文真题题库（4)
                        算法大师
华为od面试python
                        
华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
                    
                    
【华为OD技术面试真题 - 技术面】-测试八股文真题题库（1）
                        算法大师
华为od面试python算法前端
                        
华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.黑盒测试和白盒测试的区别2.假设我们公司现在开发一个类似于微信的软件1.0版本，现在要你测试这个功能：打开聊天窗口，输入文本，限制字数在200字以内。问你怎么提取测试点。功能测试性能测试安全性测试可用性测试跨平台兼容性测试网络环境测试3.接口测试的工具你了解哪些
                    
                    
python os 环境变量
                        CV矿工
python开发语言numpy
                        
环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
                    
                    
Python爬虫解析工具之xpath使用详解
                        eqa11
python爬虫开发语言
                        
文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
                    
                    
【华为OD技术面试真题 - 技术面】- python八股文真题题库（1）
                        算法大师
华为od面试python
                        
华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
                    
                    
nosql数据库技术与应用知识点
                        皆过客，揽星河
NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
                        
Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
                    
                    
《Python数据分析实战终极指南》
                        xjt921122
python数据分析开发语言
                        
对于分析师来说，大家在学习Python数据分析的路上，多多少少都遇到过很多大坑**，有关于技能和思维的**：Excel已经没办法处理现有的数据量了，应该学Python吗？找了一大堆Python和Pandas的资料来学习，为什么自己动手就懵了？跟着比赛类公开数据分析案例练了很久，为什么当自己面对数据需求还是只会数据处理而没有分析思路？学了对比、细分、聚类分析，也会用PEST、波特五力这类分析法，为啥
                    
                    
Python中深拷贝与浅拷贝的区别
                        yuxiaoyu.

                        
转自：http://blog.csdn.net/u014745194/article/details/70271868定义：在Python中对象的赋值其实就是对象的引用。当创建一个对象，把它赋值给另一个变量的时候，python并没有拷贝这个对象，只是拷贝了这个对象的引用而已。浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。也就是，把对象复制一遍，但是该对象中引用的其他对象我不复
                    
                                
怎么样才能成为专业的程序员？
                                    cocos2d-x小菜
编程PHP
                                    
  
如何要想成为一名专业的程序员？仅仅会写代码是不够的。从团队合作去解决问题到版本控制，你还得具备其他关键技能的工具包。当我们询问相关的专业开发人员，那些必备的关键技能都是什么的时候，下面是我们了解到的情况。 
  
关于如何学习代码，各种声音很多，然后很多人就被误导为成为专业开发人员懂得一门编程语言就够了？！呵呵，就像其他工作一样，光会一个技能那是远远不够的。如果你想要成为
                                
                                
java web开发 高并发处理
                                    BreakingBad
javaWeb并发开发处理高
                                    
java处理高并发高负载类网站中数据库的设计方法（java教程,java处理大量数据，java高负载数据） 一：高并发高负载类网站关注点之数据库 没错,首先是数据库,这是大多数应用所面临的首个SPOF。尤其是Web2.0的应用，数据库的响应是首先要解决的。 一般来说MySQL是最常用的，可能最初是一个mysql主机，当数据增加到100万以上，那么，MySQL的效能急剧下降。常用的优化措施是M-S（
                                
                                
mysql批量更新
                                    ekian
mysql
                                    
mysql更新优化： 
一版的更新的话都是采用update set的方式，但是如果需要批量更新的话，只能for循环的执行更新。或者采用executeBatch的方式，执行更新。无论哪种方式，性能都不见得多好。 
三千多条的更新，需要3分多钟。 
查询了批量更新的优化，有说replace into的方式，即： 
 
 
replace into tableName(id,status) values
                                
                                
微软BI（3）
                                    18289753290
微软BI SSIS
                                    
1) 
Q：该列违反了完整性约束错误；已获得 OLE DB 记录。源:“Microsoft SQL Server Native Client 11.0” Hresult: 0x80004005 说明:“不能将值 NULL 插入列 'FZCHID'，表 'JRB_EnterpriseCredit.dbo.QYFZCH'；列不允许有 Null 值。INSERT 失败。”。 
A：一般这类问题的存在是 
                                
                                
Java中的List
                                    g21121
java
                                    
        List是一个有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。 
        与 set 不同，列表通常允许重复
                                
                                
读书笔记
                                    永夜-极光
读书笔记
                                    
   1.  K是一家加工厂,需要采购原材料,有A,B,C,D 4家供应商,其中A给出的价格最低,性价比最高,那么假如你是这家企业的采购经理,你会如何决策? 
    
     传统决策: A:100%订单  B,C,D:0% 
  
  &nbs
                                
                                
centos 安装 Codeblocks
                                    随便小屋
codeblocks
                                    
1.安装gcc,需要c和c++两部分,默认安装下,CentOS不安装编译器的,在终端输入以下命令即可yum install gccyum install gcc-c++ 
  
2.安装gtk2-devel,因为默认已经安装了正式产品需要的支持库,但是没有安装开发所需要的文档.yum install gtk2* 
3. 安装wxGTK 
   yum search w
                                
                                
23种设计模式的形象比喻
                                    aijuans
设计模式
                                    
1、ABSTRACT FACTORY—追MM少不了请吃饭了，麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西，虽然口味有所不同，但不管你带MM去麦当劳或肯德基，只管向服务员说“来四个鸡翅”就行了。麦当劳和肯德基就是生产鸡翅的Factory  　　工厂模式：客户类和工厂类分开。消费者任何时候需要某种产品，只需向工厂请求即可。消费者无须修改就可以接纳新产品。缺点是当产品修改时，工厂类也要做相应的修改。如：
                                
                                
开发管理 CheckLists
                                    aoyouzi
开发管理 CheckLists
                                    
开发管理 CheckLists(23) -使项目组度过完整的生命周期 
开发管理 CheckLists(22) -组织项目资源 
开发管理 CheckLists(21) -控制项目的范围开发管理 CheckLists(20) -项目利益相关者责任开发管理 CheckLists(19) -选择合适的团队成员开发管理 CheckLists(18) -敏捷开发 Scrum Master 工作开发管理 C
                                
                                
js实现切换
                                    百合不是茶
JavaScript栏目切换
                                    
js主要功能之一就是实现页面的特效,窗体的切换可以减少页面的大小,被门户网站大量应用思路: 
   1,先将要显示的设置为display:bisible  否则设为none
    2,设置栏目的id  ,js获取栏目的id,如果id为Null就设置为显示
    3,判断js获取的id名字;再设置是否显示
 
  
代码实现: 
  
html代码: 
  <di
                                
                                
周鸿祎在360新员工入职培训上的讲话
                                    bijian1013
感悟项目管理人生职场
                                    
        这篇文章也是最近偶尔看到的，考虑到原博客发布者可能将其删除等原因，也更方便个人查找，特将原文拷贝再发布的。“学东西是为自己的，不要整天以混的姿态来跟公司博弈，就算是混，我觉得你要是能在混的时间里，收获一些别的有利于人生发展的东西，也是不错的，看你怎么把握了”，看了之后，对这句话记忆犹新。  &
                                
                                
前端Web开发的页面效果
                                    Bill_chen
htmlWebMicrosoft
                                    
1.IE6下png图片的透明显示： 
<img src="图片地址" border="0" style="Filter.Alpha(Opacity)=数值(100),style=数值(3)"/> 
或在<head></head>间加一段JS代码让透明png图片正常显示。 
 
2.<li>标
                                
                                
【JVM五】老年代垃圾回收：并发标记清理GC(CMS GC)
                                    bit1129
垃圾回收
                                    
  CMS概述 
并发标记清理垃圾回收(Concurrent Mark and Sweep GC）算法的主要目标是在GC过程中，减少暂停用户线程的次数以及在不得不暂停用户线程的请夸功能，尽可能短的暂停用户线程的时间。这对于交互式应用，比如web应用来说，是非常重要的。 
  
CMS垃圾回收针对新生代和老年代采用不同的策略。相比同吞吐量垃圾回收，它要复杂的多。吞吐量垃圾回收在执
                                
                                
Struts2技术总结
                                    白糖_
struts2
                                    
  
 
 必备jar文件 
   
 早在struts2.0.*的时候，struts2的必备jar包需要如下几个： 
commons-logging-*.jar   Apache旗下commons项目的log日志包 
freemarker-*.jar          
                                
                                
Jquery easyui layout应用注意事项
                                    bozch
jquery浏览器easyuilayout
                                    
在jquery easyui中提供了easyui-layout布局，他的布局比较局限，类似java中GUI的border布局。下面对其使用注意事项作简要介绍： 
     如果在现有的工程中前台界面均应用了jquery easyui，那么在布局的时候最好应用jquery eaysui的layout布局，否则在表单页面（编辑、查看、添加等等）在不同的浏览器会出
                                
                                
java-拷贝特殊链表：有一个特殊的链表，其中每个节点不但有指向下一个节点的指针pNext，还有一个指向链表中任意节点的指针pRand，如何拷贝这个特殊链表？
                                    bylijinnan
java
                                    

public class CopySpecialLinkedList {

	/**
	 * 题目：有一个特殊的链表，其中每个节点不但有指向下一个节点的指针pNext，还有一个指向链表中任意节点的指针pRand，如何拷贝这个特殊链表？
拷贝pNext指针非常容易，所以题目的难点是如何拷贝pRand指针。
假设原来链表为A1 -> A2 ->... -> An，新拷贝
                                
                                
color
                                    Chen.H
JavaScripthtmlcss
                                    
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"  "http://www.w3.org/TR/html4/loose.dtd">    <HTML>    <HEAD>&nbs
                                
                                
[信息与战争]移动通讯与网络
                                    comsci
网络
                                    
      两个坚持:手机的电池必须可以取下来 
               光纤不能够入户,只能够到楼宇 
 
      建议大家找这本书看看:<&
                                
                                
oracle flashback query(闪回查询)
                                    daizj
oracleflashback queryflashback table
                                    
在Oracle 10g中，Flash back家族分为以下成员： 
Flashback Database 
Flashback Drop 
Flashback Table 
Flashback Query(分Flashback Query,Flashback Version Query，Flashback Transaction Query) 
下面介绍一下Flashback Drop 和Flas
                                
                                
zeus持久层DAO单元测试
                                    deng520159
单元测试
                                    
zeus代码测试正紧张进行中,但由于工作比较忙,但速度比较慢.现在已经完成读写分离单元测试了,现在把几种情况单元测试的例子发出来,希望有人能进出意见,让它走下去. 
本文是zeus的dao单元测试: 
1.单元测试直接上代码 
  
package com.dengliang.zeus.webdemo.test;


import org.junit.Test;
import o
                                
                                
C语言学习三printf函数和scanf函数学习
                                    dcj3sjt126com
cprintfscanflanguage
                                    
printf函数 
/*
	2013年3月10日20:42:32
	地点：北京潘家园
	功能：
	目的：
		测试%x %X %#x %#X的用法
 */

# include <stdio.h>

int main(void)
{

	printf("哈哈！\n");  // \n表示换行

	int i = 10;
	printf
                                
                                
那你为什么小时候不好好读书?
                                    dcj3sjt126com
life
                                    
dady, 我今天捡到了十块钱, 不过我还给那个人了 
good girl! 那个人有没有和你讲thank you啊 
没有啦....他拉我的耳朵我才把钱还给他的, 他哪里会和我讲thank you 
  
爸爸, 如果地上有一张5块一张10块你拿哪一张呢.... 
当然是拿十块的咯... 
爸爸你很笨的, 你不会两张都拿 
  
爸爸为什么上个月那个人来跟你讨钱, 你告诉他没
                                
                                
iptables开放端口
                                    Fanyucai
linuxiptables端口
                                    
1，找到配置文件 
vi /etc/sysconfig/iptables   
  
2，添加端口开放，增加一行，开放18081端口 
-A INPUT -m state --state NEW -m tcp -p tcp --dport 18081 -j ACCEPT 
  
3，保存 
ESC
:wq! 
  
4，重启服务 
service iptables 
                                
                                
Ehcache（05）——缓存的查询
                                    234390216
排序ehcache统计query
                                    
缓存的查询 
目录 
1.    使Cache可查询 
1.1     基于Xml配置 
1.2     基于代码的配置 
2     指定可搜索的属性 
2.1     可查询属性类型 
2.2 &
                                
                                
通过hashset找到数组中重复的元素
                                    jackyrong
hashset
                                    
  如何在hashset中快速找到重复的元素呢?方法很多，下面是其中一个办法： 
 
 


 int[] array = {1,1,2,3,4,5,6,7,8,8};
         
        Set<Integer> set = new HashSet<Integer>();
         
        for(int i = 0
                                
                                
使用ajax和window.history.pushState无刷新改变页面内容和地址栏URL
                                    lanrikey
history
                                    
后退时关闭当前页面 
<script type="text/javascript"> 
 jQuery(document).ready(function ($) { 
        if (window.history && window.history.pushState) {
                                
                                
应用程序的通信成本
                                    netkiller.github.com
虚拟机应用服务器陈景峰netkillerneo
                                    
应用程序的通信成本  
什么是通信 
一个程序中两个以上功能相互传递信号或数据叫做通信。  
什么是成本 
这是是指时间成本与空间成本。 时间就是传递数据所花费的时间。空间是指传递过程耗费容量大小。  
都有哪些通信方式 
 
 全局变量 
 线程间通信 
 共享内存 
 共享文件 
 管道 
 Socket 
 硬件（串口，USB） 等等 
  
全局变量 
全局变量是成本最低通信方法，通过设置
                                
                                
一维数组与二维数组的声明与定义
                                    恋洁e生
二维数组一维数组定义声明初始化
                                    
/**  *   */ package test20111005; /**  * @author FlyingFire  * @date:2011-11-18 上午04:33:36  * @author ：代码整理  * @introduce :一维数组与二维数组的初始化  *summary：  */ public c
                                
                                
Spring Mybatis独立事务配置
                                    toknowme
mybatis
                                    
在项目中有很多地方会使用到独立事务，下面以获取主键为例      
（1）修改配置文件spring-mybatis.xml    <!-- 开启事务支持 -->    <tx:annotation-driven transaction-manager="transactionManager" />       &n
                                
                                
更新Anadroid SDK Tooks之后，Eclipse提示No update were found
                                    xp9802
eclipse
                                    
使用Android SDK Manager 更新了Anadroid SDK Tooks 之后， 
打开eclipse提示 This Android SDK requires Android Developer Toolkit version 23.0.0 or above, 点击Check for Updates  
检测一会后提示 No update were found  
                                
                
            
        
    


    

        

            按字母分类：
            ABCDEFGHIJKLMNOPQRSTUVWXYZ其他
        
    


    

        

            首页 -
            关于我们 -
            站内搜索 -
            Sitemap -
            侵权投诉
        
        
版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved.