Qt使用QSqlDatabase连接MySQL实现增删改查功能

2025-07-07 17:50
文章标签 qt qsqldatabase mysql 改查 增删 连接 功能 实现 使用 database

本文主要是介绍Qt使用QSqlDatabase连接MySQL实现增删改查功能，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

《Qt使用QSqlDatabase连接MySQL实现增删改查功能》这篇文章主要为大家详细介绍了Qt如何使用QSqlDatabase连接MySQL实现增删改查功能,文中的示例代码讲解详细,感兴趣的小伙伴...

一、创建数据表

数据库名：

我们先创建一个数据库，名字叫 game_db：

CREATE DATABASE IF NOT EXISTS game_db DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;
USE game_db;

创建玩家表：players

CREATE TABLE players PnCNA(
    player_id INT AUTO_INCREMENT PRIMARY KEY,
    username VARCHAR(32) NOT NULL UNIQUE,
    password_hash VARCHAR(64) NOT NULL,
    nickname VARCHAR(32),
    level INT DEFAULT 1,
    experience INT DEFAULT 0,
    gold INT DEFAULT 0,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

插入 20 条玩家信息 SQL 语句：

INSERT INTO players (username, password_hash, nickname, level, experience, gold) VALUES
('user001', MD5('password1'), 'Knight001', 5, 1200, 500),
('user002', MD5('password2'), 'Mage002', 3, 800, 300),
('user003', MD5('password3'), 'Archer003', 7, 1800, 750),
('user004', MD5('password4'), 'Rogue004', 2, 400, 100),
('user005', MD5('password5'), 'Cleric005', 10, 3200, 1200),
('user006', MD5('password6'), 'Paladin006', 4, 950, 400),
('user007', MD5('password7'), 'Hunter007', 6, 1400, 600),
('user008', MD5('password8'), 'Druid008', 8, 2200, 900),
('user009', MD5('password9'), 'Monk009', 9, 2500, 1000),
('user010', MD5('password10'), 'Barbarian010', 1, 100, 50),
('user011', MD5('password11'), 'Warrior011', 5, 1300, 550),
('user012', MD5('password12'), 'Sorcerer012', 3, 700, 300),
('user013', MD5('password13'), 'Assassin013', 6, 1600, 650),
('user014', MD5('password14'), 'Priest014', 7, 1900, 800),
('user015', MD5('password15'), 'Ranger015', 2, 500, 200),
('user016', MD5('password16'), 'Berserker016', 4, 1100, 450),
('user017', MD5('password17'), 'Necromancer017', 8, 2300, 950),
('user018', MD5('password18'), 'Templar018', 9, 2700, 1100),
('user019', MD5('password19'), 'Shaman019', 10, 3000, 1250),
('user020', MD5('password20'), 'Witch020', 1, 200, 100);

表中结果如下所示：

Qt使用QSqlDatabase连接MySQL实现增删改查功能

二、连接MySQL数据库

database_manager.h

#ifndef DATABASEMANAGER_H
#define DATABASEMANAGER_H

#include <QObject>
#include <QMutex>
#include <QSqlDatabase>
#include <QSqlError>

enum DatabaseType {
    MySQL = 0,
    SQLite,
    PostgreSQL,
    // 可扩展更多类型
};

typedef struct stConnectParams {
    DatabaseType dbType;

    QString strHostName;
    QString strDbName;
    QString strUserName;
    QString strPassword;
    QString strConnectionName;

    int port;
} ConnectParams;

class DatabaseManager : public QObject
{
    Q_OBJECT
public:
    static DatabaseManager& instance();

    void initConnectionParams(const ConnectParams& connectParams);
    void initializeConnection();

private:
    explicit DatabaseManager(QObject *parent = nullptr);
    ~DatabaseManager();
    DatabaseManager(const DatabaseManager&) = delete;
    DatabaseManager& operator =(const DatabaseManager&) = delete;
    DatabaseManager(const DatabaseManager&&) = delete;
    DatabaseManager& operator =(const DatabaseManager&&) = delete;

signals:

private:
    ConnectParams m_connectParams;
};

database_manager.cpp

#include "database_manager.h"

#include <QDebug>

DatabaseManager::DatabaseManager(QObject *parent) : QObject(parent)
{

}


DatabaseManager::~DatabaseManager()
{

}

DapythontabaseManager& DatabaseManager::instance()
{
    static DatabaseManager instance;
    return instance;
}

void DatabaseManager::initConnectionParams(const ConnectParams& connectParams)
{
    m_connectParams.dbType = connectParams.dbType;
    m_connectParams.strHostName = connectParams.strHostName;
    m_connectParams.strDbName = connectParams.strDbName;
    m_connectParams.strUserName = connectParams.strUserName;
    m_connectParams.strPassword = connectParams.strPassword;
    m_connectParams.strConnectionName = connectParams.strConnectionName;
    m_connectParams.port = connectParams.port;
}

void DatabaseManager::initializeConnection()
{
    if (QSqlDatabase::contains(m_connectParams.strConnectionName)) {
        qDebug() << "db:" << m_connectParams.strConnectionName << "already connected";
        return;
    }

    QString strDriver;
    switch (m_connectParams.dbType) {
    case DatabaseType::SQLite:
        strDriver = "QSQLITE";
        break;
    case DatabaseType::MySQL:
        strDriver = "QMYSQL";
        break;
    case DatabaseType::PostgreSQL:
        strDriver = "QPSQL";
        break;
    }

    if (strDriver.isEmpty()) {
        qDebug() << "can't find driver";
        return;
    }

     QSqlDatabase db = QSqlDatabase::addDatabase(strDriver, m_connectParams.strConnectionName);

    if (m_connectParams.dbType == DatabaseType::SQLite) {
        db.setDatabaseName(m_connectParams.PnCNAstrDbName); // SQLite只需数据库文件路径
    } else {
        db.setConnectOptions("MYSQL_OPT_CONNECT_TIMEOUT=5;"
                                "MYSQL_OPT_READ_TIMEOUT=5;"
                                "MYSQL_OPT_WRITE_TIMEOUT=5;");
        db.setHostName(m_connectParams.strHostName);
        db.setPort(m_connectParams.port);
        db.setDatabaseName(m_connectParams.strDbName);
        db.setUserName(m_connectParams.strUserName);
        db.setPassword(m_connectParams.strPassword);
    }

    if (!db.open()) {
        qDebug() << "Database connection failed:" << db.lastError().text();
    } else {
        qDebug() << "Database connected successfully!";
    }
}

三、封装成一个完整的轻量级 ORM 风格类

什么是ORM 模型类的？

ORM（Object-Relational Mapping）模型类的作用，是将数据库中的表与 C++（或其他语言）中的类进行映射和封装，让你能像操作普通对象那样操作数据库数据，避免直接拼接 SQL 字符串，提高代码的可读性、可维护性、安全性和抽象性。

ORM 模型类的作用总结如下：

3.1 表结构 → 类结构

ORM 会把数据库表（如 users）映射成一个类（如 User），表字段对应类成员或字段名：

// 数据库表字段
// id | name | age

// ORM类字段
QVariantMap row;
row["id"] = 1;
row["name"] = "Alice";
row["age"] = 30;

3.2 简化 SQL 操作

让你写这样的代码：

userModel.insert({{"name", "Tom"}, {"age", 25}});

而不需要写繁琐的 SQL：

INSERT INTO users (name, age) VALUES ('Tom', 25);

目标功能：

  • 封装成类 OrmModel 或基类 OrmBase
  • 支持设置数据库连接、表名
  • 支持 select / insert / update / delete 等基础操作
  • 使用 QVariantMap 传入/返回数据
  • ORM风格：调用 model.select(…) 而不是手写 SQL 字符串

类定义：OrmBase

#ifndef DBORMBASE_H
#define DBORMBASE_H

#include <QObject>
#include <QSqlDatabase>
#include <QVariantMap>
#include <QVariantList>

class DbOrmBase : public QObject
{
    Q_OBJECT
public:
    explicit DbOrmBase(const QString &tableName, const QString &connectionName);
    ~DbOrmBase();

    // CRUD
    QVariantList select(const QString &strWhereClause = "", const QStringList &columns = {});
    bool insert(const QVariantMap &values);
    bool update(const QVariantMap &values, const QString &strWhereClause);
    bool remove(const QString &strWhereClause);

private:
    bool isConnected() const;

private:
    QString m_tableName;
    QString m_connectionName;
    QSqlDatabase m_db; // 保存数据库实例
};

#endif // DBORMBASE_H

类实现：OrmBase.cpp

#include "OrmBase.h"
#include <QSqlQuery>
#include <QSqlError>
#include <QSqlRecord>
#include <QDebug>

OrmBase::OrmBase(const QString &tableName, const QString &connectionName)
    : m_tableName(tableName), m_connectionName(connectionName)
{}

QVariantList OrmBase::select(const QString &whereClause, const QStringList &columns)
{
    QVariantList results;
    QSqlDatabase db = QSqlDatabase::database(m_connectionName);
    if (!db.isOpen()) {
        qDebug() << "Database not open";
        return results;
    }

    QString columnStr = columns.isEmpty() ? "*" : columns.join(", ");
    QString sql = QString("SELECT %1 FROM %2").arg(columnStr, m_tableName);
    if (!whereClause.trimmed().isEmpty()) {
        sql += " WHERE " + whereClause;
    }

    QSqlQuery query(db);
    if (!query.exec(sql)) {
        qDebug() << "Select failed:" << query.lastError().text();
        return results;
    }

    while (query.next()) {
        QVariantMap row;
        QSqlRecord rec = query.record();
        for (int i = 0; i < rec.count(); ++i) {
            row[rec.fieldName(i)] = query.value(i);
        }
        results << row;
    }
    return results;
}

bool OrmBase::insert(const QVariantMap &values)
{
    QSqlDatabase db = QSqlDatabase::database(m_connectionName);
    if (!db.isOpen()) return false;

    QStringList columns, placeholders;
    QVariantList bindValues;
    for (auto it = values.begin(); it != values.end(); ++it) {
        columns << it.key();
        placeholders << "?";
        bindValues << it.value();
    }

    QString sql = QString("INSERT INTO %1 (%2) VALUES (%3)")
                      .arg(m_tableName)
                      .arg(columns.join(", "))
                      .arg(placeholders.join(", "));

    QSqlQuery query(db);
    query.prepare(sql);
    for (const QVariant &val : bindValues) {
        query.addBindValue(val);
    }

    if (!query.exec()) {
        qDebug() << "Insert failed:" << query.lastError().text();
        return false;
    }
    return true;
}

bool OrmBase::update(const QVariantMap &values, const QString &whereClause)
{
    QSqlDatabase db = QSqlDatabase::database(m_connectionName);
    if (!db.isOpen()) return false;

    QStringList sets;
    QVariantList bindValues;
    for (auto it = values.begin(); it != values.end(); ++it) {
        sets << QString("%1 = ?").arg(it.key());
        bindValues << it.value();
    }

    QString sql = QString("UPDATE %1 SET %2").arg(m_tableName, sets.join(", "));
    if (!whereClause.trimmed().isEmpty()) {
        sql += " WHERE " + whereClause;
    }

    QSqlQuery query(db);
    query.prepare(sql);
    for (const QVariant &val : bindValues) {
        query.addBindValue(val);
    }

    if (!query.exec()) {
        qDebug() << "Update failed:" << query.lastError().text();
        return false;
    }
    return true;
}

bool OrmBase::remove(const QString &whereClause)
{
    QSqlDatabase db = QSqlDatabase::database(m_connectionName);
    if (!db.isOpen()) return false;

    QString sql = QString("DELETE FROM %1").arg(m_tableName);
    if (!whereClause.trimmed().isEmpty()) {
        sql += " WHERE " + whereClause;
    }

    QSqlQuery query(db);
    if (!query.exec(sql)) {
        qDebug() << "Delete failed:" << query.lastError().text();
        return false;
    }
    return true;
}

使用示例：

#include <QCoreApplication>
#include <QDebug>
#include <QDateTime>

#include "database_manager.h"
#include "db_ormbase.h"

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    ConnectParams connectParams;
    connectParams.dbType = DatabaseType::MySQL;
    connectParams.strHostName = "localhost";
    connectParams.strDbName = "game_db";
    connectParams.strUserName = "root";
    connectParams.strPassword = "root";
    connectParams.strConnectionName = "user_game";
    connectParams.port = 3306;

    DatabaseManager::instance().initConnectionParams(connectParams);
    DatabaseManager::instance().initializeConnection();

    DbOrmBase userModel("players", "user_game");
    QVariantList playerList =  userModel.select("experience > 1000");

    for (const QVariant &playerVar : playerList) {
        QVariantMap playerMap = playerVar.toMap();

        int playerId = playerMap.value("player_id").toInt();
        QString username = playerMap.value("username").toString();
        QString nickname = playerMap.value("nickname").toString();
        int level = playerMap.value("level").toInt();
        int experience = playerMap.value("experience").toInt();
        int gold = playerMap.value("gold").toInt();
        QString passwordHash = playerMap.value("passwChina编程ord_hash").toString();
        QDateTime createdAt = playerMap.value("created_at").toDateTime();

        // 可以进行打印、显示、或保存到类对象中
        qDebug() << "ID:" << playerId
                 << "用户名:" << username
                 << "昵称:" << nickname
                 << "等级:" << level
                 << "经验:" << experience
                 << "金币:" << gold
                 << "密码Hash:" << passwordHash
                 << "创建时间:" << createdAt.toString(Qt::ISODate);
    }

    return a.exec();
}

