文本向量化是将文本数据转换为数值向量的过程。这种转换使得计算机能够理解和处理文本数据，从而可以应用各种机器学习和自然语言处理技术。文本向量化的主要问题是将非结构化的文本数据转换为结构化的向量表示，以便计算机能够对其进行处理和分析。通过文本向量化，可以实现文本分类、文本聚类、信息检索等任务。

在大模型时代下，文本向量化的技术发展到了embedding阶段。Embedding是一种将高维的文本数据映射到低维空间的技术，它能够捕捉到文本数据中的语义信息，并将其表示为稠密向量。这种表示更具有语义信息，相比于传统的词袋模型或者TF-IDF等表示方法，embedding能够更好地捕捉到单词之间的语义关系。

文本向量化技术发展史

整个文本向量化的发展过程是一个由简单到复杂，由低维到高维的演变过程。在早期，人们使用基于统计的方法，如词袋模型、TF-IDF等来表示文本。这些传统的基于统计的方法虽然能够实现一些简单的文本处理和自然语言理解任务，但是对于语义信息的把握能力有限，而且很难处理复杂的语言现象。随着深度学习技术的演变，尤其是Word2Vec、GloVe等词向量模型的提出，文本处理的效果和性能大幅提升，文本向量化技术开始向embedding方向发展。而后来的BERT、GPT等大型预训练模型的出现，则进一步推动了文本向量化技术的进步，使得文本向量化不仅能够表示单词或短语，还能够表示整个句子或文档的语义信息。新技术生成的文本向量不仅可以高效完成传统的自然语言处理任务，还在新兴的生成式人工智能技术（如检索增强生成等技术）中发挥了作用。

One-Hot编码（出现于2000年前）

One-Hot编码是一种将分类数据转换为二进制表示的方法，常用于数据处理和机器学习。One-Hot编码的概念一般被认为是随着计算机科学的发展而自然出现。在数字计算和数据处理的早期阶段，二进制表示极为盛行。当需要计算机处理非数值的数据（如颜色，产品类型等）时，One-Hot编码就是一种将各类数据数值化的朴素方法。

在文本向量化中，One-Hot编码的分类数据一般为单词或字符，以下以单词为例。通过这种编码方式，每个唯一的单词都用一个向量表示。向量的长度等于词汇表的单词数量，其中只有一个位置为1，其余位置都为0。这种表达方式生成的是稀疏向量，其中每个单词都由一个唯一的二进制向量表示，该向量中只有一个高位（1），其他都是低位（0）。

以“猫”、“狗”、“鱼”为例，One-Hot编码在文本向量化中的实现步骤大致如下：

首先识别所有的唯一单词，并建立长度为3的词汇表{“猫”, “狗”, “鱼”}。其次为每个单词分配索引，比如“猫”、“狗”、“鱼”分别分配索引位置0，1，2。然后为每个单词创建向量，例如，“猫”的向量是[1, 0, 0]。最后假使有一段文本内容为“猫猫狗狗”，它经过向量化后就是

[[1, 0, 0],

[1, 0, 0],

[0, 1, 0],

[0, 1, 0]]。

优点：

● 简单易实现。

● 能提供清晰明确的单词表示。

缺点：

● 词汇表偏大时会导致向量维度过高，从而造成内存使用量偏大。

● 无法存储单词之间的语义相似性（例如，”猫“和”狗“同为宠物动物应更加相似，然而在One-Hot编码中“猫”、“狗”、“鱼”三者的向量距离相同，所以不能体现这一特性）。

● 稀疏向量在某些任务中计算效率低。

Bag of words （出现于2000年前）

Bag of Words（BoW）又称词袋模型，是一种简单而有效的文本向量化方法。词袋模型目前没有归属一个具体的发明者，而是在信息检索、文本分类和自然语言处理等领域中逐渐发展演变出来的一种常用的文本表示方法。One-Hot编码虽然完成了数据从非数值到数值的转变，但在文本分类，特征提取等方面作用十分有限，且每个词都对应一个稀疏向量，存储效率较低。词袋模型将文本看作是单词的无序集合，忽略词的顺序和语法，只关注词的出现频率。因此词袋模型在One-Hot编码的基础上提升了文本向量化的效果，并减少了存储负担。

