大神网

Tag: Python

  • 如何使用OpenAI的Web UI API进行文本到图像生成

    如何使用OpenAI的Web UI API进行文本到图像生成

    嗨，大家好！如果你对使用OpenAI的Web UI API进行文本到图像生成感到困惑，不用担心，我将为你提供一份详细的教程。在这个教程中，我将向你介绍如何设置API，构建请求，获取生成的图像以及如何修改一些重要的参数。让我们一起开始吧！

    引言

    首先，让我向你介绍OpenAI的Web UI API。这个API允许你使用文本描述来生成图像，这对于许多应用程序，如创意设计和内容生成，都非常有用。在本教程中，我将向你展示如何使用这个API，并通过一个例子来说明整个过程。

    步骤 1：启用API

    首先，你需要启用Web UI API。要做到这一点，你需要在运行Web UI时使用--api命令行参数。以下是在Windows上如何设置API的示例：

    在你的 “webui-user.bat” 文件中，添加以下行：

    set COMMANDLINE_ARGS=--api

    这个命令将启用API，然后你可以通过URL http://127.0.0.1:7860/docs 来查看API的文档和可用功能。

    步骤 2：构建请求

    现在，让我们来构建一个请求，告诉API我们想要生成什么样的图像。你可以使用一个包含参数的Python字典来构建请求。以下是一个示例：

    import requests

url = "http://127.0.0.1:7860"  # 这个URL需要匹配你的Web UI的URL

payload = {
    "prompt": "可爱的小狗",
    "steps": 5
}

    在这个示例中，我们设置了两个参数：prompt是描述我们要生成的图像的文本，steps是生成的步数。你可以根据需要设置更多的参数，如果不设置，API将使用默认值。

    步骤 3：发送请求

    一旦你构建了请求，就可以将其发送给API。使用requests库来进行HTTP POST请求。以下是如何发送请求的示例：

    response = requests.post(url=f'{url}/sdapi/v1/txt2img', json=payload)

    在这个代码中，我们将请求发送到/sdapi/v1/txt2img端点，这个端点用于生成图像。确保URL与你的Web UI的URL匹配。

    步骤 4：获取生成的图像

    在API完成生成图像的任务后，它将响应返回到一个变量中，我们将其命名为response。响应中包含了三个条目："images"、"parameters"和"info"。我们需要从中提取图像。

    首先，我们使用以下代码将响应解析为JSON格式，以便更容易地处理：

    r = response.json()

    然后，我们可以从"images"中获取生成的图像。这个图像实际上是一个包含随机字符的字符串，我们需要对其进行解码。以下是如何做到这一点的示例：

    from PIL import Image
import io
import base64

for i in r['images']:
    image = Image.open(io.BytesIO(base64.b64decode(i.split(",", 1)[0])))

    现在，image变量中包含了生成的图像，你可以使用Pillow库（PIL）来进一步处理它，例如保存图像到文件。

    步骤 5：添加元数据到图像

    有时候，你可能想要将一些额外的元数据添加到生成的图像中。为了做到这一点，你可以使用/sdapi/v1/png-info端点。以下是如何将元数据添加到图像的示例：

    png_payload = {
    "image": "data:image/png;base64," + i
}
response2 = requests.post(url=f'{url}/sdapi/v1/png-info', json=png_payload)

    然后，你可以使用response2.json().get("info")来获取添加到图像的元数据。

    示例代码

    下面是一个完整的示例代码，演示了如何使用OpenAI的Web UI API进行文本到图像生成，以及如何添加元数据到图像：

    import requests
import io
import base64
from PIL import Image

url = "http://127.0.0.1:7860"

payload = {
    "prompt": "可爱的小狗",
    "steps": 5
}

response = requests.post(url=f'{url}/sdapi/v1/txt2img', json=payload)

r = response.json()

for i in r['images']:
    image = Image.open(io.BytesIO(base64.b64decode(i.split(",", 1)[0])))

    png_payload = {
        "image": "data:image/png;base64," + i
    }
    response2 = requests.post(url=f'{url}/sdapi/v1/png-info', json=png_payload)

    # 添加元数据到图像
    image.save('output.png', pnginfo=PngImagePlugin.PngInfo.add_text("parameters", response2.json().get("info")))

    自定义设置和参数

    如果你想要修改一些设置和参数，你可以使用override_settings。这个参数允许你覆盖Web UI的设置，例如CLIP跳过的层数。以下是如何使用override_settings的示例：

    override_settings = {}
