汇总：常用基本操作语句（unittest）

from selenium import webdriver
import time

driver = webdriver.Firefox()
driver.get("https://www.baidu.com")

#1.浏览器最大化
driver.maximize_window()
#2.获取当前浏览器尺寸
size = driver.get_window_size()
print(size)
#3.设置当前浏览器尺寸
driver.set_window_size(400, 400)
size = driver.get_window_size()
print(size)

#4.获取浏览器位置
position = driver.get_window_position()
print(position)
#5.设置浏览器位置
driver.set_window_position(100,200)
position = driver.get_window_position()
print(position)

-------------------------------------
#获取当前页面标题
title = driver.title
print(title)

#获取当前页面地址
url = driver.current_url
print(url)
#获取当前页面标源代码
source = driver.page_source
print(source)
------------------------------------


#1.页面刷新
driver.refresh()

#2.页面回退
driver.back()

#3.页面前进
driver.forward()

#4.页面截图
#(1)方式一
data = driver.get_screenshot_as_png()
with open('baidu1.jpg','wb') as f:
  f.write(data)
#(2)方式二
driver.get_screenshot_as_file('baidu2.png')

from selenium import webdriver
import time

driver = webdriver.Firefox()
driver.get("https://www.baidu.com")


driver.find_element_by_id("kw").send_keys("小瓶子喵")
driver.find_element_by_id("su").click()

driver.find_element_by_name("wd").send_keys("小瓶喵")

driver.find_element_by_class_name("s_ipt").send_keys("小瓶喵")

driver.find_element_by_tag_name("input").send_keys("小瓶喵")
driver.find_element_by_link_text("hao123").click()
driver.find_element_by_parttial_link_text("hao12").click()

driver.find_element_by_xpath(".//*[@id='su']").click()

driver.find_element_by_css_selector("#kw")

# 导入webdriver
from selenium import webdriver
#获取驱动路径
driver_path = './chromedriver.exe'
#创建一个浏览器对象
driver = webdriver.Chrome(executable_path=driver_path)
#设置全屏
driver.maximize_window()
driver.get('https://www.baidu.com/')
#css结合基本属性定位（id,class,标签）
element_input1 = driver.find_element_by_css_selector('#kw') #id
element_input2 = driver.find_element_by_css_selector('.s_ipt') #class
element_input3 = driver.find_element_by_css_selector('form') #标签
print(element_input1)
print(element_input2)
print(element_input3)

from selenium import webdriver
from selenium.webdriver.common.by import By
driver = webdriver.Firefox()
driver.get("https://www.baidu.com")

#复数定位
driver.find_elements_by_class_name(“xx”)[1]

#By定位
driver.find_element(By.ID,"kw")

driver.find_element(By.NAME,"wd")

driver.find_element(By.CLASS_NAME,"s_ipt")

driver.find_element(By.LINK_TEXT,"用户管理")

 

from selenium import webdriver
from selenium.webdriver.common.action_chains import ActionChains
import time
driver.get(r"https://www.baidu.com/")

time.sleep(5)
mouse = driver.find_element_by_id("s-usersetting-top")
ActionChains(driver).move_to_element(mouse).perform()
time.sleep(2)
driver.find_element_by_link_text("高级搜索").click()

 

 

 

 

 

# 切换iframe,此处id="xiaoping"
driver.switch_to.frame("xiaoping")
driver.find_element_by_name("word").send_keys("iframe输入")
# 切换后 切回来
driver.switch_to.default_content()

#class 定位
iframe = driver.find_element_by_class_name("xxxx1")
driver.switch_to.frame(iframe)
driver.find_element_by_name("word").send_keys("iframe输入")
# 切换后 切回来
driver.switch_to.default_content()

#索引定位iframe
driver.switch_to.frame(2)
driver.find_element_by_name("email").send_keys("111")

driver.switch_to.frame(0) //第一层iframe

driver.switch_to.frame(2) //第一层iframe

---------------------

跳出所有frame,回到主界面（Top页面）:

driver.switch_to.default_content()

---------------------

返回上一级frame：

driver.switch_to.parent_frame()

打印当前句柄
c_handle = driver.current_window_handle

print(c_handle)

---------------------

#打印所有的句柄

all_handle = driver.window_handles

print(all_handle)

#切换到新窗口
driver.switch_to.window(all_handle[-1])