仍以“猫”、“狗”、“鱼”为例，词袋模型在文本向量化中的实现步骤大致如下：

与One-Hot编码相同，首先识别所有的唯一单词，并建立长度为3的词汇表{“猫”, “狗”, “鱼”}。其次对于每一文本，创建一个与词汇表等长的向量。向量的每个位置对应词汇表中的一个词，该位置的值表示该词在文档中出现的次数。假使“猫”、“狗”、“鱼”的索引位置仍然分别为0，1，2，而文本依然是“猫猫狗狗”。与one-hot编码会生成一组向量不同，词袋模型只会产生一个向量[2, 2, 0]。向量中第0个元素2代表“猫”出现了两次，第1个元素2代表“狗”出现了两次，第2个元素0代表“鱼”出现了零次。

优点：

● 简单易实现。

● 对于小规模数据集，词袋模型的计算效率很高。

缺点：

● 对于大型词汇表，词袋模型生成的向量维度很高，从而导致内存使用量大。

● 完全忽略了词的顺序，无法捕捉句子的语法和结构信息。

● 仅仅统计词频，而无法捕捉词与词之间的语义关系。

TF-IDF（出现于2000年前）

TF-IDF（Term Frequency-Inverse Document Frequency），翻译为词频-逆文档频率，是一种常用于文本挖掘和信息检索的统计方法，用来评估一个词在一个文档集或语料库中的重要程度。现今的TF-IDF方法被认为是文本挖掘和信息检索领域逐渐发展和完善的结果，但逆文档频率的基本概念由计算机科学家Karen Spärck Jones在1957年提出，用来评估在一个文档集中，一个词对它所在的文档的重要性。TF-IDF可以帮助筛选出在文档中具有重要意义的词汇，常用于关键词提取、文档相似度计算和文本分类等任务。

TF-IDF由两个部分组成：词频（TF）和逆文档频率（IDF）。词频是一个词在一个文档中出现的频率。词频越高，表明这个词在该文档中越重要。词频的公式为：

逆文档频率衡量一个词在整个文档集（可能包含多个文档）中出现的稀有程度。一个词在越多文档中出现，其区分能力越低，IDF值就越小。逆文档频率的计算公式为：

两个公式中：

ft,d是词t在文档d中出现的次数。

nd是文档d中所有词的总数。

N是文档集D中文档的总数。

|{d∈D:t∈d}|是包含词t的文档总数。

最后，TF-IDF 是词频和逆文档频率的乘积，用来衡量一个词在一个文档中的重要性，其计算公式为：

举例来说，假设有以下三个文档：

文档1： ”狗追猫。“

文档2： “猫爬墙。”

文档3： “狗趴地。”

TF-IDF(“猫”,文档1, 文档集)的计算如下：

TF(“猫”,文档1) = 1/3。

IDF(“猫”,文档集) = log(3 / (1 + 2)) = 0。

TF-IDF(“猫”,文档1,文档集) = 1/3 * 0 = 0。

可以看出，由于“猫” 在多个文档中出现，因此其区分能力较低，IDF值为0，导致TF-IDF值也为0。

优点：

● 简单易实现。

● 考虑了词的重要性，减少了常见但不重要的词（如“的”、“与”等）的权重。

● 适用于自然语言处理中的多种任务，如文本分类、文本聚类、信息检索等。

缺点：

● 对于大型文档集，由于词汇量庞大，生成的 TF-IDF 矩阵往往非常稀疏，所以计算效率不高。

● 只考虑了词汇的出现频率，而忽略了词汇在文本中的顺序信息。

● 没有考虑词汇之间的语义关系。

● TF-IDF 的计算方式导致它的效果依赖于足够大的文档集，数据量不足可能导致效果不佳。

应用场景：

● 关键词提取

● 文档相似度计算

● 信息检索

● 文本分类

Word2Vec（出现于2013年）

Word2Vec是一种基于神经网络的embedding模型，由谷歌的研究人员Tomas Mikolov等在2013年提出。Word2Vec的作者认为之前的文本向量化方法很少考虑词与词之间的意义关联，所以效果不佳。因此，Word2Vec将单词映射到低维向量空间中，使得相似词在向量空间中也保持相近的距离。

