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

这篇具有很好参考价值的文章主要介绍了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 输出结果

加粗样式文章来源地址https://www.toymoban.com/news/detail-537628.html

到了这里,关于selenium 常用方法封装 标签页切换 元素点击 双击 拖拽 右击 滚动 等等的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Selenium常用元素定位方法汇总

    目录 一、webdriver定位方法 1、xpath基本定位用法 2、xpath相对路径/绝对路径定位 3、xpath文本、模糊、逻辑定位 1、 id 定位 2、 name定位 3、 class定位 4、 link定位 --精准定位 5、 partial_link定位 --模糊定位 6、 tag_name定位 --标签名定位 找到页面上所有标签名为input的标签,返回一个列

    2024年02月02日
    浏览(44)
  • 【selenium】自动化测试中,元素无法点击定位等问题的解决:js的使用方法

    在自动化测试中经常会遇到使用selenium方法定位元素点击操作失败的情况,例如,我们想实现在浏览器输入http://www.baidu.com,进入百度首页后,鼠标悬停在“更多产品”上,点击“全部产品” 若不使用js的话,代码应该如下图所示: 我们执行代码后,发现会报错 我们该如何解

    2024年02月08日
    浏览(44)
  • Selenium WebElement: Selenium 中的页面元素以及常用的属性和方法

    官方文档 本文是基于 Pytohn-3.7.4 以及 selenium-4.11.2 进行测试的,可以直接通过 pip 命令安装 selenium : 进入 python 交互界面,引入 selenium 包,检查安装结果: 在准备好 Python 环境之后,还需要安装浏览器程序, selenium 通过浏览器驱动的可执行文件对浏览器进行操作。 Windows 可以

    2024年02月10日
    浏览(45)
  • 软件测试/测试开发丨Selenium的常用元素定位方法

    Selenium是一个流行的开源框架,目前在 Web 自动化方面运用最为广泛的一个开源、无浏览器要求、可支持多语言、设计测试用例非常灵活的自动化测试框架。支持多种编程语言,并且能够模拟用户操作,例如点击、输入、提交等等。 在Selenium中,元素定位是一个非常重要的步骤

    2024年01月16日
    浏览(62)
  • html实现页面切换、顶部标签栏(可删、可切换,点击左侧超链接出现标签栏)

    效果: 代码  效果  代码 首页  page1.html 效果  代码 效果 解决切换页面时,页面中的内容会进行刷新的问题(实现切换页面,数据不会进行更新的问题) 增加关闭当前页,页面会自动锁定到打开标签页的最后一个页面 增加规定打开标签栏的总数,超过总数,关闭最早打开的页

    2024年02月11日
    浏览(50)
  • 前端:html实现页面切换、顶部标签栏(可删、可切换,点击左侧超链接出现标签栏)

    效果: 代码  效果  代码 首页  page1.html 效果  代码 效果 解决切换页面时,页面中的内容会进行刷新的问题(实现切换页面,数据不会进行更新的问题) 增加关闭当前页,页面会自动锁定到打开标签页的最后一个页面 增加规定打开标签栏的总数,超过总数,关闭最早打开的页

    2024年02月06日
    浏览(60)
  • python中selenium等到元素可点击,元素未点击成功解决办法

    python版本: 3.10.0 selenium版本: 3.141.0 浏览器: firefox 浏览器版本: 112.0.1 (64 位) 我在使用python中的selenium显示等待等到元素可点击后,点击元素,等到元素可点击了,但是元素没有点击成功。示例代码如下。 注:以上代码可点击成功,代码仅供参考 我认为等到元素可点击,但是没有

    2024年02月02日
    浏览(48)
  • 『App自动化测试之Appium应用篇』| 继承于selenium常用的元素定位方法有哪些?如何使用?

    在了解元素等位前,我们先了解下 app 的一些类型,只有了解这些 app 的类型才能针对性的选择元素定位方法; 因为不同类型的app的定位方式可能存在差异性; 我们了解到 APP 可以分为原生 APP 、 Web APP 、混合 APP 。 而原生 APP 是基于 Android 或 iOS 平台官方的语言、类库、工具

    2024年02月03日
    浏览(48)
  • selenium 新建、切换、关闭标签页(python)

    注:python 调用 selenium 版本 4.1.0 这里我安装过两个版本的selenium,调用方式是不一样的,可以查看(dir(driver)) 修改源文件: python_path + Libsite-packagesseleniumwebdrivercommonservice.py, 注意是common文件夹下的service.py 这里48行,self.creationflags 改成 134217728. 再运行就不会弹出黑色的运

    2024年02月11日
    浏览(39)
  • selenium点击多个xpath一样的元素

    如图多个元素的xpath路径是一样的,如何依次点击每个元素呢?  需要用find_element函数,用By进行定位。获取到的是一个list 然后用for循环对list进行遍历 需要注意的是find_elements是不能直接使用click()函数的,遍历时才能用click()  

    2024年02月14日
    浏览(38)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包