1、启动浏览器（实例化浏览器）
启动Chrome浏览器（驱动已放入path环境变量下）
driver = webdriver.Chrome()指定驱动路径驱动Chrome 浏览器
# .driverchromedriver.exe 为驱动存放位置,可以是相对路径或者绝对路径
driver = webdriver.Chrome(executable_path=r'.driverchromedriver.exe')启动Firefox浏览器
driver=webdriver.Firefox()
# 指定驱动路径 启动
driver=webdriver.Firefox(executable_path="..drivergeckodriver.exe")启动IE浏览器
driver=webdriver.Ie()
# 指定驱动路径 启动
driver=webdriver.Ie(executable_path=r".driverIEDriverServer.exe") 2、最大化浏览器
driver.maximize_window()driver为实例化浏览器对象（下同）
3、设置浏览器大小
driver.set_window_size(480, 800) # width 400, height 8004、打开网页
driver.get('https://www.zhihu.com/') 5、使用另外窗口打开网页
# 新开一个窗口，通过执行js来新开一个窗口
js='window.open("https://mail.163.com");'
driver.execute_script(js)6、控制浏览器前进、后退
driver.get('https://www.zhihu.com/')
driver.get('https://mail.163.com') # 在同一窗口重新打开一个网页
driver.back() # 后退 到知乎
driver.forward() # 前进 换回到1637、获取网页标题
title =driver.title # 获取网页的title获取到的title为页面源码head 标签中title中的文本信息
8、获取网页的URL
url=driver.current_url # 获取网页的URL获取的url为当前浏览器地址栏中的url
9、刷新页面
driver.refresh()10、获取浏览器窗口大小
size=driver.get_window_size()返回为字典型 如：{'width': 1050, 'height': 840}
11、关闭浏览器
driver.close()关闭的是当前浏览器窗口的页签，存在多个窗口时关闭当前的活动窗口
12、退出浏览器
driver.quit()关闭整个浏览器，包括webdriver的进程也会退出
八种属性定位页面元素：
序号 | 类型 | 示例 |
1 | id 定位 | find_element(By.ID,"id值") |
2 | name 定位 | find_element(By.NAME,"name值") |
3 | tag 定位 | find_element(By.TAG_NAME,"id值") |
4 | class 定位 | find_element(By.CLASS_NAME,"class值") |
5 | link_text 定位 | find_element(By.LINK_TEXT,"文本值") |
6 | partial_link 定位 | find_element(By.PARTIAL_LINK_TEXT,"文本模糊值") |
7 | XPath 定位 | find_element(By.XPATH,"唯一路径标识") |
8 | CSS_selector 定位 | find_element(By.CSS_SELECTOR,"各种组合") ，实际使用最多 |
webdriver中元素定位元素的简便方法：
driver.find_element_by_id('元素id属性') # ------ 最常用，简单
driver.find_element_by_name('元素name属性') # ------ 最常用，简单
driver.find_element_by_class_name('元素class属性') # ------ 易重复，看情况使用
driver.find_element_by_tag_name('元素标签名') # ------ 最不靠谱
driver.find_element_by_link_text('链接文本') # ------ 精确匹配链接 （ 标签中的文字）
driver.find_element_by_partial_link_text(‘部分链接文本’) # ------ 模糊匹配链接
driver.find_element_by_xpath() # ------ 最灵活，万能的灵药
driver.find_element_by_css_selector() # ------ 没xpath灵活1、id元素定位
id="query" class="sec-input" name="query" maxlength="100" autocomplete="off" type="text">
driver.find_element_by_id('query')
driver.find_element(By.ID,'query')2、name元素定位
name="query" maxlength="100" autocomplete="off" type="text">
driver.find_element_by_name('query')
driver.find_elemnet(By.NAME,'query')3、class name元素定位
class="sec-input" name="query" maxlength="100" autocomplete="off" type="text">
driver.find_element_by_class_name('sec-input')
driver.find_element(By.CLASS_NAME,'sec-input')4、 tag name元素定位(最不靠谱)
<input id="query" class="sec-input" name="query" maxlength="100" autocomplete="off" type="text">
driver.find_element_by_tag_name('input')
driver,find_element(By.TAG_NAME,'input')5、 link_text元素定位
页面底部搜狗输入法连接
搜狗输入法
driver.find_element_by_link_text('搜狗输入法')
driver.find_element(By.LINK_TEXT,'搜狗输入法')注意：连接文本是标签对之间的文本
6、 partial link text元素定位
<搜狗输入法
driver.find_element_by_partial_link_text('输入法')
driver.find_element(By.PARTIAL_LINK_Text,'输入法')7、 XPath元素定位(强大)
xpath 可以根据元素的父节点或者哥哥弟弟节点定位到元素。
driver.find_element_by_xpath(‘//form[@id="sf"]//input[@type="text"]’) # 上级节点定位下级子节点
driver.find_element_by_xpath(‘//span[@class="enter-input"]/preceding-sibling::span/input’) # 通过节点的弟弟节点定位注意：使用xpath最好不要使用工具获取，手写的可靠性更高
8、css元素定位
css定位元素比xpath块，id，name，class，tag name都是转换为css后定位元素。具体请看find_element方法的代码。
driver.find_elements_by_css_selector(".sec-input") # .表示class
driver.find_elements_by_css_selector("#query") # #表示id一、元素的常用操作
element.click() # 单击元素；除隐藏元素外，所有元素都可单击
element.submit() # 提交表单；可通过form表单元素提交表单
element.clear() # 清除元素的内容；如果可以的话
element.send_keys(‘需要输入的内容’) # 模拟按键输入；只针对支持输入的元素
注意：send_keys() 输入的内容必须为字符串
搜狗查询实例：
from selenium import webdriver
import time
driver = webdriver.Chrome()
driver.maximize_window() # 最大化
driver.get(r'https://www.sogou.com/') # 打开网页
driver.find_element_by_id('query').send_keys('selenium') # 搜索框输入selenium
time.sleep(2) # 等待3秒
driver.find_element_by_id('query').clear() # 清除搜索框内容
time.sleep(2)
driver.find_element_by_id('query').send_keys('selenium') # 重新输入内容
driver.find_element_by_id('sf').submit() # 提交搜索框的表单
# driver.find_element_by_id('stb').submit() # 提交按钮也可提交表单，单击按钮也可以
time.sleep(2)
driver.quit() # 关闭浏览器注意：submit() 提交表单，可以是提交按钮，也可以是表单元素，也可以是输入框元素
二、元素的常用方法
element.location 返回元素的坐标字典（相对于网页左上角0,0开始）
element.text 获取元素的文本，页面上看得到的文本
element.get_attribute('属性名称') 获得元素的属性 强调“有”
element.get_property('属性名称') 获得元素的固有属性值 强调“专”
element.is_displayed() 返回元素的结果是否可见，有些元素肉眼可见，但是他是隐藏的
示例：
from selenium import webdriver
import time
driver = webdriver.Chrome()
driver.maximize_window() # 最大化
driver.get(r'https://www.sogou.com/') # 打开网页
driver.find_element_by_id('query').send_keys('selenium') # 搜索框输入selenium
element=driver.find_element_by_id('query')
print('搜索框的内容为：',element.get_attribute('value'))
print('搜索框的class属性：',element.get_attribute('class'))
print('搜索框的type属性：',element.get_attribute('type'))
print('搜索框的坐标位置：',element.location)
print('搜索框是否可操作：',element.is_displayed())
time.sleep(2)
text = driver.find_element_by_class_name('erwm-box').text # 获取二位码的文本
print('底部二维码的文本为：',text)
time.sleep(2)
driver.quit() # 关闭浏览器1、element.location 获取元素的坐标位置
对于已加载到浏览器的底部元素，操作元素时现在chrome无法自动拖动滚动条，需要获取元素位置后，采用js拖动滚动条到相应位置采用操作元素。
2、element.text 获取元素的文本
搜狗搜索APP
搜你所想
如上，我们定位class="erwm-box"元素，获取到的文本是 [搜狗搜索APP 搜你所想] ，也就是界面上能看到的文字内容。输入框除外（输入框的值是存储在value属性中），只要是界面上的文本内容都可以获取。
多用于校验点。
3、element.get_attribute('属性名称') 获取对应的属性值，强调“有”
type="text" class="sec-input" name="query" id="query" maxlength="100" autocomplete="off">
如上搜索输入框的属性有type、class、name、id、maxlength、autocomplete；我都可以通过get_attribute()获取到他的值，因为他’有’。
value是特殊的属性，输入框，单项按钮，多选按钮多具有改属性。
4、element.get_property('属性名称') 获得元素的固有属性值，强调“专”
它与get_attribute() 差别，get_property(）是获取元素的固有属性。
我们所有的元素都有特定固有属性，如id、type、value等。
当使用get_attribute()无法获取到属性的值时，可使用get_property()。
5、element.is_displayed() 判定改元素是否可见
当我们定位到了元素，但是无法操作时，可以看看他是否可见，不可见不一定就是在界面上消失了。
6、其他方法
element.size 元素的大小
element.is_enabled() 元素是否可用
element.is_selected() 元素是否被选中，用于检测复选框或单项按钮是否被勾选
一、time.sleep(seconds) 固定等待
import time
time.sleep(3) #等待3秒time.sleep(seconds) seconds参数为整数，单位（秒）。
它是Python的time提供的休眠方法。
常用于短时间的等待，为了自动测试用例的执行效率固定等待的时间需要控制在3秒内。在用例中尽量少用固定等待。
二、智能隐性的等待implicitly_wait（回应超时等待）
driver.implicitly_wait(time_to_wait)
回应超时等待，隐性的，设置后对应的是全局，如查找元素。
driver.implicitly_wait(10) # 设置全局隐性等待时间，单位秒每次driver执行 找不到元素都会等待设置的时间，它的值设置的过长对用例执行效率有很大的影响，必须在执行完成之后还原回来。driver.implicitly_wait() 要慎之又慎的使用。
driver对它的默认值为0，driver.implicitly_wait(0)能还原隐性等待的设置时间。
三、智能显性等待WebDriverWait
WebDriverWait(driver, timeout, poll_frequency=0.5, ignored_exceptions=None)
参数说明：
driver 为webdriver驱动 timeout 最长超时时间，单位(秒) poll_frequency 循环查找元素每次间隔的时间，默认0.5秒 ignored_exceptions 超时后需要输出的异常信息
WebDriverWait()下面有两个方法可用until()和until_not()
*WebDriverWait(driver, timeout).until(method, message='')*
method 函数或者实例call()方法返回True时停止，否则超时后抛出异常。
参数说明：
method 在等待时间内调用的方法或者函数，该方法或函数需要有返回值，并且只接收一个参数driver。 message 超时时抛出TimeoutException，将message传入异常显示出来
*WebDriverWait(driver, timeout).until_not(method, message='')*
于上面的until() 相反，until_not 中的method函数或者实例call()方法返回False结束，否则抛出异常。
until方法使用的method 的函数或者类call()方法详解：
函数我们一般采用匿名函数lambda 。
lambda driver:driver.find_element(<定位元素>) # 当定位的元素时为True，无元素时为False。如示例1、2：
WebDriverWait示例1：
WebDriverWait(driver,5).until(lambda driver:driver.find_element_by_id('query'))5秒内等待元素(id='query')出现，lambda driver:driver.find_element_by_id('query') 为一个匿名函数，只有一个driver参数，返回的是查找的元素对象。
WebDriverWait示例2：
WebDriverWait(driver, 5).until_not(lambda driver:driver.find_element_by_name('query'))5秒内等待元素消失，同示例1 until_not 要求无元素返回即元素不存在于该页面。
定义类中的call()方法。
class wait_element(object):
def __init__(self, locator):
self.locator = locator
def __call__(self, driver):
return driver.find_element(self.locator)
WebDriverWait(driver, 5).until(wait_element((By.ID, 'query'))) # 等待元素出现
WebDriverWait(driver, 5).until_not(wait_element((By.ID, 'query'))) # 等待元素消失wait_element类中init()方法接收需要定位的元素，call()方法中只能有唯一变量driver，并且返回元素对象。
这样做是是不是很麻烦，其实selenium提供的一个库进行操作，expected_conditions库。引入位置
from selenium.webdriver.support import expected_conditions as ec，它囊括了我们需要使用等待的所有情况。
四、expected_conditions 类库
from selenium.webdriver.support import expected_conditions as ec # 引入包下面示例都是以搜狗搜索首页为例。
方法中参数说明 locator=(By.ID, 'id') 表示使用By方法定位元素的元组，element表示获取的webElement元素对象。
ec.title_is(‘title’) 判断页面标题等于title
*ec.title_contains(‘title’)* 判断页面标题包含title
WebDriverWait(driver, 10).until(ec.title_is('搜狗搜索引擎 - 上网从搜狗开始')) # 等待title 于参数相等
WebDriverWait(driver, 10).until(ec.title_contains('搜狗搜索引擎')) # 等待title 包含 参数的内容*ec.presence_of_element_located(locator)* 等待locator元素是否出现
ec.presence_of_all_elements_located(locator) 等待所有locator元素是否出现
WebDriverWait(driver, 10).until(ec.presence_of_element_located((By.ID, 'query')))
WebDriverWait(driver, 10).until(ec.presence_of_all_elements_located((By.ID, 'query')))*ec.visibility_of_element_located(locator)* 等待locator元素可见
ec.invisibility_of_element_located(locator) 等待locator元素隐藏
*ec.visibility_of(element)* 等待element元素可见
WebDriverWait(driver, 10).until(ec.visibility_of_element_located((By.ID, ''stb''))) # 等待元素可见
WebDriverWait(driver, 10).until(ec.invisibility_of_element_located((By.ID, ''stb''))) # 等待元素隐藏
WebDriverWait(driver, 10).until(ec.visibility_of(driver.find_element_by_link_text('高级搜索'))) # 等待元素可见*ec.text_to_be_present_in_element(locator,text)* 等待locator的元素中包含text文本
ec.text_to_be_present_in_element_value(locator,value) 等待locator元素的value属性为value
WebDriverWait(driver, 10).until(ec.text_to_be_present_in_element((By.ID, 'erwx'), '搜索APP')) # 等待元素中包含搜索APP文本
WebDriverWait(driver, 10).until(ec.text_to_be_present_in_element_value((By.ID, 'query'),'selenium')) # 等待元素的值为 selenium，一般用于输入框ec.frame_to_be_available_and_switch_to_it(locator) 等待frame可切入
WebDriverWait(driver, 10).until(ec.frame_to_be_available_and_switch_to_it((By.ID, 'frame')))
WebDriverWait(driver, 10).until(ec.frame_to_be_available_and_switch_to_it('frameid'))
ec.alert_is_present() 等待alert弹出窗口出现
WebDriverWait(driver, 10).until(ec.alert_is_present())ec.element_to_be_clickable(locator) 等待locator元素可点击
WebDriverWait(driver, 10).until(ec.element_to_be_clickable((By.ID, 'kw')))等待元素被选中，一般用于复选框,单选框
ec.element_to_be_selected(element) 等待element元素是被选中
ec.element_located_to_be_selected(locator) 等待locator元素是被选中ec.element_selection_state_to_be(element, is_selected) 等待element元素的值被选中为is_selected(布尔值)
ec.element_located_selection_state_to_be(locator,is_selected) 等待locator元素的值是否被选中is_selected(布尔值)
from selenium import webdriver
import time
from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver.support import expected_conditions as ec # 引入包
from selenium.webdriver.common.by import By
driver = webdriver.Chrome()
driver.maximize_window()
driver.get(r'https://www.baidu.com/')
driver.find_element_by_link_text('设置').click()
WebDriverWait(driver, 3).until(ec.element_to_be_clickable((By.LINK_TEXT, '搜索设置'))) # 等待搜索可点击，不可缺少
driver.find_element_by_link_text('搜索设置').click()
element = driver.find_element_by_id('s1_1')
WebDriverWait(driver, 2).until(ec.element_to_be_selected(element)) # element被选中
WebDriverWait(driver, 10).until(ec.element_located_to_be_selected((By.ID, 'SL_0'))) # id=’SL_0’ 被选中
WebDriverWait(driver, 10).until(ec.element_selection_state_to_be(element,True )) # element 被选中
WebDriverWait(driver, 10).until(ec.element_located_selection_state_to_be((By.ID, 'SL_1'), False)) # id=’SL_1’不被选中
time.sleep(3)
driver.quit()五、什么时候使用等待
固定等待sleep与隐性等待implicitly_wait尽量少用，它会对测试用例的执行效率有影响。
显性的等待WebDriverWait可以灵活运用，什么时候需要用到？
1、页面加载的时候，确认页面元素是否加载成功可以使用WebDriverWait
2、页面跳转的时候，等待跳转页面的元素出现，需要选一个在跳转前的页面不存在的元素
3、下拉菜单的时候，如上百度搜索设置的下拉菜单，需要加上个时间断的等待元素可点击
4、页面刷新的时候
总之，页面存在改变的时候；页面上本来没的元素，然后再出现的元素
一、鼠标点击操作
click(element=None) 左击 context_click(element=None) 右击 double_click(element=None) 双击 move_to_element(element) 移动鼠标到元素中间（悬停） drag_and_drop(source,target) source上按下左键拖动到target元素上 click_and_hold(element=None) 在元素上按下鼠标左键 release() 释放鼠标 perform() 执行ActionChains中存储的动作
element有None默认值的表示不传入参数该动作在原地执行。
鼠标事件具体使用示例如下：
示例1：鼠标左键点击
action=ActionChains(driver)
action.click() # 在鼠标当前位置单击
action.perform() # 执行action存储的动作
# 鼠标在 '新闻' 元素位置单击
action.click(driver.find_element_by_link_text('新闻')).perform() 注意：action.click() 动作并未执行，它只是存储在action实例中，需要通过action.perform()方法执行存储动作；鼠标键盘事件动作动作可以存储多个，然后一次性执行。如下执行Cytl+C：
ActionChains(driver).key_down(Keys.CONTROL).send_keys('c').key_up(Keys.CONTROL).perform()示例2：鼠标右击
action=ActionChains(driver)
action.context_click().perform() # 在鼠标当前位置右击
# 鼠标在 '新闻' 元素位置右击
action.context_click(driver.find_element_by_link_text('新闻')).perform()示例3：鼠标双击操作
action=ActionChains(driver)
action.double_click().perform() # 在鼠标当前位置双击
# 鼠标在 '新闻' 元素位置双击击
action.double_click(driver.find_element_by_link_text('新闻')).perform()示例4：鼠标移动
action = ActionChains(driver)
element=driver.find_element_by_link_text('设置')
# 鼠标移动到 '新闻' 元素上的中心点
action.move_to_element(element).perform()
# 鼠标在原位置向x轴移动xoffset、y轴移动yoffset；xoffset、yoffset可为正负数
action.move_by_offset(-200,100).perform()
# 鼠标移动到element元素中心点偏移xoffset、yoffset
action.move_to_element_with_offset(element,-500,600).perform()action.move_by_offset(xoffset,yoffset) 这里需要注意，如果 xoffset 为负数，表示横坐标向左移动，yoffset 为负数表示纵坐标向上移动。而且如果这两个值大于当前屏幕的大小，鼠标只能移到屏幕最边界的位置。
鼠标移动操作在测试环境中比较常用到的场景是需要获取某元素的 flyover/tips，实际应用中很多 flyover 只有当鼠标移动到这个元素之后才出现，所以这个时候通过执行 move_to_element(to_element) 操作，就能达到预期的效果。
根据我个人的经验，这个方法对于某些特定产品的图标的 flyover/tips 也不起作用，虽然在手动操作的时移动鼠标到这些图标上面可出现 flyover，但当使用 WebDriver 来模拟这一操作时，虽然方法成功执行，但 flyover 却不出来。所以在实际应用中，还需要对具体的产品页面做相应的处理。
示例5：鼠标悬停
action.click_and_hold().perform() # 鼠标在当前位置按下并不释放
# 鼠标 在'设置' 上悬停
action.click_and_hold(driver.find_element_by_link_text('设置')).perform()
action.click_and_hold(element) 这个方法实际上是执行了两个动作，首先是鼠标移动到元素 element，然后再 click_and_hold, 所以这个方法也可以写成 action.move_to_element(element).click_and_hold()。示例6：鼠标拖拽
source = driver.find_element_by_id("kw") # 获取起始位置元素
target = driver.find_element_by_id("sk") # 获取目标元素
# 将元素source拖动到target的位置
ActionChains(driver).drag_and_drop(source, target).perform()
# 鼠标拖拽动作，将 source 元素向x、y轴方向移动 (xoffset, yoffset) ，其中 xoffset 为横坐标，yoffset 为纵坐标。
ActionChains(driver).drag_and_drop_by_offset(source, -100, 100).perform()在这个拖拽的过程中，已经使用到了鼠标的组合动作，首先是鼠标点击并按住 click_and_hold( source) 元素，然后执行鼠标移动动作 (move_to)，移动到 target 元素位置或者是 (xoffset, yoffset) 位置，再执行鼠标的释放动作 (release)。所以上面的方法也可以拆分成以下的几个执行动作来完成：
ActionChains(driver).click_and_hold(source).move_to_element(target).release().perform()示例7：鼠标释放操
action = ActionChains(driver)
action.release().perform() # 释放按下的鼠标二、键盘操作
对于键盘的模拟操作，ActionChains类中有提供了按下key_down(keys)、释放key_up(keys)、按下并释放send_keys(keys_to_send) 等方法。
键盘的操作有普通键盘和修饰键盘两种 。
普通键盘为常用字母数字等；修饰键盘为Ctrl、Shift、Alt等，修饰键盘一般和其他键组合使用的键。
使用键盘操作时需要引入from selenium.webdriver.common.keys import Keys包，Keys 包中含所有特殊用键。
1、普通键盘操作
键盘操作使用send_keys(*keys_to_send)方法，该方法支持多个按键连续操作，如果需要对某个元素执行按键操作使用send_keys_to_element( element, *keys_to_send)方法。具体使用如下示例：
from selenium.webdriver.common.keys import Keys
action = ActionChains(driver)
action.send_keys(Keys.SPACE).perform() # 按下并释放空格键
action.send_keys(Keys.TAB).perform() # 按下并释放Tab键
action.send_keys(Keys.BACKSPACE).perform() # 按下并释放Backspace键
action.send_keys(Keys.BACKSPACE,Keys.SPACE).perform() # 连续执行按键动作
action.send_keys(Keys.TAB).send_keys(Keys.TAB).perform() # 也可以这样组合
'''
针对某个元素发出某个键盘的按键操作，或者是输入操作
'''
element = driver.find_element_by_id('query')
# 对一元素使用键盘操作
action.send_keys_to_element(element, 'selenium').perform()
# 上面动作拆解为下面动作
action.click(element).send_keys('selenium').perform()注意除了 ActionChains类有 send_keys（keys_to_send）方法外，WebElement 类也有一个 send_keys_to_element（keys_to_send）方法，这两个方法对于一般的输入操作基本上相同，不同点在于以下几点：
第一：Actions 中的 send_keys（*keys_to_send）对修饰键操作后并不会释放，也就是说当调用 actions.send_keys(Keys.ALT)、 actions.send_keys(Keys.CONTROL)、 action.send_keys(Keys.SHIFT) 的时候，相当于调用 actions.key_down(keys_to_send)，而如果在现实的应用中想要模拟按下并且释放这些修饰键，应该先action.reset_actions()重设action，然后再调用 action.send_keys(keys.NULL).perform()取消按下的修饰键。
第三点，在 WebDriver 中，我们可以使用 WebElement 类的 send_keys() 来上传附件，比如 element.send_keys(“D: estuploadfile est.jpg”)上文件，但不能使用ActionChains来上传附件，因为type=’file’的输入框并不支持键盘输入。
2、修饰键的使用
修饰键是键盘上的一个或者一组特别的键，当它与一般按键同时使用时，用来临时改变一般键盘的普通行为。
修饰键一般跟普通键组合使用，比如 Ctrl+A、Alt+F4等。
我们电脑中的修饰键一般有以下几种修：Ctrl、Alt(Option)、Shift、AltGr、Windows logo、Command、FN(Function)。一般使用的都是前三种。
对于修饰键的使用在Python selenium中一般使用按下key_down(keys)、释放key_up(keys)、按下并释放send_keys(keys_to_send)组合实现。
action = ActionChains(driver)
action.key_down(Keys.CONTROL).perform() # 按下ctrl键
action.key_up(Keys.CONTROL).perform() # 释放ctrl键
action.key_down(Keys.SHIFT).perform() # 按下shift键
action.key_up(Keys.SHIFT).perform() # 释放shift键
action.key_down(Keys.ALT).perform() # 按下alt键
action.key_up(Keys.ALT).perform() # 释放alt键示例：通过ctrl+c 来复制文本
ActionChains(driver).key_down(Keys.CONTROL).send_keys('c').key_up(Keys.CONTROL).perform()三、WebElement.send_keys()键盘操作
WebElement元素对象下的send_keys也支持组合键盘操作。
代码示例如下：
element = driver.find_element_by_id('query')
element.send_keys('selenium')
element.send_keys(Keys.BACK_SPACE) # 按BACKSPACE删除一个字符
element.send_keys(Keys.SPACE) # 空格键(Space)
element.send_keys(Keys.CONTROL, 'a') # 全选（Ctrl+A）
element.send_keys(Keys.CONTROL, 'c') # 复制（Ctrl+C）
element.send_keys(Keys.CONTROL, 'v') # 粘贴（Ctrl+v）
element.send_keys(Keys.TAB) # 制表键(Tab)
element.send_keys(Keys.ESCAPE) # 回退键（Esc）
element.send_keys(Keys.ENTER) # 回车键（Enter）一、层级定位(二次定位)
在实际测试过程中，一个页面可能有多个属性基本相同的元素，如果要定位到其中的一个，这时候需要用到层级定位。先定位其父元素，然后再通过父元素定位该元素。
示例：通过层级定位搜狗输入框
driver = webdriver.Chrome()
driver.maximize_window()
driver.get(r'https://www.sogou.com/')
form_element = driver.find_element_by_id('sf') # 获取form表单元素
form_element.find_element_by_id('query').send_keys('selenium') # 通过表单定位输入框
form_element.find_element_by_id('stb').click() # 通过表单定位搜索按钮
time.sleep(3)
driver.quit()如上代码，我们先定位到了form表单，然后通过表单定位下面的输入框与按钮。
注意：上面示例只通过两层定位到了元素，层级定位不一定定位两次，我们可以定位多次。
二、定位一组元素
而当我们需要获取多个属性相同的对象，并且需要批量操作该对象时，就会使用find_elements定位一组元素。
创建以下html文件，文件名checkbox.html
示例：全选上面的多选框
from selenium import webdriver
import time
driver = webdriver.Chrome()
driver.maximize_window()
driver.get(r'E:xxxcheckbox.html') # 打开checkbox.html文件，使用绝对地址
checkboxs = driver.find_elements_by_xpath('//input[@type="checkbox"]') # 获取批量的对象
for checkbox in checkboxs: # 循环控制
if not checkbox.is_selected(): # 判断多选框是否被选中
checkbox.click() # 单击
time.sleep(3)
driver.quit()三、综合运用
当我们需要定位一组元素时，页面上相似的元素会很多，这时我们需要和层级一定一起使用。先定位到该组元素的父元素，然后通过父元素定位其子孙元素。
示例1：获取搜狗微信页面搜索热词的内容
driver = webdriver.Chrome()
driver.maximize_window()
driver.get(r'http://weixin.sogou.com/')
topele = driver.find_element_by_id('topwords') # 搜索热词的父元素
tops = topele.find_elements_by_tag_name('a') # 二次批量定位热词元素
for top in tops: # 循环获取元素
print(top.text) # 打印文本内容
driver.quit()UI自动化测试中对于表格的定位是个难点，怎么样快速获取表格数据，请看下面几个示例。
示例2：定位表格获取表头
driver = webdriver.Chrome()
driver.maximize_window()
driver.get(r'http://www.w3school.com.cn/cssref/css_selectors.asp')
# //table[@class="dataintable"]//tr[1]//th 获取表头元素
table_header = driver.find_elements_by_xpath('//table[@class="dataintable"]//tr[1]//th')
for header in table_header: # 循环获取元素
print(header.text) # 打印文本内容
driver.quit()示例3：定位表格第二列数据内容
driver = webdriver.Chrome()
driver.maximize_window()
driver.get(r'http://www.w3school.com.cn/cssref/css_selectors.asp')
# //table[@class="dataintable"]//tr[y]//td[x] y第几条记录，x第几列数据
# //table[@class="dataintable"]//tr//td[2] 获取第二列数据
table_header = driver.find_elements_by_xpath('//table[@class="dataintable"]//tr//td[2]')
for header in table_header: # 循环获取元素
print(header.text) # 打印文本内容
driver.quit()示例4：获取表格中所有的数据
driver = webdriver.Chrome()
driver.maximize_window()
driver.get(r'http://www.w3school.com.cn/cssref/css_selectors.asp')
# //table[@class="dataintable"]//tr 定位所有行
tables = driver.find_elements_by_xpath('//table[@class="dataintable"]//tr')
for tr in tables: # 循环每行元素
for td in tr.find_elements_by_tag_name('td'): # 循环获取列
print(td.text, end=' ')
print('
')
driver.quit()定位表格，采用find_elements 组定位，使用xpath=//table//tr[y]//td[x]（y第几条记录，x第几列数据），当y或者x其中一个没有值时定位一行或一列。
选择获取反选下拉框元素首先要实例化select元素
from selenium.webdriver.support.ui import Select # 引入包
select_element=Select(element) # 实例化select
三种常用选择方法
select_element.select_by_index(index) 根据index定位，从0开始 select_element.select_by_value(value) 根据value属性定位 select_element.select_by_visible_text(text) 根据文本定位
反选的方法
select_element.deselect_by_index(index) 根据index定位，从0开始 select_element.deselect_by_value(value) 根据value属性定位 select_element.deselect_by_visible_text(text) 根据文本定位 select_element.deselect_all() 取消全部选择
获取选项的值
select_element.options 返回这个select元素所有的options select_element.all_selected_options 所有被选中的options select_element.first_selected_option 第一个被选中的option
创建select.html 文件，代码如下：
示例1：采用三种方法依次选择's1Id'的值
s1 = Select(driver.find_element_by_id('s1Id')) # 实例化Select，页面第一个下拉框
s1.select_by_index(1) # 选择第二项选项：o1
s1.select_by_value("o2") # 选择value="o2"的项
s1.select_by_visible_text("o3") # 选择text="o3"的值，即在下拉时我们可以看到的文本示例2：想查看一个's1Id'所有的选项
s1 = Select(driver.find_element_by_id('s1Id'))
for select in s1.options:
print(select.text)示例3：查看我已选中的所有选项，'s2Id'可以多选的选择框
s4 = Select(driver.find_element_by_id('s2Id'))
s4.select_by_index(1) # 根据顺序选择第2个
s4.select_by_value("o2val") # 根据value属性选择o2val
s4.select_by_visible_text("With spaces") # 根据展示文本选择With spaces
s4.select_by_visible_text(u" With nbsp") # 注意空格，只有为 是才用空格
for select in s4.all_selected_options: # 循环获取所有的值
print(select.text)注意：只有只有为 的空格才是空格，在html中代码只有 才代表空格，代码中的空格不是空格。
示例4：查看选择框的默认值或选中的值
s1 = Select(driver.find_element_by_id('s1Id'))
print(s1.first_selected_option.text) # 查看选择默认值
s1.select_by_value("o2")
print (s2.first_selected_option.text) # 查看选中的值示例5：取消选择
s4 = Select(driver.find_element_by_id('s2Id'))
s4.select_by_index(1)
s4.select_by_value("o2val")
s4.select_by_visible_text("With spaces")
s4.select_by_visible_text(u" With nbsp")
s4.deselect_by_index(1) # 根据值顺序取消选择
s4.deselect_by_value("o2val") # 根据value属性取消选择
s4.deselect_by_visible_text("With spaces") # 根据文本取消选择
s4.select_by_value("o2val")
s4.select_by_index(1)
s4.deselect_all() # 取消全部选择< frame>