2024年9月

《Redis 入门》系列文章总算完成了,希望这个系列文章可以想入门或刚入门的同学提供帮助,希望能让你形成学习Redis系统性概念。

当时为什么要写这个系列文章,是因为我自己就是迷迷糊糊一路踩坑走过来的,我踩完的坑就踩完了,希望你能少踩一些。

我们简单来回顾一下《Redis 入门》系列内容,希望通过这次回顾能总结一些学习新知识的经验,学习如何更快的掌握新知识,如何形成系统性概念。

1.首先我们了解了Redis基本信息,是什么,有什么,能干什么;

2.然后我们学习如何安装Redis,在不同的操作系统上(Windows、Linux、Docker),通过不同的方式(脚本、安装包、包管理器方式、源码编译等)安装;

3.接着我们寻找了Redis可视化工具,我们介绍了四大类可视化工具(命令行工具、桌面客户端工具、网页工具、插件工具),10来种软件,各有千秋。

4.然后我们正式进入Redis知识学习,了解Redis五大基础数据类型(字符串、集合、有序集合、列、哈希),并熟悉了相关指令。

5.然后我们继续结合具体编程语言C#/.NET Core,了解了6款C#/.NET Core接入Redis客户端库(ServiceStack.Redis、StackExchange.Redis、CSRedisCore、FreeRedis、NewLife.Redis、BeetleX.Redis),并对6款库应用场景做了基本了解,还分别学习了如何使用这6款库。

6.最后我们一起封装了一个简单的Redis C#/.NET Core客户端库Nuget,以达到和现有项目解耦,方便后期扩展的目的。

在整个过程中,很多时候我们会有很多选择,到底应该做什么,我相信第一次接触Redis的,很多时候都会感到很迷茫。然后只能不停的在网上找答案,不停的去尝试,踩了无数次坑以后,最后才发现原来是这样啊,瞬间恍然大悟。

我自己也是踩了很多坑走过来的,因此我想把我的经验分享给大家,然后可以系统给大家介绍如何学习Redis,可以让大家少踩一些坑,在学习的早期就形成系统性概念,从而提升学习效率。

后面我想继续和大家分享《Redis 进阶》,开始深入学习Redis相关知识,希望能给你带来一些收获,如果你有什么想法,也可以给我留言。


:测试方法代码以及示例源码都已经上传至代码库,有兴趣的可以看看。
https://gitee.com/hugogoos/Planner

Hugging Face NLP课程学习记录 - 0. 安装transformers库 & 1. Transformer 模型

说明:

0. 安装transformers库

创建conda环境并安装包:

conda create -n hfnlp python=3.12
conda install pytorch==2.3.1 torchvision==0.18.1 torchaudio==2.3.1 pytorch-cuda=12.1 -c pytorch -c nvidia
pip install transformers==4.44.2

# More
pip install seqeval
pip install sentencepiece

使用Hugging Face镜像(见
https://hf-mirror.com/
):

export HF_ENDPOINT=https://hf-mirror.com

或者在python中设置Hugging Face镜像:

import os
os.environ["HF_ENDPOINT"] = "https://hf-mirror.com"

1. Transformer 模型

Transformers 能做什么?

使用pipelines

Transformers 库中最基本的对象是
pipeline()
函数。它将模型与其必要的预处理和后处理步骤连接起来,使我们能够通过直接输入任何文本并获得最终的答案:

from transformers import pipeline

classifier = pipeline("sentiment-analysis")
classifier("I've been waiting for a HuggingFace course my whole life.")

提示:

No model was supplied, defaulted to distilbert/distilbert-base-uncased-finetuned-sst-2-english and revision af0f99b ....
[{'label': 'POSITIVE', 'score': 0.9598047137260437}]

输出:

[{'label': 'POSITIVE', 'score': 0.9598047137260437}]

输入多个句子:

classifier(
    ["I've been waiting for a HuggingFace course my whole life.", "I hate this so much!"]
)
[{'label': 'POSITIVE', 'score': 0.9598047137260437},
 {'label': 'NEGATIVE', 'score': 0.9994558691978455}]

