Python MySQL 数据库操作完整示例

📋 项目简介

这是一个结构清晰、注释详细的 Python MySQL 数据库操作示例项目，展示了如何使用面向对象的方式进行数据库的增删改查操作。

🏗️ 代码架构

职责划分

复制代码

mysql_manager.py
├── DatabaseConfig          # 数据库配置类
│   └── 职责: 管理数据库连接配置信息
│
├── DatabaseConnection      # 数据库连接管理类
│   └── 职责: 管理连接的创建、关闭和复用
│
├── TableManager           # 表管理类
│   └── 职责: 处理数据表的创建、删除等DDL操作
│
├── DataManager           # 数据操作类 (CRUD)
│   └── 职责: 处理数据的增删改查操作
│       ├── insert_one()          # 插入单条记录
│       ├── insert_many()         # 批量插入记录
│       ├── delete_by_id()        # 根据ID删除
│       ├── delete_by_condition() # 根据条件删除
│       ├── update_by_id()        # 根据ID更新
│       ├── update_by_condition() # 根据条件更新
│       ├── select_all()          # 查询所有记录
│       ├── select_by_id()        # 根据ID查询
│       ├── select_by_condition() # 根据条件查询
│       ├── select_by_custom_sql()# 自定义SQL查询
│       └── count()               # 统计记录数
│
└── main()                 # 主程序示例
    └── 职责: 演示完整的数据库操作流程

🚀 快速开始

安装依赖

pip install -r requirements.txt

或直接安装：

复制代码

pip install pymysql

配置数据库

编辑 mysql_manager.py 中的数据库配置：

复制代码

config = DatabaseConfig(
    host='localhost',          # 数据库主机地址
    port=3306,                # 数据库端口
    user='root',              # 数据库用户名
    password='your_password', # 修改为你的密码
    database='test_db'        # 数据库名称
)

运行示例

python mysql_manager.py

💡 使用示例

示例 1: 基本的增删改查

复制代码

from mysql_manager import DatabaseConfig, DatabaseConnection, DataManager

# 1. 配置并连接数据库
config = DatabaseConfig(
    host='localhost',
    port=3306,
    user='root',
    password='your_password',
    database='test_db'
)

db_conn = DatabaseConnection(config)
db_conn.connect()

# 2. 创建数据管理器
data_manager = DataManager(db_conn, 'users')

# 3. 插入数据
user_id = data_manager.insert_one({
    'name': '张三',
    'age': 25,
    'email': 'zhangsan@example.com'
})

# 4. 查询数据
user = data_manager.select_by_id(user_id)
print(user)

# 5. 更新数据
data_manager.update_by_id(user_id, {'age': 26})

# 6. 删除数据
data_manager.delete_by_id(user_id)

# 7. 关闭连接
db_conn.close()

示例 2: 批量操作

复制代码

# 批量插入
users = [
    {'name': '李四', 'age': 30, 'email': 'lisi@example.com'},
    {'name': '王五', 'age': 28, 'email': 'wangwu@example.com'},
    {'name': '赵六', 'age': 35, 'email': 'zhaoliu@example.com'}
]
data_manager.insert_many(users)

# 批量查询
all_users = data_manager.select_all(order_by='age DESC', limit=10)
for user in all_users:
    print(f"{user['name']}: {user['age']}岁")

示例 3: 条件查询

复制代码

# 按条件查询
young_users = data_manager.select_by_condition(
    conditions={'age': 25},
    order_by='name ASC'
)

# 复杂查询
users_in_beijing = data_manager.select_by_condition({
    'city': '北京',
    'age': 25
})

# 统计
count = data_manager.count({'city': '北京'})
print(f"北京用户数: {count}")

示例 4: 自定义 SQL

复制代码

# 执行自定义SQL
sql = "SELECT city, COUNT(*) as count FROM users WHERE age > %s GROUP BY city"
results = data_manager.select_by_custom_sql(sql, params=(25,))

for row in results:
    print(f"{row['city']}: {row['count']} 人")

示例 5: 创建和管理表

复制代码

from mysql_manager import TableManager

table_manager = TableManager(db_conn)

