selenium官网介绍和说明：https://www.selenium.dev/zh-cn/documentation/webdriver/getting_started/first_script/
webdriver驱动文件的路径是相对的，webdriver驱动文件的获取是自动下载的代码下载保存的，可参考：https://blog.csdn.net/weixin_45531218/article/details/133977104

初始化函数使用了新的写法，之前的用的旧的方法，要么就是报错，要么提示不适用。现在换成新版的写法，没有报错过。

当前初始化语句
chromeService = ChromeService(executable_path = ‘驱动路径’)
webdriver.Chrome(service = chromeService)

旧版本初始化语句
webdriver.Chrome(executable_path = ‘驱动路径’)

如下是服务初始化、访问页面及元素查找等基础方法的封装。

from selenium import webdriver
from selenium.common import NoSuchElementException, TimeoutException
from selenium.webdriver import ActionChains, Keys
from selenium.webdriver.chrome.service import Service as ChromeService
from selenium.webdriver.chrome.options import Options as ChromeOptions
from selenium.webdriver.common.actions.wheel_input import ScrollOrigin
from selenium.webdriver.edge.options import Options as edgeOptions
from selenium.webdriver.edge.service import Service as edgeService
from selenium.webdriver.common.by import By
from selenium.webdriver.support.select import Select
from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

class BasePage():
    '''将selenium的功能二次封装成'''

   def __init__(self, browser_name=conf.BROWSER_NAME):
        self.browser_name = browser_name
        chromedriver_path = conf.getdriverpath(browser_name) #conf是一个配置类对象，其中配置了浏览器名称、对应的驱动文件完整路径获取方法
        if self.browser_name == 'chrome':
            service = ChromeService(executable_path=chromedriver_path)
            options = ChromeOptions()
            options.add_experimental_option('detach', True)
            self.driver = webdriver.Chrome(service=service, options=options)
        elif self.browser_name == 'edge':
            service = edgeService(executable_path=chromedriver_path)
            options = edgeOptions()
            options.add_experimental_option('detach', True)
            self.driver = webdriver.Edge(service=service, options=options)

	@classmethod
    def get_driver(cls):
        if cls.driver is None:
            cls.driver = webdriver.Chrome()
        return cls.driver
        
    def open(self, url=conf.TEST_URL):
        self.driver.get(url)
        self.driver.maximize_window()

    def get(self, url):
        self.driver.get(url)
        self.driver.maximize_window()

    def refresh(self):
        self.driver.refresh()

    def quit(self):
        self.driver.quit()
        self.driver = None

    def close(self):
        self.driver.close()

    def get_title(self):
        return self.driver.title
        
    def find_element(self, locator):
        by, value = locator
        return self.driver.find_element(by=by, value=value)

    def wait_and_find_element(self, locator, timeout=30):
        '''等待元素可被定位后，返回元素'''
        try:
            return WebDriverWait(self.driver, timeout, 0.2).until(EC.visibility_of_element_located(locator))
        except Exception as e:
            logger.error("{}查找元素超时".format(locator))
            logger.error(e)

    def is_find_lement_timeout(self, locator, timeout = 3):
        """查找元素，如果元素存在，则返回元素本身，否则返回None"""
        try:
            element = WebDriverWait(self.driver, timeout).until(EC.visibility_of_element_located(locator))
            return element
        except TimeoutException:
            return None

    def set_window_size(self, weight, height):
        ''' 设置宽高 '''
        if weight >= 0 and height >= 0:
            self.driver.set_window_size(weight, height)
        else:
            self.driver.maximize_window()