将一些文本传递到pipeline时涉及三个主要步骤:

  1. 文本被预处理为模型可以理解的格式。
  2. 预处理的输入被传递给模型。
  3. 模型处理后输出最终人类可以理解的结果。

零样本分类

from transformers import pipeline

classifier = pipeline("zero-shot-classification")
classifier(
    "This is a course about the Transformers library",
    candidate_labels=["education", "politics", "business"],
)

提示:

No model was supplied, defaulted to facebook/bart-large-mnli and revision c626438 ([https://hf-mirror.com/facebook/bart-large-mnli](https://hf-mirror.com/facebook/bart-large-mnli)).
Using a pipeline without specifying a model name and revision in production is not recommended.

输出:

{'sequence': 'This is a course about the Transformers library', 'labels': ['education', 'business', 'politics'], 'scores': [0.8445952534675598, 0.11197696626186371, 0.043427806347608566]}

此pipeline称为zero-shot,因为您不需要对数据上的模型进行微调即可使用它

文本分类

现在让我们看看如何使用pipeline来生成一些文本。这里的主要使用方法是您提供一个提示,模型将通过生成剩余的文本来自动完成整段话。

from transformers import pipeline

generator = pipeline("text-generation")
generator("In this course, we will teach you how to")

提示:

No model was supplied, defaulted to openai-community/gpt2 and revision 6c0e608 (https://hf-mirror.com/openai-community/gpt2).
Using a pipeline without specifying a model name and revision in production is not recommended.

输出:

[{'generated_text': 'In this course, we will teach you how to create a simple Python script that uses the default Python scripts for the following tasks, such as adding a linker at the end of a file to a file, editing an array, etc.\n\n'}]

在pipeline中使用 Hub 中的其他模型

前面的示例使用了默认模型,但您也可以从 Hub 中选择特定模型以在特定任务的pipeline中使用 - 例如,文本生成。转到
模型中心(hub)
并单击左侧的相应标签将会只显示该任务支持的模型。
例如这样

让我们试试
distilgpt2
模型吧!以下是如何在与以前相同的pipeline中加载它:

from transformers import pipeline

generator = pipeline("text-generation", model="distilgpt2")
generator(
    "In this course, we will teach you how to",
    max_length=30,
    num_return_sequences=2
)
[{'generated_text': 'In this course, we will teach you how to make your world better. Our courses focus on how to make an improvement in your life or the things'},
 {'generated_text': 'In this course, we will teach you how to properly design your own design using what is currently in place and using what is best in place. By'}]

Mask filling

您将尝试的下一个pipeline是
fill-mask
。此任务的想法是填充给定文本中的空白:

from transformers import pipeline

unmasker = pipeline("fill-mask")
unmasker("This course will teach you all about <mask> models.", top_k=2)
[{'score': 0.19198445975780487,
  'token': 30412,
  'token_str': ' mathematical',
  'sequence': 'This course will teach you all about mathematical models.'},
 {'score': 0.04209190234541893,
  'token': 38163,
  'token_str': ' computational',
  'sequence': 'This course will teach you all about computational models.'}]

top_k
参数控制要显示的结果有多少种。请注意,这里模型填充了特殊的<
mask
>词,它通常被称为掩码标记。其他掩码填充模型可能有不同的掩码标记,因此在探索其他模型时要验证正确的掩码字是什么。

命名实体识别

命名实体识别 (NER) 是一项任务,其中模型必须找到输入文本的哪些部分对应于诸如人员、位置或组织之类的实体。让我们看一个例子:

from transformers import pipeline

ner = pipeline("ner", grouped_entities=True)
ner("My name is Sylvain and I work at Hugging Face in Brooklyn.")
No model was supplied, defaulted to dbmdz/bert-large-cased-finetuned-conll03-english ...
[{'entity_group': 'PER',
  'score': 0.9981694,
  'word': 'Sylvain',
  'start': 11,
  'end': 18},
 {'entity_group': 'ORG',
  'score': 0.9796019,
  'word': 'Hugging Face',
  'start': 33,
  'end': 45},
 {'entity_group': 'LOC',
  'score': 0.9932106,
  'word': 'Brooklyn',
  'start': 49,
  'end': 57}]

我们在pipeline创建函数中传递选项
grouped_entities=True
以告诉pipeline将对应于同一实体的句子部分重新组合在一起:这里模型正确地将“Hugging”和“Face”分组为一个组织,即使名称由多个词组成。

命名实体识别(中文)

运行来自
https://huggingface.co/shibing624/bert4ner-base-chinese
README的代码

pip install seqeval
import os
import torch
from transformers import AutoTokenizer, AutoModelForTokenClassification
from seqeval.metrics.sequence_labeling import get_entities

os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"

# Load model from HuggingFace Hub
tokenizer = AutoTokenizer.from_pretrained("shibing624/bert4ner-base-chinese")
model = AutoModelForTokenClassification.from_pretrained("shibing624/bert4ner-base-chinese")
label_list = ['I-ORG', 'B-LOC', 'O', 'B-ORG', 'I-LOC', 'I-PER', 'B-TIME', 'I-TIME', 'B-PER']

sentence = "王宏伟来自北京,是个警察,喜欢去王府井游玩儿。"

def get_entity(sentence):
    tokens = tokenizer.tokenize(sentence)
    inputs = tokenizer.encode(sentence, return_tensors="pt")
    with torch.no_grad():
        outputs = model(inputs).logits
    predictions = torch.argmax(outputs, dim=2)
    char_tags = [(token, label_list[prediction]) for token, prediction in zip(tokens, predictions[0].numpy())][1:-1]
    print(sentence)
    print(char_tags)

    pred_labels = [i[1] for i in char_tags]
    entities = []
    line_entities = get_entities(pred_labels)
    for i in line_entities:
        word = sentence[i[1]: i[2] + 1]
        entity_type = i[0]
        entities.append((word, entity_type))

    print("Sentence entity:")
    print(entities)


get_entity(sentence)
王宏伟来自北京,是个警察,喜欢去王府井游玩儿。
[('宏', 'B-PER'), ('伟', 'I-PER'), ('来', 'I-PER'), ('自', 'O'), ('北', 'O'), ('京', 'B-LOC'), (',', 'I-LOC'), ('是', 'O'), ('个', 'O'), ('警', 'O'), ('察', 'O'), (',', 'O'), ('喜', 'O'), ('欢', 'O'), ('去', 'O'), ('王', 'O'), ('府', 'B-LOC'), ('井', 'I-LOC'), ('游', 'I-LOC'), ('玩', 'O'), ('儿', 'O')]
Sentence entity:
[('王宏伟', 'PER'), ('北京', 'LOC'), ('王府井', 'LOC')]

或者通过使用
nerpy
库来使用 shibing624/bert4ner-base-chinese 这个模型。

另外,可以使用的ltp来做中文命名实体识别,其Github仓库
https://github.com/HIT-SCIR/ltp
有4.9K的星

问答系统

from transformers import pipeline

question_answerer = pipeline("question-answering")
question_answerer(
    question="Where do I work?",
    context="My name is Sylvain and I work at Hugging Face in Brooklyn",
)
{'score': 0.6949753761291504, 'start': 33, 'end': 45, 'answer': 'Hugging Face'}

请注意,此pipeline通过从提供的上下文中提取信息来工作;它不会凭空生成答案。

文本摘要

文本摘要是将文本缩减为较短文本的任务,同时保留文本中的主要(重要)信息。下面是一个例子:

from transformers import pipeline

summarizer = pipeline("summarization", device=0)
summarizer(
    """
    America has changed dramatically during recent years. Not only has the number of 
    graduates in traditional engineering disciplines such as mechanical, civil, 
    electrical, chemical, and aeronautical engineering declined, but in most of 
    the premier American universities engineering curricula now concentrate on 
    and encourage largely the study of engineering science. As a result, there 
    are declining offerings in engineering subjects dealing with infrastructure, 
    the environment, and related issues, and greater concentration on high 
    technology subjects, largely supporting increasingly complex scientific 
    developments. While the latter is important, it should not be at the expense 
    of more traditional engineering.

    Rapidly developing economies such as China and India, as well as other 
    industrial countries in Europe and Asia, continue to encourage and advance 
    the teaching of engineering. Both China and India, respectively, graduate 
    six and eight times as many traditional engineers as does the United States. 
    Other industrial countries at minimum maintain their output, while America 
    suffers an increasingly serious decline in the number of engineering graduates 
    and a lack of well-educated engineers.
"""
)

与文本生成一样,您指定结果的
max_length

min_length

翻译

对于翻译,如果您在任务名称中提供语言对(例如“
translation_en_to_fr
”),则可以使用默认模型,但最简单的方法是在
模型中心(hub)
选择要使用的模型。在这里,我们将尝试从法语翻译成英语:

pip install sentencepiece
from transformers import pipeline

translator = pipeline("translation", model="Helsinki-NLP/opus-mt-fr-en", device=0)
translator("Ce cours est produit par Hugging Face.")
[{'translation_text': 'This course is produced by Hugging Face.'}]

将英语翻译成中文:

from transformers import pipeline

translator = pipeline("translation", model="Helsinki-NLP/opus-mt-en-zh", device=0)
translator("America has changed dramatically during recent years.")
[{'translation_text': '近年来,美国发生了巨大变化。'}]

偏见和局限性

如果您打算在正式的项目中使用经过预训练或经过微调的模型。请注意:虽然这些模型是很强大,但它们也有局限性。其中最大的一个问题是,为了对大量数据进行预训练,研究人员通常会搜集所有他们能找到的内容,中间可能夹带一些意识形态或者价值观的刻板印象。

为了快速解释清楚这个问题,让我们回到一个使用BERT模型的pipeline的例子:

from transformers import pipeline

unmasker = pipeline("fill-mask", model="bert-base-uncased", device=0)
result = unmasker("This man works as a [MASK].")
print([r["token_str"] for r in result])

result = unmasker("This woman works as a [MASK].")
print([r["token_str"] for r in result])
['carpenter', 'lawyer', 'farmer', 'businessman', 'doctor']
['nurse', 'maid', 'teacher', 'waitress', 'prostitute']

当要求模型填写这两句话中缺少的单词时,模型给出的答案中,只有一个与性别无关(服务员/女服务员)。

Java领域要说让我最服气的RPC框架当属Dubbo,原因有许多,但是最吸引我的还是它把远程调用这个事情设计得很有艺术。

1、Dubbo优点较多,我只钟情其一

1.1、优点

业内对于微服务之间调用的框架选择较多,主流是Spring Cloud的Rest方式 和 Dubbo方式,我使用Dubbo方式居多。Dubbo工业级可用,稳定又高效,深受各大公司研发同学的喜爱。

Dubbo的优点较多,比如:

  • 高性能
    :Dubbo 使用的是基于 Netty 的自定义通信协议,提供了高效的二进制数据传输,使得远程服务调用性能大幅提升。
  • 模块化设计
    :Dubbo 的架构非常模块化,主要由五大核心模块组成:远程调用模块(RPC)、集群模块、负载均衡模块、容错模块和注册中心模块。
  • 每个部件都支持多协议
    :每个部件都支持多种协议,比如注册中心,支持ZK、Redis、Nacos等等。
  • 负载均衡和容错
    :Dubbo 提供了多种容错机制,比如失败重试、失败转移等。还支持多种负载均衡,比如随机、轮询、一致性哈希等。
  • 服务注册和发现
    :Dubbo引入了注册中心的概念,实现了服务的自动注册和发现。
  • SPI 扩展机制
    :在
    背八股文
    场景下,Dubbo被提及最多的就是使用了类似Java的SPI机制,提高了扩展性,这一点仁者见仁智者见智吧。

1.2、钟情其一

但是,Dubbo最吸引人的,
半支烟
觉得反而倒是它的RPC调用。Dubbo的定位是一个RPC框架,这是它的核心和立足之地,所以Dubbo将RPC的调用过程透明化,使得开发者可以专注于业务逻辑,而不用关注底层通信问题。

一个RPC框架只有聚焦于先做好它的RPC调用过程这个模块,才会有人关注,其余的优点都是在这之后,慢慢迭代而来。

作者将RPC调用的这个过程,抽象成
一种协议消息的传输机制
,再通过
控制好线程的等待和唤醒
,来实现远程方法调用。这一设计思路真是美妙,充分体验了作者的智慧。

2、RPC简易示例

学Dubbo,首先就是要学习作者这种设计理念和思路。基于此,来实现一个简易的远程方法调用,将Dubbo的RPC过程简易化。

2.1、示例步骤

简易的RPC过程步骤如下,大致分5步,依旧使用Netty作用Socket通讯工具。

  1. 使用2个Java进程来模拟2个系统之间的调用,A进程 和 B进程。
  2. A进程的某个方法,使用网络请求调用B进程的某个方法。
  3. 然后A进程的方法就处于等待状态。
  4. 等B进程的方法执行完之后,在利用网络通知到A进程。
  5. 然后A进程的方法被唤醒,继续往下执行。

2.2、示例代码

  • B进程作为服务端,启动网络服务
public class BProcessServer {
    private final int port;
    public BProcessServer(int port) {
        this.port = port;
    }

    public void start() throws InterruptedException {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) {
                            ch.pipeline().addLast(new BProcessServerHandler());
                        }
                    });

            ChannelFuture future = bootstrap.bind(port).sync();
            System.out.println("B启动了服务,端口号: " + port);
            future.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new BProcessServer(8088).start();
    }
}
  • B进程接受网络请求参数,反序列化之后,执行对应的方法,再将执行结果返回:
public class BProcessServerHandler extends SimpleChannelInboundHandler<ByteBuf> {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {
        String reqData = msg.toString(CharsetUtil.UTF_8);
        System.out.println("B进程接受到了请求数据: " + reqData);

        executeMethod(ctx);
    }

    /**
     * 执行方法
     *
     * @param ctx
     * @throws InterruptedException
     */
    private void executeMethod(ChannelHandlerContext ctx) throws InterruptedException {
        // TODO 将请求消息按照某种规则解析成方法名、方法参数等,其实就是反序列化的过程。
        System.out.println("对接受的数据做反序列化,然后开始执行 消息体里指定的方法...");

        // 模拟方法执行
        Thread.sleep(2000);
        System.out.println("执行完毕,返回结果...");

        // 将结果 通知给 A 进程
        ByteBuf dataByteBuf = ctx.alloc().buffer().writeBytes("Task completed".getBytes(CharsetUtil.UTF_8));
        ctx.writeAndFlush(dataByteBuf);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        cause.printStackTrace();
        ctx.close();
    }
}
  • A进程启动Netty客户端,建立与B进程的通信,然后发起远程调用,处于等待状态。
public class AProcessClient {

    private final String host;
    private final int port;
    private final Object lock = new Object();  // 监视器对象

    public AProcessClient(String host, int port) {
        this.host = host;
        this.port = port;
    }

