【Python】SQLAlchemy：快速上手

ORM（对象关系映射） 是一种编程技术，用于将面向对象编程中的对象模型与关系数据库中的表结构相映射。它的主要目标是简化数据库操作，使得开发者能够使用面向对象的方式来操作数据库，而不必直接编写 SQL 语句。ORM 通过将数据库表映射为对象，将表中的行映射为对象实例，并将列映射为对象属性，从而使得操作数据库的代码更加直观和简洁。

声明模型

首先，我们需要定义数据库中的表和映射到这些表的 Python 对象模型。这是通过声明模型实现的。

from sqlalchemy.orm import DeclarativeBase
from sqlalchemy.orm import mapped_column
from sqlalchemy.orm import Mapped

class Base(DeclarativeBase):
    pass

class User(Base):
    __tablename__ = "user_account"

    id: Mapped[int] = mapped_column(primary_key=True)
    name: Mapped[str] = mapped_column(String(30))
    fullname: Mapped[Optional[str]]

    def __repr__(self) -> str:
        return f"User(id={self.id!r}, name={self.name!r}, fullname={self.fullname!r})"

概述

• DeclarativeBase: 定义了一个声明式基础，用于创建 ORM 映射类。
• mapped_column: 定义类属性与数据库列的映射。
• Mapped: 表示类属性的类型。
• __tablename__: 指定 ORM 类对应的数据库表名。
• __repr__: 提供对象的字符串表示，用于调试和打印。

导入部分

from sqlalchemy.orm import DeclarativeBase
from sqlalchemy.orm import mapped_column
from sqlalchemy.orm import Mapped
from sqlalchemy import String
from typing import Optional

• DeclarativeBase: 是 SQLAlchemy 中一个新的基类，用于定义 ORM 映射。它是旧版 declarative_base 的替代品，简化了声明式基础的定义。
• mapped_column: 是用于定义 ORM 类属性的映射列的函数。它取代了旧版的 Column 函数。
• Mapped: 是一个泛型类型，用于表示映射到数据库列的属性类型。

定义 Base 类

class Base(DeclarativeBase):
    pass

• Base: 继承自 DeclarativeBase，用于作为所有 ORM 映射类的基类。它定义了一个基础类，使得继承自它的类可以被 SQLAlchemy 识别为 ORM 映射类。

定义 User 类

class User(Base):
    __tablename__ = "user_account"

    id: Mapped[int] = mapped_column(primary_key=True)
    name: Mapped[str] = mapped_column(String(30))
    fullname: Mapped[Optional[str]]
    
    def __repr__(self) -> str:
        return f"User(id={self.id!r}, name={self.name!r}, fullname={self.fullname!r})"

• User: 继承自 Base，定义了一个 ORM 映射类，映射到数据库中的 user_account 表。

• __tablename__: 指定 ORM 类映射到的数据库表名。在这里是 "user_account"。

  属性定义

  • id: Mapped[int]: 定义了一个名为 id 的列，类型为整数。它是主键列，通过 mapped_column(primary_key=True) 进行映射。
  • name: Mapped[str]: 定义了一个名为 name 的列，类型为字符串，最大长度为 30。通过 mapped_column(String(30)) 进行映射。
  • fullname: Mapped[Optional[str]]: 定义了一个名为 fullname 的列，类型为可选的字符串。由于没有使用 mapped_column 来定义它，默认将其映射到一个列，但没有指定类型和其他参数。Optional[str] 表示该列可以为 None。

__repr__ 方法

def __repr__(self) -> str:
    return f"User(id={self.id!r}, name={self.name!r}, fullname={self.fullname!r})"

• __repr__: 是一个魔术方法，用于返回对象的字符串表示形式。它在打印对象时调用，帮助调试和开发时更容易查看对象的状态。!r 表示使用 repr() 函数来获取属性的字符串表示。

创建数据库引擎和表

创建引擎后，可以使用 metadata.create_all() 方法在数据库中生成表结构。

from sqlalchemy import create_engine

engine = create_engine("sqlite://", echo=True)
Base.metadata.create_all(engine)

概述

• create_engine("sqlite://", echo=True): 创建了一个连接到 SQLite 内存数据库的引擎，并启用了 SQL 语句的日志记录。
• Base.metadata.create_all(engine): 在指定的数据库引擎上创建所有在 Base 类及其子类中定义的表结构。

导入部分

from sqlalchemy import create_engine

