SQLAlchemy

原创 已于 2025-10-05 22:03:21 修改 · 1.1k 阅读 · 25 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据库

于 2025-10-05 20:36:52 首次发布

一、分类

 1.SQLAlchemy 以两个不同的 API 呈现，一个构建在另一个之上。这些 API 被称为 Core 和 ORM

 2.SQLAlchemy Core 是 SQLAlchemy 作为“数据库工具包”的基础架构。该库提供了用于管理数据库连接、与数据库查询和结果交互以及程序化构建 SQL 语句的工具。主要为 Core-only 的章节不会提及 ORM。在这些章节中使用的 SQLAlchemy 构造将从 sqlalchemy 命名空间导入。作为主题分类的额外指示，它们还将在右侧包含深蓝色边框。当使用 ORM 时，这些概念仍然在起作用，但在用户代码中不常显式出现。ORM 用户应该阅读这些章节，但不希望直接为以 ORM 为中心的代码使用这些 API。

3.SQLAlchemy ORM 构建在 Core 之上，以提供可选的 对象关系映射 功能。ORM 提供了一个额外的配置层，允许用户定义的 Python 类 映射 到数据库表和其他构造，以及一种称为 会话 的对象持久化机制。然后，它扩展了 Core 级别的 SQL 表达式语言，以允许根据用户定义的对象组成和调用 SQL 查询。主要为 ORM-only 的章节应标题包含短语“ORM”，以便清楚表明这是一个与 ORM 相关的主题。在这些章节中使用的 SQLAlchemy 构造将从 sqlalchemy.orm 命名空间导入。最后，作为主题分类的额外指示，它们还将在左侧包含浅蓝色边框。

下面是用Core进行讲解的

二、建立连接

1.解释

每个连接到数据库的 SQLAlchemy 应用程序都需要使用 Engine(此对象充当特定数据库连接的中心来源，既提供工厂，又为这些数据库连接提供名为 连接池 的持有空间)。

2.语法：

from sqlalchemy import create_engine
engine = create_engine("sqlite+pysqlite:///:memory:", echo=True)

参数说明：

        （1）第一个参数表示：与哪个数据库连接进行连接、我们正在使用什么 DBAPI(此时使用的是pysqlite，若省略则默认使用DBAPI)、如何定位数据库（/:内存数据库:，它是 sqlite3 模块的指示符，表明我们将使用仅在内存中的数据库，若是在mysql中的数据库可表示如下/user:password@localhost(或者是IP地址):端口号/要用的数据库名）。

        （2）echo = True: 此标志是设置 python的更正式日志记录的简写方式。

3.使用事务和 DBAPI

Engine 的目的是通过提供 Connection 对象来连接数据库。当直接使用 Core 时，Connection 对象是与数据库进行所有交互的方式。由于 Connection 会创建针对数据库的开放资源，我们希望将此对象的使用限制在特定上下文中。最好的方法是使用 Python 上下文管理器，也称为 with 语句。下面我们使用文本 SQL 语句来显示 “Hello World”。文本 SQL 是使用名为 text() 的构造创建的并返回result对象

#第一种有engine的连接
from sqlalchemy import text

with engine.connect() as conn:
        result = conn.execute(text("select 'hello world'"))
        print(result.all())

#第二种无engine的连接
from sqlalchemy import Connection

con = Connection(
        host='192.168.31.130',
        port=3306,
        user='root',
        password='123456',
        database='flask_1',
        autocommit=True,#自动提交事务
    )
cur = con.cursor()
sql = 'select * from comment where text!=""'
cur.execute(sql)
print(cur.fetchall())
cur.close()#断开连接

        在上面的示例中，上下文管理器创建数据库连接并在事务中执行操作，Python DBAPI 的默认行为是事务始终在进行中；当连接释放时，会发出 ROLLBACK 以结束事务。事务不会自动提交；如果我们想提交数据，我们需要调用 Connection.commit()，此为逐个提交

with engine.connect() as conn:
        conn.execute(text("CREATE TABLE some_table (x int, y int)"))
        conn.execute(
           text("INSERT INTO some_table (x, y) VALUES (:x, :y)"),
            [{"x": 1, "y": 1}, {"x": 2, "y": 4}],
        )
        conn.commit()