    public void start() throws InterruptedException {
        EventLoopGroup group = new NioEventLoopGroup();

        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group)
                    .channel(NioSocketChannel.class)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) {
                            ch.pipeline().addLast(new AProcessClientHandler(lock));
                        }
                    });

            ChannelFuture future = bootstrap.connect(host, port).sync();
            System.out.println("A进程与B进程建立了通信连接");

            Channel channel = future.channel();

            // 发起远程调用
            callRemoteMethod(channel);

            channel.closeFuture().sync();
        } finally {
            group.shutdownGracefully();
        }
    }

    /**
     * 执行方法
     *
     * @param channel
     * @throws InterruptedException
     */
    private void callRemoteMethod(Channel channel) throws InterruptedException {
        //TODO 此处需要将调用的方法和参数,按照协议进行序列化。这次暂且省去此过程。
        System.out.println("A进程将 请求的方法和参数 进行序列化,然后向B进程发起网络调用...");

        ByteBuf dataByteBuf = channel.alloc().buffer().writeBytes("Start call method".getBytes(CharsetUtil.UTF_8));

        channel.writeAndFlush(dataByteBuf);

        // 使用wait等待B进程通知
        synchronized (lock) {
            System.out.println("A进程等待B进程的响应...");
            lock.wait();  // 等待通知
        }

        System.out.println("A进程收到了B进程的响应通知,继续往下...");
    }

    public static void main(String[] args) throws InterruptedException {
        new AProcessClient("localhost", 8088).start();
    }
}
  • A进程接受B进程的响应,同时被唤醒,然后以上
    lock.wait()
    以后的代码得以继续执行。