Word2Vec主要由两种模型架构组成：Skip-Gram和Continuous Bag of Words（CBOW）。Skip-Gram通过当前词预测其上下文词。给定一个中心词，模型会预测一个固定长度的上下文窗口（前后若干词）中的所有词。训练过程中，模型会学习到每个词的向量表示，使得能够更好地预测这些上下文词。与Skip-Gram相反，CBOW的目标是通过上下文词预测当前词。给定一个上下文窗口中的所有词，模型会预测这个窗口的中心词。

Word2Vec模型的核心思想是通过训练神经网络，使得单词与其上下文之间的关系可以在向量空间中被有效地表示。Word2Vec的输入层是一个one-hot向量（one-hot vector），长度为词汇表大小（V）。紧接着是一个投影层，由输入层经过一个权重矩阵W（维度为V x N，N为嵌入向量的维度），投影到N维向量空间中。投影层的输出通过另一个权重矩阵W’（维度为N x V），映射回一个词汇表大小的向量，此为输出层。最后经过一个Softmax层得到每个词的概率。在训练过程中，Word2Vec模型通过最大化目标函数（取决于使用Skip-Gram还是CBOW，以及采用的优化函数的方法）来更新权重矩阵，从而使得embedding能够捕捉到词汇的语义信息。

优点：

● 由于采用了浅层神经网络，训练速度较快，适合处理大规模数据。

● 能够捕捉到词与词之间的语义关系，如词性、同义词等。

● 可以用于多种自然语言处理任务，如文本分类、情感分析、机器翻译等。

缺点：

● 每个词只有一个固定的向量表示，无法处理多义词的不同语义。

● 无法考虑词在不同上下文中的语义变化。

应用场景：

● 信息检索

● 文本分类

● 推荐系统，如根据用户的评论调整推荐的产品

GloVe（出现于2014年）

GloVe (Global Vectors for Word Representation)是一种无监督的文本向量化的学习算法，由斯坦福大学的Jeffrey Pennington等在2014年提出。它通过捕捉单词在大规模语料库中的共现统计信息，生成高质量的词向量。GloVe的作者认为使用共现词的概率的比可以更好地区分相关和无关的词，因此GloVe的核心是共现矩阵和词对共现概率。共现矩阵中的每个元素Xi,j表示词j出现在词i的上下文中的次数。词对共现概率定义为：

意为词j在词i的上下文中出现的概率。GloVe 的优化目标是通过最小化一个损失函数，使得embedding能够很好地预测共现概率。损失函数如下：

其中，wi和wj分别是词i和词j的词向量，bi和bj是偏置项，f(Xij)是一个加权函数，用于减少高频共现对模型的影响。加权函数f通常定义为：

其中Xmax是一个阈值，在GloVe作者的实验中被设置为100，而3/4被认为是一个合适的α的值。
优点:
●充分利用了全局共现统计信息，使得词向量可以捕捉到词语之间的复杂关系。
●通过对共现矩阵进行处理，GloVe 的训练速度较快，适合大规模语料库。
●生成的词向量在语义上具有较强的解释力，可以很好地应用于各种自然语言处理任务，如文本分类、情感分析、问答系统等。

缺点：
●每个词只有一个固定的向量表示，无法处理多义词的不同语义。
●通常需要大规模的语料库来获得高质量的词向量表示。
● 尽管训练过程可以并行化，但仍需要较高的计算资源和时间来训练高质量embeddings。
●虽然关注单词之间的共现频率，但忽略了语法结构。

应用场景：
●文本分析
●信息检索
●问答系统

FastText（出现于2016年）

FastText是由Facebook的人工智能研究团队开发的一种用于文本分类和词向量表示的开源库，适用于大规模数据集和高性能需求的任务。FastText的相关论文由Piotr Bojanowski等人在2016年发表，FastText的作者认为之前的文本向量化方法没有考虑单词内部的子词之间的关系，所以性能受限。为了改善这个限制，FastText的核心原理包括两大部分：词向量表示和文本分类。
词向量表示

FastText 的一个关键创新在于利用了子词信息（Subword Information），即将每个单词表示为多个 n-gram 的组合。