# 创建表
columns = {
    'id': 'INT PRIMARY KEY AUTO_INCREMENT',
    'name': 'VARCHAR(100) NOT NULL',
    'age': 'INT',
    'created_at': 'TIMESTAMP DEFAULT CURRENT_TIMESTAMP'
}
table_manager.create_table('users', columns)

# 检查表是否存在
exists = table_manager.table_exists('users')
print(f"表存在: {exists}")

# 删除表
# table_manager.drop_table('users')

🔥 核心特性

上下文管理器自动处理连接

with self.db_conn.get_cursor() as cursor:

cursor.execute(sql)

自动提交和关闭游标
参数化查询防止SQL注入

安全的查询方式

sql = "SELECT * FROM users WHERE age = %s AND city = %s"

cursor.execute(sql, (25, '北京'))
字典游标返回结果

返回的是字典格式，方便访问

user = data_manager.select_by_id(1)

print(user['name']) # 直接通过键访问
异常处理和事务回滚

try:

执行数据库操作

cursor.execute(sql)

connection.commit()

except Exception as e:

connection.rollback() # 自动回滚

print(f"操作失败: {e}")

📚 API 文档

DatabaseConfig

复制代码

config = DatabaseConfig(
    host: str,        # 数据库主机
    port: int,        # 端口号
    user: str,        # 用户名
    password: str,    # 密码
    database: str,    # 数据库名
    charset: str      # 字符集（默认utf8mb4）
)

DataManager 主要方法

方法说明返回值

insert_one(data) 插入单条记录插入的ID

insert_many(data_list) 批量插入插入的记录数

delete_by_id(id) 根据ID删除 bool

delete_by_condition(conditions) 条件删除 bool

update_by_id(id, data) 根据ID更新 bool

update_by_condition(conditions, data) 条件更新 bool

select_all() 查询所有 List[Dict]

select_by_id(id) 根据ID查询 Dict

select_by_condition(conditions) 条件查询 List[Dict]

count(conditions) 统计数量 int

⚠️ 注意事项

密码安全: 不要在代码中硬编码密码，建议使用环境变量或配置文件
连接池: 生产环境建议使用连接池（如 DBUtils）
SQL注入: 始终使用参数化查询，不要拼接SQL字符串
异常处理: 生产环境需要更完善的异常处理和日志记录
事务管理: 复杂操作需要手动管理事务

🛠️ 进阶用法

使用环境变量配置

复制代码

import os

config = DatabaseConfig(
    host=os.getenv('DB_HOST', 'localhost'),
    port=int(os.getenv('DB_PORT', 3306)),
    user=os.getenv('DB_USER', 'root'),
    password=os.getenv('DB_PASSWORD'),
    database=os.getenv('DB_NAME', 'test_db')
)

添加日志记录

复制代码

import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# 在操作中使用
logger.info(f"插入成功，ID: {last_id}")
logger.error(f"操作失败: {e}")

使用上下文管理器管理连接

复制代码

class DatabaseConnection:
    def __enter__(self):
        self.connect()
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.close()

# 使用方式
with DatabaseConnection(config) as db_conn:
    data_manager = DataManager(db_conn, 'users')
    # 执行操作
    # 自动关闭连接

📝 常见问题

Q: 如何处理大量数据的插入？ A: 使用 insert_many() 批量插入，并考虑分批处理。

Q: 如何实现分页查询？ A: 使用 LIMIT 和 OFFSET：

复制代码

sql = "SELECT * FROM users LIMIT %s OFFSET %s"
results = data_manager.select_by_custom_sql(sql, (page_size, offset))

Q: 如何处理事务？ A: 使用 get_cursor() 上下文管理器会自动处理事务。

完整代码示例

复制代码

"""
MySQL 数据库管理模块
功能：提供完整的数据库连接、表创建、增删改查操作
作者：示例代码
日期：2024
"""

import pymysql
from typing import List, Dict, Optional, Any
from contextlib import contextmanager