• create_engine: 是 SQLAlchemy 用于创建数据库引擎的函数。它用于定义数据库的连接字符串，并管理与数据库的连接和操作。

创建数据库引擎

engine = create_engine("sqlite://", echo=True)

• create_engine: 这个函数用来创建一个 SQLAlchemy 的引擎实例。引擎实例是 SQLAlchemy 与数据库之间的接口，负责实际的数据库连接和执行 SQL 语句。
  • "sqlite://": 这是一个 SQLite 数据库的连接字符串。在这里使用的是内存数据库（sqlite://），即数据库会存储在内存中而不是文件系统中。你也可以指定具体的文件路径，例如 "sqlite:///path/to/database.db"，来创建一个持久化的数据库文件。
  • echo=True: 这个参数用于设置 SQLAlchemy 的日志记录功能。True 表示启用日志记录，SQLAlchemy 会输出所有执行的 SQL 语句及其执行结果。这对于调试和分析数据库操作非常有用。echo 也可以设置为 False 来禁用日志记录。

• 以下是连接到不同类型数据库时，创建 SQLAlchemy 引擎实例的输入参数的表格展示。这个表格包括了常见的数据库类型、对应的 SQLAlchemy URL 格式以及示例 URL：

  数据库类型	SQLAlchemy URL 格式	示例 URL
  SQLite	sqlite:///path/to/database.db	sqlite:///example.db
  PostgreSQL	postgresql://username:password@host:port/dbname	postgresql://user:password@localhost:5432/mydatabase
  MySQL	mysql://username:password@host:port/dbname	mysql://user:password@localhost:3306/mydatabase
  MariaDB	mariadb://username:password@host:port/dbname	mariadb://user:password@localhost:3306/mydatabase
  Oracle	oracle://username:password@host:port/dbname	oracle://user:password@localhost:1521/mydatabase
  Microsoft SQL Server	mssql+pyodbc://username:password@host:port/dbname?driver=DRIVER_NAME	mssql+pyodbc://user:password@localhost:1433/mydatabase?driver=ODBC+Driver+17+for+SQL+Server
  SQLite (in-memory)	sqlite:///:memory:	sqlite:///:memory:

创建所有表

Base.metadata.create_all(engine)

• Base.metadata: Base 是之前定义的 ORM 基类。metadata 是 SQLAlchemy 用于描述表和列的元数据对象。它包含了所有由 Base 类及其子类（例如 User 类）定义的表结构信息。

• create_all(engine): 这个方法用于在指定的数据库引擎上创建所有在 Base.metadata 中定义的表。也就是说，所有继承自 Base 的类所定义的表结构会被应用到数据库中。

  • engine: 是创建表的目标数据库引擎。这个引擎指定了连接的数据库（在这里是 SQLite 内存数据库）。

插入数据

有了表之后，可以开始向数据库插入数据。

from sqlalchemy.orm import Session

with Session(engine) as session:
    spongebob = User(name="spongebob", fullname="Spongebob Squarepants")
    session.add(spongebob)
    session.commit()

概述

• Session(engine): 初始化数据库会话，管理与数据库的交互。
• with Session(engine) as session:: 使用上下文管理器来创建会话，确保在操作完成后会话被正确关闭。
• User(name="spongebob", fullname="Spongebob Squarepants"): 创建一个新的 User 实例，准备插入到数据库中。
• session.add(spongebob): 将 spongebob 对象添加到会话中，标记为待插入。
• session.commit(): 提交事务，将所有更改持久化到数据库中。

导入部分

from sqlalchemy.orm import Session

• Session: 这是 SQLAlchemy 的一个类，用于创建一个数据库会话。会话是与数据库交互的工作单位，负责跟踪对象的状态和处理事务。它管理对数据库的增删改查操作，并在操作完成后提交事务。

创建和使用数据库会话

with Session(engine) as session:

• Session(engine): 使用创建的数据库引擎 engine 来初始化一个新的 Session 实例。这个 Session 实例用于管理与数据库的交互。

  • engine: 是之前创建的数据库引擎（在这里是 SQLite 内存数据库），它定义了连接的数据库和执行 SQL 语句的环境。

• with ... as session:: 使用上下文管理器来确保会话在使用完成后被正确关闭。上下文管理器的 with 语句块保证了在操作结束后，session 会自动调用 session.close() 方法，以释放数据库资源并确保事务的一致性。