例如，单词 “where” 可以分解为”wh”, “whe”, “her”, “ere”, “re”等 n-gram。这种方法使得模型能够捕捉到词的子词信息，从而更好地处理未登录词和拼写错误。FastText 使用基于在上文中提到的Skip-Gram的方法来训练embedding。值得注意的是，FastText不仅使用单词本身，还使用单词的所有n-gram。每个单词被表示为它所有n-gram向量的组合。为了提高计算效率，FastText 使用分层Softmax代替传统的Softmax。分层Softmax将所有类别组织成一棵二叉树，每个叶节点对应一个类别。通过减少类别数量的对数级计算，分层Softmax极大地加速了训练和预测过程。

文本分类原理

在文本分类任务中，FastText通过将文本表示为一系列词向量的平均来生成文档向量。对于一个文本d中的每个词w，其向量表示为vw。文本d的表示为所有词向量的平均，即：

FastText使用线性分类器来进行文本分类。文本向量vd通过一个全连接层，并使用Softmax函数来输出类别概率。分类模型的公式为：

其中W是权重矩阵，b是偏置项。

优点：

● 训练和预测速度也很快，适合实时应用。

● 能够处理具有大量类别的任务，并保持高效性。

● 支持多种语言的文本处理。

缺点：

● 使用静态词向量，无法捕捉上下文相关的词义变化。

应用场景：

● 文本分类

● 关键词提取

● 拼写错误纠正

ELMo（出现于2018年）

ELMo（Embeddings from Language Models）是一种由Allen Institute for AI的研究者Matthew E. Peters等在2018年提出的embedding方法，通过上下文中的词语来捕捉语义。ELMo的作者认为之前的文本向量化方式没有考虑一个词在不同上下文中意义的变化，所以与Word2Vec和GloVe不同，ELMo能够捕捉到词在不同上下文中的不同意义，从而生成更为丰富和精确的embedding。

ELMo使用双向LSTM（Long Short-Term Memory）网络作为基础架构。该网络包括一个向前的LSTM和一个向后的LSTM，它们分别从左到右和从右到左遍历文本序列，学习每个词的前向和后向上下文。这个双向LSTM被训练为一个语言模型，目标是预测句子中的下一个词（对于前向LSTM）和前一个词（对于后向LSTM）。对于给定的文本序列，ELMo会为每个词提取多层的表示。对于每个词，ELMo提供三层的embedding输出：一层来自embedding层（类似于传统的embedding），另外两层来自双向LSTM的各自输出。最后，ELMo使用这些层的加权和作为结果，公式如下：

其中γ是一个可学习的标量；sj是层j的可学习权重；ht(j)是词t在层j的表示。为了使这些输出被应用在不同任务中，ELMo提出了一种动态加权的方法，可以为不同层的输出分配不同的权重。这样，模型不仅使用了所有层的信息，还根据任务动态调整了每层信息的重要性。

优点：

● 基于整个句子的上下文信息生成embedding，能够更好地处理多义词和上下文依赖性强的词。

● 能够捕捉复杂的句子结构和长距离依赖关系。

● 预训练的ELMo模型可以很容易地迁移到各种下游自然语言处理任务中。

缺点：

● 模型较大，训练和推理过程需要大量的计算资源。

● 由于模型复杂，推理速度较慢。

应用场景：

● 情感分析

● 问答系统

● 文本分类

● 机器翻译

基于Transformer结构的embedding模型（出现于2018年后）

谷歌的研究人员Ashish Vaswani等在2017年提出了带有注意力机制的Transformer模型结构，可以利用输入序列的全局信息进行输出，改善了在RNN和LSTM中的长距离依赖问题，同时提高了并行计算能力使训练过程大幅加速。

随着transformer结构的推出，在2018年开始出现了许多各具特色的基于Transformer结构的embedding模型。其中BERT (Bidirectional Encoder Representations from Transformers) 是一种双向Transformer编码器，用于生成上下文感知的词向量。GPT (Generative Pre-trained Transformer) 系列则是单向，且主要用于文本生成任务。T5 (Text-To-Text Transfer Transformer) 将所有任务统一为文本到文本的转换。RoBERTa (Robustly Optimized BERT Approach) 对BERT进行了优化，提升了性能。DistilBERT 则是BERT的轻量级版本，旨在减少计算资源。ALBERT (A Lite BERT) 通过参数共享和因子分解，进一步减小了模型大小。这些模型同传统的embedding方法相比效果显著提高，被广泛应用于自然语言处理的各种任务。