public class AProcessClientHandler extends SimpleChannelInboundHandler<ByteBuf> {

    private final Object lock;

    public AProcessClientHandler(Object lock) {
        this.lock = lock;
    }

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {
        String resData = msg.toString(CharsetUtil.UTF_8);
        System.out.println("A进程接受到了响应数据: " + resData);

        // B 进程任务完成,使用 notify 唤醒等待的线程
        synchronized (lock) {
            lock.notify();  // 唤醒 A 进程
        }
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        cause.printStackTrace();
        ctx.close();
    }
}

3、总结

Dubbo的优秀设计思路有许多,我只钟情其一,那就是RPC的调用过程。以上是一个简易的RPC远程调用的示例,用于理解Dubbo的原理和源码,希望对你有帮助!

本篇完结!欢迎 关注、加V(yclxiao)交流、全网可搜(程序员半支烟)

原文链接:
https://mp.weixin.qq.com/s/J0fzDH-iqGnnnjqaXMLs-A

SQL Server 中的 NUL 设备/NIL设备


在 SQL Server 中,有一个特殊的设备叫做 NUL(注意,不是 NULL),它类似于文件系统中的“黑洞”。NUL 设备类似于 Linux 系统中的 /dev/null,所有写入到 NUL 的数据都会被直接丢弃。

