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

# coding:utf-8
import 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


class driver_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 = []
            位置 = 0
            for 单个句柄 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 方式 == '切换':
            if type(变量) == int:
                self.浏览器对象.switch_to.window(self.浏览器对象.window_handles[变量])
            else:
                全部句柄 = self.浏览器对象.window_handles  # 获取全部页面句柄
                for 单个句柄 in 全部句柄:  # 遍历全部页面句柄
                    self.浏览器对象.switch_to.window(单个句柄)
                    标题 = self.浏览器对象.title
                    if 标题 in 变量:
                        break

        if 方式 == '新增':
            self.浏览器对象.execute_script(f'window.open("{变量}")')

        if 方式 == '删除':
            if type(变量) == int:
                当前句柄 = self.浏览器对象.current_window_handle  # 定位当前页面句柄
                选定句柄 = self.浏览器对象.window_handles[变量]
                if str(当前句柄) != 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 变量:
                        if str(单个句柄) != str(当前句柄):
                            self.浏览器对象.close()
                            self.浏览器对象.switch_to.window(当前句柄)
                            break
                        else:
                            self.浏览器对象.close()
                            break

    def 导航键(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 类型 is None:
            使用类型 = self.定位方式
        else:
            使用类型 = 类型
        if 超时 is None:
            超时时间 = self.超时时间
        else:
            超时时间 = 超时

        当前次数 = 0
        输出结果 = False
        self.浏览器对象.implicitly_wait(3)
        while 当前次数 <= 超时时间:
            try:
                元素对象 = self.浏览器对象.find_element(使用类型, 点位)
                if 滚动:
                    self.浏览器对象.execute_script("arguments[0].scrollIntoView();", 元素对象[0])
                元素对象.click()
                输出结果 = True
                break
            except 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 类型 is None:
            使用类型 = self.定位方式
        else:
            使用类型 = 类型
        if 超时 is None:
            超时时间 = 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()
                输出结果 = True
                break
            except 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 类型 is None:
            使用类型 = self.定位方式
        else:
            使用类型 = 类型
        if 超时 is None:
            超时时间 = 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()
                输出结果 = True
                break
            except 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 类型 is None:
            使用类型 = self.定位方式
        else:
            使用类型 = 类型
        if 超时 is None:
            超时时间 = 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(元素对象)

                输出结果 = True
                break
            except 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 类型 is None:
            使用类型 = self.定位方式
        else:
            使用类型 = 类型
        if 类型 is None:
            超时时间 = 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()
                输出结果 = True
                break
            except 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 类型 is None:
            使用类型 = self.定位方式
        else:
            使用类型 = 类型
        if 类型 is None:
            超时时间 = self.超时时间
        else:
            超时时间 = 超时

        当前次数 = 0
        输出结果 = False
        self.浏览器对象.implicitly_wait(3)
        while 当前次数 <= 超时时间:
            try:
                元素对象 = self.浏览器对象.find_element(使用类型, 点位)
                if 滚动:
                    self.浏览器对象.execute_script("arguments[0].scrollIntoView();", 元素对象[0])
                if type(位置对象) == ():
                    ActionChains(self.浏览器对象).drag_and_drop_by_offset(元素对象, 位置对象[0], 位置对象[1]).perform()
                    输出结果 = True
                    break
                else:
                    ActionChains(self.浏览器对象).drag_and_drop(元素对象, 位置对象).perform()
                    输出结果 = True
                    break
            except 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 类型 is None:
            使用类型 = self.定位方式
        else:
            使用类型 = 类型
        if 类型 is None:
            超时时间 = self.超时时间
        else:
            超时时间 = 超时

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

                元素对象 = self.浏览器对象.find_element(使用类型, 点位)
                if 滚动:
                    self.浏览器对象.execute_script("arguments[0].scrollIntoView();", 元素对象[0])
                元素对象.send_keys(文本)
                输出结果 = True
                break
            except 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 类型 is None:
            使用类型 = self.定位方式
        else:
            使用类型 = 类型
        if 类型 is None:
            超时时间 = self.超时时间
        else:
            超时时间 = 超时

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

                元素对象 = self.浏览器对象.find_element(使用类型, 点位)
                if 滚动:
                    self.浏览器对象.execute_script("arguments[0].scrollIntoView();", 元素对象[0])
                输出结果 = 元素对象
                break
            except 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 类型 is None:
            使用类型 = self.定位方式
        else:
            使用类型 = 类型
        if 类型 is None:
            超时时间 = 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:
                        pass
                    try:
                        输出结果.update({
                            '自定义值': 元素对象.get_attribute(自定义)
                        })
                    except Exception as e:
                        pass
                    try:
                        输出结果.update({
                            '是否选中': 元素对象.is_selected()
                        })
                    except Exception as e:
                        pass
                    try:
                        输出结果.update({
                            '元素大小': 元素对象.size
                        })
                    except Exception as e:
                        pass
                    try:
                        输出结果.update({
                            '是否显示': 元素对象.is_displayed()
                        })
                    except Exception as e:
                        pass
                    try:
                        输出结果.update({
                            '是否使用': 元素对象.is_enabled()
                        })
                    except Exception as e:
                        pass
                    try:
                        输出结果.update({
                            '文本内容': 元素对象.text
                        })
                    except Exception as e:
                        pass
                    try:
                        输出结果.update({
                            'tagName': 元素对象.tag_name
                        })
                    except Exception as e:
                        pass
                    break
            except Exception as e:
                print(e)
            time.sleep(1)
            当前次数 += 3

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

加粗样式

最后

以上就是乐观太阳为你收集整理的selenium 常用方法封装 标签页切换 元素点击 双击 拖拽 右击 滚动 等等的全部内容，希望文章能够帮你解决selenium 常用方法封装 标签页切换 元素点击 双击 拖拽 右击 滚动 等等所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。