结语

在大模型时代，embedding成为一项必不可少的技术，主要是因为它能够有效地将大量高维数据（如文本、图像和音频信息）转换成更低维的、密集的向量表示。这种表示可以捕捉到数据的本质特征，并且在处理和计算上更为高效。通过embedding，模型可以在这些压缩的向量空间中学习数据之间的复杂关系和模式，从而提高了处理速度和准确性。此外，embedding使得模型能够在较小的表示空间中进行操作，减少了计算资源的需求，同时也便于模型的训练和推理，这对于处理现代大规模数据集尤为关键。Embedding在大模型时代扮演着桥梁的角色，跨越了原始数据和机器学习算法之间的巨大鸿沟。

在自然语言处理领域，文本向量化技术的发展带来了革命性的变化。从最早的One-Hot编码到当前基于Transformer结构的embedding模型，每一次创新都带来了更高效、更精准的文本表示方式，为文本处理提供了更为灵活、高效的解决方案。未来，随着技术的不断进步和应用场景的不断拓展，文本向量化技术将继续发挥着重要的作用，并为人工智能在文本理解和处理领域带来更广阔的发展空间。

1 单线程是对多线程的，对于多线程的开发语言，有一个请求就可以开一个线程处理。那，对于单线程语言，只有通过异步调用程序。【事件 (事件循环机制)， 回调】

2 异步是对同步说的， 最大区别就是同步需要等待，异步这不需要等待。

“同步模式”就是指后一个任务等待前一个任务结束，然后再执行，程序的执行顺序与任务的排列顺序是一致的、同步的。
“异步模式”则完全不同，每一个任务有一个或多个回调函数（callback），前一个任务结束后，不是执行后一个任务，而是执行回调函数，后一个任务则是不等前一个任务结束就执行，所以程序的执行顺序与任务的排列顺序是不一致的、异步的。

回调是一个函数，它作为参数传递给另一个函数，并在其父函数完成后执行。

你到一个商店买东西，刚好你要的东西没有货，于是你在店员那里留下了你的电话，过了几天店里有货了，店员就打了你的电话，然后你接到电话后就到店里去取了货。在这个例子里，你的电话号码就叫回调函数，你把电话留给店员就叫登记回调函数，店里后来有货了叫做触发了回调关联的事件，店员给你打电话叫做调用回调函数，你到店里去取货叫做响应回调事件。

我们绕点远路来回答这个问题。

编程分为两类：系统编程（system programming）和应用编程（application programming）。所谓系统编程，简单来说，就是编写库；而应用编程就是利用写好的各种库来编写具某种功用的程序，也就是应用。系统程序员会给自己写的库留下一些接口，即API（application programming interface，应用编程接口），以供应用程序员使用。所以在抽象层的图示里，库位于应用的底下。

当程序跑起来时，一般情况下，应用程序（application program）会时常通过API调用库里所预先备好的函数。但是有些库函数（library function）却要求应用先传给它一个函数，好在合适的时候调用，以完成目标任务。这个被传入的、后又被调用的函数就称为回调函数（callback function）。

打个比方，有一家旅馆提供叫醒服务，但是要求旅客自己决定叫醒的方法。可以是打客房电话，也可以是派服务员去敲门，睡得死怕耽误事的，还可以要求往自己头上浇盆水。这里，“叫醒”这个行为是旅馆提供的，相当于库函数，但是叫醒的方式是由旅客决定并告诉旅馆的，也就是回调函数。而旅客告诉旅馆怎么叫醒自己的动作，也就是把回调函数传入库函数的动作，称为登记回调函数（to register a callback function）。如下图所示（图片来源：维基百科）：

可以看到，回调函数通常和应用处于同一抽象层（因为传入什么样的回调函数是在应用级别决定的）。而回调就成了一个高层调用底层，底层再回过头来调用高层的过程。（我认为）这应该是回调最早的应用之处，也是其得名如此的原因。

回调机制的优势

从上面的例子可以看出，回调机制提供了非常大的灵活性。请注意，从现在开始，我们把图中的库函数改称为中间函数了，这是因为回调并不仅仅用在应用和库之间。任何时候，只要想获得类似于上面情况的灵活性，都可以利用回调。