override_settings["filter_nsfw"] = True
override_settings["CLIP_stop_at_last_layers"] = 2

override_payload = {
    "override_settings": override_settings
}
payload.update(override_payload)

    在这个示例中，我们将filter_nsfw设置为True，并将CLIP_stop_at_last_layers设置为2。然后，我们将这个override_settings添加到我们之前创建的payload中，以便在发送请求时应用这些设置。

    持久性设置

    有时候，你可能希望你的设置更加持久，而不仅仅是单个请求。你可以使用/sdapi/v1/options端点来实现这一点。以下是一个示例：

    option_payload = {
    "sd_model_checkpoint": "Anything-V3.0-pruned.ckpt [2700c435]",
    "CLIP_stop_at_last_layers": 2
}

response = requests.post(url=f'{url}/sdapi/v1/options', json=option_payload)

    在这个示例中，我们设置了模型检查点和CLIP跳过的层数，这些设置将持久保存，而不仅仅是单个请求。请注意，如果你要更改sd_model_checkpoint，则值应该与Web UI中显示的检查点名称相匹配。

    结论

    恭喜你！现在你已经学会了如何使用OpenAI的Web UI API进行文本到图像生成，以及如何自定义设置和参数。这个API为创意设计和内容生成提供了无限的可能性。希望这个教程对你有所帮助！

    关键词

    请注意：本教程中的示例和URL可能会根据最新信息发生变化，建议随时查阅OpenAI的官方文档以获取最新信息。

    这就是关于使用OpenAI的Web UI API进行文本到图像生成的详细教程。如果你有任何问题或需要进一步的帮助，欢迎随时联系我们。祝你在创意设计和内容生成方面取得成功！

  • 用 CompreFace 轻松实现人脸识别：无需机器学习技能

    用 CompreFace 轻松实现人脸识别：无需机器学习技能

    你是否曾想过在你的应用或系统中添加人脸识别功能，但又担心需要复杂的机器学习技能？不用担心，Exadel CompreFace 是一款领先的免费开源人脸识别系统，可以轻松集成到任何系统中，无需先修的机器学习技能。

    开篇故事：解锁新时代的人脸识别

    在数字时代，人脸识别技术已经成为了许多领域的重要组成部分，从手机解锁到身份验证，无处不在。但是，要在你自己的应用或系统中实现人脸识别，通常需要深奥的机器学习知识和大量的工程工作。这对于大多数人来说都是一项巨大的挑战。

    然而，现在有了一个令人兴奋的解决方案 – Exadel CompreFace。它是一个免费且开源的人脸识别系统，无需复杂的机器学习技能，即可轻松集成到你的应用或系统中。无论你是一名开发人员、企业家还是普通用户，都可以受益于这个强大的工具，为你的项目增添人脸识别功能。

    Exadel CompreFace 简介

    Exadel CompreFace 是一款基于 Docker 的应用，可以作为独立服务器或部署在云上。不需要机器学习专业知识，你就可以轻松设置和使用 CompreFace。该系统提供了人脸识别、人脸验证、人脸检测、特征点检测、口罩检测、头部姿势检测、年龄和性别识别等功能的 REST API，并可通过 Docker 轻松部署。

    主要特点

    Exadel CompreFace 提供了许多强大的特点和功能，使其成为一个出色的人脸识别解决方案：

    • 支持 CPU 和 GPU，易于扩展。
    • 开源且可自托管，为数据安全提供额外的保障。
    • 可以部署在云上或本地服务器上。
    • 无需机器学习专业知识即可设置和使用。
    • 使用 FaceNet 和 InsightFace 等先进的人脸识别方法。
    • 仅需一个 Docker 命令即可快速启动。

    如何开始使用 CompreFace

    要开始使用 Exadel CompreFace，你需要满足以下要求：

    1. 安装 Docker 和 Docker Compose（或 Docker Desktop）。
    2. 你的计算机应具备 x86 处理器 和 AVX 支持。
      在 Linux 上检查 AVX 支持，运行 lscpu | grep avx 命令。

    在 Linux 和 MacOS 上开始：

    1. 安装 Docker 和 Docker Compose。
    2. 从最新的发布版本下载存档：https://github.com/exadel-inc/CompreFace/releases
    3. 解压存档。
    4. 在该文件夹中打开终端，并运行以下命令：docker-compose up -d
    5. 在浏览器中打开服务：http://localhost:8000/login

    在 Windows 上开始：

    1. 安装 Docker Desktop。
    2. 从最新的发布版本下载存档：https://github.com/exadel-inc/CompreFace/releases
    3. 解压存档。
    4. 运行 Docker。
    5. 打开命令提示符（在 Windows 搜索栏中输入 cmd）。
    6. 打开你解压缩的存档文件夹（使用 cd 文件夹路径 命令，然后按 Enter）。
    7. 运行命令：docker-compose up -d
    8. 打开 http://localhost:8000/login

    CompreFace SDK

    CompreFace 还提供了多种语言的 SDK，以便于与你的应用集成。以下是一些可用的 SDK：

    详细文档和支持

    CompreFace 提供了详细的文档，包括如何使用、REST API 描述、配置和架构等内容。你可以在官方文档中找到所有需要的信息：文档链接。

    贡献和支持

    如果你对 Exadel CompreFace 感兴趣并希望为项目做出贡献，有许多方式可以参与：

    • 使用 CompreFace 并在 GitHub 上报告问题或提出建议。
    • 通过发布指南和文章分享知识和经验，或改进文档。
    • 为你喜欢的编程语言创建SDK，我们将把它添加到我们的文档中。
    • 将 CompreFace 支持集成到其他平台，如 Home Assistant 或 DreamFactory，我们将添加到我们的文档中。
    • 贡献代码。
    • 为人脸服务添加插件。
    • 最后但同样重要的是，在 GitHub 上为我们的免费人脸识别系统点赞。

    结尾

    Exadel CompreFace 是一款强大且易于使用的开源人脸识别系统，可以轻松集成到你的应用或系统中，无需机器学习技能。不再让人脸识别技术成为门槛，让你的项目进入新时代！

    现在，你可以探索 CompreFace，并为你的项目添加强大的人脸识别功能，无需繁琐的机器学习知识。试试看吧！

    注意：文章中的所有信息基于作者阅读的资料并按照作者的指导创建。某些细节可能已经发生变化，因此建议在使用 CompreFace 或参与项目时查阅最新的官方文档和资源。

  • 创造高清幻想面孔：探索 PULSE 自监督图像放大

    创造高清幻想面孔：探索 PULSE 自监督图像放大

    有一天，你突然翻出了你小时候的一本相册，上面有你和家人的照片。然而，你却发现这些照片的质量非常低，因为它们是在过去的老相机上拍摄的。你决定将这些珍贵的瞬间变得更加清晰和生动。幸运的是，有一种神奇的技术可以帮助你实现这一目标，那就是PULSE。

    PULSE是一个自监督图像放大工具，它可以将低分辨率的图像转化为高分辨率的图像，使它们看起来更加真实和清晰。不过需要注意的是，PULSE不会帮助你识别或重建原始图像中的人物，因为它生成的是虚构的面孔，而不是真实存在的人物。

    简介

    PULSE的工作原理相当令人惊叹。它利用生成模型（例如StyleGAN）的输出来搜索高分辨率图像，这些图像在视觉上看起来逼真，并且以正确的方式降低分辨率，从而保持图像质量。这意味着你可以将你那些模糊的旧照片变得更加清晰和生动，仿佛时光倒流，让你重新体验那些美好的时刻。

    如何使用PULSE

    如果你想使用PULSE，以下是一些开始的步骤：

    先决条件

    首先，你需要安装CMake（这是必需的，因为PULSE使用了用于人脸对齐的dlib库）。此外，PULSE目前仅支持安装了CUDA的系统（因此需要适当的GPU），并且已经在Linux和Windows上进行了测试。为了安装所需的Python包，你可以使用提供的Conda环境YAML文件，例如：

    conda create -f pulse.yml

    或者（在Windows上使用Anaconda）：

    conda env create -n pulse -f pulse.yml
