1学术

from selenium import webdriver
from time import sleep
jiemian = ‘//img[@width=”270px” and@height=”129px”]’
driver = webdriver.Chrome()
url = ‘http://www.baidu.com‘
driver.get(url)
driver.maximizewindow() # 最大化浏览器
学术_loc = ‘//a[contains(text(),”学”)]’ # 学术元素的xpath定位表达式（定位器）
学术 = driver.find_element_by_xpath(学术_loc) # 定位“学术”元素
学术.click() # 点击“学术”元素
sleep(2) # 会打开一个新窗口，等待2秒看效果
窗口标题 = driver.title
print(‘当前窗口的标题：{}’.format(窗口标题))
当前窗口的句柄 = driver.current_window_handle
print(‘当前窗口的句柄：{}’.format(当前窗口的句柄))
所有窗口的句柄列表 = driver.windowhandles
print(‘打印出所有窗口的句柄：{}’.format(所有窗口的句柄列表))
# 新窗口一般是这个列表的最后一个列表元素，
# 原先只有一个句柄，下标是0，新窗口的句柄下标是1
学术窗口的句柄 = 所有窗口的句柄_列表[1]
driver.switch_to.window(学术窗口的句柄) # 根据窗口句柄，切换到指定窗口
窗口标题 = driver.title
print(‘切换到新窗口后的标题：{}’.format(窗口标题))
if 窗口标题 == ‘百度学术 - 保持学习的态度’: # if ‘学术’ in 窗口标题:
print(‘学术页面被成功打开了’)
else:
print(‘学术页面打开失败了’)
sleep(3)
driver.quit()

2单选框

from selenium import webdriver
from time import sleep
driver = webdriver.Chrome()
driver.maximize_window()
url = ‘file:///C:/checkbox%20and%20radiobox.htm’
driver.get(url)
sleep(3)
单选框集合_loc = ‘//input[@name=”r1”]’
单选框集合 = driver.find_elements_by_xpath(单选框集合_loc)
for 单选框 in 单选框集合:
单选框.click()
sleep(0.5)
sleep(2)
driver.quit()

3处理弹框