这种灵活性是怎么实现的呢？乍看起来，回调似乎只是函数间的调用，但仔细一琢磨，可以发现两者之间的一个关键的不同：在回调中，我们利用某种方式，把回调函数像参数一样传入中间函数。可以这么理解，在传入一个回调函数之前，中间函数是不完整的。换句话说，程序可以在运行时，通过登记不同的回调函数，来决定、改变中间函数的行为。这就比简单的函数调用要灵活太多了。请看下面这段Python写成的回调的简单示例：

`even.py`

#回调函数1
#生成一个2k形式的偶数
def double(x):
    return x * 2
    
#回调函数2
#生成一个4k形式的偶数
def quadruple(x):
    return x * 4

`callback_demo.py`

from even import *

#中间函数
#接受一个生成偶数的函数作为参数
#返回一个奇数
def getOddNumber(k, getEvenNumber):
    return 1 + getEvenNumber(k)
    
#起始函数，这里是程序的主函数
def main():    
    k = 1
    #当需要生成一个2k+1形式的奇数时
    i = getOddNumber(k, double)
    print(i)
    #当需要一个4k+1形式的奇数时
    i = getOddNumber(k, quadruple)
    print(i)
    #当需要一个8k+1形式的奇数时
    i = getOddNumber(k, lambda x: x * 8)
    print(i)
    
if __name__ == "__main__":
    main()

运行`callback_demp.py`，输出如下：

3
5
9

上面的代码里，给`getOddNumber`传入不同的回调函数，它的表现也不同，这就是回调机制的优势所在。值得一提的是，上面的第三个回调函数是一个匿名函数。

易被忽略的第三方

通过上面的论述可知，中间函数和回调函数是回调的两个必要部分，不过人们往往忽略了回调里的第三位要角，就是中间函数的调用者。绝大多数情况下，这个调用者可以和程序的主函数等同起来，但为了表示区别，我这里把它称为起始函数（如上面的代码中注释所示）。

之所以特意强调这个第三方，是因为我在网上读相关文章时得到一种印象，很多人把它简单地理解为两个个体之间的来回调用。譬如，很多中文网页在解释“回调”（callback）时，都会提到这么一句话：“If you call me, I will call you back.”我没有查到这句英文的出处。我个人揣测，很多人把起始函数和回调函数看作为一体，大概有两个原因：第一，可能是“回调”这一名字的误导；第二，给中间函数传入什么样的回调函数，是在起始函数里决定的。实际上，回调并不是“你我”两方的互动，而是ABC的三方联动。有了这个清楚的概念，在自己的代码里实现回调时才不容易混淆出错。

另外，回调实际上有两种：阻塞式回调和延迟式回调。两者的区别在于：阻塞式回调里，回调函数的调用一定发生在起始函数返回之前；而延迟式回调里，回调函数的调用有可能是在起始函数返回之后。这里不打算对这两个概率做更深入的讨论，之所以把它们提出来，也是为了说明强调起始函数的重要性。网上的很多文章，提到这两个概念时，只是笼统地说阻塞式回调发生在主调函数返回之前，却没有明确这个主调函数到底是起始函数还是中间函数，不免让人糊涂，所以这里特意说明一下。另外还请注意，本文中所举的示例均为阻塞式回调。延迟式回调通常牵扯到多线程，我自己还没有完全搞明白，所以这里就不多说了。

链接：https://www.zhihu.com/question/19801131/answer/27459821

在机顶盒刷个hi-nas，然后进终端，装python3,再开机就运行py文件

systemd是现代Linux系统中用于初始化系统组件和管理系统进程的标准。以下是创建一个systemd服务用于开机就启动这个文件，基本步骤：

1. 创建一个服务文件，例如/etc/systemd/system/myservice.service，内容可能如下：

[Unit]
Description=My Python Service
After=network.target

[Service]
User=yourusername
ExecStart=/usr/bin/python3 /path/to/your_script.py
Restart=always
WorkingDirectory=/path/to/your_script_directory

[Install]
WantedBy=multi-user.target

请将yourusername替换为你的用户名，/path/to/your_script.py替换为你的Python脚本的实际路径，/path/to/your_script_directory替换为你的Python脚本所在的目录。

2. 重新加载systemd配置以识别新服务：