输出结果：

Qt使用QSqlDatabase连接MySQL实现增删改查功能

四、实现派生具体模型类

为什么要派生？

虽然 OrmBase 已支持通用 CRUD，但派生后的 UserModel 能实现：

  • 指定固定表名（如 players）
  • 添加和 players 表相关的专属函数（如 getAdultUsers()、findByName()）
  • 让调用更具语义：UserModel user; user.insert(…)

创建 UserModel 类

UserModel.h

#ifndef USERMODEL_H
#define USERMODEL_H

#include "OrmBase.h"

class UserModel : public OrmBase
{
public:
    explicit UserModel(const QString &connectionName = "default");

    // 自定义业务函数
    QVariantList getAdultUsers();
    QVariantMap findById(int id);
    QVariantList findByName(const QString &name);
};

#endif // USERMODEL_H

UserModel.cpp

#include "UserModel.h"

UserModel::UserModel(const QString &connectionName)
    : OrmBase("players", connectionName) // 固定表名为 users
{}

// 查询年龄 >= 18 的用户
QVariantList UserModel::getAdultUsers()
{
    return select("experience >= 1000", {"player_id", "username",python "experience"});
}

// 查询某个 ID 的用户（返回一行）
QVariantMap UserModel::findById(int id)
{
    auto results = select(QString("player_id = %1").arg(id));
    return results.isEmpty() ? QVariantMap() : results.first().toMap();
}

