阅读笔记lv.1

阅读笔记

  • sql中各种 count
    • 结论
    • 不同存储引擎计算方式
    • 区别
    • count() 类型
  • 责任链模式
    • 常见场景
    • 例子（闯关游戏）

sql中各种 count

结论

  • innodb
count(*) ≈ count(1) > count(主键id) > count(普通索引列) > count(未加索引列)

  • myisam
    有专门字段记录全表的行数，直接读这个字段就好了（innodb则需要一行行去算）

  • 如果确实需要获取行数，且可以接受不那么精确的行数（只需要判断大概的量级） 的话，那可以用explain里的rows，这可以满足大部分的监控场景，实现简单

  • 如果要求行数准确 ，可以建个新表，里面专门放表行数的信息

  • 如果对实时性要求比较高 的话，可以将更新行数的sql放入到对应事务里，这样既能满足事务隔离性，还能快速读取到行数信息

  • 如果对实时性要求不高 ，接受一小时或者一天的更新频率，那既可以自己写脚本遍历全表后更新行数信息。也可以将通过监听binlog将数据导入hive，需要数据时直接通过hive计算得出

不同存储引擎计算方式

  • count()方法的目的是计算当前sql语句查询得到的非NULL的行数
    在这里插入图片描述
  • 虽然在server层都叫count()方法，但在不同的存储引擎下，它们的实现方式是有区别的
    • 比如同样是读全表数据
select count(*) from table (where *** )；

当数据表小的时候，这是没问题的，但当数据量大的时候，比如未发送的短信到了百万量级 的时候，你就会发现，上面的sql查询时间会变得很长，最后timeout报错，查不出结果了 。

    • 使用 myisam引擎 的数据表里有个记录当前表里有几行数据的字段，直接读这个字段返回就好了，因此速度快得飞起
    • 使用innodb引擎 的数据表，则会选择体积最小的索引树 ，然后通过遍历叶子节点的个数挨个加起来，这样也能得到全表数据

区别

为什么innodb不能像myisam那样实现count()方法

  • 最大的区别在于myisam不支持事务，而innodb支持事务
    而事务，有四层隔离级别，其中默认隔离级别就是可重复读隔离级别（RR）

    • innodb引擎通过MVCC实现了可重复隔离级别 ，事务开启后，多次执行同样的select快照读 ，要能读到同样的数据。
    • 对于两个事务A和B，一开始表假设就2条 数据，那事务A一开始确实是读到2条数据。事务B在这期间插入了1条数据，按道理数据库其实有3条数据了，但由于可重复读的隔离级别，事务A依然还是只能读到2条数据。
    • 因此由于事务隔离级别的存在，不同的事务在同一时间下，看到的表内数据行数是不一致的 ，因此innodb，没办法，也没必要像myisam那样单纯的加个count字段信息在数据表上。

count() 类型