sudo systemctl daemon-reload

3. 启动服务：

复制sudo systemctl start myservice.service

4. 使服务在开机时自动启动：

sudo systemctl enable myservice.service

5. 检查服务状态：

sudo systemctl status myservice.service

以下是用到的py文件

import requests
import time
import datetime
from concurrent.futures import ThreadPoolExecutor
import random
#import logging

#logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')

urlList = ['https://dldir1v6.qq.com/weixin/Windows/WeChatSetup.exe', 'https://qrsj.gdl.netease.com/LauncherGame__697327.exe', 'https://downloadclient03.ztgame.com.cn/ztmianfei/client/zhengtu_setup_20231228.zip', 'https://pm.myapp.com/invc/xfspeed/qqpcmgr/download/QQPCDownload320059.exe', 'https://d4.a.kwimgs.com/kos/nlav12667/5.35.1/KwaiLive-Setup-5.35.1.2005-ReleaseFull.exe', 'https://sta-op.douyucdn.cn/dypc-client/pkg/DYTool/20240510183635704/master_DYToolEX_6.3.1.3.472.exe', 'https://download.huya.com/huyapc/install/HuyaClientInstall.exe']
thread = 5  #线程数量
goal = 0  #消耗的流量单位GB
if goal > 0:
    goal = goal * 1024 * 1024 * 1024  #GB转为B

wasted = 0  #已消费的流量
runing = 0  #正在运行的数量
#线程池
executor = ThreadPoolExecutor(max_workers=thread)
#下载连接池
session = requests.Session()
adapter = requests.adapters.HTTPAdapter(pool_connections=thread, pool_maxsize=thread+1, max_retries=1, pool_block=False)
session.mount('http://', adapter)
session.mount('https://', adapter)




# 下载文件
def download(url):
    try:
        global runing
        runing += 1
        response = session.get(url, stream=True, timeout=(10, 30))  # 连接超时10秒，读取超时30秒
        if response.status_code == 200:
            download_start_time = time.time()  # 开始下载的时间
            for chunk in response.iter_content(chunk_size=10240):  # 按块读取文件内容
                if chunk:  # 确保chunk不为空
                    pass  # 处理文件内容，例如写入文件

                # 检查下载是否超过30分钟
                if time.time() - download_start_time > 1000:  # 1800秒 = 30分钟
                    #print(f"Download has exceeded 30 minutes: {url}")
                    break  # 终止下载循环

    # except requests.exceptions.RequestException as e:  # 捕获requests异常
    #     print(f"Request failed: {e}")
    # except Exception as e:  # 捕获其他异常
    #     print(f"An error occurred: {e}")
    finally:
        runing -= 1
        if response:
            response.close()  # 关闭下载连接


def startDownload():
    time.sleep(random.randint(1, 10))
    global wasted
    wasted = 0
    # 开始下载
    i = thread
    while i > 0:
        executor.submit(download, random.choice(urlList))
        # 休眠0.01秒-0.1秒
        time.sleep(random.randint(1, 10) / 100)
        i -= 1


if __name__ == "__main__":
    startDownload()
    while True:
        # 获取当前时间
        curtime = datetime.datetime.now()
        hour = curtime.hour
        if 6 <= hour < 18:
            if (goal == 0 or wasted < goal) and runing < thread:
                #logging.info("补充下载链接数：%s", thread - runing)
                i = thread - runing
                while i > 0:
                    executor.submit(download, random.choice(urlList))
                    time.sleep(random.randint(1, 10) / 100)
                    i -= 1
            time.sleep(95)
        elif 18 <= hour < 24:
            if (goal == 0 or wasted < goal) and runing < thread:
                #logging.info("补充下载链接数：%s", thread - runing)
                i = thread - runing - 2
                while i > 0:
                    executor.submit(download, random.choice(urlList))
                    time.sleep(random.randint(1, 10) / 100)
                    i -= 1
            time.sleep(95)
        else:
            if (goal==0 or wasted < goal) and runing < thread:
                #logging.info("补充下载链接数：%s", thread - runing)
                i = thread - runing - 1
                while i> 0:
                    executor.submit(download, random.choice(urlList))
                    time.sleep(random.randint(1, 10) / 100)
                    i-=1
            time.sleep(95)