// 查询某个名字的所有用户
QVariantList UserModel::findByName(const QString &name)
{
    QString clause = QString("username = '%1'").arg(name.replace("'", "''")); // 简单防注入
    return select(clause);
}

五、支持多线程连接池 + ORM + 事务封装

将构建以下组件：

+-------------------------+
| DBConnectionPool       | 线程安全连接池类（单例）
+-------------------------+
| OrmBase                | ORM 基类（封装表操作 + 自动获取线程连接）
+-------------------------+
| OrmManager             | 管理多个模型，支持事务封装
+-------------------------+
| XxxModel : OrmBase     | 表模型（如 UserModel）
+-------------------------+

5.1 线程安全数据库连接池：DBConnectionPool

DBConnectionPool.h

#ifndef DBCONNECTIONPOOL_H
#define DBCONNECTIONPOOL_H

#include <QSqlDatabase>
#include <QMutex>
#include <QMap>
#include <QThreadStorage>

class DBConnectionPool
{
public:
    static DBConnectionPool &instance();

    void init(const QString &driver,
              const QString &host,
              int port,
              const QString &dbName,
              const QString &user,
              const QString &password,
              int maxConn = 10);

    QSqlDatabase getConnection();
    void closeAll();

private:
    DBConnectionPool() = default;
    Q_DISABLE_COPY(DBConnectionPool)