# ================================
# 1. 数据库配置类
# 职责：管理数据库连接配置信息
# ================================
class DatabaseConfig:
    """数据库配置类，存储连接所需的所有参数"""

    def __init__(self, host: str, port: int, user: str,
                 password: str, database: str, charset: str = 'utf8mb4'):
        """
        初始化数据库配置
        
        参数:
            host: 数据库主机地址
            port: 数据库端口号
            user: 数据库用户名
            password: 数据库密码
            database: 数据库名称
            charset: 字符集编码，默认utf8mb4
        """
        self.host = host
        self.port = port
        self.user = user
        self.password = password
        self.database = database
        self.charset = charset

    def to_dict(self) -> Dict[str, Any]:
        """
        将配置转换为字典格式
        
        返回:
            包含所有配置信息的字典
        """
        return {
            'host': self.host,
            'port': self.port,
            'user': self.user,
            'password': self.password,
            'database': self.database,
            'charset': self.charset
        }


# ================================
# 2. 数据库连接管理类
# 职责：管理数据库连接的创建、关闭和复用
# ================================
class DatabaseConnection:
    """数据库连接管理类，负责连接的生命周期管理"""

    def __init__(self, config: DatabaseConfig):
        """
        初始化数据库连接管理器
        
        参数:
            config: DatabaseConfig对象，包含连接配置
        """
        self.config = config
        self.connection = None

    def connect(self) -> pymysql.Connection:
        """
        创建并返回数据库连接
        
        返回:
            pymysql连接对象
        
        异常:
            如果连接失败会抛出异常
        """
        try:
            self.connection = pymysql.connect(**self.config.to_dict())
            print(f"✓ 成功连接到数据库: {self.config.database}")
            return self.connection
        except Exception as e:
            print(f"✗ 数据库连接失败: {e}")
            raise

    def close(self):
        """关闭数据库连接"""
        if self.connection:
            self.connection.close()
            print("✓ 数据库连接已关闭")

    @contextmanager
    def get_cursor(self):
        """
        上下文管理器：获取游标并自动管理提交和关闭
        
        用法:
            with db_conn.get_cursor() as cursor:
                cursor.execute(sql)
        
        yield:
            数据库游标对象
        """
        cursor = None
        try:
            # 确保有活动连接
            if not self.connection or not self.connection.open:
                self.connect()

            # 创建游标
            cursor = self.connection.cursor(pymysql.cursors.DictCursor)
            yield cursor

            # 提交事务
            self.connection.commit()
        except Exception as e:
            # 发生错误时回滚
            if self.connection:
                self.connection.rollback()
            print(f"✗ 操作失败，已回滚: {e}")
            raise
        finally:
            # 关闭游标
            if cursor:
                cursor.close()


# ================================
# 3. 表管理类
# 职责：处理数据表的创建、删除等DDL操作
# ================================
class TableManager:
    """表管理类，负责数据表的结构操作"""

    def __init__(self, db_connection: DatabaseConnection):
        """
        初始化表管理器
        
        参数:
            db_connection: DatabaseConnection对象
        """
        self.db_conn = db_connection

    def create_table(self, table_name: str, columns: Dict[str, str]) -> bool:
        """
        创建数据表
        
        参数:
            table_name: 表名
            columns: 列定义字典，格式 {'列名': '列类型及约束'}
        
        返回:
            True表示成功，False表示失败
        
        示例:
            columns = {
                'id': 'INT PRIMARY KEY AUTO_INCREMENT',
                'name': 'VARCHAR(100) NOT NULL',
                'age': 'INT'
            }
        """
        try:
            # 构建列定义字符串
            column_definitions = ', '.join(
                [f"{col_name} {col_type}" for col_name, col_type in columns.items()]
            )

            # 构建完整的CREATE TABLE语句
            sql = f"""
            CREATE TABLE IF NOT EXISTS {table_name} (
                {column_definitions}
            ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
            """

            with self.db_conn.get_cursor() as cursor:
                cursor.execute(sql)

            print(f"✓ 表 '{table_name}' 创建成功")
            return True
        except Exception as e:
            print(f"✗ 表创建失败: {e}")
            return False

    def drop_table(self, table_name: str) -> bool:
        """
        删除数据表
        
        参数:
            table_name: 要删除的表名
        
        返回:
            True表示成功，False表示失败
        """
        try:
            sql = f"DROP TABLE IF EXISTS {table_name}"

            with self.db_conn.get_cursor() as cursor:
                cursor.execute(sql)

            print(f"✓ 表 '{table_name}' 删除成功")
            return True
        except Exception as e:
            print(f"✗ 表删除失败: {e}")
            return False

    def table_exists(self, table_name: str) -> bool:
        """
        检查表是否存在
        
        参数:
            table_name: 表名
        
        返回:
            True表示存在，False表示不存在
        """
        try:
            sql = f"SHOW TABLES LIKE '{table_name}'"

            with self.db_conn.get_cursor() as cursor:
                cursor.execute(sql)
                result = cursor.fetchone()

            return result is not None
        except Exception as e:
            print(f"✗ 检查表存在性失败: {e}")
            return False