我们可以利用这个特性,在不需要实际生成备份文件的情况下进行测试或模拟备份操作。


完整备份的常规操作
通常情况下,我们对某个数据库进行完整备份时,可以使用以下最简单的 SQL 语句:

BACKUP DATABASE AdventureWorks2012 TO DISK = N'AdventureWorks2012.BAK'

执行后,SQL Server 会显示备份的结果

已为数据库 'AdventureWorks2012',文件 'AdventureWorks2012' (位于文件 1 上)处理了 24328页。
已为数据库
'AdventureWorks2012',文件 'AdventureWorks2012_log' (位于文件 1 上)处理了 2页。BACKUP DATABASE 成功处理了 24330 页,花费 4.103 秒(46.326 MB/秒)。



备份文件将存储在实例的默认备份路径中。可以通过以下 SQL 查询来确认该路径:

DECLARE @BackupDest VARCHAR(200)EXEC master.dbo.xp_instance_regread N'HKEY_LOCAL_MACHINE', N'Software\Microsoft\MSSQLServer\MSSQLServer', N'BackupDirectory', @BackupDestOUTPUT;SELECT @BackupDest;



使用 NUL 设备进行备份
如果不想实际生成备份文件,但需要测试备份操作或了解备份时间等,可以将备份数据写入 NUL 设备。
SQL Server 支持两种方式将备份写入 NUL 设备:使用 NUL 或 NUL:。

BACKUP DATABASE AdventureWorks2012 TO DISK = N'NUL' 
GO
BACKUP DATABASE AdventureWorks2012 TO DISK = N'NUL:'
GO

执行后,SQL Server 同样会显示备份的结果

已为数据库 'AdventureWorks2012',文件 'AdventureWorks2012' (位于文件 1 上)处理了 24328页。
已为数据库
'AdventureWorks2012',文件 'AdventureWorks2012_log' (位于文件 1 上)处理了 2页。BACKUP DATABASE 成功处理了 24330 页,花费 1.499 秒(126.803 MB/秒)。