from selenium import webdriver
from time import sleep
driver = webdriver.Chrome()
# url = ‘file://C:\switch_to_alert.html’
url = ‘http://www.51testing.com/‘
driver.get(url)
driver.maximize_window()
driver.find_element_by_xpath(‘//a[text()=”加入收藏”]’).click()
sleep(2)
driver.switch_to.alert.accept() # 切入到alert然后确定
# driver.switch_to.alert.dismiss() # 切入到alert然后取消
# driver.switch_to.alert.send_keys(‘在alert里输入文字’) # 切入到alert然后输入文字
sleep(5)
driver.quit()

4切入iframe

from selenium import webdriver
from time import sleep
driver = webdriver.Chrome()
driver.maximize_window()
url = ‘https://www.juhe.cn/‘
driver.get(url)
sleep(10)
# 切入frame：
# # 方式1：如果有id，直接传入id即可
# frame_id = ‘layui-layer-iframe1’
# driver.switch_to.frame(frame_id)
# 方式2：写出这个frame的xpath，然后通过find_element方法找到元素，把找到后的元素传进去
frame_loc = ‘//iframe[@id=”layui-layer-iframe1”]’
frame = driver.find_element_by_xpath(frame_loc)
driver.switch_to.frame(frame)
# 输入手机号
telephone_loc = ‘//input[@id=”mobilephone”]’
telephone = driver.find_element_by_xpath(telephone_loc)
telephone.send_keys(‘13812345678’)
sleep(1.5)
close_window_btn_loc = ‘//div[@id=”regIntroPoP”]//a[text()=”×”]’
driver.find_element_by_xpath(close_window_btn_loc).click()
driver.switch_to.default_content() # 切换回主frame
driver.find_element_by_xpath(‘//a[@class=”header-btn1” and text()=”登录”]’).click()
sleep(3)
driver.quit()

5鼠标键盘模拟事件

from at_common import get_driver
from at_common import open_url
from at_common import find_element_by_xpath
from at_common import quit_driver
from time import sleep
from selenium.webdriver import ActionChains
from selenium.webdriver.common.keys import Keys
driver = get_driver()
open_url(driver, ‘http://www.baidu.com‘)
search_box_loc = ‘//input[@id=”kw”]’
quit_driver(driver)

6 at_common

from selenium import webdriver
def getdriver():
chromedriver = webdriver.Chrome()
return chromedriver
def openurl(driver, url):
driver.get(url)
driver.maximize_window()
def quit_driver(driver):
driver.quit()
def find_element_by_xpath(driver, xpath_locator):
element = driver.find_element_by_xpath(xpath_locator)
return element
if __name == ‘__main‘:
driver = get_driver()
open_url(driver, ‘http://www.baidu.com‘)
sou_suo_kuang = find_element_by_xpath(driver, ‘//input[@id=”kw”]’)
sou_suo_kuang.send_keys(‘面向对象的封装’)
bai_du_yi_xia = find_element_by_xpath(driver, ‘//input[@id=”su”]’)
bai_du_yi_xia.click()
quit_driver(driver)

7 下拉框select

she_zhi_loc = ‘//span[text()=”设置”]’
she_zhi = driver.find_element_by_xpath(she_zhi_loc)
ActionChains(driver).move_to_element(she_zhi).perform()
gao_ji_sou_suo_loc = ‘//a[text()=”高级搜索”]’
gao_ji_sou_suo = driver.find_element_by_xpath(gao_ji_sou_suo_loc)
gao_ji_sou_suo.click()
sleep(5)
# shi_jian_loc = ‘//span[@id=”adv-setting-gpc”]//div[@class=”c-select-selection”]’
dropdown_list_loc = ‘//div[@class=”c-select adv-gpc-select”]’
dropdown_list = driver.find_element_by_xpath(dropdown_list_loc)
dropdown_list.click()
sleep(3)
this_year_loc = ‘//p[text()=”{}”]’.format(‘最近一年’)
this_year = driver.find_element_by_xpath(this_year_loc)
this_year.click()
current_selected_option_loc = ‘//span[@id=”adv-setting-gpc”]//span[@class=”c-select-selected-value”]’
current_selected_option = driver.find_element_by_xpath(current_selected_option_loc)
print(‘当前选项%s’ % current_selected_option.text)
sleep(3)
driver.quit()

8智能等待

（智能）显示等待，需要用到WebDriverWait类，需要导入才能使用
# 它是位于包路径selenium.webdriver.support.wait模块下面的现有类
from selenium.webdriver.support.wait import WebDriverWait
# 显示等待需要配合expected_conditions模块里的各种“预期条件”类一起使用
# expected_conditions模块在selenium.webdriver.support包路径下
# 行业里，我们一般把它别名为EC来使用，因为本身太长了
from selenium.webdriver.support import expected_conditions as EC
# 显示等待需要配合by模块里的By类一起使用，
# 因为很多“预期条件”类的参数需要填写元组形式的locator，如下：
# baidu_search_loc = (By.XPATH, ‘//input[@id=”kw”]’)
# 但是切记，使用时，不要加去解包，这是规则，因为背后，别人会为你做好解包工作
from selenium.webdriver.common.by import By
# WebDriverWait即显式等待，由于它是第三方工具，
# 所以第一个参数需要传入你正在使用的driver
# 第二个参数是智能等待的时间，比如我设置60秒，
# 一旦满足条件立即结束等待，继续运行后面的代码，
# 但是如果超过了设置的时间，则会抛出异常
wait = WebDriverWait(driver, 60)
# 1. 智能等待：until/until_not 元素可见
# 这个方法的参数填写的是定位器（locator），如下面的mobile_phone_loc
# 但是切记，不要解包，也就是说不需要写，
# 因为封装这个方法的工程师在方法内部帮你解包了，看源代码一看便知
# 如果成功，返回值是元素对象，然后你拿变量去接收，这个变量就是元素了，接下来就可以对元素做操作了
# 如果失败返回False布尔值
mobile_phone_loc = (By.XPATH, ‘//input[@name=”mobilephone”]’)
elem = wait.until(EC.visibility_of_element_located(mobile_phone_loc))
elem.send_keys(‘13812345678’)
# 2. 智能等待：until/until_not Frame可见并且状态正常，然后自动切入进该Frame
# 这个方法的参数填写的是frame的定位器，如下面的iframe1_loc
# 同样，不需要写*号去解包（后面相同的不再重复阐述）
# 返回值只有布尔值，你可以通过打印语句去判断是True还是False
iframe1_loc = (By.XPATH, ‘//iframe[@name=”layui-layer-iframe1”]’)
boolean_res = wait.until(EC.frame_to_be_available_and_switch_to_it(iframe1_loc))
print(‘boolean_res =’, boolean_res)
# 3. 智能等待：until/until_not 警告窗口出现
# 这个方法没有参数，有时候，我们在网页上点击一个按钮时，会出现一个弹出式的警告确认窗口
# 比如你再点击支付按钮时，一般都会弹出一个再次确认的窗口，这个就是alert窗口
# 如果条件满足（成功）则返回alert对象，然后你可以操作alert对象，失败返回False
alert = wait.until(EC.alert_is_present())
alert.accept()
# 4. 智能等待：until/until_not 元素可以被点击（能被点击也就是一定是可见的，所以包含可见功能了）
# 这个方法的参数也是传入元素定位器
# 比如我想要自动化测试一下百度首页上的【百度一下】按钮是不是可以正常进行点击的工作，就要用到这个方法
# 返回值：条件成功满足，返回元素对象；不满足，返回False
bai_du_yi_xia_loc = (By.XPATH, ‘//input[@id=”su”]’)
elem = wait.until(EC.element_to_be_clickable(bai_du_yi_xia_loc))
elem.click()
# 5. 智能等待：until/until_not 元素可以被单选或多选（能被选择也就是一定是可见的，所以包含可见功能了）
# 这个方法的参数也是传入元素定位器
# 比如我想测试一下某些单选框或者多选框，他们是不是可以被选择的（而不是灰色只读的），
# 类似这样的场景，就可以使用这个方法了
# 返回值：条件成功满足，返回元素对象；不满足，返回False
locator = (By.XPATH, ‘’)
elem = wait.until(EC.element_to_be_selected(locator))
elem.click()

9 智能等待2

from time import sleep
# from selenium.webdriver.support.wait import WebDriverWait
# from selenium.webdriver.support import expected_conditions as EC
# from selenium import webdriver
#
#
# dr = webdriver.Chrome()
# dr.implicitly_wait(10)
# dr.maximize_window()
# dr.get(‘https://www.juhe.cn/‘)
#
# login_window_frame_loc = ‘//iframe[@id=”layui-layer-iframe1”]’
# login_window_frame = dr.find_element_by_xpath(login_window_frame_loc)
# WebDriverWait(dr, 20).until(EC.frame_to_be_available_and_switch_to_it(login_window_frame))
# telephone_loc = ‘//input[@id=”mobilephone”]’
# telephone = dr.find_element_by_xpath(telephone_loc)
# telephone.send_keys(13812345678)
#
# sleep(2)
# dr.quit()
from selenium import webdriver
driver = webdriver.Chrome()
driver.find_element_by
# 隐式等待
driver.implicitly_wait(10)
driver.maximize_window()
driver.get(‘https://www.juhe.cn/‘)
# 智能等待，显式等待
from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver.support.expected_conditions import visibility_of_element_located
from selenium.webdriver.support.expected_conditions import frame_to_be_available_and_switch_to_it
# WebDriverWait()有两个参数：1、你目前所使用的driver；2、智能等待的设置时间
# .until(条件句)配合WebDriverWait的使用
# 定义元组形式的定位器，如果使用xpath表达元素，就写By.XPATH
from selenium.webdriver.common.by import By
弹出的窗口_frame_loc = (By.XPATH, ‘//iframe[@id=”layui-layer-iframe1”]’)
# frame_to_be_available_and_switch_to_it()这个条件方法，参数填写你要等待和切入的frame元素
wait = WebDriverWait(driver, 10)
r = wait.until(frame_to_be_available_and_switch_to_it(弹出的窗口_frame_loc))
print(r)
# visibility_of_element_located()这个条件方法，参数填写你要智能等待的元素的“元组类型”的定位器表达式,
# 如果在设置的时间内，等待到元素，则返回元素，反之，Python会抛出“等待超时”这个异常
wait = WebDriverWait(driver, 20)
手机号码_loc = (By.XPATH, ‘//input[@id=”mobilephone”]’)
# 直接在visibility_of_element_located()方法后面放入“元组形态”的定位器表达式
# 等待成功，则返回元素
手机号码 = wait.until(visibility_of_element_located(手机号码_loc))
print(‘元素长这样：{}’.format(手机号码))
手机号码.send_keys(‘13812345678’)
from time import sleep
sleep(2)
driver.quit()

10 checkbox复选框

from selenium import webdriver
from time import sleep
driver = webdriver.Chrome()
url = ‘file:///C:/checkbox%20and%20radiobox.htm’
driver.get(url)
driver.maximize_window()
checkboxes_loc = ‘//input[@type=”checkbox”]’
checkboxes = driver.find_elements_by_xpath(checkboxes_loc)
# 第一轮
i = 0
for checkbox in checkboxes:
i = i + 1
checkbox.click()
print(‘第{0}个复选框被选中啦！’.format(i))
sleep(0.5)
driver.save_screenshot(‘/Screenshots/foo.png’)
# 第二轮
if checkboxes[2].is_selected():
checkboxes[2].click()
sleep(0.5)
print(‘第3个元素已经被反选。’)
else:
print(‘第3个元素本来就是反选状态，无需再次点击’)
driver.save_screenshot(‘D:\myScreenshots\round_two.png’)
sleep(3)
driver.quit()