键盘操作和鼠标操作，包括普通文本和特殊字符的输入，鼠标点击和页面滚动。

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

    def wait_and_click(self, locator, timeout=30):
        '''等待元素可点击后，点击'''
        ele = WebDriverWait(self.driver, timeout).until(EC.element_to_be_clickable(locator))
        ele.click()

    def move_and_click(self, locator):
        """ 将鼠标移动到元素位置，并按下enter键 """
        (ActionChains(self.driver)\
         .move_to_element(self.wait_and_find_element(locator))\
         .send_keys(Keys.ENTER)\
         .perform())

    def send_keys(self, locator, text):
        self.find_element(locator).send_keys(text)

    def wait_and_send_keys(self, locator, text):
        self.wait_and_find_element(locator).send_keys(text)

    def send_enter(self, locator):
        self.wait_and_find_element(locator).send_keys(Keys.ENTER)

    # 获取元素文本内容
    def get_text(self, locator):
        return self.find_element(locator).text

    def wait_and_get_text(self, locator, timeout=30):
        return self.wait_and_find_element(locator, timeout).text

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

    def clear_and_send_keys(self, locator, text):
        ele = self.wait_and_find_element(locator)
        ele.clear()
        ele.send_keys(text)
        def scroll_to_element(self, locator):
        '''滚动到指定元素，会将指定元素滚动到屏幕底端'''
        ActionChains(self.driver) \
            .scroll_to_element(self.wait_and_find_element(locator)) \
            .perform()

    def scroll_from_origin(self, locator, x, y):
        '''滚动到指定元素之后，再继续滚动
        x x>0 向右滚动   x<0 向左滚动
        y y>0 向下滚动   y<0 向上滚动
        '''
        ele = self.wait_and_find_element(locator)
        scroll_origin = ScrollOrigin.from_element(ele)
        ActionChains(self.driver) \
            .scroll_from_origin(scroll_origin, x, y) \
            .perform()

    def move_to_element(self, locator, timeout=30):
        '''将鼠标移动到指定元素'''
        ActionChains(self.driver) \
            .move_to_element(self.wait_and_find_element(locator,timeout)) \
            .perform()

等待

    def force_wait(self, wait_time):
        '''强制等待'''
        time.sleep(wait_time)

    def implicitly_wait(self, timeout):
        ''' 隐式等待
        当脚本执行到某个元素定位时会以轮询的方式不断判断元素是否存在
        一旦找到元素，驱动程序将返回元素引用，代码将继续执行，因此较大的隐式等待值不一定会增加会话的持续时间。
        '''
        self.driver.implicitly_wait(timeout)

    def explicit_wait(self, timeout=30, method=None, message=''):
        '''显示等待
        指定的条件不成立，则继续等待，每隔poll_frequency秒的时间调用一次method方法
        超过timeout秒后，条件仍不成立，则抛出异常
        '''
        try:
            if method:
                return WebDriverWait(self.driver, timeout, 0.2).until(method, message)
            else:
                return WebDriverWait(self.driver, timeout, 0.2)
        except Exception as e:
            logger.error(e) #logger为日志类对象

frame切换

    def switch_frame_by_frame_name(self, iframe_name):
        '''通过iframe/frame的 name属性来查找并切换到frame'''
        self.driver.switch_to.frame(iframe_name)

    def switch_frame_by_frame(self, frame):
        ''' frame为一个元素对象，直接切换到frame'''
        self.driver.switch_to.frame(frame)

    def switch_frame_to_default_content(self):
        self.driver.switch_to.default_content()

窗口切换

####window切换
    def get_window_handles(self):
    	#获取所有窗口
        return self.driver.window_handles

    def get_current_window(self):
    	#获取当前窗口
        return self.driver.current_window_handle

    def switch_to_window(self, window_handle):
    	#切换到指定 窗口
        self.driver.switch_to.window(window_handle)

    def switch_to_window_by_index(self, index):
        """切换到第index个窗口，index从0开始"""
        all_handles = self.driver.window_handles
        if len(all_handles) > index:
            self.driver.switch_to.window(all_handles[index])

截图操作

    def savescreenshot(self, pic_name):
        pic_path = conf.SCREEN_PATH + '\\' + pic_name
        self.driver.save_screenshot(pic_path)

    def get_screenshot_as_png(self):
        '''返回当前截图，不保存'''
        return self.driver.get_screenshot_as_png()