sele = driver.find_element_by_class_name("c-select-selection")
Select(sele).select_by_visible_text("最近一周")
#value
Select(sele).select_by_value("20")
#索引
Select(sele).select_by_index(1)

 

alert = driver.switch_to.alert
t = alert.text
print(t)
alert.accept()
# 切换到弹出框：a = driver.switch_to_alert()
# 打印弹出框文本信息：print(a.text)
# 确定按钮：a.accept()
# 取消按钮：a.dismiss()
# 输入值：a.send_keys()

 

 

 

 from selenium.webdriver.support.wait import WebDriverWait
 ele = WebDriverWait(self.driver, timeout, self.t).until(EC.presence_of_element_located(locator))
 ele.send_keys("123")

 

#只要一个符合条件的元素加载出来就通过
presence_of_element_located()
#元素可见则通过
visibility_of_element_located()

 

 

 

# _*_ coding:UTF-8

import time
from selenium import webdriver
from selenium.webdriver import ActionChains
from selenium.webdriver.common.keys import Keys
# 创建一个浏览器对象
driver = webdriver.Chrome()
#打开网页地址
driver.maximize_window()
driver.get('http://sahitest.com/demo/keypress.htm')
time.sleep(3)
key_up_radio = driver.find_element_by_id('r1') # 监测按键升起
key_down_radio = driver.find_element_by_id('r2') # 监测按键按下
key_press_radio = driver.find_element_by_id('r3') # 监测按键按下升起
enter = driver.find_elements_by_xpath('//form[@name="f1"]/input')[1] # 输入框
result = driver.find_elements_by_xpath('//form[@name="f1"]/input')[0] # 监测结果
# 监测key_down
key_down_radio.click()
ActionChains(driver).key_down(Keys.CONTROL,enter).key_up(Keys.CONTROL).perform()
# 监测key_up
key_up_radio.click()
enter.click()
ActionChains(driver).key_down(Keys.SHIFT).key_up(Keys.SHIFT).perform()
# 监测key_press
key_press_radio.click()
enter.click()
ActionChains(driver).send_keys('a').perform()

 

 

 

 

from selenium import webdriver
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support.ui import Select
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.support import expected_conditions as EC

class Base():

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

    def find(self,locator):
        ele = WebDriverWait(self.driver, 10).until(lambda x: x.find_element(*locator))
        return ele

    def send(self,locator,text):
        ele =self.find(locator)
        ele.send_keys(text)

    def click(self,locator):
        self.find(locator).click()


    def clear(self,locator):
        self.find(locator).clear()

    def get_text(self, locator):
        '''获取元素文本值'''
        try:
            ele =self.find(locator).text
        except:
            ele =""
        return ele


    def is_element_exist(self,locator):
        '''判断元素是否存在，结果返回布尔值 ture 或 false'''
        try:
            self.find(locator)
            print("找到元素了！！！！！")
            return True
        except:
            print("找不到元素")
            return False

    def text_in_element(self,locator,_text):
        '''判断元素text属性'''
        try:
            r = WebDriverWait(self.driver,30,1).until(EC.text_to_be_present_in_element(locator,_text))
            return r
        except:
            return False

    def value_in_element(self,locator,text):
        '''判断元素value属性'''
        try:
            r = WebDriverWait(self.driver,30,1).until(EC.text_to_be_present_in_element(locator,_text))
            return r
        except:
            return False

    def move_to_element(self,locator):
        '''鼠标悬停'''
        element = self.find(locator)
        ActionChains(self.driver).move_to_element(element).perform()

    def select_by_index(self,locator,index=0):
        '''select下拉框，index索引'''
        element =self.find(locator)
        Select(element).select_by_index(index)

    def select_by_value(self,locator,value):
        '''select下拉框，value'''
        element =self.find(locator)
        Select(element).select_by_index(value)

    def select_by_text(self,locator,_text):
        '''select下拉框，文本'''
        element =self.find(locator)
        Select(element).select_by_visible_text(_text)

    def is_alert(self,timeout=3):
        '''判断是否有alert，没有返回false，有返回alert对象'''
        try:
            alert = WebDriverWait(self.driver,timeout,1).until(EC.alert_is_present())
            return alert
        except:
            return False

    def js_focus_element(self,locator):
        '''聚焦元素'''
        target =self.find(locator)
        self.driver.execute_scrit("arguments[0].scrollIntoView();",target)

    def js_focus_top(self,locator):
        '''滑动到顶部'''
        js ="window.scrollTo(0,0)"
        self.driver.execute_scrit(js)


    def js_focus_end(self,locator):
        '''滑动到底部'''
        js ="window.scrollTo(0,document.body.scrollHeight)"
        self.driver.execute_scrit(js)