创建并添加记录

    spongebob = User(name="spongebob", fullname="Spongebob Squarepants")

• User(name="spongebob", fullname="Spongebob Squarepants"): 创建一个 User 实例，表示要插入到数据库中的记录。name 和 fullname 是 User 类中的属性值，对应于数据库中的列。

添加到会话

    session.add(spongebob)

• session.add(spongebob): 将 spongebob 对象添加到当前会话中。这并不会立即将数据写入数据库，而是将其标记为待插入的状态。会话会在后续的提交操作中将这些更改应用到数据库中。

提交事务

    session.commit()

• session.commit(): 提交当前会话中的所有更改，将待插入的数据持久化到数据库中。提交操作会结束当前事务，并将所有标记为待处理的更改（包括插入、更新和删除操作）保存到数据库中。

简单查询

插入数据后，可以使用 select 语句从数据库中检索数据。

from sqlalchemy import select

stmt = select(User).where(User.name == "spongebob")
with Session(engine) as session:
    result = session.scalars(stmt).one()
    print(result)

概述

• from sqlalchemy import select: 导入 select 函数，用于构建 SQL 查询语句。
• stmt = select(User).where(User.name == "spongebob"): 创建一个查询 User 表中 name 列为 "spongebob" 的记录的 SQL 查询对象。
• with Session(engine) as session:: 使用上下文管理器创建数据库会话，确保会话在完成后正确关闭。
• session.scalars(stmt).one(): 执行查询，返回结果集，并从中提取单个结果。
• print(result): 打印查询结果的详细信息。

导入部分

from sqlalchemy import select

• select: 这是 SQLAlchemy 中用于构建 SQL 查询语句的函数。它允许你指定从哪个表中选择数据，并且可以添加条件来过滤结果。

构建查询

stmt = select(User).where(User.name == "spongebob")

• select(User): 创建一个 SELECT 查询，选择 User 表中的所有列。User 是之前定义的映射到数据库的表的类。

• where(User.name == "spongebob"): 添加一个过滤条件，指定查询应仅返回 name 列等于 "spongebob" 的记录。User.name 是 User 类中的属性，表示数据库表中的列。

• stmt: 这是一个 Select 对象，表示构建好的 SQL 查询语句。它尚未执行，只是定义了查询的内容和条件。

执行查询并获取结果

with Session(engine) as session:

• Session(engine): 使用创建的数据库引擎 engine 初始化一个新的 Session 实例，用于与数据库交互。

• with ... as session:: 使用上下文管理器来确保会话在使用完成后被正确关闭。会话在执行查询后会自动调用 session.close()，以释放资源并保持数据的一致性。

执行查询

    result = session.scalars(stmt).one()

• session.scalars(stmt): 执行查询并返回一个可迭代的结果集。scalars 方法用于提取查询结果的单一列的值，并以生成器形式返回。这在你只对查询结果中的某些特定列感兴趣时很有用。因为这里查询的是整个 User 对象，因此实际返回的是完整的对象。

• one(): 从结果集中获取单个结果。如果查询返回多个结果，one() 方法会引发 MultipleResultsFound 异常；如果没有结果，one() 方法会引发 NoResultFound 异常。在这种情况下，假设查询会找到唯一的结果。

• result: 存储查询的结果，这里是 User 对象。

打印结果

    print(result)

• print(result): 打印查询结果，这里是 User 对象。由于 User 类定义了 __repr__ 方法，打印结果时会显示对象的详细信息。

多表关系与关联查询

ORM 支持定义和操作表之间的关系，比如一对多关系。

from typing import List
from sqlalchemy.orm import relationship

class Address(Base):
    __tablename__ = "address"

    id: Mapped[int] = mapped_column(primary_key=True)
    email_address: Mapped[str]
    user_id: Mapped[int] = mapped_column(ForeignKey("user_account.id"))

    user: Mapped["User"] = relationship(back_populates="addresses")

class User(Base):
    __tablename__ = "user_account"

    id: Mapped[int] = mapped_column(primary_key=True)
    name: Mapped[str] = mapped_column(String(30))
    fullname: Mapped[Optional[str]]

    addresses: Mapped[List[Address]] = relationship(back_populates="user")

概述

• from typing import List: 导入 List 泛型，用于指定 Mapped 类型的列表。
• from sqlalchemy.orm import relationship: 导入 relationship 函数，用于定义模型类之间的关系。
• Address 类: 映射到 address 表，定义了与 User 表的外键关系，并通过 relationship 定义了双向关系。
• User 类: 映射到 user_account 表，定义了与 Address 表的关系，并通过 relationship 定义了双向关系。

