自动化介绍：UI自动化测试

Selenium简介：测试web应用程序用户界面（ui）的常用框架
pip install selenium==2.53.6

#pip install selenium or pip install-U selenium
#python setup.py install
from selenium import selenium
python -m pydoc -p   #查看帮助文档

配置apache服务器：

将项目放入webapps下
bin目录下startup.bat启动服务器
浏览器输入：localhost:8080/login.jsp 访问，localhost可变本ip地址

操作浏览器：

#打开浏览器：导宝-打开浏览器-获取网址-关闭窗口
from selenium import webdriver #导入包

ie

driver=webdriver.Ie()

谷歌chromedriver

#引入chromedriver.exe
chromedriver = r"C:\Users\11111\AppData\Local\Google\Chrome\Application\chromedriver.exe"
driver=webdriver.Chrome(chromedriver)

火狐FireFox

driver=webdriver.Firefox()

窗口操作

driver.get(r'https://www.baidu.com/') #打开网址
time.sleep(second) #休眠second秒，需要import time包
driver.refresh() #刷新页面
driver.back() #返回上一页
driver.forward() #进入下一页
driver.maxmize_window() #窗口最大
driver.set_window_size(width,hight)  #指定窗口大小
driver.get_screenshot_as_file("path.jpg") #截取全屏定义图片位置&名字
driver.close() #关闭窗口
driver.quit() #关闭窗口，以进程的形式
driver.name    #获取浏览器名称
driver.page_source    #页面源码

加载插件

url=r"C:\Users\Administrator\AppData\Roaming\Mozilla\Firefox\Profiles\sgycpmyp.default"    #找到配置文件路径
profile=webdriver.FirefoxProfile(url)
driver=webdriver.Firefox(profile)

元素的定位：(element单数/elements复数)

element/By定位：

    from selenium.webdriver.common.by import By
        ~  .find_element(self, by=By.ID, value=None)
        ~  .find_element("id","kw")

id定位:

    from selenium import webdriver
        ~  .find_element_by_id(value)

name定位:

    from selenium import webdriver
        ~  .find_element_by_name(value)

class_name定位：

    from selenium import webdriver
        ~  .find_element_by_class_name(value)

css定位：

    from selenium import webdriver
    #代表id属性
    .代表class属性
        ~  .find_element_by_css_selector(value)
    标签
        ~  .find_element_by_css_selector("input")
    父子标签
        ~  .find_element_by_css_selector("input>input")
    标签属性
        ~  .find_element_by_css_selector("[name='kw']")
    标签组合
        ~  .find_element_by_css_selector("input.kw>input>a>tr#su")
    #通过层级关系
        #//form[id='form'']/span/input
    #通过逻辑运算不需要and
        # "input[id='kw'][name='wd']"
        # dri.find_element_by_css_selector("input[id='kw'][name='wd']").send_keys(u"哈哈") 

link_text定位：

    from selenium import webdriver
        ~  .find_element_by_link_text(value)

partial_link_text定位：

    from selenium import webdriver
        ~  .find_element_by_partial_link_text(value)

tag_name定位：

    from selenium import webdriver
        ~  .find_element_by_tag_name(value)

