分类: 站长笔记

虚拟人生记录,站长思维沉淀

  • 从零开始搭建和运行一个小型AI模型

    当AI模型如ChatGPT、Alpaca、ChatGLM和Bloom等大模型成为热门话题的同时,许多人可能感到时间紧迫,想要跟上AI时代的步伐。然而,对于一般人来说,进入AI领域似乎需要大量资源和知识。本文将以工程师的视角,从零开始搭建和运行一个小型AI模型,以便更接地气地理解AI的工作原理。

    开篇故事

    假设你是一位普通的工程师,对AI领域充满好奇心,但你认为学习AI需要庞大的算力和海量的数据,感到无从下手。然而,你相信时代不会放弃那些跟不上它步伐的人,而是会压倒他们,因此,你决定学习一些AI知识,以便更好地适应这个新时代。

    AI模型的工作原理

    首先,我们需要了解AI模型是如何工作的。神经网络是AI的核心计算模型,而深度学习则通过神经网络实现特征学习和模式分析,广泛应用于图像识别等领域。为了更好地理解,我们以最基础的手写数字识别为例,看看一个神经网络的AI模型是如何工作的。

    MNIST(Modified National Institute of Stands and Technology)是一个开源的数据集,包含了6万个手写数字图像,每个图像都是28×28的黑底白字。有了这个开源数据集,我们可以训练一个识别手写数字的AI模型,这个练习被称为AI领域的"Hello, world"。

    编写AI模型

    要编写这个AI模型,我们需要使用一种称为卷积神经网络(CNN)的神经网络结构,具体到代码层面,我们需要使用PyTorch这样的训练框架。PyTorch底层使用C++开发,外部用Python调用,非常方便易用。

    下面是一个简单的手写数字识别神经网络模型的Python代码示例:

    import torch.nn as nn
    
    class NeuralNetwork(nn.Module):
        def __init__(self):
            super().__init__()
            self.conv1 = nn.Conv2d(1, 32, 3, 1)
            self.conv2 = nn.Conv2d(32, 64, 3, 1)
            self.fc1 = nn.Linear(in_features=64 * 5 * 5, out_features=128)
            self.fc2 = nn.Linear(in_features=128, out_features=10)
    
        def forward(self, x):
            x = nn.functional.relu(self.conv1(x))
            x = nn.functional.max_pool2d(x, kernel_size=2)
            x = nn.functional.relu(self.conv2(x))
            x = nn.functional.max_pool2d(x, kernel_size=2)
            x = x.view(-1, 64 * 5 * 5)
            x = nn.functional.relu(self.fc1(x))
            x = self.fc2(x)
            return x

    这个神经网络模型包含了两个卷积层和两个全连接层,用于输入1通道的手写数字图片,经过卷积、池化和全连接层后,输出10个数字的分类结果。

    训练AI模型

    接下来,我们需要使用MNIST数据集来训练这个模型。PyTorch框架已经集成了MNIST数据集,可以轻松地进行下载、加载和训练。

    以下是一个简单的AI模型训练的Python代码示例:

    from time import time
    
    import torch
    import torch.nn as nn
    import torch.optim as optim
    
    from torchvision import datasets
    from torch.utils.data import DataLoader
    from torchvision.transforms import ToTensor
    
    from model import NeuralNetwork  # 引用前面定义的神经网络模型
    
    # ...代码细节略...
    
    if __name__ == '__main__':
        main()

    这段代码完成了数据集的准备、模型的训练和模型的保存。训练结果表明,经过5轮训练,准确率可以达到99%以上。

    使用AI模型

    现在我们已经有了一个预训练的模型,可以用于手写数字识别。我们可以用实际的手写数字图片来测试模型。

    以下是一个用于测试AI模型的Python代码示例:

    import torch
    from torchvision import transforms
    
    from PIL import Image, ImageOps
    from model import NeuralNetwork  # 引用前面定义的神经网络模型
    
    # ...代码细节略...
    
    if __name__ == '__main__':
        main()

    这段代码实际上将输入的手写数字图片转换成模型可接受的参数,然后用模型进行识别,输出识别结果和概率。

    将AI模型产品化

    虽然我们已经有了预训练的模型,并且可以用于手写数字识别,但是要让用户能够方便地使用这个模型,我们需要进一步优化,至少需要提供一个用户界面。以下是一个简单的Web界面,允许用户在页面上用鼠标手写数字,然后通过API获取识别结果的示例:

    <!-- HTML代码 -->
    <!DOCTYPE html>
    <html>
    <head>
        <title>手写数字识别</title>
    </head>
    <body>
        <canvas id="drawing-canvas" width="200" height="200"></canvas>
        <button id="recognize-button">识别</button>
        <p id="result-text"></p>
    
        <script src="main.js"></script>
    </body>
    </html>
    // JavaScript代码(main.js文件)
    // ...代码细节略...
    # Python代码(Flask API
    
    服务)
    # ...代码细节略...

    这个简单的Web界面允许用户在画布上手写数字,然后点击“识别”按钮,通过API获取识别结果。

    思考

    AI模型和传统程序有哪些不同之处?让我们来总结一下:

    • 代码量:AI模型的代码相对较少,通常只有数十到数百行,而传统程序可能需要数千行甚至数十万行代码。

    • 输入参数:传统程序通常有较少的输入参数,例如用户注册信息,而AI模型的输入参数通常是复杂的图像、文本或数据。

    • 输出结果:传统程序的输出结果是精确的,而AI模型的输出是概率形式的,具有一定的不确定性。

    • 代码参数:传统程序的代码参数是由开发者硬编码的,而AI模型的参数是通过训练数据确定的,开发者无法事先知道每个参数的具体含义。

    • 执行层次:传统程序的执行路径复杂,需要经过多层函数调用,而AI模型通常只有几层网络。

    • 执行路径:传统程序的执行路径可以精确跟踪,而AI模型的执行路径无法事先确定,只能通过训练来评估。

    • 并行性:AI模型具有大规模的并行性,通常使用GPU进行加速,而传统程序的并行性较低。

    • 计算资源:AI模型主要依赖GPU进行计算,而传统程序主要依赖CPU。

    • 开发时间:传统程序的开发时间主要消耗在编写代码上,而AI模型的开发时间主要消耗在训练模型上。

    • 数据需求:AI模型需要大量的训练数据来调整模型参数,而传统程序主要依赖用户产生的数据。

    • 程序质量:传统程序的质量取决于设计架构和代码优化,而AI模型的质量取决于神经网络模型和训练数据的质量。

    总的来说,虽然AI模型的代码相对较少,但其复杂性在于模型参数的数量和训练过程的复杂性。AI模型是一种黑盒逻辑,输出结果具有一定的不确定性,需要通过训练和调整来提高准确性。与传统程序相比,AI模型更侧重于数据和模型的质量。

    结语

    尽管AI模型可能看起来复杂,但我们可以从零开始构建和训练一个小型的AI模型,以更好地理解其工作原理。AI时代已经到来,即使作为普通人,也有机会学习和应用AI知识,适应这个新时代的发展。

  • 家庭教育年金险:为子女未来的明天提前规划

    教育是每个家庭都关注的重要话题。我们都希望给孩子提供最好的教育,确保他们拥有光明的未来。然而,高昂的教育费用可能会成为父母的负担。在这篇文章中,我们将介绍一种智慧的方法——家庭教育年金险,它可以帮助父母提前规划子女的教育,让他们的未来更加光明。

    开篇故事:小明的教育之路

    小明是一个拥有可爱儿子的父亲。当他的儿子刚刚出生时,他就开始思考如何为孩子的教育未来提前做好准备。他听说了教育年金险这个概念,觉得这是一个理想的解决方案。于是,他购买了一份教育年金险产品,每年缴纳10万元,计划缴纳10年,总计缴纳100万元。

    这个教育年金险产品不仅为小明的儿子提供了保障,还为他提供了一份明智的财务规划。在这份保单下,小明的儿子将在未来的不同阶段获得教育金,帮助他顺利完成学业。最终,在30岁时,他的儿子将获得一笔可用于支付房贷等用途的一次性教育金,总计达到203万元。这笔资金将为孩子的未来提供坚实的支持,让他能够追求更广阔的梦想。

    了解教育年金险

    教育年金险,顾名思义,是一种专门用于子女教育的年金险。这种险种为父母提供了一个智能的方式,为孩子的教育未来提前规划财务。现在,让我们深入了解教育年金险的核心特点:

    1. 早规划,财富增值

    教育年金险适合父母为未成年子女购买。而且,越早购买,同样的保费下,由于累积时间长,最后收到的教育年金就越多。这意味着,通过提前规划,你可以为子女的未来财务提供更多的支持。

    2. 灵活的返还规则

    不同的教育年金产品具有不同的返还规则。有些产品没有高中阶段的教育金,而相应地,大学阶段的领取金额可能更高。因此,你可以根据家庭的实际情况选择适合的产品。这种灵活性让你能够根据孩子的年龄和需求来调整教育金的计划。

    3. 分阶段领取

    教育年金险的一个关键特点是按照子女的年龄分阶段领取教育金。通常,高中阶段每年领取4.5万元,大学阶段每年领取9万元,研究生阶段每年领取11万元。这种分阶段的领取有助于确保资金在关键时期得到充分利用,支持子女的学业。

    4. 一次性支付

    最后,教育年金险通常在子女的25到30岁之间结束。在这个时候,你的子女将获得一笔一次性教育金,可以用于未来的任何用途,例如支付房贷、创业或继续教育。这笔资金是一个重要的财务支持,为孩子的未来提供了更多的选择。

    如何选择适合的教育年金险产品?

    选择适合的教育年金险产品是一个关键的决策,它需要考虑多个因素。以下是一些指导原则,帮助你做出明智的选择:

    1. 早购买

    早规划是成功的关键。尽早购买教育年金险,可以让你在累积时间上获得更多的利益,为子女的教育提供更多的支持。不要等到孩子已经在学校了才考虑购买。

    2. 理解返还规则

    不同的教育年金产品具有不同的返还规则。仔细了解产品的细节,特别是分阶段领取的方式和一次性支付的时间。确保选择的产品与你的家庭需求相匹配。

    3. 财务规划

    在购买教育年金险之前,进行财务规划是很重要的。确定你可以承担的保费金额,以及计划的缴纳期限。这将有助于你选择合适的产品,并确保你的财务计划不受影响。

    1. 咨询专业人士

    最后,不要犹豫咨询专业人士,如保险顾问或理财规划师。他们可以为你提供有关不同教育年金险产品的建议,并帮助你制定符合你家庭需求的计划。

    小结

    教育年金险是为父母提供智能财务规划的重要工具,旨在为子女的教育未来提前做好准备。通过早规划、灵活的返还规则、分阶段领取和一次性支付,教育年金险为父母和子女提供了更多的选择和支持。选择适合的产品和计划是关键,因此务必进行充分的研究和咨询,确保你为子女的未来做出明智的决策。

    如果你也关心子女的教育未来,那么教育年金险可能是一个值得考虑的选择。通过这种智能的财务规划,你可以为孩子的明天提前规划,让他们的梦想更有可能实现。

  • 如何科学配置家庭资产,让钱为你工作

    你是否曾为如何合理配置家庭资产而烦恼?家庭资产配置是一个备受关注的话题,因为它直接关系到我们的财富保值和增值。今天,我将为你介绍一种科学的方法,让你的钱更高效地工作,同时降低风险。这个方法基于马科维茨的资产配置多元化理论,同时考虑了不同家庭情况的调整。

    开篇故事:小明的困惑

    小明是一个普通的上班族,他每月工资入账3万元。然而,他面临一个问题:除去日常开支和房贷,几乎没有结余,更别提家庭资产配置了。他感到困惑,不知道如何才能让自己的钱更好地工作。

    这是许多人都会面临的问题。然而,我们要明确一点,配置家庭资产的钱,并不是你挣的钱,而是结余的钱。结余等于收入减去支出。所以,小明的情况是,月收入3万元,日常开支1万元,房贷1万元,结余为1万元。因此,小明可以配置的家庭资产是结余的1万元,而不是整个3万元。如果你也面临类似的问题,记住,配置家庭资产的前提是要有结余,而不是只挣更多的钱。

    马科维茨的资产配置多元化理论

    在我们深入家庭资产配置的方法之前,让我们简要了解一下马科维茨的资产配置多元化理论。这个理论的核心思想是,通过将资产分散投资于不同的类别,可以降低风险,同时获得更稳定的回报。

    根据这个理论,我们可以将家庭资产分成以下四个基本部分,每个部分的资金分配比例可以根据家庭的实际情况进行调整:

    1. 要花的钱(10%)

    这部分资金用于应对短期生活费用,通常是3到6个月的生活费。这是你的紧急备用金,以防突发情况。

    2. 保命的钱(20%)

    这部分资金用于应对疾病和意外情况,可以通过购买意外险、医疗险、定寿险等专款专用产品来实现。目的是解决家庭突发的大开支,如医疗费用或意外损失。

    3. 生钱的钱(30%)

    这部分资金用于投资,包括股票、基金、房产等高风险高回报的资产。虽然它们可能带来较高的收益,但也伴随着较高的风险。

    4. 保本的钱(40%)

    这部分资金用于保本稳健升值,只能用于购买国债、寿险等稳定的投资产品。虽然不追求大幅升值,但它们在安全性和稳健性方面有着重要的作用。

    配置家庭资产的关键

    现在让我们更深入地了解如何配置家庭资产,并确保它为你工作,而不是仅仅积少成多。

    结余才是配置的资金

    再次强调,配置家庭资产的资金不是你挣的钱,而是结余的钱。结余等于你的收入减去支出。所以,无论你的收入多少,只有在有结余的情况下,才能进行家庭资产配置。如果你每月的支出和开销占据了全部收入,那么你无法配置家庭资产,因为没有可用的结余。

    灵活调整配置比例

    家庭资产配置的比例并不是一成不变的,可以根据家庭的实际情况进行调整。例如,如果你的公司提供了足够的医疗险和意外险,那么你可以在保命的钱上节省一些资金。另外,年轻时,你可以多配置一些生钱的钱,而年纪大了,就可以增加保本的钱的比例。合理的配置可以根据家庭需要进行灵活调整,以满足不同阶段的需求。

    高风险投资和保本的钱互补

    高风险投资和保本的钱并不是相互竞争的,而是相互互补的关系。高风险投资可以带来潜在的高回报,但伴随着较高的风险。而保本的钱虽然回报相对较低,但它们在保值和稳健方面表现出色。关键在于,这些资金都应该来自你的结余。

    避免一把梭的风险

    很多人犯了一个常见的错误,把家庭所有的钱都投入高风

    险的资产,如股票市场。当突发状况需要一大笔钱时,他们可能被迫在股市处于低谷时卖出资产。尽管几年后股市可能会涨回来,但这个人已经不在投资市场上了,因为他已经把自己的积蓄全部用掉了。

    这种情况的根本原因在于没有合理隔离高风险投资和保本、保命的钱。因此,要以长期稳定的心态进行高风险投资,首先要规划好保本和保命的钱。这样,在高风险资产波动时,你不需要动用家庭储蓄,能够更好地应对市场的起伏,穿越牛市和熊市。

    注意场外杠杆的风险

    最后,我要提醒大家,避免使用场外杠杆,特别是在高风险投资中。场外杠杆包括借钱、信用卡套现、抵押房产、小额贷款等形式的借贷。这些杠杆可以放大盈利,但也可能导致本金损失。一旦爆仓,场外杠杆不仅会亏掉未来的收入,甚至可能对未来的生活造成严重影响。

    小结

    家庭资产配置的目的是在保护家庭免受意外风险的前提下,规划好要花的钱、保命的钱、生钱的钱和保本的钱,以实现财富的稳健增长。不要将保本的钱(如国债、保险等)与生钱的钱(如股票、基金等)进行收益率比较,因为它们的目标和风险完全不同。最重要的是,要确保高风险投资和保本、保命的钱来自你的结余,避免使用场外杠杆。

    在配置家庭资产时,要根据自己的情况进行合理的分配,保持冷静的头脑,不要像赌徒一样孤注一掷。只有通过科学的方法和合理的规划,才能让你的钱更好地为你工作,实现财务自由。

    希望这篇文章对你有所启发,让你更好地理解家庭资产配置的重要性和方法。如果你有任何疑问或想分享你的经验,欢迎在下方留言,让我们一起探讨这个话题。

  • 打造安全的网站加密教程:使用webDES保护你的数据

    你是否曾经想过,如何在自己的网站上确保用户的数据安全?随着网络犯罪的不断增加,网站安全性已经成为一个至关重要的问题。今天,我们将介绍一种强大的数据加密工具——webDES,它可以帮助你保护用户的敏感信息。无论你是一个网站管理员还是一个开发者,这篇文章都将帮助你了解如何使用webDES增强你的网站安全性。

    故事开篇

    在数字时代,数据就像是黄金一样宝贵。让我们来看一个真实的故事,以彰显数据安全的重要性。

    故事开始于一位名叫小明的年轻开发者,他决定创建一个在线商店,以销售手工制作的艺术品。他积极投入工作,网站很快就开始吸引了许多访问者。然而,小明很快就发现,一些用户的个人信息被黑客盗取了,他的声誉也受到了损害。

    这个故事告诉我们一个重要的教训:无论你的网站规模大小,保护用户数据都是至关重要的。而webDES将成为你实现这一目标的得力工具。

    什么是webDES?

    WebDES是一个用于数据加密的JavaScript库。它采用了DES(数据加密标准)算法,这是一种广泛使用的对称密钥加密算法。DES的强大之处在于它可以有效地保护数据免受黑客和恶意攻击者的侵害。

    为什么选择webDES?

    • 安全性: webDES使用DES算法,提供了强大的数据加密保护,确保用户数据不会轻易泄漏。

    • 易于使用: webDES库设计简单,易于集成到任何网站或应用程序中。

    • 广泛支持: 无论是前端还是后端,webDES都有相应的支持和文档,确保你能够轻松上手。

    • 开源: webDES是一个开源项目,拥有强大的社区支持,你可以随时查阅源代码和文档。

    如何使用webDES?

    现在让我们深入了解如何在你的网站中使用webDES来保护用户数据。以下是一些基本步骤:

    步骤1: 引入webDES库

    首先,你需要在你的网站中引入webDES库。你可以通过将以下代码添加到你的HTML文件中来实现:

    <script src="webDES.js"></script>

    步骤2: 创建webDES实例

    一旦你引入了webDES库,你就可以创建一个webDES实例,如下所示:

    var webInstance = new webDES();

    步骤3: 加密数据

    现在,你可以使用webDES来加密用户的敏感数据。假设你有一个用户的密码需要加密,你可以使用以下代码:

    var encryptedPassword = webInstance.encrypt('user_password');

    步骤4: 解密数据

    如果需要访问加密后的数据,你可以使用webDES来解密它,如下所示:

    var decryptedPassword = webInstance.decrypt(encryptedPassword);

    webDES的安全性探讨

    虽然webDES提供了强大的数据加密保护,但也有一些注意事项需要考虑:

    • 密钥管理: 确保你的加密密钥是安全的,不要将其硬编码在代码中。

    • 更新: 定期更新webDES库以确保你使用的是最新版本,以修复潜在的安全漏洞。

    • 监控: 使用日志和监控工具来检测潜在的攻击和异常活动。

    结语

    在这个数字化的时代,网站安全性至关重要。使用webDES,你可以轻松地加密和保护用户的数据,确保他们的隐私不会受到侵犯。无论你是一个网站管理员还是一个开发者,都可以受益于这个强大的工具。

    希望这篇文章对你有所帮助,让你更好地保护你的网站和用户数据。如果你有任何疑问或需要进一步的指导,请随时联系我们。

    不管你是一个网站管理员还是一个开发者,都可以通过webDES来保护你的用户数据。这个简单但强大的工具可以确保你的网站免受黑客的侵害,为用户提供更安全的在线体验。试试吧,让你的网站更加安全!

  • 使用Python下载并合并M3U8视频

    在互联网时代,视频内容丰富多样,M3U8是一种常见的视频流媒体格式,例如在线直播、视频网站等。有时候,我们可能想要下载并保存这些M3U8格式的视频供离线观看,或者进行其他处理。本教程将向你展示如何使用Python编写一个脚本,来下载M3U8格式的视频,并将分散的TS文件合并成一个完整的视频文件。

    步骤 1:导入必要的库

    首先,我们需要导入一些Python库,以便后续的操作。我们将使用os.path来处理文件路径,urllib.parse来处理URL,asyncioaiohttp来进行异步操作,以及re来进行正则表达式匹配。

    import os.path
    import urllib.parse
    import asyncio
    import aiohttp
    import re

    步骤 2:设置请求头和目标URL

    在下载M3U8视频时,我们通常需要设置一些请求头,以模拟正常的浏览器请求,避免被网站屏蔽或限制。同时,我们需要指定要下载的M3U8视频的目标URL。

    path = 'ts'  # 保存TS文件的目录
    url = 'https://www.99meijutt.com/play/102788-1-0.html'  # 目标M3U8视频的URL
    
    headers = {
        'User-Agent':
            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36'
    }

    步骤 3:定义全局变量和函数

    我们需要定义一些全局变量,以及一些异步函数,来实现M3U8视频的下载和合并。这些函数包括:

    • get_url(url):获取M3U8文件的URL。
    • get_m3u8url(url_m3u8):获取M3U8文件的完整URL。
    • get_tsurl(url2, base_url):获取TS文件的URL,并下载到本地。
    • download(full_ts_url, i):下载TS文件。
    • merge(filename):合并TS文件成为完整的视频。

    步骤 4:主函数

    最后,我们定义了一个main函数,来组织整个下载和合并的过程。在main函数中,我们按照以下步骤执行:

    1. 获取第一次的URL。
    2. 获取M3U8文件的URL。
    3. 获取TS文件的URL并下载。
    4. 并发下载TS文件。
    5. 合并TS文件成为一个完整的视频文件。

    结语

    通过这个Python脚本,你可以轻松地下载并合并M3U8格式的视频,而无需手动一个一个地下载和合并TS文件。这个技巧对于那些希望保存在线视频供离线观看的人来说非常有用。希望这篇教程对你有所帮助,让你更好地利用Python来处理和下载在线视频!

    通过本教程,你已经学会了如何使用Python编写一个脚本,下载和合并M3U8格式的视频文件。这个技巧对于那些希望保存在线视频供离线观看的人来说非常有用。无论是观看在线直播、保存在线视频,还是进行其他视频处理,Python都可以为你提供强大的自动化工具,希望你能充分利用这个方法,让视频处理变得更加轻松愉快!

  • 教程:使用Python自动分类整理照片

    作为一个热爱摄影的摄影师或者只是一个热爱拍照的普通人,你的电脑可能积累了大量的照片。这些照片散落在各个文件夹中,有时候你可能会感到疑惑,不知道应该如何将它们有序地整理起来。手动分类和整理这些照片是一项耗时耗力的工作,但好在有Python这个强大的工具,可以帮助你自动化这一过程。在本教程中,我将向你展示如何使用Python编写一个脚本,自动分类整理你的照片。

    步骤 1:导入必要的库

    首先,我们需要导入一些Python库,以便后续的操作。我们将使用os库来处理文件和文件夹,使用re库来进行正则表达式匹配,以及使用shutil库来移动文件。

    import os
    import re
    import os.path as osp
    import shutil

    步骤 2:设置正则表达式

    我们将使用正则表达式来匹配文件名,以便筛选出照片文件。在本例中,我们希望筛选出以.jpg结尾的文件,因此设置了一个正则表达式。

    reg = re.compile(r'.*(.jpg)$')  # 以jpg结尾匹配照片

    步骤 3:获取照片文件路径列表

    接下来,我们需要获取当前工作路径下所有照片文件的绝对路径,并将它们存放在一个列表内。以下是获取文件路径列表的代码:

    def file_path():
        """
        获取当前工作路径下所有照片绝对路径,并存放在一个列表内
        """
        file_path = []  # 照片文件路径列表
        filenames = os.listdir(path)  # 获取当前文件夹下的所有文件名
        list_j = [osp.join(path, x) for x in filenames if osp.isfile(osp.join(path, x))
                  if reg.findall(x)]  # 获取照片的文件名,并拼接完整路径
        for s in list_j:
            if s:  # 非空
                file_path.append(s)
    
        # 根据文件名中的时间排序
        file_path.sort(key=lambda x: osp.basename(osp.splitext(x)[0])[8:19], reverse=False)
    
        return file_path

    这段代码首先使用os.listdir函数获取当前工作路径下的所有文件名,然后通过正则表达式筛选出以.jpg结尾的文件,并将它们的绝对路径存放在file_path列表中。最后,我们对文件路径列表进行排序,以确保照片按照时间顺序排列。

    步骤 4:分类和整理照片

    现在,我们将编写代码来自动分类和整理照片。用户可以输入要创建的文件夹名称和每个文件夹应包含的照片数量。脚本将按照用户的要求创建文件夹,并将照片移动到相应的文件夹中。

    def fenlei():
        while True:
            summ = 0
            dic = {}
            lit = []
            resm = len(file_path())
            name = input("请输入要创建的文件夹名称:")
            if not name:
                break
            else:
                num = int(input("请输入照片数量:"))
                summ += num  # 分配照片数量
                resm -= num  # 剩余照片数量
                if not num:
                    break
                else:
                    print(f'此文件夹共分配{summ}张照片', f"{f'还剩{resm}张照片待分配':.^30}")
                    for i in range(summ):
                        lit.append(file_path()[i])
                        dic[name] = lit
    
            new_path = osp.join(path, name)
            if not osp.exists(new_path):
                os.mkdir(new_path)
            for file in lit:
                shutil.move(file, new_path)
    
            print()
            sr = input("是否继续创建文件夹?(y/n): ")
            if sr == "y":
                continue
            else:
                src = osp.basename(path) + "-已分类"
                dst = osp.join(osp.dirname(path), src)
                os.rename(path, dst)  # 重命名已分类
                print(f"{'照片已全部分好':.^34}")
                break

    这段代码实现了一个循环,让用户可以连续创建多个文件夹并分配照片。用户需要输入文件夹名称和照片数量。脚本将根据用户的输入创建文件夹,并将照片移动到相应的文件夹中。用户可以选择继续创建文件夹或退出。

    结语

    通过本教程,你已经学会了如何使用Python编写一个简单的脚本,用于自动分类和整理照片。这个技巧可以帮助你节省时间,使文件整理变得更加高效。无论是整理照片还是其他类型的文件,Python都可以为你提供强大的自动化工具,希望你能充分利用这个方法,让文件整理变得轻松愉快!

  • 如何使用Python爬取豆瓣电影Top250的电影海报

    作为一位电影爱好者,你可能经常关注豆瓣电影上的Top250电影榜单,想要了解哪些电影备受推崇。而且,你可能也希望将一些你喜欢的电影的海报保存下来,以便日后欣赏或分享。但是,手动一个一个点击电影,然后下载海报显然是一项枯燥的任务。

    好在有Python这个强大的工具,你可以编写一个简单的脚本,自动爬取豆瓣电影Top250的电影海报,将它们保存到你的电脑上。这不仅能够省时省力,还能够让你一次性获取所有电影的海报。接下来,我将向你展示如何使用Python来实现这一目标。

    步骤 1:导入必要的库

    首先,我们需要导入一些Python库,以便后续的操作。我们将使用requests库来发送HTTP请求,以获取豆瓣电影Top250的页面内容。此外,我们还将使用正则表达式(re库)来从页面中提取电影海报的信息。

    import requests
    import re

    步骤 2:设置请求头

    在发送HTTP请求之前,我们需要设置一些请求头,以模拟浏览器的请求,避免被豆瓣服务器拒绝访问。这是一种常见的做法,以确保我们的爬虫行为合法且不会被阻止。

    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36 Edg/115.0.1901.188"
    }

    步骤 3:爬取豆瓣电影Top250页面

    接下来,我们将编写代码来发送HTTP请求,获取豆瓣电影Top250的页面内容。豆瓣电影Top250的页面URL中包含了不同页数的数据,我们可以通过循环来遍历多个页面,获取更多电影信息。

    for i in range(0, 226, 25):
        url = f"https://movie.douban.com/top250?start={i}&filter="
        response = requests.get(url, headers=headers)

    在这个示例中,我们使用range函数生成了一系列不同页数的URL,每页包含25部电影。通过循环,我们可以逐页获取电影信息。

    步骤 4:使用正则表达式提取电影海报信息

    豆瓣电影Top250页面中包含了电影的信息,其中包括电影的海报URL。我们可以使用正则表达式来提取这些URL。以下是提取电影海报URL的代码示例:

    a = re.findall("<img width=\"100\" alt=\"(.*?)\"", response.text, re.S)
    for vbn in a:
        print(vbn)

    在这段代码中,我们使用re.findall函数来查找页面中与正则表达式"<img width=\"100\" alt=\"(.*?)\""匹配的内容。这个正则表达式用于匹配电影海报的URL。然后,我们将提取到的海报URL打印出来。

    完整代码

    下面是整个爬取豆瓣电影Top250电影海报的完整代码:

    import requests
    import re
    
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36 Edg/115.0.1901.188"
    }
    
    for i in range(0, 226, 25):
        url = f"https://movie.douban.com/top250?start={i}&filter="
        response = requests.get(url, headers=headers)
        a = re.findall("<img width=\"100\" alt=\"(.*?)\"", response.text, re.S)
        for vbn in a:
            print(vbn)

    结语

    通过这个简单的Python脚本,你可以轻松地爬取豆瓣电影Top250的电影海报信息,而不需要手动一个一个点击下载。这个技巧不仅可以用于获取电影海报,还可以用于爬取其他类型的信息,只需稍作修改即可。

    通过本教程,你已经学会了如何使用Python编写一个简单的爬虫脚本,用于获取豆瓣电影Top250的电影海报信息。这个技巧可以帮助你节省时间,快速获取感兴趣的电影海报,同时也是学习Python网络爬虫的一个有趣的项目。希望你能够充分利用这个方法,获取更多有用的数据!

  • 自动获取Steam限时免费游戏信息并实时推送教程

    假设你是一位热爱玩游戏的玩家,而且还热衷于追踪Steam平台上的限时免费游戏优惠。你不想错过任何一个免费游戏的机会,因此你希望能够及时获取到这些信息,并在游戏免费期间立刻领取。但是,为了获取这些信息,你不得不经常访问Steam网站,查找相关页面,非常繁琐。那么,有没有一种方法可以自动获取Steam限时免费游戏信息,并实时推送给你呢?

    幸运的是,我们可以使用Python来实现这个目标。本教程将教你如何编写一个Python脚本,可以自动爬取Steam网站上的限时免费游戏信息,并通过消息推送的方式将这些信息实时发送给你,以便你不会错过任何一个免费游戏的机会。

    步骤 1:导入必要的库

    首先,我们需要导入一些Python库,以便后续的操作。我们将使用requests库来发送HTTP请求,以获取Steam网站的页面内容。此外,我们还将使用BeautifulSoup库来解析HTML页面。

    import requests
    from bs4 import BeautifulSoup

    步骤 2:定义消息推送函数

    在这个步骤中,我们将定义一个消息推送函数,用于将限时免费游戏的信息发送给你。在本例中,我们将使用PUSHPLUS来实现消息推送。你需要注册一个PUSHPLUS账户,并创建一个推送通道,以获取一个Token。将这个Token替换为下面代码中的your_token

    def pushplus(_item, _message):
        token = 'your_token_here'  # 替换为你的PUSHPLUS Token
        api = 'http://www.pushplus.plus/send'
        _d = {
            "token": token,
            "title": _item,
            "content": _message
        }
        req = requests.post(api, data=_d)

    步骤 3:爬取Steam限时免费游戏信息

    接下来,我们将编写代码来爬取Steam网站上的限时免费游戏信息。我们将使用steamstats.cn这个网站作为示例,该网站提供了Steam限时免费游戏的信息。

    url = 'https://steamstats.cn/xi'
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.72 Safari/537.36 Edg/90.0.818.41'
    }
    
    r = requests.get(url, headers=headers)
    r.raise_for_status()
    r.encoding = r.apparent_encoding
    soup = BeautifulSoup(r.text, "html.parser")
    tbody = soup.find('tbody')

    在这个代码段中,我们首先指定了Steam限时免费游戏信息的URL,并设置了请求头,以模拟浏览器发送请求。然后,我们使用requests库发送HTTP GET请求,并获取响应内容。接下来,我们使用BeautifulSoup库将HTML页面解析为一个树状结构,并找到包含游戏信息的<tbody>标签。

    步骤 4:解析游戏信息并推送消息

    现在,我们已经找到了包含限时免费游戏信息的HTML元素,接下来需要解析这些信息并将其推送给你。

    desp = "?当前可领限时免费游戏?" + '\n'
    if tbody is not None:
        tr = tbody.find_all('tr')
        i = 1
        for tr in tr:
            # 解析每一行游戏信息
            td = tr.find_all('td')
            name = td[1].string.strip().replace('\n', '').replace('\r', '')
            gametype = td[2].string.replace(" ", "").replace('\n', '').replace('\r', '')
            start = td[3].string.replace(" ", "").replace('\n', '').replace('\r', '')
            end = td[4].string.replace(" ", "").replace('\n', '').replace('\r', '')
            time = td[5].string.replace(" ", "").replace('\n', '').replace('\r', '')
            oringin = td[6].find('span').string.replace(" ", "").replace('\n', '').replace('\r', '')
            sp = str(td[6]).split('"')
            http = sp[3]
    
            # 构建游戏信息字符串
            desp = desp + "序号:" + str(i) + '\n' + "游戏名称:" + name + '\n' + "类型:" + gametype + '\n' + "开始时间:" + start + '\n' + "结束时间:" + end + '\n' + "是否永久:" + time + '\n' + "平台:" + oringin + '\n' + "链接:" + http + '\n'
            i = i + 1
        else:
            desp = desp + "无"

    在这个代码段中,我们遍历了每一行限时免费游戏的信息,并使用BeautifulSoup提供的方法解析每个单元格的内容。然后,我们构建了一个包含游戏信息的字符串desp

    步骤 5:消息推送

    最后,我们调用之前定义的pushplus函数,将限时免费游戏的信息推送给你。

    pushplus("?今日喜加一?", desp)

    完整代码

    下面是整个自动获取Steam限时免费游戏信息并实时推送的代码的完整版:

    import requests
    from bs4 import BeautifulSoup
    
    def pushplus(_item, _message):
        token = 'your_token
    
    _here'  # 替换为你的PUSHPLUS Token
        api = 'http://www.pushplus.plus/send'
        _d = {
            "token": token,
            "title": _item,
            "content": _message
        }
        req = requests.post(api, data=_d)
    
    url = 'https://steamstats.cn/xi'
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.72 Safari/537.36 Edg/90.0.818.41'
    }
    
    r = requests.get(url, headers=headers)
    r.raise_for_status()
    r.encoding = r.apparent_encoding
    soup = BeautifulSoup(r.text, "html.parser")
    tbody = soup.find('tbody')
    
    desp = "?当前可领限时免费游戏?" + '\n'
    if tbody is not None:
        tr = tbody.find_all('tr')
        i = 1
        for tr in tr:
            # 解析每一行游戏信息
            td = tr.find_all('td')
            name = td[1].string.strip().replace('\n', '').replace('\r', '')
            gametype = td[2].string.replace(" ", "").replace('\n', '').replace('\r', '')
            start = td[3].string.replace(" ", "").replace('\n', '').replace('\r', '')
            end = td[4].string.replace(" ", "").replace('\n', '').replace('\r', '')
            time = td[5].string.replace(" ", "").replace('\n', '').replace('\r', '')
            oringin = td[6].find('span').string.replace(" ", "").replace('\n', '').replace('\r', '')
            sp = str(td[6]).split('"')
            http = sp[3]
    
            # 构建游戏信息字符串
            desp = desp + "序号:" + str(i) + '\n' + "游戏名称:" + name + '\n' + "类型:" + gametype + '\n' + "开始时间:" + start + '\n' + "结束时间:" + end + '\n' + "是否永久:" + time + '\n' + "平台:" + oringin + '\n' + "链接:" + http + '\n'
            i = i + 1
        else:
            desp = desp + "无"
    
    pushplus("?今日喜加一?", desp)

    结语

    通过这个自动获取Steam限时免费游戏信息并实时推送的Python脚本,你可以轻松地获取最新的游戏优惠信息,并确保不错过任何一个免费游戏的机会。这个脚本展示了如何使用Python的requests库和BeautifulSoup库来爬取网页内容,以及如何使用消息推送服务将信息实时发送给你。

    通过本教程,你已经学会了如何使用Python编写一个自动获取Steam限时免费游戏信息并实时推送的脚本。这个技巧不仅对游戏爱好者有用,还可以作为学习Python网络爬虫和消息推送的一个实际项目。希望你能够充分利用这个方法,及时获取到最新的游戏优惠信息!

  • 为你的Python项目自动安装依赖库:让你的代码自己动手装

    你是否曾经遇到过这样的情况:你在开发一个Python项目,但是随着项目的增长,你需要不断地添加新的依赖库(也就是Python的第三方模块),以便实现各种功能。当你将你的项目分享给其他人或部署到不同的环境时,你必须确保这些依赖库也已经安装,否则你的代码将无法正常运行。

    有一天,你决定分享你的项目给一个朋友,你很自信地告诉他只需运行你的代码,一切都会自动完成。但是,当你的朋友尝试运行代码时,却发现他必须手动安装一大堆依赖库,这让整个过程变得相当繁琐。你感到有点尴尬,因为你之前并没有考虑到这个问题。

    现在,让我们来解决这个问题。我将向你介绍一个简单而有效的方法,可以自动检测和安装Python项目所需的依赖库。这将使你的项目更加用户友好,减少了其他人使用你的代码时的不便。

    如何解决这个问题?

    解决这个问题的思路非常简单:我们可以编写一个Python脚本,让它扫描你的项目代码,找出项目中所使用的所有依赖库,并自动安装这些依赖库。这样,当其他人或你自己需要运行项目时,只需运行这个脚本,所有依赖库都会被自动安装,而无需手动操作。

    下面,我将向你介绍如何编写这个依赖库自动安装脚本,并将其分为几个步骤。

    步骤 1:寻找项目中的Python文件

    首先,我们需要找到你的项目中的所有Python文件。这些文件包括.py和.pyw文件,它们是Python代码的扩展名。

    import os
    
    def dir_files(directory, extension):
        """遍历目录内指定后缀"""
        file_list = []
        for root, dirs, files in os.walk(directory):
            for file in files:
                if file.endswith(extension):
                    if "tempCodeRunnerFile" not in file:  # CodeRunner生成的临时文件忽略掉
                        file_list.append(os.path.join(root, file))
        return file_list
    
    # 指定项目文件夹路径
    python_file_folders = [r"E:\Backup\脚本", r"E:\管理系统", r"E:\桌面文件"]
    
    # 查找项目中的Python文件
    python_files = []
    for folder in python_file_folders:
        python_files += dir_files(folder, ".py") + dir_files(folder, ".pyw")
    
    print("找到的Python文件:", python_files)

    在这个步骤中,我们使用了os库的os.walk函数来遍历指定目录下的所有文件和子目录。然后,我们筛选出扩展名为.py和.pyw的文件,并将它们的路径存储在python_files列表中。

    步骤 2:解析Python文件中的依赖库

    接下来,我们需要分析每个Python文件,找出它们所导入的依赖库。我们将使用Python的ast(抽象语法树)模块来解析代码文件。

    import ast
    
    def parse_imports(filename):
        """解析python源文件import了哪些库"""
        with open(filename, "r", encoding="utf-8") as f:
            tree = ast.parse(f.read())
        imports = set()
        for node in ast.iter_child_nodes(tree):
            if isinstance(node, ast.Import):
                for alias in node.names:
                    imports.add(alias.name.split(".")[0])
            elif isinstance(node, ast.ImportFrom):
                module_name = node.module.split(".")[0] if node.module else ""
                for alias in node.names:
                    imports.add(module_name + "." + alias.name.split(".")[0])
    
        return list(imports)
    
    # 解析Python文件中的依赖库
    all_imports = []
    for python_file in python_files:
        imports = parse_imports(python_file)
        all_imports += [library.split(".")[0] for library in imports]
    
    print("项目中使用的依赖库:", all_imports)

    在这个步骤中,我们首先打开每个Python文件,然后使用ast.parse函数将其内容解析为抽象语法树。接下来,我们遍历抽象语法树,找出所有的ImportImportFrom节点,这些节点包含了导入的依赖库信息。最后,我们将依赖库的名称提取出来,并存储在all_imports列表中。

    步骤 3:自动安装依赖库

    现在,我们已经知道了项目中使用的所有依赖库,接下来就是自动安装它们。我们可以使用Python的subprocess库来执行pip install命令,以安装这些依赖库。

    import subprocess
    
    def pip_install(libraries):
        """判断是否安装了库 没有就直接pip安装"""
        for library in libraries:
            library = library.split(".")[0]
            try:
                __import__(library)
            except ImportError:
                print(f"{library} 没有安装,正在使用pip安装...")
                subprocess.call(["pip", "install", library])
    
    # 自动安装依赖库
    if all_imports:
        imports = set(all_imports)
        pip_install(imports)

    在这个步骤中,我们定义了一个pip_install函数,它会检查每个依赖库是否已经安装,如果没有安装就使用subprocess.call来执行pip install命令进行安装。

    整脚本

    下面是整个自动安装依赖库的脚本的完整代码:

    import os
    import ast
    import subprocess
    
    def dir_files(directory, extension):
        """遍历目录内指定后缀"""
        file_list = []
        for root, dirs, files in os.walk(directory):
            for file in files:
                if file.endswith(extension):
                    if "tempCodeRunnerFile" not in file:  # CodeRunner生成的临时文件忽略掉
                        file_list.append(os.path.join(root, file))
        return file_list
    
    def parse_imports(filename):
        """解析python源文件import了哪些库"""
        with open(filename, "r", encoding="utf-8") as f:
            tree = ast.parse(f.read())
        imports = set()
        for node in ast.iter_child_nodes(tree):
            if isinstance(node, ast.Import):
                for alias in node.names:
                    imports.add(alias.name.split(".")[0])
            elif isinstance(node, ast.ImportFrom):
                module_name = node.module.split(".")[0] if node.module else ""
                for alias in node.names:
                    imports.add(module_name + "." + alias.name.split(".")[0])
    
        return list(imports)
    
    def pip_install(libraries):
        """判断是否安装了库 没有就直接pip安装"""
        for library in libraries:
            library = library.split(".")[0]
            try:
                __import__(library)
            except ImportError:
                print(f"{library} 没有安装,正在使用pip安装...")
                subprocess.call(["pip", "install", library])
    
    if __name__ == "__main__":
        # 指定项目文件夹路径
        python_file_folders = [r"E:\Backup\脚本", r"E:\管理系统", r"E:\桌面文件"]
    
        # 查找项目中的Python文件
        python_files = []
        for folder in python_file_folders:
            python_files += dir_files(folder, ".py") + dir_files(folder, ".pyw")
    
        print("找到的Python文件:", python_files)
    
        # 解析Python文件中的依赖库
        all_imports = []
        for python_file in python_files:
            imports = parse_imports(python_file)
            all_imports += [library.split(".")[0] for library in imports]
    
        print("项目中使用的依赖库:", all_imports)
    
        # 自动安装依赖库
        if all_imports:
            imports = set(all_imports)
            pip_install(imports)

    结语

    通过这个简单的自动安装依赖库的脚本,你可以使你的Python项目更加易于分享和部署。不再需要手动安装依赖库,只需运行这个脚本,一切都会自动完成。这不仅提高了代码的可移植性,还可以减少其他人或你自己在使用你的代码时的不便。

    希望这篇教程对你有所帮助,让你的Python项目更加智能化,让代码自己动手装依赖库!

  • 自动学籍照片裁剪工具:一键裁剪满足规格的学籍照片

    学校、培训机构、教育部门等经常需要处理大量学生或员工的学籍照片。这些照片通常需要符合特定的规格,包括尺寸和头像的居中等要求。手动裁剪这些照片是一项繁琐的任务,但我们可以使用Python编写一个自动化工具来简化这个过程。在本教程中,我们将介绍如何使用Python和一些强大的图像处理库来创建一个自动学籍照片裁剪工具。

    开篇故事

    假设你是一名学校管理员,你每年都需要处理大批学生的学籍照片。这些照片来自各种来源,尺寸和质量各不相同。你发现手动裁剪这些照片非常费时费力,而且容易出错。你希望有一种简单的方式来自动化这个任务,以节省时间和精力。好在你学习了Python编程,你决定创建一个自动学籍照片裁剪工具,让这项任务变得轻松而高效。

    准备工作

    在开始编写代码之前,我们需要准备一些工具和库。首先,确保你已经安装了Python。此外,我们将使用以下库来完成这个项目:

    • OpenCV:一个强大的计算机视觉库,用于图像处理。
    • dlib:一个机器学习工具包,包含了人脸检测器。

    你可以使用以下命令来安装这些库:

    pip install opencv-python
    pip install dlib

    还需要准备一些学籍照片,放在一个文件夹中,以便后续处理。确保这些照片具有不同的尺寸和质量,以模拟实际情况。

    项目概览

    我们的自动学籍照片裁剪工具将具备以下功能:

    1. 自动检测学籍照片中的人脸。
    2. 以检测到的人脸为中心,将照片裁剪成规定尺寸的半身照片。
    3. 保存裁剪后的照片到指定文件夹。

    现在,让我们逐步创建这个工具。

    步骤 1:导入所需库

    首先,我们需要导入所需的Python库。这些库包括OpenCV、dlib和os。

    import cv2
    import dlib
    import os

    步骤 2:定义人脸检测和裁剪函数

    我们将创建一个函数来执行人脸检测和裁剪。该函数将接受输入照片的路径、输出照片的路径、目标尺寸和延伸比例作为参数。延伸比例用于确定裁剪框的大小,以便获得半身照片。

    def detect_face_and_half_body(input_image_path, output_image_path, target_size=(260, 320), extend_ratio=1.0):
        # 使用OpenCV加载图像
        image = cv2.imread(input_image_path)
    
        # 将图像转换为灰度图像,以加快人脸检测速度
        gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    
        # 从Dlib加载人脸检测器模型
        face_detector = dlib.get_frontal_face_detector()
    
        # 在图像中检测人脸
        faces = face_detector(gray_image)
    
        if len(faces) > 0:
            # 假设图像中只有一个人脸(你可以修改代码来处理多个人脸)
            face = faces[0]
    
            # 获取人脸的边界框坐标
            x, y, w, h = face.left(), face.top(), face.width(), face.height()
    
            # 计算人脸的中心点
            center_x = x + w // 2
            center_y = y + h // 2
    
            # 计算
    
    半身图像的裁剪区域的坐标
            crop_width = int(w * (1 + extend_ratio))
            crop_height = int(h * (1 + extend_ratio))
            crop_x1 = max(0, center_x - crop_width // 2)
            crop_y1 = max(0, center_y - crop_height // 2)
            crop_x2 = min(center_x + crop_width // 2, image.shape[1])
            crop_y2 = min(center_y + crop_height // 2, image.shape[0])
    
            # 裁剪图像以获取半身图像
            half_body_image = image[crop_y1:crop_y2, crop_x1:crop_x2]
    
            # 将半身图像调整到目标尺寸
            resized_image = cv2.resize(half_body_image, target_size, interpolation=cv2.INTER_AREA)
    
            # 保存调整后的图像
            cv2.imwrite(output_image_path, resized_image)
    
            print(f"检测到人脸,半身图像已保存:{output_image_path}")
        else:
            print(f"未在图像中检测到人脸:{input_image_path}")

    在这个函数中,我们首先加载输入图像并将其转换为灰度图像,以加快人脸检测速度。然后,我们使用Dlib库中的人脸检测器来检测图像中的人脸。

    如果检测到人脸,我们假设图像中只有一个人脸,并计算出人脸的位置和大小。接下来,我们根据延伸比例计算出半身图像的裁剪区域,并将图像裁剪到这个区域。最后,我们将裁剪后的图像调整到目标尺寸并保存到指定的输出路径。

    步骤 3:批量处理照片

    现在我们已经定义了单张照片的处理函数,接下来我们将创建一个函数来批量处理一个文件夹中的所有照片。

    def batch_detect_face_and_half_body(input_folder, output_folder, target_size=(260, 320), extend_ratio=1.0):
        if not os.path.exists(output_folder):
            os.makedirs(output_folder)
    
        for filename in os.listdir(input_folder):
            if filename.lower().endswith(('.png', '.jpg', '.jpeg', '.gif')):
                input_image_path = os.path.join(input_folder, filename)
                output_image_path = os.path.join(output_folder, filename)
                detect_face_and_half_body(input_image_path, output_image_path, target_size, extend_ratio)

    这个函数将遍历输入文件夹中的所有照片文件,并调用我们之前定义的处理函数来处理每张照片。处理后的照片将保存在输出文件夹中。

    步骤 4:运行自动裁剪工具

    现在,我们已经完成了自动学籍照片裁剪工具的编写。要使用这个工具,只需调用batch_detect_face_and_half_body函数,并提供输入文件夹、输出文件夹、目标尺寸和延伸比例作为参数。

    if __name__ == "__main__":
        input_folder = "输入文件夹路径"  # 替换为你的输入文件夹路径
        output_folder = "输出文件夹路径"  # 替换为你的输出文件夹路径
        target_size = (260, 320)
        extend_ratio = 2.0  # 增大extend_ratio以获得更大范围的半身图像
    
        batch_detect_face_and_half_body(input_folder, output_folder, target_size, extend_ratio)

    现在你可以运行这个脚本,它将自动处理输入文件夹中的所有照片,并将裁剪后的照片保存在输出文件夹中。

    结语

    通过这个自动学籍照片裁剪工具,你可以轻松地处理大批学籍照片,确保它们符合规定的尺寸和格式。这个工具可以节省大量时间和精力,特别是在处理大量照片时。希望这个项目对你有所帮助,让你的工作更加高效!