if __name__ == '__main__':
    '''自测函数'''
    from selenium import webdriver
    driver = webdriver.Firefox()
    driver.get("http://192.168.43.57/phpwind/admin.php#initiator")
    loc1 = ("name","admin_name")
    loc2 = ("name", "admin_pwd")
    loc3 = ("name", "submit")
    login_xpath = ("xpath",'html/body/table/tbody[1]/tr[1]/td/div/div/p/a[2]')

    b = Base(driver)  #实例
    b.send(loc1,"admin")
    b.send(loc2, "123456")
    b.click(loc3)
    t = b.get_text(login_xpath)
    print(t)
    assert t == "[注销]"

 

 

 

from datetime import time
from selenium import webdriver
from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.select import Select
from selenium.webdriver.common.action_chains import ActionChains
from common.logger import Logger
from selenium.common.exceptions import TimeoutException
import time

logger = Logger('webbase.py').getLogger()

class WebBase():
    '''基于原生的selenium做二次封装'''

    _instance = False
    timeout = 10

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


    def findElement(self, locator, timeout=timeout):
        '''定位到元素，返回元素对象，没定位到，Timeout异常'''
        try:
            if isinstance(locator, list):
                locator = tuple(locator)
            if not isinstance(locator, tuple):
                logger.error('locator参数类型错误，必须传元祖类型：loc = ("id", "value1")')
            logger.debug("正在定位元素信息：定位方式->%s, value值->%s" % (locator[0], locator[1]))
            ele = WebDriverWait(self.driver, timeout, self.t).until(EC.presence_of_element_located(locator))
            logger.debug("定位元素{}成功".format(locator))
            return ele
        except TimeoutException as e:
            logger.error('未定位到元素',locator)
            raise e

    def findElements(self, locator):
        if not isinstance(locator, tuple):
            print('locator参数类型错误，必须传元祖类型：loc = ("id", "value1")')
        else:
            try:
                print("正在定位元素信息：定位方式->%s, value值->%s"%(locator[0], locator[1]))
                eles = WebDriverWait(self.driver, self.timeout, self.t).until(EC.presence_of_all_elements_located(locator))
                return eles
            except:
                return []

    def sendKeys(self, locator, text=''):
        '''输入文本'''
        try:
            ele = self.findElement(locator)
            ele.send_keys(text)
            logger.debug('send keys {} 成功'.format(text))
        except Exception as e:
            logger.error('send keys {} 失败'.format(text))
            raise e


    def click(self, locator):
        '''点击元素'''
        try:
            ele = self.findElement(locator)
            ele.click()
            logger.debug('click {} 成功'.format(locator))
        except Exception as e:
            logger.error('click {} 失败'.format(locator))
            raise e

    def clear(self, locator):
        '''清空文本'''
        ele = self.findElement(locator)
        ele.clear()

    def isSelected(self, locator):
        '''判断元素是否被选中，返回bool值'''
        ele = self.findElement(locator)
        r = ele.is_selected()
        return r


    def is_title(self, _title=''):
        '''判断标题存在，返回bool值'''
        try:
            result = WebDriverWait(self.driver, self.timeout, self.t).until(EC.title_is(_title))
            print(result.get_attribute("innerHTML"))
            return result
        except:
            return False

    def is_title_contains(self, _title=''):
        '''判断标题中包含某个文本，返回bool值'''
        try:
            result = WebDriverWait(self.driver, self.timeout, self.t).until(EC.title_contains(_title))
            return result
        except:
            return False

    def is_text_in_element(self, locator, _text=''):
        '''判断元素中是否有某个文本，返回bool值'''
        if not isinstance(locator, tuple):
            print('locator参数类型错误，必须传元祖类型：loc = ("id", "value1")')
        try:
            result = WebDriverWait(self.driver, self.timeout, self.t).until(EC.text_to_be_present_in_element(locator, _text))
            return result
        except:
            return False

    def is_value_in_element(self, locator, _value=''):
        '''判断元素中是否有某个值，返回bool值, value为空字符串，返回Fasle'''
        if not isinstance(locator, tuple):
            print('locator参数类型错误，必须传元祖类型：loc = ("id", "value1")')
        try:
            result = WebDriverWait(self.driver, self.timeout, self.t).until(EC.text_to_be_present_in_element_value(locator, _value))
            return result
        except:
            return False

    def is_alert(self, timeout=3):
        '''判断alert,存在返回alert实例，不存在，返回false'''
        try:
            result = WebDriverWait(self.driver, timeout, self.t).until(EC.alert_is_present())
            return result
        except:
            return False

    def get_title(self):
        '''获取title'''
        return self.driver.title

    def get_text(self, locator):
        '''获取文本'''
        try:
            t = self.findElement(locator).text
            return t
        except:
            print("获取text失败，返回'' ")
            return ""

    def get_attribute(self, locator, name):
        '''获取属性'''
        try:
            element = self.findElement(locator)
            return element.get_attribute(name)
        except:
            print("获取%s属性失败，返回'' "%name)
            return ""


    def js_focus_element(self, locator):
        '''聚焦元素'''
        target = self.findElement(locator)
        self.driver.execute_script("arguments[0].scrollIntoView();", target)

    def js_scroll_top(self):
        '''滚动到顶部'''
        js = "window.scrollTo(0,0)"
        self.driver.execute_script(js)

    def js_scroll_end(self,x=0):
        '''滚动到底部'''
        js = "window.scrollTo(%s,document.body.scrollHeight)"%x
        self.driver.execute_script(js)

    def select_by_index(self, locator, index=0):
        '''选择下拉列表，通过索引,index是索引第几个，从0开始，默认选第一个'''
        element = self.findElement(locator)  # 定位select这一栏
        Select(element).select_by_index(index)

    def select_by_value(self, locator, value):
        '''选择下拉列表，通过value属性'''
        element = self.findElement(locator)
        Select(element).select_by_value(value)


    def select_by_text(self, locator, text):
        '''选择下拉列表，通过文本值定位'''
        element = self.findElement(locator)
        Select(element).select_by_visible_text(text)


    def switch_iframe(self, id_index_locator):
        '''切换iframe'''
        try:
            time.sleep(1)
            if isinstance(id_index_locator, int):
                self.driver.switch_to.frame(id_index_locator)
            elif isinstance(id_index_locator, str):
                self.driver.switch_to.frame(id_index_locator)
            elif isinstance(id_index_locator, list):
                ele = self.findElement(id_index_locator)
                self.driver.switch_to.frame(ele)
            logger.info("iframe 切换为{}".format(id_index_locator))
            time.sleep(1)
        except Exception as e:
            logger.error("iframe{}切换异常".format(id_index_locator))
            raise e


    def switch_iframe_out(self):
        '''切换iframe到最外层'''
        try:
            self.driver.switch_to.default_content()
        except:
            print("iframe切换异常")

    def switch_iframe_up(self):
        '''切换iframe到上一层'''
        try:
            self.driver.switch_to.parent_frame()
        except:
             print("iframe切换异常")

    def switch_handle(self, window_name):
        '''切换窗口'''
        self.driver.switch_to.window(window_name)

    def switch_alert(self):
        '''切换弹窗'''
        alert = WebDriverWait.until(EC.alert_is_present())
        return alert

    def move_to_element(self, locator):
        '''鼠标悬停操作'''
        ele = self.findElement(locator)
        ActionChains(self.driver).move_to_element(ele).perform()

    def isElementExist(self,locator, timeout):
        '''判断元素是否存在'''
        try:
            if isinstance(locator, list):
                locator = tuple(locator)
            WebDriverWait(self.driver,timeout).until(EC.presence_of_element_located(locator))
            logger.debug('只查询：查询元素{} 存在'.format(locator))
            return True
        except Exception as e:
            logger.debug('只查询：查询元素{} 不存在'.format(locator))
            return False





if __name__ == "__main__":
    driver = webdriver.Firefox()
    web = WebBase(driver)
    driver.get("https://home.cnblogs.com/u/yoyoketang/")
    loc_1 = ("id", "header_user_left")
    t = web.get_text(loc_1)
    print(t)