conda activate pulse

    在某些环境中（例如在Windows上），你可能需要编辑pulse.yml文件，删除每个依赖项的特定版本哈希值，并删除仍然在运行conda env create后引发错误的任何依赖项（例如readline）。

    最后，首次运行代码时，你需要与互联网连接，因为它将自动从Google Drive下载相关的预训练模型（如果已经下载，它将使用本地副本）。如果公共的Google Drive容量不足，你可以将文件添加到你自己的Google Drive中，然后获取共享链接，将链接中的ID替换为你自己Drive文件的共享链接中提供的新文件ID，将其替换为align_face.py和PULSE.py中的链接。

    数据准备

    默认情况下，run.py的输入数据应该放在./input/目录下（虽然这可以通过修改来更改）。然而，这假定人脸已经被对齐和降分辨率。如果你的数据不是这种格式，可以将它们放在realpics目录下，并运行align_face.py，它将自动为你执行对齐和降分辨率操作（同样，如果更方便，所有目录都可以通过命令行参数进行更改）。在此阶段，你需要选择一个降分辨率的因子。

    需要注意的是，如果你的数据已经具有较低的分辨率，进一步降分辨率将保留非常少的信息。在这种情况下，你可以选择使用双三次插值将图像放大到较高分辨率（通常是1024×1024），然后允许align_face.py为你执行降分辨率操作。

    应用PULSE

    一旦你的数据已经格式化，你只需要运行以下命令：

    python run.py

    尽情享受吧！

    通过PULSE，你可以轻松将低分辨率图像转化为高分辨率图像，让你的珍贵回忆变得更加清晰和生动，仿佛重新回到那个美好的时刻。

    这就是PULSE的神奇之处，它为你提供了一个强大的工具，让你能够重新发现并分享那些珍贵的瞬间。

    不过需要谨记，尊重隐私和伦理原则，不要滥用这项技术。

    希望你能享受使用PULSE，为你的照片带来全新的生命！

  • Retrieval-based-Voice-Conversion-WebUI使用指南

    Retrieval-based-Voice-Conversion-WebUI使用指南

    曾经有一位年轻的音乐爱好者，他对声音的变化充满了浓厚兴趣。然而，他一直感到无奈，因为要实现声音的转换似乎需要高昂的成本和专业的设备。但是有一天，他发现了一个神奇的工具，一个名为”Retrieval-based-Voice-Conversion-WebUI”的项目。这个项目让他能够以前所未有的简单方式改变声音，他的音乐世界因此而翻开了新的一页。

    掌握声音的魔法

    音乐、娱乐和创作中声音的变化一直是一个令人着迷的领域。无论是将一首歌曲的声音转化为不同的风格，还是将自己的声音变成卡通角色，声音转换技术都有着广泛的应用。但是在过去，要实现声音的转换通常需要专业的音频工程师和昂贵的设备。

    然而，随着技术的进步，现在有了一种全新的声音转换框架，名为”Retrieval-based-Voice-Conversion-WebUI”，它是基于VITS（Variational Inference Text-to-Speech）的，提供了一个简单易用的界面，让任何人都能够轻松实现声音的转换。

    什么是”Retrieval-based-Voice-Conversion-WebUI”？

    “Retrieval-based-Voice-Conversion-WebUI”是一个开源项目，旨在提供一个基于VITS的声音转换框架，它具有以下特点：

    1. 减少音色泄漏

    通过使用前1名检索（Top1 retrieval）来替换源特征为训练集特征，”Retrieval-based-Voice-Conversion-WebUI”能够显著减少音色泄漏，确保声音转换的质量。

    2. 简单快速的训练

    即使在相对较弱的图形卡上，”Retrieval-based-Voice-Conversion-WebUI”也能够进行简单快速的训练。这意味着你不需要昂贵的硬件来开始声音转换项目。

    3. 少量数据也能获得良好结果

    “Retrieval-based-Voice-Conversion-WebUI”支持使用少量数据进行训练，即使只有10分钟的低噪音语音，也能够获得相对好的结果。

    4. 模型融合以改变音色

    如果你想改变音色，”Retrieval-based-Voice-Conversion-WebUI”支持模型融合，让你能够实现更多样化的声音效果。

    5. 易于使用的Web界面

    “Retrieval-based-Voice-Conversion-WebUI”提供了一个易于使用的Web界面，让你能够轻松进行声音转换，无需复杂的命令行操作。

    6. 强大的高音声音提取算法

    “Retrieval-based-Voice-Conversion-WebUI”使用了一种最强大的高音声音提取算法，确保声音转换时不会出现静音问题。这个算法比传统的方法更快速，资源消耗更低，效果更好。

    7. 跨硬件支持

    “Retrieval-based-Voice-Conversion-WebUI”支持Nvidia、AMD、Intel等不同品牌的图形卡，让你可以选择最适合你的硬件来进行声音转换。

    准备环境

    在使用”Retrieval-based-Voice-Conversion-WebUI”之前，你需要准备好以下环境：

    安装主要依赖项

    首先，你需要安装Python 3.8或更高版本，并通过pip安装以下主要依赖项：

    # 安装PyTorch相关核心依赖项，如果已安装则跳过