# ================================
# 4. 数据操作类 (CRUD)
# 职责：处理数据的增删改查操作
# ================================
class DataManager:
    """数据管理类，负责数据的增删改查操作"""

    def __init__(self, db_connection: DatabaseConnection, table_name: str):
        """
        初始化数据管理器
        
        参数:
            db_connection: DatabaseConnection对象
            table_name: 要操作的表名
        """
        self.db_conn = db_connection
        self.table_name = table_name

    # -------------------- 增 (Create) --------------------
    def insert_one(self, data: Dict[str, Any]) -> Optional[int]:
        """
        插入单条记录
        
        参数:
            data: 要插入的数据字典，格式 {'列名': 值}
        
        返回:
            插入记录的ID，失败返回None
        
        示例:
            data = {'name': '张三', 'age': 25, 'email': 'zhangsan@example.com'}
        """
        try:
            # 提取列名和值
            columns = ', '.join(data.keys())
            placeholders = ', '.join(['%s'] * len(data))
            values = tuple(data.values())

            # 构建INSERT语句
            sql = f"INSERT INTO {self.table_name} ({columns}) VALUES ({placeholders})"

            with self.db_conn.get_cursor() as cursor:
                cursor.execute(sql, values)
                last_id = cursor.lastrowid

            print(f"✓ 插入成功，ID: {last_id}")
            return last_id
        except Exception as e:
            print(f"✗ 插入失败: {e}")
            return None

    def insert_many(self, data_list: List[Dict[str, Any]]) -> int:
        """
        批量插入多条记录
        
        参数:
            data_list: 数据字典列表
        
        返回:
            成功插入的记录数
        
        示例:
            data_list = [
                {'name': '张三', 'age': 25},
                {'name': '李四', 'age': 30}
            ]
        """
        if not data_list:
            return 0

        try:
            # 使用第一条记录的键作为列名
            columns = ', '.join(data_list[0].keys())
            placeholders = ', '.join(['%s'] * len(data_list[0]))

            # 构建INSERT语句
            sql = f"INSERT INTO {self.table_name} ({columns}) VALUES ({placeholders})"

            # 提取所有记录的值
            values_list = [tuple(data.values()) for data in data_list]

            with self.db_conn.get_cursor() as cursor:
                cursor.executemany(sql, values_list)
                affected_rows = cursor.rowcount

            print(f"✓ 批量插入成功，共 {affected_rows} 条记录")
            return affected_rows
        except Exception as e:
            print(f"✗ 批量插入失败: {e}")
            return 0

    # -------------------- 删 (Delete) --------------------
    def delete_by_id(self, id_value: Any) -> bool:
        """
        根据ID删除记录
        
        参数:
            id_value: ID值
        
        返回:
            True表示成功，False表示失败
        """
        return self.delete_by_condition({'id': id_value})

    def delete_by_condition(self, conditions: Dict[str, Any]) -> bool:
        """
        根据条件删除记录
        
        参数:
            conditions: 删除条件字典，格式 {'列名': 值}
        
        返回:
            True表示成功，False表示失败
        
        示例:
            conditions = {'age': 25, 'status': 'inactive'}
        """
        try:
            # 构建WHERE子句
            where_clause = ' AND '.join([f"{key} = %s" for key in conditions.keys()])
            values = tuple(conditions.values())

            # 构建DELETE语句
            sql = f"DELETE FROM {self.table_name} WHERE {where_clause}"

            with self.db_conn.get_cursor() as cursor:
                cursor.execute(sql, values)
                affected_rows = cursor.rowcount

            print(f"✓ 删除成功，影响 {affected_rows} 条记录")
            return True
        except Exception as e:
            print(f"✗ 删除失败: {e}")
            return False

    def delete_all(self) -> bool:
        """
        删除表中所有记录（慎用！）
        
        返回:
            True表示成功，False表示失败
        """
        try:
            sql = f"DELETE FROM {self.table_name}"

            with self.db_conn.get_cursor() as cursor:
                cursor.execute(sql)
                affected_rows = cursor.rowcount

            print(f"⚠ 已删除所有记录，共 {affected_rows} 条")
            return True
        except Exception as e:
            print(f"✗ 删除所有记录失败: {e}")
            return False

    # -------------------- 改 (Update) --------------------
    def update_by_id(self, id_value: Any, update_data: Dict[str, Any]) -> bool:
        """
        根据ID更新记录
        
        参数:
            id_value: ID值
            update_data: 要更新的数据字典
        
        返回:
            True表示成功，False表示失败
        
        示例:
            update_data = {'name': '王五', 'age': 28}
        """
        return self.update_by_condition({'id': id_value}, update_data)

    def update_by_condition(self, conditions: Dict[str, Any],
                            update_data: Dict[str, Any]) -> bool:
        """
        根据条件更新记录
        
        参数:
            conditions: 更新条件字典
            update_data: 要更新的数据字典
        
        返回:
            True表示成功，False表示失败
        
        示例:
            conditions = {'status': 'pending'}
            update_data = {'status': 'completed', 'updated_at': '2024-01-01'}
        """
        try:
            # 构建SET子句
            set_clause = ', '.join([f"{key} = %s" for key in update_data.keys()])

            # 构建WHERE子句
            where_clause = ' AND '.join([f"{key} = %s" for key in conditions.keys()])

            # 合并所有值
            values = tuple(list(update_data.values()) + list(conditions.values()))

            # 构建UPDATE语句
            sql = f"UPDATE {self.table_name} SET {set_clause} WHERE {where_clause}"

            with self.db_conn.get_cursor() as cursor:
                cursor.execute(sql, values)
                affected_rows = cursor.rowcount

            print(f"✓ 更新成功，影响 {affected_rows} 条记录")
            return True
        except Exception as e:
            print(f"✗ 更新失败: {e}")
            return False

    # -------------------- 查 (Read) --------------------
    def select_all(self, order_by: Optional[str] = None,
                   limit: Optional[int] = None) -> List[Dict[str, Any]]:
        """
        查询所有记录
        
        参数:
            order_by: 排序字段，如 'age DESC'
            limit: 限制返回数量
        
        返回:
            记录列表，每条记录为字典
        """
        try:
            sql = f"SELECT * FROM {self.table_name}"

            # 添加排序
            if order_by:
                sql += f" ORDER BY {order_by}"

            # 添加限制
            if limit:
                sql += f" LIMIT {limit}"

            with self.db_conn.get_cursor() as cursor:
                cursor.execute(sql)
                results = cursor.fetchall()

            print(f"✓ 查询成功，返回 {len(results)} 条记录")
            return results
        except Exception as e:
            print(f"✗ 查询失败: {e}")
            return []

    def select_by_id(self, id_value: Any) -> Optional[Dict[str, Any]]:
        """
        根据ID查询单条记录
        
        参数:
            id_value: ID值
        
        返回:
            记录字典，未找到返回None
        """
        results = self.select_by_condition({'id': id_value})
        return results[0] if results else None

    def select_by_condition(self, conditions: Dict[str, Any],
                            order_by: Optional[str] = None,
                            limit: Optional[int] = None) -> List[Dict[str, Any]]:
        """
        根据条件查询记录
        
        参数:
            conditions: 查询条件字典
            order_by: 排序字段
            limit: 限制返回数量
        
        返回:
            记录列表
        
        示例:
            conditions = {'age': 25, 'city': '北京'}
        """
        try:
            # 构建WHERE子句
            where_clause = ' AND '.join([f"{key} = %s" for key in conditions.keys()])
            values = tuple(conditions.values())

            # 构建SELECT语句
            sql = f"SELECT * FROM {self.table_name} WHERE {where_clause}"

            # 添加排序
            if order_by:
                sql += f" ORDER BY {order_by}"

            # 添加限制
            if limit:
                sql += f" LIMIT {limit}"

            with self.db_conn.get_cursor() as cursor:
                cursor.execute(sql, values)
                results = cursor.fetchall()

            print(f"✓ 条件查询成功，返回 {len(results)} 条记录")
            return results
        except Exception as e:
            print(f"✗ 条件查询失败: {e}")
            return []

    def select_by_custom_sql(self, sql: str, params: tuple = ()) -> List[Dict[str, Any]]:
        """
        执行自定义SQL查询
        
        参数:
            sql: SQL查询语句
            params: SQL参数元组
        
        返回:
            查询结果列表
        
        示例:
            sql = "SELECT * FROM users WHERE age > %s AND city = %s"
            params = (25, '北京')
        """
        try:
            with self.db_conn.get_cursor() as cursor:
                cursor.execute(sql, params)
                results = cursor.fetchall()

            print(f"✓ 自定义查询成功，返回 {len(results)} 条记录")
            return results
        except Exception as e:
            print(f"✗ 自定义查询失败: {e}")
            return []

    def count(self, conditions: Optional[Dict[str, Any]] = None) -> int:
        """
        统计记录数量
        
        参数:
            conditions: 统计条件字典，None表示统计所有
        
        返回:
            记录数量
        """
        try:
            if conditions:
                # 构建WHERE子句
                where_clause = ' AND '.join([f"{key} = %s" for key in conditions.keys()])
                values = tuple(conditions.values())
                sql = f"SELECT COUNT(*) as count FROM {self.table_name} WHERE {where_clause}"
            else:
                sql = f"SELECT COUNT(*) as count FROM {self.table_name}"
                values = ()

            with self.db_conn.get_cursor() as cursor:
                cursor.execute(sql, values)
                result = cursor.fetchone()

            count = result['count'] if result else 0
            print(f"✓ 统计完成，共 {count} 条记录")
            return count
        except Exception as e:
            print(f"✗ 统计失败: {e}")
            return 0