NUL 设备还可以通过备份判断磁盘的读吞吐量,即使你备份至多个NUL设备。备份至NUL设备主要是读取数据,写数据并没有写入具体的磁盘中。

BACKUP DATABASE AdventureWorks2012 TO DISK = N'NUL',DISK = N'NUL',DISK = N'NUL',DISK = N'NUL' ,DISK = N'NUL'



总结
备份至 NUL 设备的主要用途包括:
1、备份吞吐量验证:NUL 设备可以用来测试数据库的
读 IOPS 性能
,帮助验证备份时的读写吞吐量。
2、没有日志备份导致磁盘满:如果日志文件长期未备份而变得非常大导致磁盘空间不足,可以通过将
日志备份写入 NUL 设备
来快速释放日志空间,之后再进行日志文件收缩或者设置简单模式收缩文件。
3、在高可用配置:特别是 SQL Server2016或者以上版本, AlwaysOn AG 场景中,使用
automatic seeding 功能
配置可用性数据库前需要备份,可将数据库备份至NUL设备后再初始化同步。
4、COPY_ONLY 备份:在不希望中断备份链(不truncate日志文件里的日志)但需要在生产环境中进行测试时,可以使用
COPY_ONLY 参数
来创建临时备份,避免对生产环境的备份链产生影响。

需要注意的是,备份至 NUL 设备时的读操作对性能的影响与实际备份相似,因此在生产环境中进行测试时,仍需谨慎评估其影响。



参考文章
https://www.modb.pro/db/452106
https://blog.csdn.net/lnotime/article/details/104847946
https://cloud.tencent.com.cn/developer/information/%E6%AD%A3%E5%9C%A8%E8%BF%98%E5%8E%9F%E6%95%B0%E6%8D%AE%E5%BA%93SQL%20Server%20-%E6%95%B0%E6%8D%AE%E4%B8%BAnull%E4%B8%8D%E8%83%BD%E5%AF%B9null%E5%80%BC%E8%B0%83%E7%94%A8%E6%AD%A4%E6%96%B9%E6%B3%95%E6%88%96%E5%B1%9E%E6%80%A7


本文版权归作者所有,未经作者同意不得转载。

1、前言

在数字化时代,自动化工具成为了提升工作效率和生产力的重要手段。Python作为一种广泛使用的编程语言,以其强大的功能和易用性受到许多开发者的青睐。 而今天给大家推荐一款开源的自动化脚本工具:
AutoKey

结合Python的强大编程能力与AutoKey的任务自动化特性,用户可以高效地完成各种复杂的操作。比如在日常办公工作中,我们经常会遇到许多重复性的任务,如数据录入、文件整理、邮件发送等。这些任务不仅耗时,而且容易出错。为了提高工作效率,我们可以利用Python和AutoKey两款工具,实现办公自动化。从而释放双手,让计算机为我们做出更多的工作。

2、AutoKey介绍

AutoKey
是一个适用于 Linux 和 X11 系统的开源的桌面自动化工具,能够根据预设的文本或键盘快捷键触发相应的操作,主要用于提高用户的工作效率。通过结合 Python 脚本,你可以创建自定义的键盘快捷方式、文本替换以及复杂的自动化任务。对于需要经常性输入固定文本、启动复杂命令的用户,AutoKey 提供了非常强大的功能。

3、AutoKey主要功能和适用场景

AutoKey主要可通过热键(快捷键)触发文本、命令、脚本或复杂的宏来执行任务。

3.1 主要功能

它的核心功能主要包括以下几个方面:

1、文本输入自动化:

  • 自动输入:可以预先录制或编写文本序列,然后通过热键触发这些文本的输入,从而快速完成重复性文本输入任务。
  • 替换:自动替换文本中的特定模式或关键字,例如,将所有的电子邮件地址替换为链接。
  • 自动更正:在输入过程中自动更正拼写错误。