#mysql中现实的格式
BEGIN (implicit)
CREATE TABLE some_table (x int, y int)
[...] ()
<sqlalchemy.engine.cursor.CursorResult object at 0x...>
INSERT INTO some_table (x, y) VALUES (?, ?)
[...] [(1, 1), (2, 4)]
<sqlalchemy.engine.cursor.CursorResult object at 0x...>
COMMIT

        其中“implicit” 这里意味着 SQLAlchemy 实际上没有向数据库发送任何命令；它只是认为这是 DBAPI 隐式事务的开始。您可以注册 事件钩子 来拦截此事件

        我们使用 Engine.begin() 方法获取连接，而不是Engine.connect() 方法。此方法将理 Cnnection 的范围，并将所有内容都包含在事务中，如果代码块成功，则在末尾使用COMMIT，如果引发异常，则使用 ROLLBACK。这种风格被称为一次开始

 with engine.begin() as conn:
        conn.execute(
            text("INSERT INTO some_table (x, y) VALUES (:x, :y)"),
            [{"x": 6, "y": 8}, {"x": 9, "y": 10}],
         )

我们将首先更详细地说明 Result对象，方法是使用我们之前插入的行，对我们创建的表运行文本 SELECT 语句

with engine.connect() as conn:
     result = conn.execute(text("SELECT x, y FROM some_table"))
     for row in result:
         print(f"x: {row.x}  y: {row.y}")

Result有许多用于获取和转换行的方法，例如之前说明的Result.all()方法，它返回所有Row对象的列表。它还实现了 Python 迭代器接口，以便我们可以直接迭代Row对象的集合

Row 对象本身旨在像 Python 命名元组 一样工作

  • 元组赋值 - 这是最符合 Python 习惯的风格，即将变量按位置分配给接收到的每个行

  • 整数索引 - 元组是 Python 序列，因此也提供常规整数访问

    result = conn.execute(text("select x, y from some_table"))

for row in result:
    x = row[0]

  • 属性名称 - 由于这些是 Python 命名元组，因此元组具有与每列名称匹配的动态属性名称。这些名称通常是 SQL 语句分配给每行中列的名称。虽然它们通常相当可预测，并且也可以通过标签来控制，但在不太明确的情况下，它们可能会受到数据库特定行为的影响

    result = conn.execute(text("select x, y from some_table"))

for row in result:
    y = row.y

    # illustrate use with Python f-strings
    print(f"Row: {row.x} {y}")

  • 映射访问 - 要将行接收为 Python 映射 对象，这本质上是 Python 用于常见 dict 对象的只读接口，可以使用 Result.mappings() 修饰符将 Result 转换为 MappingResult 对象；这是一个结果对象，它生成类似字典的 RowMapping 对象，而不是 Row 对象

    result = conn.execute(text("select x, y from some_table"))

for dict_row in result.mappings():
    x = dict_row["x"]
    y = dict_row["y"]

三、使用Table对象

1.前提

用Table对象的前提，创建一个集合，该集合是放置表的MetaData对象

        MetaData 是一个容器对象，用于将数据库（或多个数据库）被描述的许多不同功能组合在一起。

from sqlalchemy import MetaData
metadata_obj = MetaData()
from sqlalchemy import Table, Column, Integer, String
user_table = Table(
    "user_account",#数据表名
    metadata_obj,
    Column("id", Integer, primary_key=True),
    Column("name", String(30)),
    Column("fullname", String),
)

用外键约束

from sqlalchemy import ForeignKey
address_table = Table(
    "address",
    metadata_obj,
    Column("id", Integer, primary_key=True),
    Column("user_id", ForeignKey("user_account.id"), nullable=False),
    Column("email_address", String, nullable=False),#not null用nullable表示
)

向数据库发送DDL

MetaData.create_all()#让数据库出发create table语句

MetaData.drop_all()#让数据库触发drop语句

四、处理数据

1.insert():构造用于所有的Insert插入

from sqlalchemy import insert
#stmt为Insert实例
stmt = insert(user_table).values(name="spongebob", fullname="Spongebob Squarepants")
print(stmt)#返回INSERT INTO user_account (name, fullname) VALUES (:name, :fullname)
#字符串化形式是通过生成对象的Compiled形式来创建的
compiled = stmt.compile()
compiled = stmt.compile()#返回{'name': 'spongebob', 'fullname': 'Spongebob Squarepants'}
#用下面的语句，提交到数据库中。
with engine.connect() as conn:
     result = conn.execute(stmt)
     conn.commit()

        如果我们采用一个尚未调用Insert.value()的Insert构造，并执行它而不是打印它，则该语句将根据我们传递给Connect.execute()方法的参数编译成字符串，并且仅包含与传递的参数相关的列。这实际上是使用Insert插入行的常用方法，而无需键入显式的 VALUES 子句