导入部分

from typing import List
from sqlalchemy.orm import relationship

• List: 从 typing 模块导入的泛型类型，表示一个列表。用于在类型注解中指定 Mapped 类型的列表。
• relationship: 从 SQLAlchemy 导入的函数，用于定义模型类之间的关系。它允许你在模型之间建立关联，并提供访问相关对象的便利。

定义 Address 类

class Address(Base):
    __tablename__ = "address"

    id: Mapped[int] = mapped_column(primary_key=True)
    email_address: Mapped[str]
    user_id: Mapped[int] = mapped_column(ForeignKey("user_account.id"))

    user: Mapped["User"] = relationship(back_populates="addresses")

• class Address(Base): 定义一个名为 Address 的模型类，继承自 Base，这是所有模型类的基类。它映射到数据库中的 address 表。

• __tablename__ = "address": 指定数据库表的名称为 "address"。

• id: Mapped[int] = mapped_column(primary_key=True): 定义一个列 id，类型为整数，作为主键（primary_key=True）。Mapped 是 SQLAlchemy 中的类型注解，用于指定列的类型。

• email_address: Mapped[str]: 定义一个列 email_address，类型为字符串。这个列用来存储电子邮件地址。

• user_id: Mapped[int] = mapped_column(ForeignKey("user_account.id")): 定义一个列 user_id，类型为整数，并设置为外键，引用 user_account 表的 id 列。ForeignKey 用于设置外键约束，表示 Address 表中的 user_id 列将链接到 User 表中的 id 列。

• user: Mapped["User"] = relationship(back_populates="addresses"): 定义一个属性 user，它表示 Address 和 User 之间的关系。relationship 用于定义关系属性，back_populates 参数指定了 User 类中的 addresses 属性来建立双向关系。

定义 User 类

class User(Base):
    __tablename__ = "user_account"

    id: Mapped[int] = mapped_column(primary_key=True)
    name: Mapped[str] = mapped_column(String(30))
    fullname: Mapped[Optional[str]]

    addresses: Mapped[List[Address]] = relationship(back_populates="user")

• class User(Base): 定义一个名为 User 的模型类，继承自 Base，映射到数据库中的 user_account 表。

• __tablename__ = "user_account": 指定数据库表的名称为 "user_account"。

• id: Mapped[int] = mapped_column(primary_key=True): 定义一个列 id，类型为整数，作为主键。

• name: Mapped[str] = mapped_column(String(30)): 定义一个列 name，类型为字符串，最大长度为 30 个字符。mapped_column 是用于映射列的函数，String(30) 指定了字符串的长度限制。

• fullname: Mapped[Optional[str]]: 定义一个列 fullname，类型为可选的字符串（Optional[str]）。fullname 列可以为空。

• addresses: Mapped[List[Address]] = relationship(back_populates="user"): 定义一个属性 addresses，表示 User 和 Address 之间的关系。Mapped[List[Address]] 表示这个属性是一个 Address 对象的列表。relationship(back_populates="user") 建立双向关系，其中 back_populates 参数指定了 Address 类中的 user 属性来建立反向关联。

复杂查询：JOIN 操作

通过 JOIN，可以在多个表之间执行复杂查询。

from typing import List
from sqlalchemy.orm import relationship

class Address(Base):
    __tablename__ = "address"

    id: Mapped[int] = mapped_column(primary_key=True)
    email_address: Mapped[str]
    user_id: Mapped[int] = mapped_column(ForeignKey("user_account.id"))

    user: Mapped["User"] = relationship(back_populates="addresses")

class User(Base):
    __tablename__ = "user_account"

    id: Mapped[int] = mapped_column(primary_key=True)
    name: Mapped[str] = mapped_column(String(30))
    fullname: Mapped[Optional[str]]

    addresses: Mapped[List[Address]] = relationship(back_populates="user")

概述

• 查询构造:

  • select(Address): 定义从 Address 表中查询数据。
  • .join(Address.user): 连接 Address 和 User 表。
  • .where(User.name == "spongebob"): 添加查询条件，只返回与 "spongebob" 相关的记录。

• 执行查询:

  • Session(engine): 创建一个数据库会话。
  • session.scalars(stmt).all(): 执行查询并获取所有结果。
  • for address in results: 遍历结果。
  • print(address): 输出结果。

