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

最新推荐文章于 2024-05-14 23:45:00 发布
最新推荐文章于 2024-05-14 23:45:00 发布
阅读量1k 收藏
点赞数
分类专栏： python笔记 文章标签： selenium python 测试工具
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42778518/article/details/127621015
版权 
# 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 输出结果

加粗样式

老姜一不小心
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Selenium 滚动页面至元素可见的方法
09-17
总之，Selenium 提供了多种方法来处理页面滚动，包括使用`window.scrollBy()`和`scrollIntoView()`。这些技术对于自动化测试和网页交互非常有用，特别是当需要操作位于视口之外的元素时。通过熟练掌握这些技巧，可以...
selenium鼠标双击操作
热门推荐
CHM_6hongming6的博客
12-30 1万+
from selenium.webdriver import ActionChains from selenium import webdriver #定位到要双击的元素 driver = webdriver.Chrme() element =driver.find_element_by_xpath("xxx") #对定位到的元素执行鼠标双击操作 ActionChains(driver).double_click(element).perform() ...
selenium之鼠标操作详解
一个不太黑的测试人~
08-28 6390
人类频繁的用手操作鼠标和键盘，为了解决这个问题，selenium工具为我们提供了一个类来处理这些事件— Actionchains ，该类可以完成鼠标移动，鼠标点击事件、键盘输入、内容菜单交互等交互行为。
「Python｜Selenium｜场景案例」如何模拟鼠标单击、双击、右击、长按和拖拽等操作？
过美好生活，做高效程序员
02-05 6163
本文主要介绍如何在使用selenium进行自动化测试的时候模拟各种鼠标操作。
selenium模拟双击动作
xjhzjut的博客
03-05 333
【代码】selenium模拟双击动作。
Python爬虫（4）-Selenium模拟鼠标操作
入佛门六根不净，入商场狼性不足
01-29 6810
Python爬虫（4）-Selenium模拟鼠标操作
python selenium 对浏览器标签页进行关闭和切换的方法
09-20
本篇文章主要介绍如何使用Selenium来管理和切换浏览器的标签页。 首先，要关闭整个浏览器，你可以调用`driver.quit()`方法。这不仅会关闭当前活动的标签页，还会终止与浏览器的连接，结束整个测试会话。例如： ```...
selenium切换标签页解决get超时问题的完整代码
09-16
### Selenium切换标签页解决GET超时问题 在自动化测试或网页爬虫开发过程中，经常会遇到因为网络延迟等原因导致页面加载超时的问题。Selenium WebDriver 是一个用于自动化 Web 应用程序测试的工具，它提供了控制...
python selenium 对浏览器标签页进行关闭和切换的方法.pdf
04-17
在处理多标签页场景时，Selenium 提供了相应的 API 和方法来控制浏览器标签页的关闭和切换。以下是关于这些操作的详细说明： 1. **关闭浏览器全部标签页**： 使用 `driver.quit()` 方法会关闭整个浏览器实例，包括...
Selenium自动操作鼠标的方法及示例（鼠标左右键单击、左键双击、拖动等）
最新发布
分享式获得也是一种学习的态度
05-14 2962
每个人都有惰性，但不断学习是好好生活的根本，共勉！
Selenium学习（5）其他操纵元素的方法/双击/移动鼠标/拖拽
tiffany_263的博客
06-22 2150
*注意** ： 有些弹窗并非浏览器的alert 窗口，而是**html元素**，这种对话框，只需要通过之前介绍的选择器选中并进行相应的操作就可以了。如果我们要点击的元素不在窗口可见区内，新版本的selenium协议， 浏览器发现要操作（比如点击操作）的元素，不在可见区内，往往会操作失败，浏览网页的时候，我们的窗口标题是不断变化的，可以使用WebDriver的title属性来获取当前窗口的标题栏字符串。然后，我们就可以点击 开发者工具栏的 查看箭头， 再去 点击 糯米图标 ，查看其属性了。
selenium —— webdriver(python) 鼠标事件(双击，右键)
myh919的博客
10-26 857
本节重点：、ActionChains类、context_click()右击、double_click()双击、drag_and_drop()拖动 测试的产品中有一个操作是右键点击文件列表会弹出一个快捷菜单，可以方便的选择快捷菜单中的选择对文件进行操作（删除、移动、重命名），之前学习元素的点击非常简单：
selenium的使用
Mpc
11-27 246
介绍 Selenium 是一个自动化测试工具，利用它可以驱动浏览器执行特定的动作，如点击、下拉等操作，同时还可以获取浏览器当前呈现的页面的源代码，做到可见即可爬。对于一些 JavaScript 动态渲染的页面来说，此种抓取方式非常有效。 基本使用 from selenium import webdriver driver = webdriver.Chrome() driver.get('http...
Selenium学习笔记之015：鼠标事件
A_Captain
07-27 966
ActionChains 类： context_click() 右击 double_click() 双击 drag_and_drop() 拖动 鼠标的双击、右击、拖动等应该怎样写呢？例如右击：
在selenium自动化中实现双击操作的正确方法
zou75718的博客
08-19 8180
我们知道在selenium中，以named定位为例，单击元素的代码为：driver.find_element_by_name(“name”).click(),那么，实现双击元素的代码能不能写成：driver.find_element_by_name(“name”).double_click()呢？显然不行。因为selenium里根本没有这种写法。那么双击操作要怎么实现呢，这里要到一个类，ActionChains()，这个类封装了所有对页面元素可以进行的高级操作，也就是说双击是一种高级操作。下面看一下代码：
Python+selenium —— UI自动化之鼠标操作
11-08 331
导入鼠标操作的包1、定位元素或坐标2、选择合适的操作（可以多个操作组合）3、执行perform()示例1：鼠标移动到某个元素，左键点击，右键点击，双击示例2：鼠标移动到某个坐标，左键按下不松，拖拽鼠标到指定位置再松开注意：多次执行move_by_offset(xoffset, yoffset) ，移动的坐标会累加，导致目标位置超出边界报错，所以要在多次移动之间加上ActionChains(driver).reset_actions()来清除坐标的累计。
selenium自动化测试-鼠标键盘操作
一个不太黑的测试人~
03-02 2136
之前定位的时候，用到了click点击元素，selenium除了click模拟鼠标单击操作外，还提供了双击、右击、悬停、拖动等操作，使用这些要
Python自动化测试之Selenium
08-07
本课程详细介绍了Selenium Python版本的自动化测试方法和实践，通过本课程的学习你将掌握如下内容：Selenium 测试环境搭建单元测试、生成测试报告、定位元素、WebDriver属性和方法、WebElement属性和方法、操作form表单、操作下拉列表、处理等待、远程测试、Selenium Grid、鼠标事件、键盘事件、调用js、屏幕截图、Selenium IDE、文件上传、设置代理、无界面运行、参数化测试、数据驱动的测试DDT等。
selenium在打开的页面停留
07-27
在你提供的代码中，selenium在打开的页面停留的问题可能是由于页面加载速度较慢导致的。selenium在打开网页后，需要等待页面加载完全才能执行后续的操作。如果页面加载速度较慢，selenium可能会在页面首页停留，而没有执行`driver.get()`操作。 为了解决这个问题，你可以使用显式等待来等待页面加载完成。显式等待是一种在特定条件下等待特定时间的方法。你可以使用`WebDriverWait`类和`ExpectedConditions`类来实现显式等待。例如，你可以使用`ExpectedConditions.visibilityOfElementLocated`来等待页面上的某个元素可见，然后再执行后续的操作。 另外，你还可以使用隐式等待来设置一个全局的等待时间，让selenium在查找元素时等待一段时间。你可以使用`driver.manage().timeouts().implicitlyWait`方法来设置隐式等待的时间。 综上所述，你可以在代码中添加显式等待或隐式等待来解决selenium在打开的页面停留的问题。这样可以确保页面加载完成后再执行后续的操作。 #### 引用[.reference_title] - *1* [Mac中Java+Selenium无法打开网址的解决方法](https://blog.csdn.net/weixin_37623976/article/details/105843877)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* *3* [python爬虫（十六）selenium页面等待](https://blog.csdn.net/hwwaizs/article/details/120107589)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值