selenium 常用方法封装 标签页切换 元素点击 双击 拖拽 右击 滚动 等等

# coding:utf-8import datetime, hmac, random, string, time, uuid, pymysql, requests, ujson
from decimal import Decimal
from selenium import webdriver
from selenium.webdriver.common.action_chains import ActionChains

classdriver_api:def__init__(self, 浏览器对象, 超时时间=15, 定位方式='xpath'):
        self.超时时间 = 超时时间
        self.定位方式 = 定位方式
        self.浏览器对象 = 浏览器对象

    def 标签页(self, 方式='查询', 变量=False):"""
        对标签页进行操作

        :param 方式: 对标签页进行操作的方式:     
            '查询':返回当前所有标签页信息;           
            '切换':切换到指定标签页;          
            '新增':新增一个标签页;           
            '删除':删除一个标签页;           
        :param 变量: 方式不同入参不同 
            '查询':入参布尔值True返回当前信息;
            '切换':入参int标识位置 入参str标识标签页标题(模糊匹配);
            '新增':入参url链接地址;
            '删除':入参int标识位置 入参str标识标签页标题(模糊匹配);
        :return: 只有查询时有返回
        """if 方式 =='查询':
            当前句柄 = self.浏览器对象.current_window_handle  # 定位当前页面句柄
            全部句柄 = self.浏览器对象.window_handles  # 获取全部页面句柄
            all_return =[]
            位置 =0for 单个句柄 in 全部句柄:# 遍历全部页面句柄
                self.浏览器对象.switch_to.window(单个句柄)
                uir = self.浏览器对象.current_url
                标题 = self.浏览器对象.title
                句柄 = 单个句柄
                if 单个句柄 == 当前句柄:
                    all_return.append({'uir': uir,'标题': 标题,'句柄': 句柄,'位置': 位置,'当前':1,})else:
                    all_return.append({'uir': uir,'标题': 标题,'句柄': 句柄,'位置': 位置,'当前':0,})
                位置 +=1
            self.浏览器对象.switch_to.window(当前句柄)# 切换到新页面if 变量:
                输出 =[_ for _ in all_return if _['当前']==1]return 输出[0]else:return all_return

        if 方式 =='切换':iftype(变量)==int:
                self.浏览器对象.switch_to.window(self.浏览器对象.window_handles[变量])else:
                全部句柄 = self.浏览器对象.window_handles  # 获取全部页面句柄for 单个句柄 in 全部句柄:# 遍历全部页面句柄
                    self.浏览器对象.switch_to.window(单个句柄)
                    标题 = self.浏览器对象.title
                    if 标题 in 变量:breakif 方式 =='新增':
            self.浏览器对象.execute_script(f'window.open("{变量}")')if 方式 =='删除':iftype(变量)==int:
                当前句柄 = self.浏览器对象.current_window_handle  # 定位当前页面句柄
                选定句柄 = self.浏览器对象.window_handles[变量]ifstr(当前句柄)!=str(选定句柄):
                    self.浏览器对象.switch_to.window(选定句柄)
                    self.浏览器对象.close()
                    self.浏览器对象.switch_to.window(当前句柄)else:
                    self.浏览器对象.switch_to.window(选定句柄)
                    self.浏览器对象.close()else:
                当前句柄 = self.浏览器对象.current_window_handle  # 定位当前页面句柄
                全部句柄 = self.浏览器对象.window_handles  # 获取全部页面句柄for 单个句柄 in 全部句柄:# 遍历全部页面句柄
                    self.浏览器对象.switch_to.window(单个句柄)
                    标题 = self.浏览器对象.title
                    if 标题 in 变量:ifstr(单个句柄)!=str(当前句柄):
                            self.浏览器对象.close()
                            self.浏览器对象.switch_to.window(当前句柄)breakelse:
                            self.浏览器对象.close()breakdef 导航键(self, 方式='刷新'):"""
        类型于手机的导航栏

        :param 方式: 对标签页进行操作的方式:     
            '刷新':刷新当前页面;           
            '返回':返回上一步 相当于点击浏览器左上角的返回按钮;          
            '前进':前进下一步 相当于点击浏览器左上角的前进按钮  前提是你可用进行下一步 看一下浏览器左上角的前进按钮是否是可用状态 是可用状态才行;           
            '关闭':删除一个标签页;           
        :return: 
        """if 方式 =='刷新':
            self.浏览器对象.refresh()if 方式 =='返回':
            self.浏览器对象.back()if 方式 =='前进':
            self.浏览器对象.forward()if 方式 =='关闭':
            self.浏览器对象.close()def 点击(self, 点位, 滚动=False, 类型=None, 超时=None):"""
        右击对应的元素

        :param 点位: 元素对象的点位信息 
            默认使用类初始化的'xpath'方式 如果初始化用的是什么 后续其他操作就是什么 如果要该 请用类型进行入参
        :param 滚动: 是否通过滚动找到元素
            默认不滚动 如果元素需要滚动才能看见 请传布尔值True
        :param 类型: 元素对象的定位方式
            默认类初始化的方式 可选:
                ID = "id"
                XPATH = "xpath"
                LINK_TEXT = "link text"
                PARTIAL_LINK_TEXT = "partial link text"
                NAME = "name"
                TAG_NAME = "tag name"
                CLASS_NAME = "class name"
                CSS_SELECTOR = "css selector"
        :param 超时: 等待元素最长时间
            等待元素可用的最长时间 默认类初始化的时间
        :return: 
        """if 类型 isNone:
            使用类型 = self.定位方式
        else:
            使用类型 = 类型
        if 超时 isNone:
            超时时间 = self.超时时间
        else:
            超时时间 = 超时

        当前次数 =0
        输出结果 =False
        self.浏览器对象.implicitly_wait(3)while 当前次数 <= 超时时间:try:
                元素对象 = self.浏览器对象.find_element(使用类型, 点位)if 滚动:
                    self.浏览器对象.execute_script("arguments[0].scrollIntoView();", 元素对象[0])
                元素对象.click()
                输出结果 =Truebreakexcept Exception as e:print(e)
                time.sleep(1)
            当前次数 +=3
        self.浏览器对象.implicitly_wait(self.超时时间)return 输出结果

    def 双击(self, 点位, 滚动=False, 类型=None, 超时=None):"""
        右击对应的元素

        :param 点位: 元素对象的点位信息 
            默认使用类初始化的'xpath'方式 如果初始化用的是什么 后续其他操作就是什么 如果要该 请用类型进行入参
        :param 滚动: 是否通过滚动找到元素
            默认不滚动 如果元素需要滚动才能看见 请传布尔值True
        :param 类型: 元素对象的定位方式
            默认类初始化的方式 可选:
                ID = "id"
                XPATH = "xpath"
                LINK_TEXT = "link text"
                PARTIAL_LINK_TEXT = "partial link text"
                NAME = "name"
                TAG_NAME = "tag name"
                CLASS_NAME = "class name"
                CSS_SELECTOR = "css selector"
        :param 超时: 等待元素最长时间
            等待元素可用的最长时间 默认类初始化的时间
        :return: 
        """if 类型 isNone:
            使用类型 = self.定位方式
        else:
            使用类型 = 类型
        if 超时 isNone:
            超时时间 = self.超时时间
        else:
            超时时间 = 超时

        当前次数 =0
        输出结果 =False
        self.浏览器对象.implicitly_wait(3)while 当前次数 <= 超时时间:try:
                元素对象 = self.浏览器对象.find_element(使用类型, 点位)if 滚动:
                    self.浏览器对象.execute_script("arguments[0].scrollIntoView();", 元素对象[0])
                ActionChains(self.浏览器对象).double_click(元素对象).perform()
                输出结果 =Truebreakexcept Exception as e:print(e)
                time.sleep(1)
            当前次数 +=3
        self.浏览器对象.implicitly_wait(self.超时时间)return 输出结果

    def 右击(self, 点位, 滚动=False, 类型=None, 超时=None):"""
        右击对应的元素

        :param 点位: 元素对象的点位信息 
            默认使用类初始化的'xpath'方式 如果初始化用的是什么 后续其他操作就是什么 如果要该 请用类型进行入参
        :param 滚动: 是否通过滚动找到元素
            默认不滚动 如果元素需要滚动才能看见 请传布尔值True
        :param 类型: 元素对象的定位方式
            默认类初始化的方式 可选:
                ID = "id"
                XPATH = "xpath"
                LINK_TEXT = "link text"
                PARTIAL_LINK_TEXT = "partial link text"
                NAME = "name"
                TAG_NAME = "tag name"
                CLASS_NAME = "class name"
                CSS_SELECTOR = "css selector"
        :param 超时: 等待元素最长时间
            等待元素可用的最长时间 默认类初始化的时间
        :return: 
        """if 类型 isNone:
            使用类型 = self.定位方式
        else:
            使用类型 = 类型
        if 超时 isNone:
            超时时间 = self.超时时间
        else:
            超时时间 = 超时

        当前次数 =0
        输出结果 =False
        self.浏览器对象.implicitly_wait(3)while 当前次数 <= 超时时间:try:
                元素对象 = self.浏览器对象.find_element(使用类型, 点位)if 滚动:
                    self.浏览器对象.execute_script("arguments[0].scrollIntoView();", 元素对象[0])
                ActionChains(self.浏览器对象).context_click(元素对象).perform()
                输出结果 =Truebreakexcept Exception as e:print(e)
                time.sleep(1)
            当前次数 +=3
        self.浏览器对象.implicitly_wait(self.超时时间)return 输出结果

    def 长按(self, 点位, 时间=3, 滚动=False, 类型=None, 超时=None):"""
        长按对应的元素

        :param 点位: 元素对象的点位信息 
            默认使用类初始化的'xpath'方式 如果初始化用的是什么 后续其他操作就是什么 如果要该 请用类型进行入参
        :param 时间: 长按元素的时间
            默认按住3秒
        :param 滚动: 是否通过滚动找到元素
            默认不滚动 如果元素需要滚动才能看见 请传布尔值True
        :param 类型: 元素对象的定位方式
            默认类初始化的方式 可选:
                ID = "id"
                XPATH = "xpath"
                LINK_TEXT = "link text"
                PARTIAL_LINK_TEXT = "partial link text"
                NAME = "name"
                TAG_NAME = "tag name"
                CLASS_NAME = "class name"
                CSS_SELECTOR = "css selector"
        :param 超时: 等待元素最长时间
            等待元素可用的最长时间 默认类初始化的时间
        :return: 
        """if 类型 isNone:
            使用类型 = self.定位方式
        else:
            使用类型 = 类型
        if 超时 isNone:
            超时时间 = self.超时时间
        else:
            超时时间 = 超时

        当前次数 =0
        输出结果 =False
        self.浏览器对象.implicitly_wait(3)while 当前次数 <= 超时时间:try:
                元素对象 = self.浏览器对象.find_element(使用类型, 点位)if 滚动:
                    self.浏览器对象.execute_script("arguments[0].scrollIntoView();", 元素对象[0])

                操作对象 = ActionChains(self.浏览器对象)
                操作对象.click_and_hold(元素对象)
                操作对象.perform()
                time.sleep(时间)
                操作对象.release(元素对象)

                输出结果 =Truebreakexcept Exception as e:print(e)
                time.sleep(1)
            当前次数 +=3
        self.浏览器对象.implicitly_wait(self.超时时间)return 输出结果

    def 悬停(self, 点位, 滚动=False, 类型=None, 超时=None):"""
        触发对应元素的  鼠标悬停事件  鼠标没有真正移动到哪里 但是你可以理解成鼠标悬停在哪里了

        :param 点位: 元素对象的点位信息 
            默认使用类初始化的'xpath'方式 如果初始化用的是什么 后续其他操作就是什么 如果要该 请用类型进行入参
        :param 滚动: 是否通过滚动找到元素
            默认不滚动 如果元素需要滚动才能看见 请传布尔值True
        :param 类型: 元素对象的定位方式
            默认类初始化的方式 可选:
                ID = "id"
                XPATH = "xpath"
                LINK_TEXT = "link text"
                PARTIAL_LINK_TEXT = "partial link text"
                NAME = "name"
                TAG_NAME = "tag name"
                CLASS_NAME = "class name"
                CSS_SELECTOR = "css selector"
        :param 超时: 等待元素最长时间
            等待元素可用的最长时间 默认类初始化的时间
        :return: 
        """if 类型 isNone:
            使用类型 = self.定位方式
        else:
            使用类型 = 类型
        if 类型 isNone:
            超时时间 = self.超时时间
        else:
            超时时间 = 超时

        当前次数 =0
        输出结果 =False
        self.浏览器对象.implicitly_wait(3)while 当前次数 <= 超时时间:try:

                元素对象 = self.浏览器对象.find_element(使用类型, 点位)if 滚动:
                    self.浏览器对象.execute_script("arguments[0].scrollIntoView();", 元素对象[0])
                ActionChains(self.浏览器对象).move_to_element(元素对象).perform()
                输出结果 =Truebreakexcept Exception as e:print(e)
                time.sleep(1)
            当前次数 +=3
        self.浏览器对象.implicitly_wait(self.超时时间)return 输出结果

    def 拖拽(self, 点位, 位置对象, 滚动=False, 类型=None, 超时=None):"""
        触发对应元素的  鼠标悬停事件  鼠标没有真正移动到哪里 但是你可以理解成鼠标悬停在哪里了

        :param 点位: 元素对象的点位信息 
            默认使用类初始化的'xpath'方式 如果初始化用的是什么 后续其他操作就是什么 如果要该 请用类型进行入参
        :param 位置对象: 拖拽的目标对象 必填的哦
            默认使用元素对象 即默认移动到指定的元素对象位置
            传人元祖（x,y）对象即移动指定像素 将元素向x和y轴分别拖动x和y
        :param 滚动: 是否通过滚动找到元素
            默认不滚动 如果元素需要滚动才能看见 请传布尔值True
        :param 类型: 元素对象的定位方式
            默认类初始化的方式 可选:
                ID = "id"
                XPATH = "xpath"
                LINK_TEXT = "link text"
                PARTIAL_LINK_TEXT = "partial link text"
                NAME = "name"
                TAG_NAME = "tag name"
                CLASS_NAME = "class name"
                CSS_SELECTOR = "css selector"
        :param 超时: 等待元素最长时间
            等待元素可用的最长时间 默认类初始化的时间
        :return: 
        """if 类型 isNone:
            使用类型 = self.定位方式
        else:
            使用类型 = 类型
        if 类型 isNone:
            超时时间 = self.超时时间
        else:
            超时时间 = 超时

        当前次数 =0
        输出结果 =False
        self.浏览器对象.implicitly_wait(3)while 当前次数 <= 超时时间:try:
                元素对象 = self.浏览器对象.find_element(使用类型, 点位)if 滚动:
                    self.浏览器对象.execute_script("arguments[0].scrollIntoView();", 元素对象[0])iftype(位置对象)==():
                    ActionChains(self.浏览器对象).drag_and_drop_by_offset(元素对象, 位置对象[0], 位置对象[1]).perform()
                    输出结果 =Truebreakelse:
                    ActionChains(self.浏览器对象).drag_and_drop(元素对象, 位置对象).perform()
                    输出结果 =Truebreakexcept Exception as e:print(e)
                time.sleep(1)
            当前次数 +=3
        self.浏览器对象.implicitly_wait(self.超时时间)return 输出结果

    def 输入(self, 点位, 文本='', 滚动=False, 类型=None, 超时=None):"""
        向对应元素输入指定内容

        :param 点位: 元素对象的点位信息 
            默认使用类初始化的'xpath'方式 如果初始化用的是什么 后续其他操作就是什么 如果要该 请用类型进行入参
        :param 文本: 向对象输入的文本
            不填就输入空气
        :param 滚动: 是否通过滚动找到元素
            默认不滚动 如果元素需要滚动才能看见 请传布尔值True
        :param 类型: 元素对象的定位方式
            默认类初始化的方式 可选:
                ID = "id"
                XPATH = "xpath"
                LINK_TEXT = "link text"
                PARTIAL_LINK_TEXT = "partial link text"
                NAME = "name"
                TAG_NAME = "tag name"
                CLASS_NAME = "class name"
                CSS_SELECTOR = "css selector"
        :param 超时: 等待元素最长时间
            等待元素可用的最长时间 默认类初始化的时间
        :return: 
        """if 类型 isNone:
            使用类型 = self.定位方式
        else:
            使用类型 = 类型
        if 类型 isNone:
            超时时间 = self.超时时间
        else:
            超时时间 = 超时

        当前次数 =0
        输出结果 =False
        self.浏览器对象.implicitly_wait(3)while 当前次数 <= 超时时间:try:

                元素对象 = self.浏览器对象.find_element(使用类型, 点位)if 滚动:
                    self.浏览器对象.execute_script("arguments[0].scrollIntoView();", 元素对象[0])
                元素对象.send_keys(文本)
                输出结果 =Truebreakexcept Exception as e:print(e)
                time.sleep(1)
            当前次数 +=3
        self.浏览器对象.implicitly_wait(self.超时时间)return 输出结果

    def 检测(self, 点位, 滚动=False, 类型=None, 超时=None):"""
        检测元素是否存在 并输出元素对象

        :param 点位: 元素对象的点位信息 
            默认使用类初始化的'xpath'方式 如果初始化用的是什么 后续其他操作就是什么 如果要该 请用类型进行入参
        :param 滚动: 是否通过滚动找到元素
            默认不滚动 如果元素需要滚动才能看见 请传布尔值True
        :param 类型: 元素对象的定位方式
            默认类初始化的方式 可选:
                ID = "id"
                XPATH = "xpath"
                LINK_TEXT = "link text"
                PARTIAL_LINK_TEXT = "partial link text"
                NAME = "name"
                TAG_NAME = "tag name"
                CLASS_NAME = "class name"
                CSS_SELECTOR = "css selector"
        :param 超时: 等待元素最长时间
            等待元素可用的最长时间 默认类初始化的时间
        :return:
            找到输出元素对象  找不到输出布尔值False
        """if 类型 isNone:
            使用类型 = self.定位方式
        else:
            使用类型 = 类型
        if 类型 isNone:
            超时时间 = self.超时时间
        else:
            超时时间 = 超时

        当前次数 =0
        输出结果 =False
        self.浏览器对象.implicitly_wait(3)while 当前次数 <= 超时时间:try:

                元素对象 = self.浏览器对象.find_element(使用类型, 点位)if 滚动:
                    self.浏览器对象.execute_script("arguments[0].scrollIntoView();", 元素对象[0])
                输出结果 = 元素对象
                breakexcept Exception as e:print(e)
                time.sleep(1)
            当前次数 +=3
        self.浏览器对象.implicitly_wait(self.超时时间)return 输出结果

    def 获取(self, 点位, 自定义='class', 滚动=False, 类型=None, 超时=None):"""
        获取元素的相关信息

        :param 点位: 元素对象的点位信息
            默认使用类初始化的'xpath'方式 如果初始化用的是什么 后续其他操作就是什么 如果要该 请用类型进行入参
        :param 自定义: 要获取的额外信息
            默认是'class' 可用自己输入 例如id name 等等
        :param 滚动: 是否通过滚动找到元素
            默认不滚动 如果元素需要滚动才能看见 请传布尔值True
        :param 类型: 元素对象的定位方式
            默认类初始化的方式 可选:
                ID = "id"
                XPATH = "xpath"
                LINK_TEXT = "link text"
                PARTIAL_LINK_TEXT = "partial link text"
                NAME = "name"
                TAG_NAME = "tag name"
                CLASS_NAME = "class name"
                CSS_SELECTOR = "css selector"
        :param 超时: 等待元素最长时间
            等待元素可用的最长时间 默认类初始化的时间
        :return:
            找到元素 输出元素的相关信息  找不到输出空字典{}
        """if 类型 isNone:
            使用类型 = self.定位方式
        else:
            使用类型 = 类型
        if 类型 isNone:
            超时时间 = self.超时时间
        else:
            超时时间 = 超时

        当前次数 =0
        输出结果 ={}
        self.浏览器对象.implicitly_wait(3)while 当前次数 <= 超时时间:try:
                元素对象 = self.浏览器对象.find_element(使用类型, 点位)if 滚动:
                    self.浏览器对象.execute_script("arguments[0].scrollIntoView();", 元素对象[0])if 元素对象:try:
                        输出结果.update({'坐标': 元素对象.location
                        })except Exception as e:passtry:
                        输出结果.update({'自定义值': 元素对象.get_attribute(自定义)})except Exception as e:passtry:
                        输出结果.update({'是否选中': 元素对象.is_selected()})except Exception as e:passtry:
                        输出结果.update({'元素大小': 元素对象.size
                        })except Exception as e:passtry:
                        输出结果.update({'是否显示': 元素对象.is_displayed()})except Exception as e:passtry:
                        输出结果.update({'是否使用': 元素对象.is_enabled()})except Exception as e:passtry:
                        输出结果.update({'文本内容': 元素对象.text
                        })except Exception as e:passtry:
                        输出结果.update({'tagName': 元素对象.tag_name
                        })except Exception as e:passbreakexcept Exception as e:print(e)
            time.sleep(1)
            当前次数 +=3

        self.浏览器对象.implicitly_wait(self.超时时间)return 输出结果

加粗样式