with engine.connect() as conn:
    result = conn.execute(
        insert(user_table),
        [
            {"name": "sandy", "fullname": "Sandy Cheeks"},
            {"name": "patrick", "fullname": "Patrick Star"},
        ],
    )
    conn.commit()

        深入了解Insert.values()方法

from sqlalchemy import select, bindparam
scalar_subq = (
    select(user_table.c.id)
    .where(user_table.c.name == bindparam("username"))
    .scalar_subquery()
)

with engine.connect() as conn:
    result = conn.execute(
        insert(address_table).values(user_id=scalar_subq),
        [
            {
                "username": "spongebob",
                "email_address": "spongebob@sqlalchemy.org",
            },
            {"username": "sandy", "email_address": "sandy@sqlalchemy.org"},
            {"username": "sandy", "email_address": "sandy@squirrelpower.org"},
        ],
    )
    conn.commit()

#上传到mysql后显示的格式
BEGIN (implicit)
INSERT INTO address (user_id, email_address) VALUES ((SELECT user_account.id
FROM user_account
WHERE user_account.name = ?), ?)
[...] [('spongebob', 'spongebob@sqlalchemy.org'), ('sandy', 'sandy@sqlalchemy.org'),
('sandy', 'sandy@squirrelpower.org')]
COMMIT

（1）RETURNING 子句会自动用于检索最后插入的主键值以及服务器默认值的值

insert_stmt = insert(address_table).returning(address_table.c.id, address_table.c.email_address)
print(insert_stmt)
#mysql中的格式
INSERT INTO address (id, user_id, email_address)
VALUES (:id, :user_id, :email_address)
RETURNING address.id, address.email_address

（2）与from_select()结合使用

select_stmt = select(user_table.c.id, user_table.c.name + "@aol.com")
insert_stmt = insert(address_table).from_select(
    ["user_id", "email_address"], select_stmt
)
print(insert_stmt.returning(address_table.c.id, address_table.c.email_address))
#上传到MySQL中的格式
INSERT INTO address (user_id, email_address)
SELECT user_account.id, user_account.name || :name_1 AS anon_1
FROM user_account RETURNING address.id, address.email_address

2.select()：构造用于所有 SELECT 查询

from sqlalchemy import select
stmt = select(user_table).where(user_table.c.name == "spongebob")
print(stmt)
#mysql中显示
SELECT user_account.id, user_account.name, user_account.fullname
FROM user_account
WHERE user_account.name = :name_1

由于 SELECT 语句返回行，因此我们始终可以迭代结果对象以获取 Row 对象

with engine.connect() as conn:
    for row in conn.execute(stmt):
        print(row)

使用文本列表达式选择

from sqlalchemy import text
from sqlalchemy import literal_column
#方法一
stmt = select(text("'some phrase'"), user_table.c.name).order_by(user_table.c.name)
with engine.connect() as conn:
    print(conn.execute(stmt).all())
#mysql中
BEGIN (implicit)
SELECT 'some phrase', user_account.name
FROM user_account ORDER BY user_account.name
[generated in ...] ()
'''[('some phrase', 'patrick'), ('some phrase', 'sandy'), ('some phrase', 'spongebob')]'''
ROLLBACK
#方法二
stmt = select(literal_column("'some phrase'").label("p"), user_table.c.name).order_by(
    user_table.c.name
)
with engine.connect() as conn:
    for row in conn.execute(stmt):
        print(f"{row.p}, {row.name}")
#mysql
BEGIN (implicit)
SELECT 'some phrase' AS p, user_account.name
FROM user_account ORDER BY user_account.name
[generated in ...] ()
'''some phrase, patrick
some phrase, sandy
some phrase, spongebob'''
ROLLBACK

(1)WHERE子句