查询构造

stmt = (
    select(Address)
    .join(Address.user)
    .where(User.name == "spongebob")
)

• select(Address): 创建一个 SELECT 查询，目标是 Address 表。这是查询的起始点，表示我们想从 Address 表中检索数据。

• .join(Address.user): 将 Address 表和 User 表连接起来。这个连接基于 Address 表中的 user 关系属性，user 属性通过外键 user_id 关联到 User 表。这允许我们在查询中利用 User 表中的数据。

• .where(User.name == "spongebob"): 添加一个 WHERE 子句，指定查询条件为 User.name 等于 "spongebob"。这意味着我们只关心那些与名为 "spongebob" 的用户相关联的 Address 记录。

执行查询

with Session(engine) as session:
    results = session.scalars(stmt).all()
    for address in results:
        print(address)

• with Session(engine) as session:: 使用 Session 上下文管理器来创建一个会话（session）。Session 是 SQLAlchemy 中用来执行数据库操作的对象，engine 是连接数据库的引擎。上下文管理器确保会话在操作完成后正确关闭。

• results = session.scalars(stmt).all(): 执行查询并获取结果。session.scalars(stmt) 用于执行查询，并返回一个可迭代的结果集。scalars 方法提取查询结果中的标量值（即查询中只涉及到一个列的结果），而 all() 方法则将所有匹配的结果加载到列表中。

• for address in results:: 遍历查询结果中的每个 Address 对象。

• print(address): 打印每个 Address 对象的内容。假设 Address 类中定义了 __repr__ 方法，这样会输出每个地址的详细信息。

修改与删除数据

SQLAlchemy ORM 还支持对已有数据的修改和删除操作。

with Session(engine) as session:
    # 修改
    patrick = session.get(User, 3)
    patrick.fullname = "Patrick Starfish"
    
    # 删除
    session.delete(patrick)
    session.commit()

概述

1. 创建会话:

   • Session(engine): 创建一个与数据库的会话。
   • with ... as session: 确保会话在操作完成后自动关闭。

2. 修改操作:

   • session.get(User, 3): 根据主键从数据库中获取 User 对象。
   • patrick.fullname = "Patrick Starfish": 修改对象的属性。

3. 删除操作:

   • session.delete(patrick): 标记对象为删除状态。

4. 提交事务:

   • session.commit(): 将所有更改持久化到数据库中，包括修改和删除操作。

上下文管理器创建会话

with Session(engine) as session:

• with Session(engine) as session:: 使用 Session 上下文管理器来创建一个会话（session）。Session 是用来执行数据库操作的对象，engine 是连接数据库的引擎。上下文管理器 (with 语句) 确保在 with 代码块结束时，session 会自动关闭，从而避免资源泄露。

修改操作

# 修改
patrick = session.get(User, 3)
patrick.fullname = "Patrick Starfish"

• patrick = session.get(User, 3): 使用 session.get 方法根据主键（id）从数据库中获取 User 对象。这里 User 是模型类，3 是要获取的用户的主键值。如果数据库中存在具有 id=3 的用户，session.get 会返回该用户对象 (patrick)；否则返回 None。

• patrick.fullname = "Patrick Starfish": 修改获取到的用户对象的 fullname 属性。这里将 fullname 属性设置为 "Patrick Starfish"。这会标记该对象为已修改状态，但实际上不会立即写入数据库，直到 commit 操作完成。

删除操作

# 删除
session.delete(patrick)

• session.delete(patrick): 使用 session.delete 方法标记 patrick 对象为删除状态。这表示希望从数据库中删除 patrick 对象。此操作只是将删除标记添加到会话中，实际删除操作会在 commit 时执行。

提交事务

session.commit()

• session.commit(): 提交当前会话中的所有更改。commit 方法将所有标记为修改或删除的操作持久化到数据库中。包括之前对 patrick 对象的 fullname 修改和删除操作。提交操作后，这些更改会永久保存到数据库中，并且会话状态会被重置。

实战：学生信息管理系统

from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

# 创建ORM基类
Base = declarative_base()

class Student(Base):
    """
    学生信息表对应的ORM模型类。
    定义学生的ID、姓名和年龄字段。
    """
    __tablename__ = 'students'
    id = Column(Integer, primary_key=True, autoincrement=True)
    name = Column(String, nullable=False)
    age = Column(Integer, nullable=False)

    def __repr__(self):
        return f"<Student(id={self.id}, name='{self.name}', age={self.age})>"