    QString m_driver, m_host, m_dbName, m_user, m_password;
    int m_port = 3306;
    int m_maxConn = 10;

    QMutex m_mutex;
    int m_connIndex = 0;

    QThreadStorage<QString> m_threadConnName;
};

#endif // DBCONNECTIONPOOL_H

DBConnectionPool.cpp

#include "DBConnectionPool.h"
#include <QSqlDatabase>
#include <QSqlError>
#include <QDebug>

DBConnectionPool &DBConnectionPool::instance()
{
    static DBConnectionPool pool;
    return pool;
}

void DBConnectionPool::init(const QString &driver,
                            const QString &host,
                            int port,
                            const QString &dbName,
                            const QString &user,
                            const QString &password,
                            int maxConn)
{
    m_driver = driver;
    m_host = host;
    m_port = port;
    m_dbName = dbName;
    m_user = user;
    m_password = password;
    m_maxConn = maxConn;
}

QSqlDatabase DBConnectionPool::getConnection()
{
    if (!m_threadConnName.hasLocalData()) {
        QMutexLocker locker(&m_mutex);
        QString connName = QString("conn_%1").arg(++m_connIndex);
        m_threadConnName.setLocalData(connName);

        QSqlDatabase db = QSqlDatabase::addDatabase(m_driver, connName);
        db.setHostName(m_host);
        db.setPort(m_port);
        db.setDatabaseName(m_dbName);
        db.setUserName(m_user);
        db.setPassword(m_password);
        db.setConnectOptions("MYSQL_OPT_CONNECT_TIMEOUT=5;"
                             "MYSQL_OPT_RECONNECT=1");

        if (!db.open()) {
            qCritical() << "Failed to open DB:" << db.lastError().text();
        }
    }
    return QSqlDatabase::database(m_threadConnName.localData());
}