2、键盘和鼠标操作自动化:

  • 宏录制:记录键盘和鼠标操作,创建可重复使用的宏。
  • 宏执行:通过热键或触发条件执行宏,实现复杂的操作自动化。
  • 模拟点击:自动执行鼠标点击操作。

3、命令和脚本执行:

  • 命令执行:通过热键执行系统命令,如打开文件、运行程序等。
  • 脚本执行:支持多种脚本语言,如Python、Lua等,可以编写复杂的自动化脚本。

4、定时任务:

  • 定时执行:设置特定时间点或时间间隔执行任务,如定时检查邮件、定时提醒等。

5、系统集成:

  • 系统通知:通过AutoKey发送系统通知,提醒用户执行某些操作。
  • 与其他应用集成:可以与其他应用程序如浏览器、文本编辑器等集成,扩展其功能。

6、跨平台支持:

  • AutoKey 支持多个操作系统,包括Linux、macOS和Windows,用户可以在不同的平台上使用。

7、用户界面:

  • 图形用户界面:AutoKey 提供了一个图形用户界面,方便用户创建和管理自动化任务。
  • 命令行界面:AutoKey 也提供命令行工具,允许用户通过命令行进行操作。

AutoKey 的核心功能使其成为提高工作效率和减少重复性工作的一种强大工具,尤其适合那些需要频繁输入或执行相同操作的用户。通过AutoKey,用户可以定制自己的工作流程,从而更加专注于任务的核心内容。

3.2 适用场景

AutoKey 的应用场景非常广泛,以下是一些典型例子:

  • 重复性操作
    : 比如填写表单、复制粘贴文本、发送邮件等,使用 AutoKey 可以自动完成这些任务,节省时间和精力。
  • 自动化操作流程
    : 比如将网页上的数据提取到表格中、自动生成报告等,使用 AutoKey 可以将这些流程自动化,提高效率。
  • 游戏升级辅助
    : 在游戏中,可使用 AutoKey自动完成一些重复性的操作,例如刷怪、采集等。
  • 个人日常工作
    : 通过 AutoKey 可以将一些个人工作流程自动化,例如整理文件、管理时间、快速搜索信息等,提高工作效率。

4、AutoKey安装、使用

1、安装

pip3 install autokey

不同安装方式可参考:
https://github.com/autokey/autokey/wiki/Installing

2、以下是一些简单的 AutoKey 脚本示例:

# 复制当前窗口的标题到剪贴板
import autokey

window = autokey.Window.active()
title = window.title()
autokey.Clipboard.set_text(title)

3、假设我们想要自动化登录到一个网站的操作。我们可以通过以下Python代码来实现:

# 导入autokey模块
import autokey

# 定义一个函数来执行登录操作
def login_to_website():
    # 启动浏览器并打开网站
    autokey.run_command("open -a /Applications/Google Chrome.app https://www.example.com")
    # 等待页面加载
    autokey.sleep(5)
    # 输入用户名和密码
    autokey.type_string("username")
    autokey.press("tab")
    autokey.type_string("password")
    # 按下回车键进行登录
    autokey.press("enter")

# 设置触发关键字
hotkey = autokey.Hotkey()
hotkey.set_keyboard_shortcut("ctrl+shift+l")
hotkey.set_function(login_to_website)

# 保存脚本
autokey.script.save()

在这个例子中,我们定义了一个名为login_to_website的函数,它会启动浏览器,打开指定的网址,输入用户名和密码,然后登录。我们为这个函数设置了一个快捷键ctrl+shift+l,这样每当我们在任何地方按下这个快捷键组合时,都会触发这个登录操作。

4、更多官方使用API可查阅:

https://autokey.github.io/index.html

5、小结

通过结合Python的强大功能和AutoKey的自动化特性,我们可以构建出强大的自动化脚本来解决日常任务。无论是简单的文本输入,还是复杂的网页操作,Python和AutoKey都能提供有效的解决方案。随着自动化技术的不断进步,这类技术组合将会在提升工作效率方面发挥更大的作用。

项目地址

https://github.com/autokey/autokey