xpath定位：W3C标准,xpath同一级别多个标签从1开始

    from selenium import webdriver
        ~  .find_element_by_xpath(value)

    表达式：
        nodename    选取此节点所有子节点
        /    从根节点选取
        //    从匹配选择的当前节点选择文档中的节点，而不考虑他们的位置
        .    选取当前节点
        ..    选取当前节点的父节点
        @    选取属性
    <?xml version="1.0"encoding="ISO-8859-1"?>
    <bookstore>
        <book>
            <title>HarryPotter<title>
            <author>JK.Rowling<author>
            <year>2005<year>
            <price>29.99<price>
        </book>
    </bookstore>
    /bookstore/book[1]
    /boolstore/book[last()]
    /bookstore/book[last()-1]
    /bookstore/book[postion()<3]
    driver.current_window_handle()     #获得当前窗口句柄    //title[@lang]
    //title[@lang='eng']
    /bookstore/book[price>35.00]
    /bookstore/book[price>35.00]/title
    标签：#input标签如果只有一个则可以不用[x]
    dri.find_element_by_xpath("/html/body/div/div/div/div/div/form/span/input")
    标签属性：
    dri.find_element_by_xpath("//input[@id='su']")
    超链接：
    dri.find_element_by_xpath("//a[@href='http://home.baidu.com']")
    标签属性组合
    dri.find_element_by_xpath("//input[@id='kw' and @class='s_ipt']") #属性组合的形式
    文本值定位：
    dri.find_element_by_xpath("//a[contains(text(),'新闻')]") #标签之间存在唯一的文本值
    模糊定位：
    dri.find_element_by_xpath("//a[contains(@href,'xueshu')]") #其他属性值过长时，可以使用此方法
    #网页中动态属性的定位
    #start-with()
    dri.find_element_by_xpath("//input[start-with(@name,'ti_trhao')]")
    #end-with()
    dri.find_element_by_xpath("//input[end-with(@name,'ti_trhao')]")
    #contains()
    dri.find_element_by_xpath("//input[contains(@id,'username')]")
    #多标签多属性组合式定位
    dri.find_element_by_xpath("//input[@id='kw1]//input[start-with(@id,'nice')]/div[1]/form[3]")

元素的属性值：

元素.get_attribute(属性名) #获取定位到的元素的指定属性值
元素.size #获取输入框尺寸
元素.text #获取百度页面备案信息
元素.tag_name #获取标签名
元素.is_displayed() #返回元素是否可见(true/false)
driver.title #当前页面标题
driver.current_url #当前页面url

鼠标事件

from selenium.webdriver.common.action_chains import ActionChains

常用方法：
perform() #执行所有actionchains中的行为
move_to_element() #鼠标悬停
context_click() #右击鼠标
double_click() # 双击鼠标
drag_and_drop(source,target) #拖动鼠标