void DBConnectionPool::closeAll()
{
    QMutexLocker locker(&m_mutex);
    for (int i = 1; i <= m_connIndex; ++i) {
        QString name = QString("conn_%1").arg(i);
        if (QSqlDatabase::contains(name)) {
            QSqlDatabase::removeDatabase(name);
        }
    }
    m_connIndex = 0;
}

5.2 ORM 基类 OrmBase（使用连接池）

class OrmBase
{
public:
    OrmBase(const QString &tableName);
    virtual ~OrmBase() = default;

    bool insert(const QVariantMap &values);
    QVariantList select(const QString &whereClause = "", const QStringList &columns = {});
    bool update(const QVariantMap &values, const QString &whereClause);
    bool remove(const QString &whereClause);

    QSqlDatabase db() const;

protected:
    QString m_tableName;
};

关键点：OrmBase 中不再保存 QSqlDatabase 实例，而是每次从线程池中获取：

QSqlDatabase OrmBase::db() const
{
    return DBConnectionPool::instance().getConnection();
}

5.3 事务封装类 OrmManager

用于封装如下逻辑：

  • beginTransaction()
  • commit()
  • rollback()
class OrmManager
{
public:
    static bool beginTransaction();
    static bool commit();
    static bool rollback();
};

实现：

bool OrmManager::beginTransaction()
{
    QSqlDatabase db = DBConnectionPool::instance().getConnection();
    return db.transaction();
}

bool OrmManager::commit()
{
    QSqlDatabase db = DBConnectionPool::instance().getConnection();
    return db.commit();
}

bool OrmManager::rollback()
{
    QSqlDatabase db = DBConnectionPool::instance().getConnection();
    return db.rollback();
}

5.4 使用示例：线程内事务 + 多表操作

DBConnectionPool::instance().init("QMYSQL", "127.0.0.1", 3306, "testdb", "root", "123456");

UserModel user;
OrderModel order;

OrmManager::beginTransaction();
bool ok1 = user.insert({{"name", "Tom"}});
bool ok2 = order.insert({{"user_id", 1}, {"amount", 200.0}});
if (ok1 && ok2)
    OrmManager::commit();
else
    OrmManager::rollback();

5.5 线程使用示例（多线程安全）

QtConcurrent::run([](){
    UserModel u;
    u.insert({{"name", "ThreadUser"}});
});

以上就是Qt使用QSqlDatabase连接MySQL实现增删改查功能的详细内容，更多关于QSqlDatabase连接MySQL实现增删改查的资料请关注China编程(www.chinasem.cn)其它相关文章！

这篇关于Qt使用QSqlDatabase连接MySQL实现增删改查功能的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1155317。

相关文章

Java通过驱动包(jar包)连接MySQL数据库的步骤总结及验证方式

Java通过驱动包(jar包)连接MySQL数据库的步骤总结及验证方式

《Java通过驱动包(jar包)连接MySQL数据库的步骤总结及验证方式》本文详细介绍如何使用Java通过JDBC连接MySQL数据库,包括下载驱动、配置Eclipse环境、检测数据库连接等关键步骤,... 目录一、下载驱动包二、放jar包三、检测数据库连接JavaJava 如何使用 JDBC 连接 mys
阅读更多...
SpringBoot线程池配置使用示例详解