class StudentDB:
    """
    学生信息管理系统的数据库操作类。
    提供增删改查功能。
    """
    def __init__(self, db_url='sqlite:///students.db'):
        # 创建数据库连接
        self.engine = create_engine(db_url)
        # 创建所有表
        Base.metadata.create_all(self.engine)
        # 创建数据库会话
        self.Session = sessionmaker(bind=self.engine)

    def add_student(self, name, age):
        """
        添加学生信息到数据库。
        """
        session = self.Session()
        new_student = Student(name=name, age=age)
        session.add(new_student)
        session.commit()
        session.refresh(new_student)
        print(f"Added student: {new_student}")
        session.close()


    def delete_student(self, student_id):
        """
        根据学生ID删除学生信息。
        """
        session = self.Session()
        student = session.query(Student).filter_by(id=student_id).first()
        if student:
            session.delete(student)
            session.commit()
            print(f"Deleted student: {student}")
        else:
            print(f"No student found with ID: {student_id}")
        session.close()

    def update_student(self, student_id, name=None, age=None):
        """
        更新学生信息，可以选择更新姓名和/或年龄。
        """
        session = self.Session()
        student = session.query(Student).filter_by(id=student_id).first()
        if student:
            if name:
                student.name = name
            if age:
                student.age = age
            session.commit()
            print(f"Updated student: {student}")
        else:
            print(f"No student found with ID: {student_id}")
        session.close()

    def get_student(self, student_id):
        """
        根据学生ID查询学生信息。
        """
        session = self.Session()
        student = session.query(Student).filter_by(id=student_id).first()
        session.close()
        if student:
            print(f"Retrieved student: {student}")
        else:
            print(f"No student found with ID: {student_id}")

    def list_students(self):
        """
        列出所有学生信息。
        """
        session = self.Session()
        students = session.query(Student).all()
        session.close()
        if students:
            for student in students:
                print(student)
        else:
            print("No students found.")

def main():
    db = StudentDB()

    while True:
        print("\n学生信息管理系统")
        print("1. 添加学生")
        print("2. 删除学生")
        print("3. 更新学生")
        print("4. 查询学生")
        print("5. 列出所有学生")
        print("6. 退出")

        choice = input("请选择操作: ")

        if choice == '1':
            name = input("输入学生姓名: ")
            age = int(input("输入学生年龄: "))
            db.add_student(name=name, age=age)
        elif choice == '2':
            student_id = int(input("输入要删除的学生ID: "))
            db.delete_student(student_id=student_id)
        elif choice == '3':
            student_id = int(input("输入要更新的学生ID: "))
            name = input("输入新的学生姓名(若不修改可留空): ")
            age_input = input("输入新的学生年龄(若不修改可留空): ")
            age = int(age_input) if age_input else None
            db.update_student(student_id=student_id, name=name or None, age=age)
        elif choice == '4':
            student_id = int(input("输入要查询的学生ID: "))
            db.get_student(student_id=student_id)
        elif choice == '5':
            db.list_students()
        elif choice == '6':
            print("退出系统")
            break
        else:
            print("无效的选择，请重试。")

if __name__ == "__main__":
    main()

代码说明

1. 主菜单界面:

   • 使用while True循环创建一个持续运行的主菜单，用户可以通过输入数字选择不同的操作。
   • 通过选择1到6可以分别执行添加学生、删除学生、更新学生、查询学生、列出所有学生和退出系统的操作。

2. 各项功能的实现:

   • add_student: 通过用户输入的姓名和年龄来添加学生。
   • delete_student: 通过用户输入的学生ID来删除相应的学生。
   • update_student: 通过用户输入的学生ID和可能的新姓名、年龄来更新学生信息。
   • get_student: 通过用户输入的学生ID来查询特定学生的信息。
   • list_students: 列出数据库中所有的学生信息。

3. 输入验证:

   • 通过简单的输入处理来确保用户输入有效的数字和字符串。

使用方法

运行程序后，系统会显示一个操作菜单，用户可以根据提示选择操作，如输入1以添加学生，或输入6以退出系统。每次操作都会有进一步的提示，以便用户输入所需的信息。

这套代码不仅展示了如何使用SQLAlchemy进行数据库操作，还通过一个简单的命令行界面实现了对学生信息管理系统的操作，使得整个系统功能完善且易于使用。