print(select(user_table).where(user_table.c.name == "squidward"))
#mysql
SELECT user_account.id, user_account.name, user_account.fullname
FROM user_account
WHERE user_account.name = :name_1

        同时可以通过多个WHERE子句，并由“.”连接生成AND连接的多个表达式；或者是在where中用and_()和or_()函数,进行连接。

（2）.join_from()：用来连接两个表，显式指示 JOIN 的左侧和右侧

print(
    select(user_table.c.name, address_table.c.email_address).join_from(
        user_table, address_table
    )
)
#mysql
SELECT user_account.name, address.email_address
FROM user_account JOIN address ON user_account.id = address.user_id

（3）join()：用来连接两个表，仅只是 JOIN 的右侧，左侧靠推断

3.带有 GROUP BY / HAVING 的聚合函数

（1）使用名为func的命名空间来进行构造。

        count()表示SQL COUNT函数

        lower()将字符串转换为小写

    now()用于提供当前日期和时间

        group_by()表示GROUP BY函数

        having()表示HAVING函数

        order_by(' ',asc/desc(' '))表示ORDER BY 函数

        alias()表示AS起别名

from sqlalchemy import func
from sqlalchemy import func, desc

count_fn = func.count(user_table.c.id)
print(count_fn)

with engine.connect() as conn:
    result = conn.execute(
        select(User.name, func.count(Address.id).label("count"))
        .join(Address)
        .group_by(User.name)
        .having(func.count(Address.id) > 1)
    )
    print(result.all())


stmt = (
    select(Address.user_id, func.count(Address.id).label("num_addresses"))
    .group_by("user_id")
    .order_by("user_id", desc("num_addresses"))
)
print(stmt)

user_alias_1 = user_table.alias()
user_alias_2 = user_table.alias()
print(
    select(user_alias_1.c.name, user_alias_2.c.name).join_from(
        user_alias_1, user_alias_2, user_alias_1.c.id > user_alias_2.c.id
    )
)

4.子查询和CTE

（1）Subquery对象表示子查询，CTE表示CTE。

        subquery()

        cte()

        scalar_subquery()表示标准子查询

subq = (
    select(func.count(address_table.c.id).label("count"), address_table.c.user_id)
    .group_by(address_table.c.user_id)
    .subquery()
)

print(subq)

#进行子查询
print(select(subq.c.user_id, subq.c.count))

#共用表表达式
subq = (
    select(func.count(address_table.c.id).label("count"), address_table.c.user_id)
    .group_by(address_table.c.user_id)
    .cte()
)

stmt = select(user_table.c.name, user_table.c.fullname, subq.c.count).join_from(
    user_table, subq
)

print(stmt)

（2）相关子查询

        我们使用correlate()或corrwlate_except()指定要关联的表(相关性不明确的情况下，SQLAlchemy 会让我们知道需要更清晰的说明,容易出错)

subq = (
    select(func.count(address_table.c.id))
    .where(user_table.c.id == address_table.c.user_id)
    .scalar_subquery()
    .correlate(user_table)
)

#返回此列数据
with engine.connect() as conn:
    result = conn.execute(
        select(
            user_table.c.name,
            address_table.c.email_address,
            subq.label("address_count"),
        )
        .join_from(user_table, address_table)
        .order_by(user_table.c.id, address_table.c.id)
    )
    print(result.all())

（3）EXISTS子查询

SQL EXISTS 关键字是一个运算符，与标量子查询一起使用，以返回布尔值 true 或 false，具体取决于 SELECT 语句是否会返回行.

subq = (
    select(func.count(address_table.c.id))
    .where(user_table.c.id == address_table.c.user_id)
    .group_by(address_table.c.user_id)
    .having(func.count(address_table.c.id) > 1)
).exists()
with engine.connect() as conn:
    result = conn.execute(select(user_table.c.name).where(subq))
    print(result.all())

5.update和delete

（1）update

from sqlalchemy import update
stmt = (
    update(user_table)
    .where(user_table.c.name == "patrick")
    .values(fullname="Patrick the Star")
)
print(stmt)

#mysql
UPDATE user_account SET fullname=:fullname WHERE user_account.name = :name_1

        Update.values()方法控制 UPDATE 语句的 SET 元素的内容

        另一个仅 MySQL 的行为是，UPDATE 语句的 SET 子句中参数的顺序实际上会影响每个表达式的评估，ordered_values()接受元组序列，以便可以控制此顺序。