鼠标悬停在搜索设置按钮上

    mouse=driver.find_element_by_link_text("设置"')
    ActionChains(driver).move_to_ element(mouse).perform()

键盘事件

from selenium.webdriver.common.keys import Keys

删除/Backspace

send_keys(Keys.BACK_SPACE)

空格/space

send_keys(Keys.SPACE)

制表/tab

send_keys(Keys.TAB)

回退/esc

send_keys(Keys.ESCAPE)

回车/enter

send_keys(Keys.ENTER)

全选/ctrl+a

send_keys(Keys.CONTROL,'a')

复制/ctrl+c

send_keys(Keys.CONTROL,'c')

剪切/ctrl+x

send_keys(Keys.CONTROL,'x')

粘贴/ctrl+v

send_keys(Keys.CONTROL,'v')

键盘F1...F12

send.keys(Keys.F1/F12)

等待

显式等待：

    from selenium.webdriver.support.ui  import WebDriverWait
    from selenium.webdriver.support.ui  import excepted_conditions as EC
    from selenium.webdriver.common.by import By

判断元素Expected Conditions的使用场景有2种：

直接在断言中使用
与WebDriverWait配合使用，动态等待页面上元素出现或者消失
element=WebDriverWait.(driver,timeout,poll_friquency=0.5,ignored_exceptions=None)
driver:浏览器驱动
timeout=:最长超时时间
poll_frequency:检测的间隔
ignored_exceptions:超时后的异常信息，默认是NoSuchElementException
方法注释：：
until(method,message=' '):
notuntil(method,message=' '):
exception_conditions类方法注释：：
title_is() #判断当前页面的title是否精确等于预期
title_contains() #判断当前页面的title是否包含预期字符串
presence_of_ele: ment_located() #判断某个元素是否被加到了dom树里，并不代表该元素一定可见
visibility_of_element_located() #判断某个元素是否可见.可见代表元素非隐藏，并且元素的宽和高都不等于0
visibility_of() #跟上面的方法做一样的事情，只是上面的方法要传入locator，这个方法直接传定位到的element就好了
presence_of_all_elements_located() #判断是否至少有1个元素存在于dom树中。举个例子，如果页面上有n个元素的class都是'column-md-3'，那么只要有1个元素存在，这个方法就返回True
text_to_be_present_in_element() # 判断某个元素中的text是否包含了预期的字符串
text_to_be_present_in_element_value() # 判断某个元素中的value属性是否包含了预期的字符串
frame_to_be_available_and_switch_to_it() # 判断该frame是否可以switch进去，如果可以的话，返回True并且switch进去，否则返回False
invisibility_of_element_located() # 判断某个元素中是否不存在于dom树或不可见
element_to_be_clickable() # 判断某个元素中是否可见并且是enable的，这样的话才叫clickable
staleness_of() # 等某个元素从dom树中移除，注意，这个方法也是返回True或False
element_to_be_selected() # 判断某个元素是否被选中了,一般用在下拉列表
element_selection_state_to_be() # 判断某个元素的选中状态是否符合预期
element_located_selection_state_to_be() # 跟上面的方法作用一样，只是上面的方法传入定位到的element，而这个方法传入locator
alert_is_present() # 判断页面上是否存在alert

隐式等待：

driver.implicitly_wait(seconds)
Sleep休眠方法：
import time

selenium中的三种等待方式（显示等待WebDriverWait()、隐式等待implicitly()、强制等待sleep()）：

sleep()： 强制等待，设置固定休眠时间。 python 的 time 包提供了休眠方法 sleep() ， 导入 time 包后就可以使用 sleep()，进行脚本的执行过程进行休眠。
implicitly_wait()：隐式等待，也叫智能等待，是 webdirver 提供的一个超时等待。隐的等待一个元素被发现，或一个命令完成。如果超出了设置时间的则抛出异常。
WebDriverWait()：显示等待，同样也是 webdirver 提供的方法。在设置时间内，默认每隔一段时间检测一次当前页面元素是否存在，如果超过设置时间检测不到则抛出异常。默认检测频率为0.5s，默认抛出异常为： NoSuchElementException
python selenium 显示等待WebDriverWait与条件判断expected_conditions举例：

    #coding=utf-8  
    from selenium import webdriver  
    from selenium.webdriver.common.by import By  
    from selenium.webdriver.support import expected_conditions as EC  
    from selenium.webdriver.support.wait import WebDriverWait  

    driver.implicitly_wait(5)  
        '''''隐式等待和显示等待都存在时，超时时间取二者中较大的'''   
    WebDriverWait(driver,10).until(EC.title_is(u"百度一下，你就知道"))  
        '''''判断title,返回布尔值'''  
  
    WebDriverWait(driver,10).until(EC.title_contains(u"百度一下"))  
        '''''判断title，返回布尔值'''  
  
    WebDriverWait(driver,10).until(EC.presence_of_element_located((By.ID,'kw')))  
        '''''判断某个元素是否被加到了dom树里，并不代表该元素一定可见，如果定位到就返回WebElement'''  
  
    WebDriverWait(driver,10).until(EC.visibility_of_element_located((By.ID,'su')))  
        '''''判断某个元素是否被添加到了dom里并且可见，可见代表元素可显示且宽和高都大于0'''  
  
    WebDriverWait(driver,10).until(EC.visibility_of(driver.find_element(by=By.ID,value='kw')))  
        '''''判断元素是否可见，如果可见就返回这个元素'''  
  
    WebDriverWait(driver,10).until(EC.presence_of_all_elements_located((By.CSS_SELECTOR,'.mnav')))  
        '''''判断是否至少有1个元素存在于dom树中，如果定位到就返回列表'''  
  
    WebDriverWait(driver,10).until(EC.visibility_of_any_elements_located((By.CSS_SELECTOR,'.mnav')))  
        '''''判断是否至少有一个元素在页面中可见，如果定位到就返回列表'''  
  
    WebDriverWait(driver,10).until(EC.text_to_be_present_in_element((By.XPATH,"//*[@id='u1']/a[8]"),u'设置'))  
        '''''判断指定的元素中是否包含了预期的字符串，返回布尔值'''  
    WebDriverWait(driver,10).until(EC.text_to_be_present_in_element_value((By.CSS_SELECTOR,'#su'),u'百度一下'))  
        '''''判断指定元素的属性值中是否包含了预期的字符串，返回布尔值'''  
  
    #WebDriverWait(driver,10).until(EC.frame_to_be_available_and_switch_to_it(locator))  
        '''''判断该frame是否可以switch进去，如果可以的话，返回True并且switch进去，否则返回False'''  
        #注意这里并没有一个frame可以切换进去 
  WebDriverWait(driver,10).until(EC.invisibility_of_element_located((By.CSS_SELECTOR,'#swfEveryCookieWrap')))  
        '''''判断某个元素在是否存在于dom或不可见,如果可见返回False,不可见返回这个元素'''  
        #注意#swfEveryCookieWrap在此页面中是一个隐藏的元素  
  
    WebDriverWait(driver,10).until(EC.element_to_be_clickable((By.XPATH,"//*[@id='u1']/a[8]"))).click()  
        '''''判断某个元素中是否可见并且是enable的，代表可点击'''  
        driver.find_element_by_xpath("//*[@id='wrapper']/div[6]/a[1]").click()  
        #WebDriverWait(driver,10).until(EC.element_to_be_clickable((By.XPATH,"//*[@id='wrapper']/div[6]/a[1]"))).click()  
  
    #WebDriverWait(driver,10).until(EC.staleness_of(driver.find_element(By.ID,'su')))  
        '''''等待某个元素从dom树中移除'''  
        #这里没有找到合适的例子  
  
    WebDriverWait(driver,10).until(EC.element_to_be_selected(driver.find_element(By.XPATH,"//*[@id='nr']/option[1]")))  
        '''''判断某个元素是否被选中了,一般用在下拉列表'''  
  
    WebDriverWait(driver,10).until(EC.element_selection_state_to_be(driver.find_element(By.XPATH,"//*[@id='nr']/option[1]"),True))  
        '''''判断某个元素的选中状态是否符合预期'''  
  
    WebDriverWait(driver,10).until(EC.element_located_selection_state_to_be((By.XPATH,"//*[@id='nr']/option[1]"),True))  
        '''''判断某个元素的选中状态是否符合预期'''  
        driver.find_element_by_xpath(".//*[@id='gxszButton']/a[1]").click()  
  
    instance = WebDriverWait(driver,10).until(EC.alert_is_present())  
        '''''判断页面上是否存在alert,如果有就切换到alert并返回alert的内容'''  
        print instance.text  
        instance.accept()

多表单切换：

location=driver.findelement(locator)
switch_to.frame(id/name/location)
switch_to_frame()
switch_to.parent_content()    #跳出当前一级表单
switch_to.default_content()     #跳回最外面页面
dri.switch_to_default_content()    #跳回当前默认窗口

多窗口切换：

driver.window_handles()     #获取打开窗口的句柄
driver.switch_to.window(handle)     #用于切换到相应的窗口
switch_to_window

上传文件：

import SendKeys
示例网址:http://www.sahitest.com/demo/php/fileUpload.htm
input标签：
input输入框：
元素.sendkeys(r"path")
input非输入框→input按钮：
SendKeys.SendKeys(r"path") # 发送文件地址，在输入法不是系统默认的输入发时候，路径的输入可能在第三方输入法的输入框中
time.sleep(1)
SendKeys.SendKeys("{ENTER}") # 发送回车键
AutoiIt:
https://www.autoitscript.com/site/autoit/downloads/
AutoiIt window info #识别控件信息
Scite script editor #编辑脚本
脚本方法：
ControlFocus("title","窗口文本",controlID) #设置输入焦点到指定窗口的某个控件上
WinWait("title题","窗口文本",超时时间) #暂停脚本的执行直至指定窗口存在（出现）为止
ControlSetText("title","窗口文本",controlID,"新文本") #修改指定控件文本
Sleep(延迟)
ControlClick("title","窗口文本"，控件ID，按钮，点击次数) #向指定控件发送鼠标点击命令
tools→go/F5 ：执行
import os
os.system(au3脚本路径)

文件下载

FireFox下载：

profile=webdriver.FireFox Profile () #获取 Profile
profile.set_preference("属性","值") #设置 Profile 属性
属性：
browser.download.dir：指定下载路径
browser.download.folderList：设置成 2 表示使用自定义下载路径；设置成 0 表示下载到桌面；设置成 1 表示下载到默认路径
browser.download.manager.showWhenStarting：在开始下载时是否显示下载管理器
browser.helperApps.neverAsk.saveToDisk：对所给出文件类型不再弹出框进行询问
eg：
profile = webdriver.FirefoxProfile()
profile.set_preference('browser.download.dir', 'd:\')
profile.set_preference('browser.download.folderList', 2)
profile.set_preference('browser.download.manager.showWhenStarting', False)
profile.set_preference('browser.helperApps.neverAsk.saveToDisk', 'application/zip')
driver = webdriver.Firefox(firefox_profile=profile)

Charm下载:

属性：
download.default_directory：设置下载路径
profile.default_content_settings.popups：设置为 0 禁止弹出窗口
eg：
options = webdriver.ChromeOptions()
prefs = {'profile.default_content_settings.popups': 0, 'download.default_directory': 'd:\'}
options.add_experimental_option('prefs', prefs)
driver = webdriver.Chrome(executable_path='D:\chromedriver.exe', chrome_options=options)

各种框处理：

下拉框：

Select：
from selenium.webdriver.support.ui import Select
Select(driver.find_element("key","value")).select_by_index(self,index)
.select_by_visible_text(self,text)
.select_by_value(self,value)
e.g.
Select(driver.find_element_by_name("NR")).select_by_index(2)
Select(driver.find_element_by_name("NR")).select_by_visible_text("每页显示50条")
Select(driver.find_element_by_name("NR")).select_by_value('50')
Select类方法：
select_by_index() :通过索引定位
select_by_value() :通过value值定位
select_by_visible_text() :通过文本值定位
deselect_all() ：取消所有选项
deselect_by_index() ：取消对应index选项
deselect_by_value() ：取消对应value选项
deselect_by_visible_text() ：取消对应文本选项
first_selected_option() ：返回第一个选项
all_selected_options() ：返回所有的选项
CSS:
dri.find_element_by_css_selector("select#nr>option:nth-child(3)").click()
dri.find_element_by_css_selector("select#nr>option[@value='30']:nth-child()").click()
定位父元素select（下面语句中的id=aaa）,然后通过tag name找到所有option，得到option元素的数组，然后通过数组索引（[1]）定位，最后click:
driver.find_element_by_id("aaa").find_elements_by_tag_name("option")[1].click()
跟第1条差不多思想，不过用option元素的value属性来定位了，下面代码是通过xpath来写的，可以换成 by_css:
driver.find_element_by_xpath("//select[@id='aaa']").find_element_by_xpath("//option[@value='5PM']").click()

弹框（警告框处理）：

switch_to.alert()
switch_to_alert() #定位到弹框
text #获取弹框文本
accept() #接受/确定弹框
dismiss() #解散/关闭弹框
send_keys(value) #发送文本至弹框
eg:
dt=driver.switch_to_alert() / dt=driver.switch_to.alert()
dt.accept()

复选框：

driver.find_element_by_css_selector("span#li>input:nth-child(2)").click()
.pop().click() #最后一个点击
.pop（-1）：默认获取一组元素的最后一个
.pop（0）：默认获取一组元素的第一个
.pop（1）：默认获取一组元素的第二个
list=dri.find_elements_by_xpath("//*[@type='checkbox']") #获取所有框
print list
for x in list:
if x.get_attribute("value")=="lan": #选择符合条件的框
x.click()
dri.find_element_by_css_selector("span#li>input:nth-child(2)").is_selected() #是否被选

抓捕异常：

from selenium.common.exceptions import *
try:
    ...
except Exception，e:
    ...
else：
    ...
（finally：）
    ...

JS定位：

document.getElementById("id")
document.getElementsByName("name")[0].value="test"      返回列表，如果只有一个取下标0
document.getElementsByTagName("tag")
document.getElementsByClassName("class")
document.querySelectorAll()
eg:
jsusename='document.getElementById("account").clear()'
dri.execute_script(jsusename)
jspassword='document.getElementById("account").value="admin"'
dri.execute_script(jspassword)

JS日期：

#移除属性
js='document.getElementById("train_date").removeAttribute("readonly");'
dri.execute_script(js)
#jQuery方法移除属性
# js="$('input[id=train_date]').removeAttr('readonly')"     #1移除属性
# js="$('input[id=train_date]').Attr('readonly',false)"     #2设置为false
# js="$('input[id=train_date]').removeAttr('readonly','')"     #3设置为空，同2
#用js方法输入日期
time.sleep(5)
jsdate='document.getElementById("train_date").value="2018-05-01"'
dri.execute_script(jsdate)

单元测试：

#test方法必须 要以test开头
import unittest
class IntegerArithmeticTestCase(unittest.TestCase):
    def setUp(self):
        self.dri = webdriver.Firefox()
        self.dri.get(r"https://www.baidu.com/")
        time.sleep(3)
    def tearDown(self):
        time.sleep(3)
        self.dri.close()
    def testlogin(self):
        self.dri=webdriver.Firefox()
        self.dri.get(r"https://www.baidu.com/")
        self.dri.find_element_by_id("kw").send_keys("test")
        time.sleep(3)
        self.dri.find_element_by_id("su").click()
        time.sleep(3)
        titles=self.dri.title
        self.assertEqual(titles,u"test_百度搜索")

if __name__=='__main__':
    unittest.main()

① setup():每个测试函数运行前运行
② teardown():每个测试函数运行完后执行
③ setUpClass():必须使用@classmethod装饰器,所有test运行前运行一次
④ tearDownClass():必须使用@classmethod装饰器,所有test运行完后运行一次

单元测试用例：

import unittest
import HTMLTestRunner
class Reports(unittest.TestCase):
    def testpanduan01(self):
        self.assertEqual(1,6)
    def testpanduan02(self):
        self.assertIn("aaa","aaaaabbbbbccccdddd")
if __name__=="__main__":
    # 指定执行测试用例
    testunit=unittest.TestSuite()
    testunit.addTest(Reports("testpanduan01"))
    testunit.addTest(Reports("testpanduan02"))
    #增加时间
    now=timereport=time.strftime("%Y%m%d%S%M%S")
    uu="panduanReport.html"
    print timereport+uu
    # fp=open(now+"panduanReport.html","w")
    # 写测试报告
    fp=open("panduanReport"+now+".html","w")
    runner=HTMLTestRunner.HTMLTestRunner(stream=fp,title=u"测试报告书",description=u"这是测试报告的描述")
    runner.run(testunit)

断言语法 解释
assertEqual(a, b) 判断a==b
assertNotEqual(a, b) 判断a！=b
assertTrue(x) bool(x) is True
assertFalse(x) bool(x) is False
assertIs(a, b) a is b
assertIsNot(a, b) a is not b
assertIsNone(x) x is None
assertIsNotNone(x) x is not None
assertIn(a, b) a in b
assertNotIn(a, b) a not in b
assertIsInstance(a, b) isinstance(a, b)
assertNotIsInstance(a, b)

单元测试修饰器：

class login(unittest.TestCase):
#setup().teardowm()每个用例都执行，+class后添加修饰器@classmethod...之开始结束执行一次
    # def setUp(self):
    @classmethod
    def setUpClass(cls):
        cls.dri=webdriver.Firefox()
        cls.dri.get(r"https://www.baidu.com/")
        print "start*******************"
    # def tearDown(self):
    @classmethod
    def tearDownClass(cls):
        cls.dri.close()
        print "%%%%%%%%%%%%%%%%%%%%%end"
    @unittest.skip("msg") #跳过测试用例
    def test001(self):
        print "this is num1"
    def test002(self):
        print "this is num2"
#test用例执行顺序.根据ASCLL
#   0-9  A-Z    a-z

等待：

from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as ec

操作excel：

import xlrd

打开excel文件

data=xlrd.open_workbook("test.xlsx")

获取指定sheet

table=data.sheets()[0]
table=data.sheet_by_index(0)
table=data.sheet_by_name("Sheet1")

row行 col列

行数a

a=table.nrows

列数b

b=table.ncols

第一行的值

table.row_values(0)

第一列的值

table.col_values(0)

python读取Excel实例

（1）安装python官方Excel库-->xlrd
（2）获取Excel文件位置并读取
（3）读取sheet
（4）读取指定rows和cols内容

DDt:

import ddt
data=[存放字典数据n对]
类名前用修饰器@ddt.ddt
class Ddtdemo(unittest.TestCase):
测试用例test前用修饰器@ddt.data(data) *data 表示传入所有的数据
def testdemo(self,data):

data从excel读取数据文件：

data1=filesname.classname("init参数文件") init参数文件是读取文件方法类的传入参数
data=filesname.classname.waysname(data1)

range() 函数可创建一个整数列表，一般用在 for 循环中
range(start, stop[, step])
start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)

python的ConfigParser模块：

该模块的作用 就是使用模块中的RawConfigParser()、ConfigParser()、 SafeConfigParser()这三个方法（三者择其一），创建一个对象使用对象的方法对指定的配置文件做增删改查 操作。
在调用这三个函数时，切记这三个函数会将调用optionxform()，在传递键值对数据时，会将键名 全部转化为小写：
RawConfigParser()：
ConfigParser.RawConfigParser([defaults[, dict_type[, allow_no_value]]])
defaults : 如果指定默认值，则使用默认值的键值对
dict_type：使用新的section的键值对
allow_no_value ：默认是False，如果是True，表示可以接收空值（None）
return：对象
ConfigParser(）：
ConfigParser.ConfigParser([defaults[, dict_type[, allow_no_value]]])
SafeConfigParser()：
ConfigParser.SafeConfigParser([defaults[, dict_type[, allow_no_value]]])

Python os.path 模块介绍:

os.path.abspath(path) 返回path规范化的绝对路径（但这个路径不一定是真实的路径），如果path仅是一个文件名，使用该函数后返回的路径是当前工作目录路径连接改文件名后所组成的新的路径名。
os.path.split(path) 将path分割成目录和文件名二元组返回
os.path.dirname(path) 返回path的目录，其实就是os.path.split(path)的第一个元素
os.path.basename(path) 返回path最后的文件名。如果path以/或\结尾，就会返回空值。即os.path.split(path)的第二个元素。
os.path.commonprefix(list) 返回list中所有path共有的最长的路径，从左向右，相同字符。
os.path.exists(path) 如果path存在，返回True；如果path不存在，返回False。
os.path.isabs(path) 如果path是绝对路径，返回True。
os.path.normpath(path) 规范path字符串形式（规范文件路径）
os.path.isfile(path) 判断路径是否为文件，是返回True，否则返回False
os.path.isdir(path) 如果path是一个存在的目录，返回True，否则返货False。
os.path.islink(path) 是否是链接；但如果系统不支持链接，则返回False。
os.path.join(path1 [, path2 [, ….]]) 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略。
os.path.normcase(path) 在Linux下，该函数会原样返回path，在Windows平台上会将路径中所有的字符转换为小写，并将所有斜杠转换为反斜杠，同时将路径规范化。
os.path.splitdrive(path) 拆分驱动器和路劲，主要对win，对Linux元组第一个总是空的。
os.path.splitext(path) 分离文件名与扩展名；默认返回（fname, fextension）元组，可做分片操作，以” . “为分隔符。
os.path.getsize(filename) 返回文件的大小（单位字节），如果filename为目录返回0L
os.path.getatime(filename) 返回文件或目录的最后存取时间。
os.path.getctime(filename)返回浮点数的文件或目录的创建时间，在类Unix系统上是文件最近更改的时间，在Windows上是文件或目录的创建时间。
os.path.getmtime(filename) 返回文件或目录的最后修改时间
os.path.walk(top, func, arg)：列出目录树下的目录路径和文件路劲
参数说明：
top：表示需要遍历的目录树的路径
func：表示回调函数，对遍历路径进行处理。所谓回调函数，是作为某个函数的的参数使用，当某个时间触发时，程序将调用定义好的回调函数处理某个任务。回调函数必须提供3个参数：第1个参数为walk()的参数tag，第2个参数表示目录列表，第3个参数表示文件列表。
arg：是传递给回调参数func的元组.回调函数的一个参数必须是arg，为回调函数提供处理参数.参数arg可以为空。

编码格式：

unicodeתutf-8:
import sys
reload(sys)
sys.setdefaultencoding('utf-8')

封装包的定义：

封装：
common:基础方法
case:测试用例
page：配置，查找定位页面元素
exec.py顶层文件作为main函数，执行所有的测试用例
我的定义：
page：页面定位元素，文本，弹框，文本值
case：测试用例
common：继承page类后的测试用例方法
source：资源配置设置与读取