pip install torch torchvision torchaudio

    如果你使用的是Windows，并且有Nvidia的Ampere架构（RTX30xx）的显卡，你需要根据这个链接的经验，指定与PyTorch相对应的cuda版本进行安装。

    如果你使用的是Linux，并且有AMD显卡，你需要使用以下命令来安装适用于ROCm 5.4.2的PyTorch版本：

    pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/rocm5.4.2

    使用Poetry安装其他依赖项

    你可以使用Poetry来安装”Retrieval-based-Voice-Conversion-WebUI”的其他依赖项：

    # 安装Poetry依赖管理工具，如果已安装则跳过
curl -sSL https://install.python-poetry.org | python3 -

# 安装项目依赖项
poetry install

    如果你不使用Poetry，也可以使用pip来安装它们：

    # 对于Nvidia显卡用户
pip install -r requirements.txt

# 对于Windows上的AMD/Intel显卡用户（使用DirectML）：
pip install -r requirements-dml.txt

# 对于Linux / WSL上使用Python 3.10的Intel ARC显卡用户：
pip install -r requirements-ipex.txt

# 对于Linux上的AMD显卡用户（使用ROCm）：
pip install -r requirements-amd.txt

    准备

    其他预训练模型

    “Retrieval-based-Voice-Conversion-WebUI”需要其他预训练模型来进行推断和训练。你需要从他们的Huggingface空间下载这些模型。

    以下是”Retrieval-based-Voice-Conversion-WebUI”所需的预训练模型和其他文件的列表：

    • ./assets/hubert/hubert_base.pt
    • ./assets/pretrained
    • ./assets/uvr5_weights

    如果你想测试模型的v2版本，还需要下载以下文件：

    • ./assets/pretrained_v2
    • ./assets/pretrained_v2

    如果你使用Windows，可能还需要下载以下两个文件，如果已经安装了FFmpeg和FFprobe，则可以跳过：

    • ffmpeg.exe
    • ffprobe.exe

    最后，如果你想使用最新的SOTA RMVPE（Real-time Multif0 Voice Pitch Estimation）声音提取算法，你需要下载RMVPE权重文件，并将其放在”Retrieval-based-Voice-Conversion-WebUI”的根目录中。

    • rmvpe.pt

    对于AMD/Intel显卡用户，还需要下载以下文件：

    • rmvpe.onnx

    如何使用”Retrieval-based-Voice-Conversion-WebUI”

    一旦你准备好了环境和预训练模型，你就可以开始使用”Retrieval-based-Voice-Conversion-WebUI”了。如果你使用的是Windows或macOS，你可以下载并解压”RVC-beta.7z”，然后使用”go-web.bat”（Windows）或”sh ./run.sh”（macOS）来启动Web界面。

    如果你使用的是Linux，可以使用以下命令启动Web界面：

    python infer-web.py

    如果你使用的是Intel ARC显卡，需要在启动Web界面之前运行source /opt/intel/oneapi/setvars.sh命令。

    如果你使用的是Linux，并且有AMD显卡（使用ROCm），可以按照这里的说明安装所有必需的驱动程序。然后运行上述命令启动Web界面。

    结语

    “Retrieval-based-Voice-Conversion-WebUI”是一个令人惊叹的工具，它为声音转换提供了前所未有的简便性和效果。无论你是音乐制作人、娱乐爱好者还是创作者，都可以借助这个框架来实现声音的变换和创造。不再需要昂贵的设备和复杂的操作，现在你可以轻松地探索声音的奇妙世界。

    如果你对声音转换技术感兴趣，不妨尝试一下”Retrieval-based-Voice-Conversion-WebUI”，你会被它的功能和便利性所折服的。

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

    从零开始搭建和运行一个小型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知识，适应这个新时代的发展。

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

    使用Python下载并合并M3U8视频

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

    步骤 1：导入必要的库

    首先，我们需要导入一些Python库，以便后续的操作。我们将使用os.path来处理文件路径，urllib.parse来处理URL，asyncio和aiohttp来进行异步操作，以及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这个强大的工具，可以帮助你自动化这一过程。在本教程中，我将向你展示如何使用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的电影海报

    如何使用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网站，查找相关页面，非常繁琐。那么，有没有一种方法可以自动获取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项目所需的依赖库。这将使你的项目更加用户友好，减少了其他人使用你的代码时的不便。

    如何解决这个问题？

    解决这个问题的思路非常简单：我们可以编写一个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函数将其内容解析为抽象语法树。接下来，我们遍历抽象语法树，找出所有的Import和ImportFrom节点，这些节点包含了导入的依赖库信息。最后，我们将依赖库的名称提取出来，并存储在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项目更加智能化，让代码自己动手装依赖库！