SpringBoot线程池配置使用示例详解

《SpringBoot线程池配置使用示例详解》SpringBoot集成@Async注解,支持线程池参数配置（核心数、队列容量、拒绝策略等）及生命周期管理,结合监控与任务装饰器,提升异步处理效率与系统... 目录一、核心特性二、添加依赖三、参数详解四、配置线程池五、应用实践代码说明拒绝策略（Rejected
阅读更多...
C++ Log4cpp跨平台日志库的使用小结

C++ Log4cpp跨平台日志库的使用小结

《C++Log4cpp跨平台日志库的使用小结》Log4cpp是c++类库,本文详细介绍了C++日志库log4cpp的使用方法,及设置日志输出格式和优先级,具有一定的参考价值,感兴趣的可以了解一下... 目录一、介绍1. log4cpp的日志方式2.设置日志输出的格式3. 设置日志的输出优先级二、Window
阅读更多...
SQL中如何添加数据(常见方法及示例)

SQL中如何添加数据(常见方法及示例)

《SQL中如何添加数据(常见方法及示例)》SQL全称为StructuredQueryLanguage,是一种用于管理关系数据库的标准编程语言,下面给大家介绍SQL中如何添加数据,感兴趣的朋友一起看看吧... 目录在mysql中，有多种方法可以添加数据。以下是一些常见的方法及其示例。1. 使用INSERT I
阅读更多...
Ubuntu如何分配​​未使用的空间

Ubuntu如何分配​​未使用的空间

《Ubuntu如何分配​​未使用的空间》Ubuntu磁盘空间不足,实际未分配空间8.2G因LVM卷组名称格式差异（双破折号误写）导致无法扩展,确认正确卷组名后,使用lvextend和resize2fs... 目录1：原因2：操作3：报错5：解决问题：确认卷组名称​6：再次操作7：验证扩展是否成功8：问题已解
阅读更多...
基于Python实现一个图片拆分工具

基于Python实现一个图片拆分工具

《基于Python实现一个图片拆分工具》这篇文章主要为大家详细介绍了如何基于Python实现一个图片拆分工具,可以根据需要的行数和列数进行拆分,感兴趣的小伙伴可以跟随小编一起学习一下... 简单介绍先自己选择输入的图片，默认是输出到项目文件夹中，可以自己选择其他的文件夹，选择需要拆分的行数和列数，可以通过
阅读更多...
Python中将嵌套列表扁平化的多种实现方法

Python中将嵌套列表扁平化的多种实现方法

《Python中将嵌套列表扁平化的多种实现方法》在Python编程中,我们常常会遇到需要将嵌套列表（即列表中包含列表）转换为一个一维的扁平列表的需求,本文将给大家介绍了多种实现这一目标的方法,需要的朋... 目录python中将嵌套列表扁平化的方法技术背景实现步骤1. 使用嵌套列表推导式2. 使用itert
阅读更多...
使用Docker构建Python Flask程序的详细教程

使用Docker构建Python Flask程序的详细教程

《使用Docker构建PythonFlask程序的详细教程》在当今的软件开发领域,容器化技术正变得越来越流行,而Docker无疑是其中的佼佼者,本文我们就来聊聊如何使用Docker构建一个简单的Py... 目录引言一、准备工作二、创建 Flask 应用程序三、创建 dockerfile四、构建 Docker
阅读更多...
Python使用vllm处理多模态数据的预处理技巧

Python使用vllm处理多模态数据的预处理技巧

《Python使用vllm处理多模态数据的预处理技巧》本文深入探讨了在Python环境下使用vLLM处理多模态数据的预处理技巧,我们将从基础概念出发,详细讲解文本、图像、音频等多模态数据的预处理方法,... 目录1. 背景介绍1.1 目的和范围1.2 预期读者1.3 文档结构概述1.4 术语表1.4.1 核
阅读更多...
Python使用pip工具实现包自动更新的多种方法

Python使用pip工具实现包自动更新的多种方法

《Python使用pip工具实现包自动更新的多种方法》本文深入探讨了使用Python的pip工具实现包自动更新的各种方法和技术,我们将从基础概念开始,逐步介绍手动更新方法、自动化脚本编写、结合CI/C... 目录1. 背景介绍1.1 目的和范围1.2 预期读者1.3 文档结构概述1.4 术语表1.4.1 核
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2