count方法的大原则是server层会从innodb存储引擎里读来一行行数据，并且只累计非null的值 。但这个过程，根据count()方法括号内的传参，有略有不同。

  • count（*）
    server层拿到innodb返回的行数据，不对里面的行数据做任何解析和判断 ，默认取出的值肯定都不是null，直接行数+1
  • count(1)
    server层拿到innodb返回的行数据，每行放个1进去，默认不可能为null，直接行数+1.
    • InnoDB 引擎遍历整张表，但不取值。server 层对于返回的每一行，放一个数字“1”进去，判断是不可能为空的，按行累加
  • count(字段）
    count(字段)是不统计，字段值为null的值
    • count(主键 id) 来说，InnoDB 引擎会遍历整张表，把每一行的 id 值都取出来，返回给 server 层。server 层拿到 id 后，判断是不可能为空的，就按行累加

    • count(字段)，server要字段，就返回字段，如果字段为空，就不做统计，字段的值过大，都会造成效率低下

      由于指明了要count某个字段，innodb在取数据的时候，会把这个字段解析出来 返回给server层，所以会比count(1)和count(*)多了个解析字段出来的流程

在这里插入图片描述
文

责任链模式

  • 责任链模式是一种行为设计模式， 允许你将请求沿着处理者链进行发送。收到请求后， 每个处理者均可对请求进行处理， 或将其传递给链上的下个处理者。

在这里插入图片描述

常见场景

  1. 多条件的流程判断（如导入文件校验条件较多，且需逐层校验成功的；或类似闯关游戏，必须达到一定分数/条件才能开始下一关）
    导入功能可能【模板方法】更适合
    • 模板方法可以提供大部分相同的【模板】，根据不同的导入场景做小部分调整，实现各自独立的业务，大体上导入功能差不多
    • 一次性实现一个算法的不变部分，并将可变的行为留给子类来实现
    • 各子类中公共的行为被提取出来并集中到一个公共父类中，从而避免代码重复
      在这里插入图片描述
  1. ERP 系统流程审批：总经理、人事经理、项目经理
  2. Java 过滤器的底层实现 Filter

例子（闯关游戏）

  • 假设现在有一个闯关游戏，进入下一关的条件是上一关的分数要高于 xx：

  • 游戏一共 3 个关卡
    进入第二关需要第一关的游戏得分大于等于 80
    进入第三关需要第二关的游戏得分大于等于 90

简易版（多层 if 逐层判断是否满足条件）

//第一关
public class FirstPassHandler {
    public int handler(){
        System.out.println("第一关-->FirstPassHandler");
        return 80;
    }
}

//第二关
public class SecondPassHandler {
    public int handler(){
        System.out.println("第二关-->SecondPassHandler");
        return 90;
    }
}


//第三关
public class ThirdPassHandler {
    public int handler(){
        System.out.println("第三关-->ThirdPassHandler，这是最后一关啦");
        return 95;
    }
}


//客户端
public class HandlerClient {
    public static void main(String[] args) {

        FirstPassHandler firstPassHandler = new FirstPassHandler();//第一关
        SecondPassHandler secondPassHandler = new SecondPassHandler();//第二关
        ThirdPassHandler thirdPassHandler = new ThirdPassHandler();//第三关

        int firstScore = firstPassHandler.handler();
        //第一关的分数大于等于80则进入第二关
        if(firstScore >= 80){
            int secondScore = secondPassHandler.handler();
            //第二关的分数大于等于90则进入第二关
            if(secondScore >= 90){
                thirdPassHandler.handler();
            }
        }
    }
}
  • 实际上的 handle() 根据业务来传参及计算分数
  • 缺点
    当关数越多/条件越多时代码会变得很长，无限月读（if 嵌套）
if(第1关通过){
    // 第2关 游戏
    if(第2关通过){
        // 第3关 游戏
        if(第3关通过){
           // 第4关 游戏
            if(第4关通过){
                // 第5关 游戏
                if(第5关通过){
                    // 第6关 游戏
                    if(第6关通过){
                        //...
                    }
                }
            } 
        }
    }
}

升级（责任链链表拼接每一关）

  • 可以通过链表将每一关连接起来，形成责任链的方式，第一关通过后是第二关，第二关通过后是第三关… （减少客户端代码过多的 if 嵌套）
public class FirstPassHandler {
    /**
     * 第一关的下一关是 第二关
     */
    private SecondPassHandler secondPassHandler;

    public void setSecondPassHandler(SecondPassHandler secondPassHandler) {
        this.secondPassHandler = secondPassHandler;
    }

    //本关卡游戏得分
    private int play(){
        return 80;
    }

    public int handler(){
        System.out.println("第一关-->FirstPassHandler");
        if(play() >= 80){
            //分数>=80 并且存在下一关才进入下一关
            if(this.secondPassHandler != null){
                return this.secondPassHandler.handler();
            }
        }

        return 80;
    }
}

public class SecondPassHandler {

    /**
     * 第二关的下一关是 第三关
     */
    private ThirdPassHandler thirdPassHandler;

    public void setThirdPassHandler(ThirdPassHandler thirdPassHandler) {
        this.thirdPassHandler = thirdPassHandler;
    }

    //本关卡游戏得分
    private int play(){
        return 90;
    }

    public int handler(){
        System.out.println("第二关-->SecondPassHandler");

        if(play() >= 90){
            //分数>=90 并且存在下一关才进入下一关
            if(this.thirdPassHandler != null){
                return this.thirdPassHandler.handler();
            }
        }

        return 90;
    }
}

public class ThirdPassHandler {

    //本关卡游戏得分
    private int play(){
        return 95;
    }

    /**
     * 这是最后一关，因此没有下一关
     */
    public int handler(){
        System.out.println("第三关-->ThirdPassHandler，这是最后一关啦");
        return play();
    }
}

public class HandlerClient {
    public static void main(String[] args) {

        FirstPassHandler firstPassHandler = new FirstPassHandler();//第一关
        SecondPassHandler secondPassHandler = new SecondPassHandler();//第二关
        ThirdPassHandler thirdPassHandler = new ThirdPassHandler();//第三关

        firstPassHandler.setSecondPassHandler(secondPassHandler);//第一关的下一关是第二关
        secondPassHandler.setThirdPassHandler(thirdPassHandler);//第二关的下一关是第三关

        //说明：因为第三关是最后一关，因此没有下一关
        //开始调用第一关 每一个关卡是否进入下一关卡 在每个关卡中判断
        firstPassHandler.handler();

    }
}
  • 缺点
    从代码中可以看到，每一关的处理逻辑中都有一个 set**PassHandler() 方法，只是参数类型不一样，但是作用其实是一样的，只是用来判断是否有下一关
    每个关卡中都有下一关的成员变量并且是不一样的，形成链很不方便，代码扩展性不行

进化（责任链改造—抽象）

  • 每个关卡中都有下一关的成员变量并且是不一样的，那么我们可以在关卡上抽象出一个父类或者接口，然后每个具体的关卡去继承或者实现，将参数合并成一个，不再需要在各自的 set**PassHandler 中传递不同的参数
  • 责任链设计模式的基本组成
    • 抽象处理者（Handler）角色： 定义一个处理请求的接口，包含抽象处理方法和一个后继连接
    • 具体处理者（Concrete Handler）角色： 实现抽象处理者的处理方法，判断能否处理本次请求，如果可以处理请求则处理，否则将该请求转给它的后继者
    • 客户类（Client）角色： 创建处理链，并向链头的具体处理者对象提交请求，它不关心处理细节和请求的传递过程
      在这里插入图片描述
public abstract class AbstractHandler {

    /**
     * 下一关用当前抽象类来接收
     */
    protected AbstractHandler next;

    public void setNext(AbstractHandler next) {
        this.next = next;
    }

    public abstract int handler();
}

public class FirstPassHandler extends AbstractHandler{

    private int play(){
        return 80;
    }

    @Override
    public int handler(){
        System.out.println("第一关-->FirstPassHandler");
        int score = play();
        if(score >= 80){
            //分数>=80 并且存在下一关才进入下一关
            if(this.next != null){
                return this.next.handler();
            }
        }
        return score;
    }
}

public class SecondPassHandler extends AbstractHandler{

    private int play(){
        return 90;
    }

    public int handler(){
        System.out.println("第二关-->SecondPassHandler");

        int score = play();
        if(score >= 90){
            //分数>=90 并且存在下一关才进入下一关
            if(this.next != null){
                return this.next.handler();
            }
        }

        return score;
    }
}

public class ThirdPassHandler extends AbstractHandler{

    private int play(){
        return 95;
    }

    public int handler(){
        System.out.println("第三关-->ThirdPassHandler");
        int score = play();
        if(score >= 95){
            //分数>=95 并且存在下一关才进入下一关
            if(this.next != null){
                return this.next.handler();
            }
        }
        return score;
    }
}

public class HandlerClient {
    public static void main(String[] args) {

        FirstPassHandler firstPassHandler = new FirstPassHandler();//第一关
        SecondPassHandler secondPassHandler = new SecondPassHandler();//第二关
        ThirdPassHandler thirdPassHandler = new ThirdPassHandler();//第三关

        // 和上面没有更改的客户端代码相比，只有这里的set方法发生变化，其他都是一样的
        firstPassHandler.setNext(secondPassHandler);//第一关的下一关是第二关
        secondPassHandler.setNext(thirdPassHandler);//第二关的下一关是第三关

        //说明：因为第三关是最后一关，因此没有下一关

        //从第一个关卡开始
        firstPassHandler.handler();

    }
}
  • 从代码中可以看到，此次进化引入了一个 抽象处理者，让每一关的具体处理者都继承该类，后续在设置下一关对象的时候就不必各自编写各自的set**PassHandler() 方法，而是直接使用相同的处理方法，只需要编写各自的 handler() 得分方法，进一步简化了代码

终极进化（责任链工厂改造）

public enum GatewayEnum {
    // handlerId, 拦截者名称，全限定类名，preHandlerId，nextHandlerId
    API_HANDLER(new GatewayEntity(1, "api接口限流", "cn.dgut.design.chain_of_responsibility.GateWay.impl.ApiLimitGatewayHandler", null, 2)),
    BLACKLIST_HANDLER(new GatewayEntity(2, "黑名单拦截", "cn.dgut.design.chain_of_responsibility.GateWay.impl.BlacklistGatewayHandler", 1, 3)),
    SESSION_HANDLER(new GatewayEntity(3, "用户会话拦截", "cn.dgut.design.chain_of_responsibility.GateWay.impl.SessionGatewayHandler", 2, null)),
    ;

    GatewayEntity gatewayEntity;

    public GatewayEntity getGatewayEntity() {
        return gatewayEntity;
    }

    GatewayEnum(GatewayEntity gatewayEntity) {
        this.gatewayEntity = gatewayEntity;
    }
}

public class GatewayEntity {

    private String name;

    private String conference;

    private Integer handlerId;

    private Integer preHandlerId;

    private Integer nextHandlerId;
}


public interface GatewayDao {

    /**
     * 根据 handlerId 获取配置项
     * @param handlerId
     * @return
     */
    GatewayEntity getGatewayEntity(Integer handlerId);

    /**
     * 获取第一个处理者
     * @return
     */
    GatewayEntity getFirstGatewayEntity();
}

public class GatewayImpl implements GatewayDao {

    /**
     * 初始化，将枚举中配置的handler初始化到map中，方便获取
     */
    private static Map<Integer, GatewayEntity> gatewayEntityMap = new HashMap<>();

    static {
        GatewayEnum[] values = GatewayEnum.values();
        for (GatewayEnum value : values) {
            GatewayEntity gatewayEntity = value.getGatewayEntity();
            gatewayEntityMap.put(gatewayEntity.getHandlerId(), gatewayEntity);
        }
    }

    @Override
    public GatewayEntity getGatewayEntity(Integer handlerId) {
        return gatewayEntityMap.get(handlerId);
    }

    @Override
    public GatewayEntity getFirstGatewayEntity() {
        for (Map.Entry<Integer, GatewayEntity> entry : gatewayEntityMap.entrySet()) {
            GatewayEntity value = entry.getValue();
            //  没有上一个handler的就是第一个
            if (value.getPreHandlerId() == null) {
                return value;
            }
        }
        return null;
    }
}

public class GatewayHandlerEnumFactory {

    private static GatewayDao gatewayDao = new GatewayImpl();

    // 提供静态方法，获取第一个handler
    public static GatewayHandler getFirstGatewayHandler() {

        GatewayEntity firstGatewayEntity = gatewayDao.getFirstGatewayEntity();
        GatewayHandler firstGatewayHandler = newGatewayHandler(firstGatewayEntity);
        if (firstGatewayHandler == null) {
            return null;
        }

        GatewayEntity tempGatewayEntity = firstGatewayEntity;
        Integer nextHandlerId = null;
        GatewayHandler tempGatewayHandler = firstGatewayHandler;
        // 迭代遍历所有handler，以及将它们链接起来
        while ((nextHandlerId = tempGatewayEntity.getNextHandlerId()) != null) {
            GatewayEntity gatewayEntity = gatewayDao.getGatewayEntity(nextHandlerId);
            GatewayHandler gatewayHandler = newGatewayHandler(gatewayEntity);
            tempGatewayHandler.setNext(gatewayHandler);
            tempGatewayHandler = gatewayHandler;
            tempGatewayEntity = gatewayEntity;
        }
    // 返回第一个handler
        return firstGatewayHandler;
    }

    /**
     * 反射实体化具体的处理者
     * @param firstGatewayEntity
     * @return
     */
    private static GatewayHandler newGatewayHandler(GatewayEntity firstGatewayEntity) {
        // 获取全限定类名
        String className = firstGatewayEntity.getConference(); 
        try {
            // 根据全限定类名，加载并初始化该类，即会初始化该类的静态段
            Class<?> clazz = Class.forName(className);
            return (GatewayHandler) clazz.newInstance();
        } catch (ClassNotFoundException | IllegalAccessException | InstantiationException e) {
            e.printStackTrace();
        }
        return null;
    }


}

public class GetewayClient {
    public static void main(String[] args) {
        GetewayHandler firstGetewayHandler = GetewayHandlerEnumFactory.getFirstGetewayHandler();
        firstGetewayHandler.service();
    }
}
  • 待深究

文

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/315000.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Python 全栈体系【四阶】（十二）

Python 全栈体系【四阶】（十二）

第四章 机器学习 十五、朴素贝叶斯 朴素贝叶斯是一组功能强大且易于训练的分类器&#xff0c;它使用贝叶斯定理来确定给定一组条件的结果的概率&#xff0c;“朴素”的含义是指所给定的条件都能独立存在和发生。朴素贝叶斯是多用途分类器&#xff0c;能在很多不同的情景下找到…
阅读更多...
leetcode17 电话号码的字母组合

leetcode17 电话号码的字母组合

方法1 if-else方法 if-else方法的思路及其简单粗暴&#xff0c;如下图所示&#xff0c;以数字234为例&#xff0c;数字2所对应的字母是abc&#xff0c;数字3所对应的是def&#xff0c;数字4所对应的是ghi&#xff0c;最后所产生的结果就类似于我们中学所学过的树状图一样&…
阅读更多...
跟着cherno手搓游戏引擎【4】窗口抽象、GLFW配置

跟着cherno手搓游戏引擎【4】窗口抽象、GLFW配置

引入GLFW&#xff1a; 在vendor里创建GLFW文件夹&#xff1a; 在github上下载&#xff0c;把包下载到GLFW包下。 GitHub - TheCherno/glfw: A multi-platform library for OpenGL, OpenGL ES, Vulkan, window and input修改SRC/premake5.lua的配置&#xff1a;12、13、15、36…
阅读更多...
异地快速传输大文件的常用方法

异地快速传输大文件的常用方法

在企业间的信息沟通与协作中&#xff0c;快速传输大文件是一项基本需求。然而&#xff0c;跨地域传输庞大文件时&#xff0c;往往面临着网络带宽、文件大小、传输速度以及数据安全等多方面的挑战。本文将介绍四种常用的异地快速传输大文件的方法&#xff0c;并分析它们的优缺点…
阅读更多...
数据结构学习之顺序栈应用的案例（有效的括号）

数据结构学习之顺序栈应用的案例（有效的括号）

实例要求&#xff1a; 给定一个只包括 (&#xff0c;)&#xff0c;{&#xff0c;}&#xff0c;[&#xff0c;] 的字符串 s &#xff0c;判断字符串是否有效&#xff1b; 有效字符串需满足的条件&#xff1a; 1、左括号必须用相同类型的右括号闭合&#xff1b; 2、左括号必须…
阅读更多...
robot_sim配置

robot_sim配置

robot_sim https://github.com/Suyixiu/robot_sim 的issue https://www.bilibili.com/video/BV19f4y1h73E/ 下评论 文件来源 其余克隆 基于几何的抓取 banana不显示 解决参考 https://github.com/Suyixiu/robot_sim/issues/2 &#xff08;项目配置主要参考&#xff09; …
阅读更多...
LabVIEW在动态力传感器校准技术的创新应用

LabVIEW在动态力传感器校准技术的创新应用

简介 动态力传感器校准装置集成了冲击法原理和自动化控制&#xff0c;实现精准、高效的传感器校验。LabVIEW的图形化界面提供简便操作和实时数据分析&#xff0c;显著提高了校准过程的准确度和效率。 01 系统设计和功能 动态力传感器在工业生产中发挥着重要作用&#xff0c;…
阅读更多...
完整的模型验证套路

完整的模型验证套路

读取图片 from PIL import Imageimg_path "../Yennefer_of_Vengerberg.jpg" image Image.open(img_path) print(image)转换成灰度图&#xff08;可选&#xff09; image image.convert(L) image.show()转换成RGB格式 image image.convert(RGB)因为png格式是四…
阅读更多...
软件测试|MySQL SHOW DATABASES详解

软件测试|MySQL SHOW DATABASES详解

简介 在MySQL中&#xff0c;SHOW DATABASES是一条SQL语句&#xff0c;用于显示当前MySQL服务器上所有可用的数据库。这条简单而常用的命令可以让你快速查看服务器上的数据库列表。本文将详细介绍SHOW DATABASES的使用方法以及相关注意事项。 语法 在 MySQL 中&#xff0c;可…
阅读更多...
Linux系统——DNS解析详解

Linux系统——DNS解析详解

目录 一、DNS域名解析 1.DNS的作用 2.域名的组成 2.1域名层级结构关系特点 2.2域名空间构成 2.3域名的四种不同类型 2.3.1延伸 2.3.2总结 3.DNS域名解析过程 3.1递归查询 3.2迭代查询 3.3一次DNS解析的过程 4.DNS系统类型 4.1缓存域名服务器 4.2主域名服务器 4…
阅读更多...
pytorch学习笔记（七 ）

pytorch学习笔记（七 ）

池化类似压缩 最大池化-上采样 例如给一个3的话就会生成一个33的窗口&#xff08;生成相同的高和宽&#xff09;&#xff0c;给一个tuple就会给出一个相同的池化核。stride默认值就是核的大小 dilation 在卷积dialation设置之后每一个会和另外的差一个&#xff0c;空洞卷积 …
阅读更多...
微信小程序——调节手机屏幕亮度案例分享

微信小程序——调节手机屏幕亮度案例分享

✅作者简介&#xff1a;2022年博客新星 第八。热爱国学的Java后端开发者&#xff0c;修心和技术同步精进。 &#x1f34e;个人主页&#xff1a;Java Fans的博客 &#x1f34a;个人信条&#xff1a;不迁怒&#xff0c;不贰过。小知识&#xff0c;大智慧。 &#x1f49e;当前专栏…
阅读更多...
C++核心编程——类和对象（二）

C++核心编程——类和对象（二）

本专栏记录C学习过程包括C基础以及数据结构和算法&#xff0c;其中第一部分计划时间一个月&#xff0c;主要跟着黑马视频教程&#xff0c;学习路线如下&#xff0c;不定时更新&#xff0c;欢迎关注。 当前章节处于&#xff1a; ---------第1阶段-C基础入门 ---------第2阶段实战…
阅读更多...
代码随想录算法训练营第六天|哈希表理论基础，242.有效的字母异位词，349. 两个数组的交集，202. 快乐数，1. 两数之和

代码随想录算法训练营第六天|哈希表理论基础，242.有效的字母异位词，349. 两个数组的交集，202. 快乐数，1. 两数之和

刷题建议 刷题建议与debug 代码随想录目前基本都有了视频讲解&#xff0c;一定要先看视频&#xff0c;事半功倍。写博客&#xff0c;将自己的感悟沉淀下来&#xff0c;不然会忘大家提问的时候&#xff0c;记得要把问题描述清楚&#xff0c;自己在哪一步遇到了问题&#xff0c…
阅读更多...
嵌入式linux 编译qt5（以v851s为例）

嵌入式linux 编译qt5（以v851s为例）

本文参考Blev大神的博客&#xff1a;Yuzuki Lizard V851S开发板 --移植 QT5.12.9教程&#xff08;群友Blev提供&#xff09; - Allwinner / 柚木PI-V851S - 嵌入式开发问答社区 (100ask.net) 一. 环境准备 1.下载qt5源码&#xff1a;Open Source Development | Open Source …
阅读更多...
访问学者申请需要注意什么？

访问学者申请需要注意什么？

访问学者申请是一项复杂而重要的过程&#xff0c;需要申请人在准备材料和过程中注意一些关键事项&#xff0c;以确保顺利完成申请并提高成功率。以下是知识人网小编的一些建议&#xff0c;希望对你的访问学者申请有所帮助。 1. 详细了解目标学术机构&#xff1a; 在申请访问学…
阅读更多...
vscode中文插件以及运行php代码

vscode中文插件以及运行php代码

vscode中文版插件 vscode运行php代码 1.插件安装 2.配置项 左上角文件——首选项——设置——输入php.validate.executablePath {"workbench.colorTheme": "Default Dark Modern","php.validate.executablePath": "E:/phpstudy/php.exe&q…
阅读更多...
一篇文章带你了解Python常用自动化测试框架——Pytest！

一篇文章带你了解Python常用自动化测试框架——Pytest！

在之前的文章里我们已经学习了Python自带测试框架UnitTest&#xff0c;但是UnitTest具有一定的局限性 这篇文章里我们来学习第三方框架Pytest&#xff0c;它在保留了UnitTest框架语法的基础上有着更多的优化处理 下面我们将从以下角度来介绍Pytest&#xff1a; Pytest基本介…
阅读更多...
[ctf.show 元旦水友赛 2024] crypto

[ctf.show 元旦水友赛 2024] crypto

感觉半个多月回家没有打开过电脑了。看到ctf.show上元旦的比赛&#xff0c;才想起似乎应该看看。 月月的爱情故事 上来这就是个小脑洞题&#xff0c;给了一大段文字和一个base64的串。并且提示&#xff1a;试试摩斯吧&#xff01; 从文字上看只有三种标点符号&#xff0c;显…
阅读更多...
【书生·浦语大模型实战营04】《(4)XTuner 大模型单卡低成本微调实战》学习笔记

【书生·浦语大模型实战营04】《(4)XTuner 大模型单卡低成本微调实战》学习笔记

《(4)XTuner 大模型单卡低成本微调实战》 课程文档&#xff1a;《XTuner 大模型单卡低成本微调实战》 1 Finetune简介 LLM的下游应用中&#xff0c;增量预训练和指令跟随是经常会用到两种的微调模式 1.1 增量预训练微调 使用场景&#xff1a;让基座模型学习到一些新知识&a…
阅读更多...
最新文章

Copyright @ 2022~2023