# ================================
# 5. 主程序示例
# 职责：演示如何使用上述类进行数据库操作
# ================================
def main():
    """主程序：演示完整的数据库操作流程"""

    print("=" * 60)
    print("MySQL 数据库操作示例程序")
    print("=" * 60)

    # ---------- 步骤1: 配置数据库连接 ----------
    print("\n【步骤1】配置数据库连接")
    config = DatabaseConfig(
        host='localhost',  # 数据库主机
        port=3306,  # 数据库端口
        user='root',  # 数据库用户名
        password='your_password',  # 数据库密码（请修改为实际密码）
        database='test_db'  # 数据库名称
    )

    # ---------- 步骤2: 创建连接 ----------
    print("\n【步骤2】创建数据库连接")
    db_conn = DatabaseConnection(config)

    try:
        db_conn.connect()

        # ---------- 步骤3: 创建表 ----------
        print("\n【步骤3】创建数据表")
        table_manager = TableManager(db_conn)

        # 定义表结构
        columns = {
            'id': 'INT PRIMARY KEY AUTO_INCREMENT COMMENT "主键ID"',
            'name': 'VARCHAR(100) NOT NULL COMMENT "姓名"',
            'age': 'INT COMMENT "年龄"',
            'email': 'VARCHAR(100) COMMENT "邮箱"',
            'city': 'VARCHAR(50) COMMENT "城市"',
            'created_at': 'TIMESTAMP DEFAULT CURRENT_TIMESTAMP COMMENT "创建时间"'
        }

        table_manager.create_table('users', columns)

        # ---------- 步骤4: 初始化数据管理器 ----------
        print("\n【步骤4】初始化数据管理器")
        data_manager = DataManager(db_conn, 'users')

        # ---------- 步骤5: 插入数据 ----------
        print("\n【步骤5】插入数据")

        # 5.1 插入单条记录
        print("\n5.1 插入单条记录:")
        user1 = {
            'name': '张三',
            'age': 25,
            'email': 'zhangsan@example.com',
            'city': '北京'
        }
        user1_id = data_manager.insert_one(user1)

        # 5.2 批量插入记录
        print("\n5.2 批量插入记录:")
        users = [
            {'name': '李四', 'age': 30, 'email': 'lisi@example.com', 'city': '上海'},
            {'name': '王五', 'age': 28, 'email': 'wangwu@example.com', 'city': '广州'},
            {'name': '赵六', 'age': 35, 'email': 'zhaoliu@example.com', 'city': '深圳'},
            {'name': '钱七', 'age': 22, 'email': 'qianqi@example.com', 'city': '北京'}
        ]
        data_manager.insert_many(users)

        # ---------- 步骤6: 查询数据 ----------
        print("\n【步骤6】查询数据")

        # 6.1 查询所有记录
        print("\n6.1 查询所有记录:")
        all_users = data_manager.select_all(order_by='age DESC')
        for user in all_users:
            print(f"  - ID: {user['id']}, 姓名: {user['name']}, "
                  f"年龄: {user['age']}, 城市: {user['city']}")

        # 6.2 根据ID查询
        print("\n6.2 根据ID查询:")
        if user1_id:
            user = data_manager.select_by_id(user1_id)
            if user:
                print(f"  找到用户: {user['name']}, 年龄: {user['age']}")

        # 6.3 根据条件查询
        print("\n6.3 根据条件查询（城市=北京）:")
        beijing_users = data_manager.select_by_condition({'city': '北京'})
        for user in beijing_users:
            print(f"  - {user['name']}, 年龄: {user['age']}")

        # 6.4 统计记录数
        print("\n6.4 统计记录数:")
        total_count = data_manager.count()
        beijing_count = data_manager.count({'city': '北京'})
        print(f"  总记录数: {total_count}")
        print(f"  北京用户数: {beijing_count}")

        # ---------- 步骤7: 更新数据 ----------
        print("\n【步骤7】更新数据")

        # 7.1 根据ID更新
        print("\n7.1 根据ID更新:")
        if user1_id:
            data_manager.update_by_id(user1_id, {'age': 26, 'city': '杭州'})
            updated_user = data_manager.select_by_id(user1_id)
            if updated_user:
                print(f"  更新后: {updated_user['name']}, "
                      f"年龄: {updated_user['age']}, 城市: {updated_user['city']}")

        # 7.2 根据条件批量更新
        print("\n7.2 根据条件批量更新（城市=上海 -> 城市=苏州）:")
        data_manager.update_by_condition(
            conditions={'city': '上海'},
            update_data={'city': '苏州'}
        )

        # ---------- 步骤8: 删除数据 ----------
        print("\n【步骤8】删除数据")

        # 8.1 根据条件删除
        print("\n8.1 根据条件删除（年龄>30）:")
        data_manager.delete_by_condition({'age': 35})

        # 8.2 查看删除后的结果
        print("\n8.2 删除后查询所有记录:")
        remaining_users = data_manager.select_all()
        print(f"  剩余用户数: {len(remaining_users)}")

        # ---------- 步骤9: 自定义SQL查询 ----------
        print("\n【步骤9】自定义SQL查询")
        custom_sql = "SELECT city, COUNT(*) as count FROM users GROUP BY city"
        city_stats = data_manager.select_by_custom_sql(custom_sql)
        print("  各城市用户统计:")
        for stat in city_stats:
            print(f"    {stat['city']}: {stat['count']} 人")

        # ---------- 步骤10: 清理（可选） ----------
        print("\n【步骤10】清理操作（注释掉以保留数据）")
        # 如果需要删除表，取消下面的注释
        # table_manager.drop_table('users')

    except Exception as e:
        print(f"\n程序执行出错: {e}")

    finally:
        # ---------- 步骤11: 关闭连接 ----------
        print("\n【步骤11】关闭数据库连接")
        db_conn.close()

    print("\n" + "=" * 60)
    print("程序执行完毕")
    print("=" * 60)


# ================================
# 程序入口
# ================================
if __name__ == '__main__':
    main()

📄 许可证

本项目仅供学习参考使用。

🤝 贡献

欢迎提出问题和改进建议！

Python MySQL 数据库操作完整示例

自动提交和关闭游标

安全的查询方式

返回的是字典格式，方便访问

执行数据库操作