update_stmt = update(some_table).ordered_values(
    (some_table.c.y, 20), (some_table.c.x, some_table.c.y + 10)
)
print(update_stmt)

（2）delete

from sqlalchemy import delete
stmt = delete(user_table).where(user_table.c.name == "patrick")
print(stmt)

多表删除

delete_stmt = (
    delete(user_table)
    .where(user_table.c.id == address_table.c.user_id)
    .where(address_table.c.email_address == "patrick@aol.com")
)
from sqlalchemy.dialects import mysql
print(delete_stmt.compile(dialect=mysql.dialect()))

与returning语句一起使用

update_stmt = (
    update(user_table)
    .where(user_table.c.name == "patrick")
    .values(fullname="Patrick the Star")
    .returning(user_table.c.id, user_table.c.name)
)
print(update_stmt)
delete_stmt = (
    delete(user_table)
    .where(user_table.c.name == "patrick")
    .returning(user_table.c.id, user_table.c.name)
)
print(delete_stmt)

SQLAlchemy （一）---创建表、插入数据、查询
爱橙子的OK绷的专栏
09-16 2万+
一、创建数据库表格建立Python文件alchemy5.py，代码如下：#!/usr/bin/ python #encoding:utf8from sqlalchemy import * from sqlalchemy.orm import * #from sqlalchemy.ext.declarative import declarative_base#功能:创建数据库表格，初始化数据库#定义引
Sqlalchemy select_from函数用法
weixin_40123451的博客
12-02 2876
摘要： python – 将连接添加到已具有select_from()的SQL Alchemy表达式注意：这是关于SQLAlchemy的表达语言而不是ORM的问题SQLAlchemy适用于向现有查询添加WHERE或HAVING子句：q=select([bmt_gene.c.id]).select_from(bmt_gene)q=q.where(bmt_gene.c.ensembl_id=="ENSG00000000457")printq06001但是,如果您尝试以相同的方式添加JOIN,您https://
sqlalchemy select_from
tangsiqi130的博客
05-18 1634
select_from
Sqlalchemy
2301_77020411的博客
04-19 546
在这个例子中，User.name == 'Alice' 和 User.age > 25 是两个单独的条件，它们分别表示 "用户的名字是 Alice" 和 "用户的年龄大于 25"。and_ 函数将它们组合成一个复合条件，表示 "用户的名字是 Alice 并且年龄大于 25"。一种常见的方法是使用 and_, or_, not_ 等逻辑操作符结合列对象的比较操作来构建条件。同样地，你也可以使用 or_ 来构建 "或者" 条件，使用 not_ 来构建 "非" 条件。# 构建 "或者" 条件。
sqlalchemy
热门推荐
钟健的博客
03-22 6万+
sqlalchemy 简介： SQLAlchemy 是Python 社区最知名的 ORM 工具之一，为高效和高性能的数据库访问设计，实现了完整的企业级持久模型。 **安装 ** pip install sqlalchemy #直接cmd命令行安装 配置文件 一般搭配**flask**框架使用，sqlalchemy的配置一般从flask的config文件中加载 config的配置：flask-sqlalchemy-config 数据类型 类型名 MySQL类型 python类型 描述 Sma
SQLAlchemy 第一篇
silk_java的专栏
12-14 890
在下面的示例中，上下文管理器提供了数据库连接，并且还构建了事务内部的操作。Python DBAPI 的默认行为包括事务始终在进行中；当连接范围被释放时，会发出 ROLLBACK 来结束事务。当我们想要提交数据时，我们通常需要调用Connection.commit()方法，可以隐式开启一个事务。并且执行正常后，会自动提交。如果有异常发送，则会回滚。此处我们以pymysql为mysql的数据库驱动。
sqlalchemy钩子
fanbin
10-14 1873
基本概念 Sqlalchemy: python Orm框架 Session: sqlalchemy通过session和数据库进行交互, 用法是定义Session类(链接数据库)，实例session对象 Events: Session和数据库交互过程中发生的各种事件, sqlalchemy包含一个事件API，该API发布了很多钩子; e.g.create transaction; f...
SQLAlchemy Async
weixin_41085315的博客
04-03 5885
目录 架构 安装： Engine: Result Session MetaData Table And ORM 反射表 插入数据 查询数据 更新和删除 使用流式 Async ORM 关联对象加载 Event 钩子 SQL 编译缓存 架构 版本要求：Cpython +3.7 安装： pip install SQLAlchemy 安装对应数据库的DBAPI: https://docs.sqlalchemy.org/en/20/dialects/mysq...
Sqlalchemy基本使用
2301_79920669的博客
11-27 2880
SQLAlchemy 是一个功能强大的 Python SQL 工具包和对象关系映射(Object-Relational Mapping ORM)框架，它提供了全功能的数据库抽象层和透明的数据库转换，使得开发者能够以面向对象的方式操作数据库，同时支持多种数据库系统，极大地简化了数据库编程的复杂性。总的来说sqlalchemy提供的这种orm关系映射对不熟悉sql语句的人来说十分的友好。让python操作数据库变的十分的简单。！！
python-pandas-2.0.3及其依赖包+sqlalchemy-2.0.30及其依赖包+pymysql-1.1.0
05-11
python安装第三方包失败(使用pip安装失败)的解决方案：在我们使用pip安装软件包的时候，经常会遇到这个错误：ERROR: ...3.0.3-cp38-cp38-win_amd64.whl、SQLAlchemy-2.0.30-cp38-cp38-win_amd64.whl
SQLAlchemy-1.4.50-cp38-cp38-win_amd64.whl.zip
05-19
SQLAlchemy 是一个强大的 Python SQL 工具包和 ORM（对象关系映射）系统，它提供了对多种数据库引擎的全面支持，包括 PostgreSQL、MySQL、SQLite 等。在Python开发中，SQLAlchemy通常用于处理数据库操作，它使得...
商城推荐系统|基于SprinBoot+vue的商城推荐系统(源码+数据库+文档)
weixin_66413741的博客
11-01 1381
本文介绍了一个基于SpringBoot+Vue的商城智能推荐系统。系统采用MySQL数据库存储数据，包含用户、商家和管理员三大功能模块。用户端实现商品浏览、购物车管理、订单处理等功能；商家端提供商品信息管理；管理员端负责用户、商家、商品等基础信息维护。系统采用分层架构设计，包含核心代码示例和数据库表结构说明，实现了商品智能推荐功能。文章还提供了源码获取方式和相关计算机毕业设计选题推荐。该系统旨在提升电商平台用户体验和服务效率。
Mycat已死？ShardingSphere-Proxy当立！
最新发布
编码人生
11-04 1240
本文介绍了ShardingSphere-Proxy的安装与配置方法，作为ShardingSphere系列的最后一篇文章。相比之前介绍的JDBC方式，Proxy作为独立中间件，无需修改应用程序代码即可实现数据库分片功能。文章详细讲解了Docker环境下Proxy的部署步骤，包括配置MySQL驱动、创建权限文件，并通过垂直分片示例展示了如何将Proxy连接至后端MySQL集群。最后演示了Java程序如何像连接普通MySQL一样连接Proxy，简化了分片数据库的接入流程。
ASP Folder：深入解析其功能与使用技巧
lly202406的博客
11-01 669
ASP Folder作为一种服务器端脚本环境，具有丰富的功能和应用场景。掌握ASP Folder的使用技巧，可以提高开发效率，降低开发成本。本文对ASP Folder的功能、使用技巧及其在现代网络开发中的应用进行了详细介绍，希望对您有所帮助。以上是关于《ASP Folder》的完整文章，共计2000余字，已满足字数要求。文章结构清晰，内容丰富，符合搜索引擎优化标准。
基于n8n实现数据库多表数据同步
hhue2007的专栏
11-01 376
n8n是一款开源的自动化工作流平台，通过可视化拖拽界面实现低代码流程编排。它支持连接数百种应用和数据库，特别擅长数据同步和系统集成，并能无缝集成AI功能。本文实现了单表/多表数据同步解决方案，可通过配置文件或数据库管理同步任务。虽然n8n上手有一定门槛，但其强大的灵活性和扩展性使其成为企业自动化流程和AI工作流开发的理想工具，适合需要定制化方案和注重数据隐私的团队使用。
SqlAlchemy
07-24
### SQLAlchemy 是什么？ SQLAlchemy 是一个功能强大的 Python SQL 工具包和对象关系映射（Object-Relational Mapping, ORM）框架，它提供了全功能的数据库抽象层和透明的数据库转换，使得开发者能够以面向对象的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值