簡介

什么是SQLAlchemy？

SQLAlchemy是一個Python的SQL工具和ORM框架，可以通過Python代碼直接操作關(guān)系型數(shù)據(jù)庫，也可以使用ORM模型進行對象關(guān)系映射。它支持多種數(shù)據(jù)庫，并提供了強大的SQL表達式和查詢API。

SQLAlchemy可以分為兩個部分：Core和ORM。

1. Core：提供了底層的SQL表達式和查詢API，支持多種數(shù)據(jù)庫的可移植操作，例如連接管理、事務(wù)管理、對象關(guān)系映射、元數(shù)據(jù)管理等。
2. ORM：提供了基于Core的高級API，使得開發(fā)者可以使用Python的面向?qū)ο笳Z法方式來進行數(shù)據(jù)庫操作，把數(shù)據(jù)庫表中的記錄映射到Python中的對象實例上。ORM部分可以通過繼承和關(guān)聯(lián)來輕松進行數(shù)據(jù)關(guān)系的管理和維護，大大簡化了數(shù)據(jù)庫操作的難度。

以下是SQLAlchemy的一些優(yōu)點：

1. 可移植性：支持多種數(shù)據(jù)庫，并提供了統(tǒng)一的API，使得應(yīng)用程序?qū)τ诓煌瑪?shù)據(jù)庫的切換和遷移更加容易。
2. 易用性：提供了易用的API和強大的對象關(guān)系映射功能，開發(fā)者可以使用面向?qū)ο蟮姆绞絹聿僮鲾?shù)據(jù)庫，并且可以把數(shù)據(jù)庫表中的記錄映射到Python中的對象實例上。
3. 易擴展性： SQLAchemy由活躍的開源社區(qū)維護，提供了完整的文檔、教程和資料支持，可以方便地擴展和定制。
4. 性能表現(xiàn)良好：SQLAlchemy在實現(xiàn)中采用了連接池管理連接，緩存查詢結(jié)果等技術(shù)，以確保較高的性能和可伸縮性。

總之，SQLAlchemy是Python操作數(shù)據(jù)庫的一個非常強大和優(yōu)美的工具和框架，無論是從開發(fā)者的角度還是從性能方面考慮，都是一個非常不錯的選擇。

SQLAlchmey有哪些優(yōu)點？

SQLAlchemy擁有以下優(yōu)點：

1. 可移植性：SQLAlchemy支持多種數(shù)據(jù)庫，如MySQL、SQLite、PostgreSQL等，通過Python代碼操作多個數(shù)據(jù)庫。開發(fā)者可以使用相同的API操作不同的數(shù)據(jù)庫，這使得應(yīng)用程序?qū)τ诓煌瑪?shù)據(jù)庫的切換和遷移更加容易。
2. 易用性：SQLAlchemy提供了易用的API和強大的對象關(guān)系映射功能，開發(fā)者可以使用面向?qū)ο蟮姆绞絹聿僮鲾?shù)據(jù)庫，并且可以把數(shù)據(jù)庫表中的記錄映射到Python中的對象實例上。
3. 靈活強大：SQLAlchemy提供了底層的SQL表達式和查詢API，支持多種數(shù)據(jù)庫的可移植操作，例如連接管理、事務(wù)管理、對象關(guān)系映射、元數(shù)據(jù)管理等。同時，SQLAlchemy還提供了高級的ORM功能，如對象關(guān)系映射、事務(wù)管理等。
4. 可擴展性：SQLAlchemy由活躍的開源社區(qū)維護，提供了完整的文檔、教程和資料支持，可以方便地擴展和定制。
5. 性能表現(xiàn)良好：SQLAlchemy在實現(xiàn)中采用了連接池管理連接，緩存查詢結(jié)果等技術(shù)，以確保較高的性能和可伸縮性。

總之，SQLAlchemy是Python操作數(shù)據(jù)庫的一款非常優(yōu)秀的工具和框架，無論是從開發(fā)者的角度還是從性能方面考慮，都是一個非常不錯的選擇。

為什么使用SQLAlchemy？

使用SQLAlchemy有以下幾個優(yōu)勢：

1. 簡化數(shù)據(jù)庫操作：使用SQLAlchemy可以通過Python代碼直接進行數(shù)據(jù)庫的連接、查詢、更新等操作，而不需要編寫SQL語句。開發(fā)者可以使用面向?qū)ο蟮姆绞絹聿僮鲾?shù)據(jù)庫，并且可以把數(shù)據(jù)庫表中的記錄映射到Python中的對象實例上，這使得數(shù)據(jù)庫操作變得更加簡單、直觀。
2. 支持多種數(shù)據(jù)庫：SQLAlchemy支持多種不同的關(guān)系型數(shù)據(jù)庫，包括MySQL、PostgreSQL、SQLite等，使得應(yīng)用程序在多個數(shù)據(jù)庫之間切換和遷移更加容易。
3. 提高代碼復用性：SQLAlchemy提供了一系列模塊和功能，使得開發(fā)者可以編寫可復用的代碼。例如，可以把數(shù)據(jù)庫操作封裝為函數(shù)或類，方便其他模塊和應(yīng)用重用。
4. 可擴展性：SQLAlchemy由活躍的開源社區(qū)維護，提供了完整的文檔、教程和資料支持，可以方便地擴展和定制。同時，SQLAlchemy還提供了底層的SQL表達式和查詢API，以及高級的ORM功能，這使得開發(fā)者可以選擇適合自己的操作方式。

總之，使用SQLAlchemy可以讓開發(fā)者更加方便地操作數(shù)據(jù)庫，并且增加可重用性和可擴展性。它是一個強大、靈活、易用的Python ORM框架，適用于各種規(guī)模的項目，是開發(fā)Python應(yīng)用的優(yōu)秀選擇。

入門指南

安裝SQLAlchemy

安裝SQLAlchemy非常簡單，只需要使用pip工具安裝即可。以下是安裝步驟：

打開命令行窗口，輸入以下命令安裝SQLAlchemy：

pip install SQLAlchemy

等待安裝完成后，可以使用以下命令來檢查SQLAlchemy是否正確安裝：

python -c "import sqlalchemy; print(sqlalchemy.__version__)"

正確安裝后會輸出SQLAlchemy版本號。
安裝完成后，就可以在Python代碼中引入SQLAlchemy模塊，開始使用它提供的數(shù)據(jù)庫操作功能。

連接數(shù)據(jù)庫

在使用SQLAlchemy之前，需要先創(chuàng)建一個數(shù)據(jù)庫連接對象，用來連接數(shù)據(jù)庫并進行之后的操作。連接對象是SQLAlchemy提供的一個核心概念，在連接對象上進行的所有操作都會被自動提交到數(shù)據(jù)庫中。

下面是連接MySQL數(shù)據(jù)庫的示例代碼：

from sqlalchemy import create_engine

# 連接數(shù)據(jù)庫
engine = create_engine('mysql+pymysql://username:password@localhost/dbname')

# 進行一些數(shù)據(jù)庫操作
# ...

# 關(guān)閉連接
engine.dispose()

其中，create_engine方法用于創(chuàng)建一個數(shù)據(jù)庫連接對象，它的參數(shù)為數(shù)據(jù)庫的連接字符串。連接字符串的格式為：

數(shù)據(jù)庫類型+數(shù)據(jù)庫驅(qū)動://用戶名:密碼@主機名:端口號/數(shù)據(jù)庫名

例如，上面的示例中，連接字符串為：mysql+pymysql://username:password@localhost/dbname，以MySQL數(shù)據(jù)庫為例，它的含義為：

• mysql：數(shù)據(jù)庫類型；
• pymysql：MySQL數(shù)據(jù)庫驅(qū)動；
• username：數(shù)據(jù)庫用戶名；
• password：數(shù)據(jù)庫密碼；
• localhost：數(shù)據(jù)庫主機名；
• dbname：數(shù)據(jù)庫名。

在實際使用中，需要根據(jù)不同的數(shù)據(jù)庫類型，選擇相應(yīng)的數(shù)據(jù)庫驅(qū)動，例如MySQL可以選擇pymysql、mysqlclient等。

創(chuàng)建連接對象后，就可以在該對象上進行各種數(shù)據(jù)庫操作，例如查詢數(shù)據(jù)、插入數(shù)據(jù)、更新數(shù)據(jù)等。最后，需要調(diào)用dispose方法關(guān)閉數(shù)據(jù)庫連接，釋放資源。

查詢數(shù)據(jù)

SQLAlchemy提供了兩種查詢數(shù)據(jù)的方式：基于SQL語句的查詢和基于ORM的查詢。

1. 基于SQL語句的查詢

使用SQLAlchemy可以直接執(zhí)行SQL語句來查詢數(shù)據(jù)。以下是一個查詢MySQL數(shù)據(jù)庫中所有員工信息的示例代碼：

from sqlalchemy import create_engine

# 連接數(shù)據(jù)庫
engine = create_engine('mysql+pymysql://username:password@localhost/dbname')

# 執(zhí)行查詢語句
result = engine.execute("SELECT * FROM employees")

# 處理查詢結(jié)果
for row in result:
    print(row)

# 關(guān)閉連接
engine.dispose()

這個示例使用execute方法執(zhí)行一條SELECT語句，并將結(jié)果存儲在result變量中。結(jié)果是一個ResultSet對象，可以通過迭代的方式獲取每一條記錄，并使用下標或字段名訪問各個字段的值。

1. 基于ORM的查詢

SQLAlchemy還支持基于ORM的查詢，這種方式更加靈活和易用。以下是一個使用ORM查詢MySQL數(shù)據(jù)庫中所有員工信息的示例代碼：

from sqlalchemy import create_engine, Table, Column, Integer, String, MetaData

# 聲明表結(jié)構(gòu)
metadata = MetaData()
employees = Table('employees', metadata,
    Column('id', Integer, primary_key=True),
    Column('name', String),
    Column('age', Integer),
    Column('salary', Integer)
)

# 連接數(shù)據(jù)庫
engine = create_engine('mysql+pymysql://username:password@localhost/dbname')

# 執(zhí)行查詢語句
result = employees.select().execute()

# 處理查詢結(jié)果
for row in result:
    print(row)

# 關(guān)閉連接
engine.dispose()

這個示例使用ORM方式聲明了一個名為employees的表結(jié)構(gòu)，然后使用select方法獲取了所有記錄，并將結(jié)果存儲在result變量中。結(jié)果也是一個ResultSet對象，可以使用迭代和字段訪問的方式處理每一條記錄。

使用ORM方式的查詢需要先聲明表結(jié)構(gòu)，這可以通過使用Table和Column類來實現(xiàn)，具體可以參考SQLAlchemy的文檔。ORM方式能夠提高代碼的可讀性和可維護性，尤其是在復雜的查詢場景中，比起手寫SQL語句更加方便易懂。

插入數(shù)據(jù)

使用SQLAlchemy插入數(shù)據(jù)與查詢數(shù)據(jù)類似，也可以使用基于SQL語句和基于ORM的兩種方式進行。

1. 基于SQL語句的插入

以下是一個示例代碼，向MySQL數(shù)據(jù)庫中的員工表中插入一條記錄：

from sqlalchemy import create_engine

# 連接數(shù)據(jù)庫
engine = create_engine('mysql+pymysql://username:password@localhost/dbname')

# 構(gòu)造插入語句
sql = "INSERT INTO employees(name, age, salary) VALUES (%s, %s, %s)"
params = ("Tom", 25, 5000)

# 執(zhí)行插入語句
engine.execute(sql, params)

# 關(guān)閉連接
engine.dispose()

這個示例使用execute方法執(zhí)行一條INSERT語句，將參數(shù)傳遞給params變量。注意，SQLAlchemy的execute方法中，占位符使用的是%s，不同的數(shù)據(jù)庫類型可能使用不同的占位符。

1. 基于ORM的插入

以下是一個使用ORM向MySQL數(shù)據(jù)庫中的員工表中插入一條記錄的示例：

from sqlalchemy import create_engine, Table, Column, Integer, String, MetaData

# 聲明表結(jié)構(gòu)
metadata = MetaData()
employees = Table('employees', metadata,
    Column('id', Integer, primary_key=True),
    Column('name', String),
    Column('age', Integer),
    Column('salary', Integer)
)

# 連接數(shù)據(jù)庫
engine = create_engine('mysql+pymysql://username:password@localhost/dbname')

# 構(gòu)造插入語句
ins = employees.insert().values(name='Tom', age=25, salary=5000)

# 執(zhí)行插入語句
conn = engine.connect()
conn.execute(ins)

# 關(guān)閉連接
conn.close()
engine.dispose()

這個示例使用ORM方式聲明了一個名為employees的表結(jié)構(gòu)，然后使用insert方法構(gòu)造了一條INSERT語句，并將其傳遞給execute方法。注意，這里使用了connect方法來獲取一個新的數(shù)據(jù)庫連接對象，在更新和刪除等操作后也需要及時關(guān)閉連接對象。

更新和刪除數(shù)據(jù)

在SQLAlchemy中，更新和刪除數(shù)據(jù)是通過調(diào)用 Session 對象的方法來實現(xiàn)的。Session 是SQLAlchemy中的一個核心概念，它表示與數(shù)據(jù)庫的一次會話，可以用來執(zhí)行各種數(shù)據(jù)庫操作。下面分別介紹如何使用 Session 對象來更新和刪除數(shù)據(jù)。

更新數(shù)據(jù)

更新數(shù)據(jù)可以通過如下步驟完成：

1. 創(chuàng)建 session 對象，并查詢要更新的記錄

from sqlalchemy.orm import Session
from myapp.models import User   # 假設(shè)這里有一個 User 模型

session = Session()

# 查詢要更新的記錄
user = session.query(User).filter_by(id=1).first()

1. 修改要更新的屬性

# 修改屬性
user.name = "new_name"
user.age = 30

1. 提交更改

# 提交更改
session.commit()

完整代碼如下：

from sqlalchemy.orm import Session
from myapp.models import User   # 假設(shè)這里有一個 User 模型

session = Session()

# 查詢要更新的記錄
user = session.query(User).filter_by(id=1).first()

# 修改屬性
user.name = "new_name"
user.age = 30

# 提交更改
session.commit()

刪除數(shù)據(jù)

刪除數(shù)據(jù)也可以通過如下步驟完成：

1. 創(chuàng)建 session 對象，并查詢要刪除的記錄

from sqlalchemy.orm import Session
from myapp.models import User   # 假設(shè)這里有一個 User 模型

session = Session()

# 查詢要刪除的記錄
user = session.query(User).filter_by(id=1).first()

1. 調(diào)用 session.delete 方法刪除記錄

# 刪除記錄
session.delete(user)

1. 提交更改

# 提交更改
session.commit()

完整代碼如下：

from sqlalchemy.orm import Session
from myapp.models import User   # 假設(shè)這里有一個 User 模型

session = Session()

# 查詢要刪除的記錄
user = session.query(User).filter_by(id=1).first()

# 刪除記錄
session.delete(user)

# 提交更改
session.commit()

需要注意的是，刪除操作只是刪除了對應(yīng)數(shù)據(jù)庫記錄的表項，而未將其置空。如果需要在代碼中繼續(xù)操作該對象，請確保已經(jīng)刪完畢再進行。

ORM模型

什么是ORM？

ORM指的是對象關(guān)系映射(Object-Relational Mapping)，是將關(guān)系數(shù)據(jù)庫中的數(shù)據(jù)表與面向?qū)ο缶幊陶Z言中的對象建立直接映射關(guān)系的一種技術(shù)。

ORM的作用是將關(guān)系型數(shù)據(jù)庫中的數(shù)據(jù)轉(zhuǎn)換成程序中的對象，讓程序員能夠使用面向?qū)ο蟮姆绞絹聿僮麝P(guān)系型數(shù)據(jù)庫。ORM框架將數(shù)據(jù)庫與業(yè)務(wù)邏輯解耦，提高了程序的可維護性和可擴展性。

ORM框架提供了一種簡單的方式來執(zhí)行數(shù)據(jù)添加、修改、刪除和查詢操作，這樣程序員就無需編寫復雜的SQL語句。ORM框架還提供了一種面向?qū)ο蟮臄?shù)據(jù)抽象層，使得業(yè)務(wù)邏輯和數(shù)據(jù)訪問層之間的交互更加直觀和靈活。

常見的ORM框架包括Hibernate、MyBatis、Entity Framework等。

SQLAchemy中的ORM實現(xiàn)

SQLAlchemy是一個強大的SQL工具包，它允許我們與多種關(guān)系型數(shù)據(jù)庫進行交互。它有兩種主要的實現(xiàn)方式：使用SQLAlchemy Core來編寫SQL語句（類似于使用原生SQL），或者使用SQLAlchemy的ORM（對象關(guān)系映射）來處理數(shù)據(jù)庫操作。

ORM是一種將對象模型（用于編寫應(yīng)用程序）和關(guān)系模型（用于存儲數(shù)據(jù)的表和列）進行映射的技術(shù)。ORM使我們可以使用對象的方式來處理數(shù)據(jù)庫操作，而不是直接在代碼中編寫SQL語句。這使得代碼更加清晰易懂，并且可以提高開發(fā)效率。

SQLAlchemy的ORM實現(xiàn)包括以下幾個方面：

1. 定義數(shù)據(jù)模型

使用ORM實現(xiàn)之前，首先需要定義數(shù)據(jù)模型。在SQLAlchemy中，我們可以定義數(shù)據(jù)模型類來代表表和表中的列。一般來說，每個類都與數(shù)據(jù)庫中的一個表相關(guān)聯(lián)，而類中的每個屬性（字段）則代表表中的一個列。

例如，假設(shè)我們有一個名為“users”的表，其中包含id、name和email這三個列。那么我們可以定義一個名為“User”的類，如下所示：

from sqlalchemy import Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

class User(Base):
    __tablename__ = 'users'

    id = Column(Integer, primary_key=True)
    name = Column(String)
    email = Column(String)

在這個例子中，我們首先導入了 Column、Integer和String等模塊，它們分別代表了表中的列的數(shù)據(jù)類型。然后，我們繼承了一個名為“declarative_base”的類，并將其保存為Base變量。在這個基礎(chǔ)類中，我們可以定義所有的數(shù)據(jù)模型類。隨后，我們定義了一個名為“User”的類，它包含了與“users”表中的每個列相對應(yīng)的屬性。

1. 創(chuàng)建數(shù)據(jù)庫表

一旦我們定義了數(shù)據(jù)模型類，我們還需要使用ORM來創(chuàng)建數(shù)據(jù)庫表。這可以通過SQLAlchemy的Schema工具來實現(xiàn)，如下所示：

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

engine = create_engine('postgresql://username:password@host/dbname')
Session = sessionmaker(bind=engine)
Base.metadata.create_all(engine)

在這個例子中，我們首先使用了“create_engine”來創(chuàng)建一個指向數(shù)據(jù)庫引擎的引擎對象，然后使用“Session”類創(chuàng)建一個會話工廠。最后，我們調(diào)用“Base.metadata.create_all(engine)”來創(chuàng)建（或更新）所有定義的數(shù)據(jù)模型類對應(yīng)的數(shù)據(jù)庫表。

1. 操作數(shù)據(jù)庫

在創(chuàng)建好數(shù)據(jù)模型和數(shù)據(jù)庫表之后，我們可以使用ORM對數(shù)據(jù)庫進行查詢、插入、更新和刪除等操作。

例如，我們可以使用Session對象來查詢名為“John”的用戶：

session = Session()

john = session.query(User).filter_by(name='John').first()

在這個例子中，我們首先創(chuàng)建了一個Session對象。然后，我們使用“query”方法來查詢“User”類所對應(yīng)的數(shù)據(jù)庫表，使用“filter_by”方法來過濾出名為“John”的用戶，再使用“first”方法來返回第一個結(jié)果（如果沒有結(jié)果，則返回None）。

除了查詢操作，我們還可以使用Session對象來插入、更新和刪除數(shù)據(jù)。例如，我們可以使用如下代碼將一個名為“Jane”的用戶插入到數(shù)據(jù)庫中：

jane = User(name='Jane', email='jane@example.com')
session.add(jane)
session.commit()

在這個例子中，我們首先創(chuàng)建了一個名為“jane”的用戶對象。然后，我們使用Session對象的“add”方法來將該對象插入到數(shù)據(jù)庫中，最后使用“commit”方法來提交更改。

綜上所述，SQLAlchemy的ORM實現(xiàn)提供了一種將對象模型和關(guān)系模型進行映射的高效方法。使用ORM可以讓我們更加方便地編寫代碼，提高開發(fā)效率。

ORM如何映射到數(shù)據(jù)庫表？

ORM（對象關(guān)系映射）是一種編程技術(shù)，它將面向?qū)ο缶幊陶Z言中的對象模型映射到關(guān)系數(shù)據(jù)庫中的關(guān)系模型。ORM框架通常使用元數(shù)據(jù)（如注釋）或映射配置文件來將對象和數(shù)據(jù)庫表之間建立映射關(guān)系。

ORM映射的過程通常包括三個步驟：

1.對象模型定義：首先，開發(fā)者需要定義對象模型，通常是用類和屬性來定義，這些類和屬性與業(yè)務(wù)模型相關(guān)聯(lián)。

2.映射定義：映射定義是指開發(fā)者將對象模型映射到關(guān)系模型的過程。ORM框架使用元數(shù)據(jù)或映射配置文件來描述對象模型和數(shù)據(jù)庫表之間的映射關(guān)系，開發(fā)者需要根據(jù)自己的需要進行配置。通常，開發(fā)者需要定義表名、列名、數(shù)據(jù)類型，還需要定義對象之間的關(guān)系，例如一對多、多對多等等。

3.執(zhí)行操作：當映射定義完成后，開發(fā)者就可以通過ORM框架執(zhí)行對數(shù)據(jù)庫的操作，例如查詢、更新、刪除等操作。ORM框架將這些操作轉(zhuǎn)換為SQL語句，并將它們發(fā)送到關(guān)系數(shù)據(jù)庫中進行處理。

ORM映射到數(shù)據(jù)庫表的關(guān)鍵在于映射定義，也是最復雜的部分。開發(fā)者需要注意將對象模型和數(shù)據(jù)庫表之間的一一對應(yīng)、定義屬性之間的關(guān)系、并設(shè)置數(shù)據(jù)類型等。同時，開發(fā)者還要理解ORM框架映射定義的規(guī)則和特性，以便更好地設(shè)計和調(diào)試映射關(guān)系。

如何使用ORM進行增刪改查？

ORM（對象關(guān)系映射）是一種編程技術(shù)，用于將關(guān)系型數(shù)據(jù)庫中的數(shù)據(jù)映射到具有面向?qū)ο筇匦缘木幊陶Z言中，以此簡化數(shù)據(jù)庫操作。使用ORM可以減少與數(shù)據(jù)庫直接交互的代碼量，并提高代碼的可讀性和可維護性。

一般來說，ORM框架都提供了對CRUD（增刪改查）操作的支持。下面就以Django框架為例，介紹如何使用ORM進行增刪改查。

【增】創(chuàng)建新的數(shù)據(jù)記錄

在Django中，使用ORM創(chuàng)建新的數(shù)據(jù)記錄需要完成以下步驟：

1. 定義模型

首先需要在models.py文件中定義一個模型，模型定義了數(shù)據(jù)庫中表的結(jié)構(gòu)和字段信息。例如，定義一個Students模型：

from django.db import models

class Students(models.Model):
    name = models.CharField(max_length=50)
    age = models.IntegerField()
    grade = models.CharField(max_length=50)

1. 創(chuàng)建實例

然后可以使用該模型創(chuàng)建一個實例：

student = Students(name='Tom', age=18, grade='grade 3')

1. 調(diào)用save方法

最后，可以調(diào)用實例的save方法將數(shù)據(jù)保存到數(shù)據(jù)庫中：

student.save()

該實例會自動被映射到數(shù)據(jù)庫表中，并生成一個唯一的ID值。

【刪】刪除數(shù)據(jù)記錄

使用ORM刪除數(shù)據(jù)的操作也很簡單，只需要調(diào)用模型的delete方法即可。例如，刪除一條記錄：

student = Students.objects.get(name='Tom')
student.delete()

【改】修改數(shù)據(jù)記錄

使用ORM修改數(shù)據(jù)的操作也很簡單。首先需要獲取到要修改的記錄的實例，然后修改該實例的屬性值，最后調(diào)用該實例的save方法即可。例如：

student = Students.objects.get(name='Tom')
student.age = 19
student.save()

【查】查詢數(shù)據(jù)記錄

查詢數(shù)據(jù)記錄是最為常見的操作，Django ORM提供了許多查詢API。常見的查詢API包括：

1. 查詢所有數(shù)據(jù)

students = Students.objects.all() # 查詢所有數(shù)據(jù)

1. 按條件查詢數(shù)據(jù)

按條件查詢數(shù)據(jù)可以使用filter方法，例如：

students = Students.objects.filter(grade='grade 3') # 查詢grade為'grade 3'的所有記錄

也可以使用exclude方法排除某些記錄，例如：

students = Students.objects.exclude(age__lt=18) # 排除age小于18的所有記錄

1. 獲取單條數(shù)據(jù)記錄

獲取單條記錄可以使用get方法，例如：

student = Students.objects.get(name='Tom')

如果查詢到的記錄數(shù)不為1，則會拋出MultipleObjectsReturned異常。如果查詢不到記錄，則會拋出Students.DoesNotExist異常。

1. 使用原始SQL查詢數(shù)據(jù)

有時候需要使用原始SQL查詢數(shù)據(jù)，可以使用raw方法。例如：

students = Students.objects.raw('SELECT * FROM students WHERE grade="%s"' % 'grade 3')

這里需要注意SQL注入的問題，應(yīng)該使用參數(shù)占位符或者參數(shù)化查詢來避免注入攻擊。

高級話題

數(shù)據(jù)庫連接池

SQLAlchemy是一種用Python編寫的靈活的 ORM 框架，可以與 SQL 數(shù)據(jù)庫進行交互。其中一個強大的功能是它的連接池機制，允許您管理數(shù)據(jù)庫連接并避免頻繁創(chuàng)建和斷開連接的開銷，從而提高性能。下面是使用SQLAlchemy連接池的步驟：

1. 導入模塊：

from sqlalchemy import create_engine
from sqlalchemy.orm import scoped_session, sessionmaker
from sqlalchemy.pool import QueuePool

1. 創(chuàng)建數(shù)據(jù)庫引擎（engine）和連接池：

使用create_engine() 方法創(chuàng)建數(shù)據(jù)庫引擎，并將連接池與之關(guān)聯(lián)。實例化QueuePool類并將其傳遞給create_engine()的 poolclass 參數(shù)。

engine = create_engine('postgresql://user:password@host/dbname', poolclass=QueuePool)

QueuePool是一種線程安全的數(shù)據(jù)庫連接池，用于支持多個線程或進程訪問同一數(shù)據(jù)庫?？梢赃x擇池的大小等屬性。

1. 創(chuàng)建Session工廠：

Session工廠創(chuàng)建一個Session實例，用于與數(shù)據(jù)庫建立連接。創(chuàng)建scoped_session() 方法，并將連接池和引擎?zhèn)鬟f給sessionmaker() 工廠：

session_factory = sessionmaker(bind=engine)
Session = scoped_session(session_factory)

在這里，scoped_session() 方法返回一個可跨線程使用的局部會話。當多個線程使用會話時，它會自動為每個線程創(chuàng)建一個會話。并且它會在會話使用后自動關(guān)閉連接。

1. 使用Session連接到數(shù)據(jù)庫：

接下來，使用Session()方法連接到數(shù)據(jù)庫，并在需要訪問數(shù)據(jù)庫時使用它。

session = Session()
# perform database operations using session object
session.commit()
session.close()

在需要關(guān)閉連接時，使用close()方法關(guān)閉會話。

通過使用SQLAlchemy的連接池，可以在不影響應(yīng)用程序性能的情況下降低數(shù)據(jù)庫連接的開銷。同時，它也提供了保護機制，可以避免出現(xiàn)內(nèi)存泄漏和其他異常。

事務(wù)管理

SQLAlchemy是一個Python ORM框架，它提供了事務(wù)管理機制以確保數(shù)據(jù)完整性和一致性。事務(wù)是數(shù)據(jù)庫操作的基本單位，它是一系列SQL語句的集合，它要么完整地執(zhí)行，要么完全不執(zhí)行，從而保證數(shù)據(jù)的狀態(tài)一致。

在SQLAlchemy中，開啟事務(wù)的方式是通過 Session 對象的 begin() 方法實現(xiàn)的。在一個事務(wù)中，所有的查詢、插入、更新和刪除操作都將被視為一個單獨的操作，直到 commit() 方法被調(diào)用。如果事務(wù)中發(fā)生錯誤或異常，所有已提交的更改將被回滾。

以下示例演示了如何使用SQLAlchemy進行事務(wù)管理：

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

# 創(chuàng)建數(shù)據(jù)庫連接
engine = create_engine('postgresql://user:password@localhost/mydatabase')

# 創(chuàng)建Session類，用于與數(shù)據(jù)庫進行交互
Session = sessionmaker(bind=engine)

# 創(chuàng)建Session實例
session = Session()

try:
    # 開始事務(wù)
    with session.begin():
        # 執(zhí)行SQL語句
        session.execute("INSERT INTO users (name, email, age) VALUES ('Alice', 'alice@example.com', 20)")
        session.execute("UPDATE users SET age = 21 WHERE name = 'Bob'")

    # 提交事務(wù)
    session.commit()

except:
    # 回滾事務(wù)
    session.rollback()
    raise

finally:
    # 關(guān)閉連接
    session.close()

在以上示例中，我們首先創(chuàng)建了一個數(shù)據(jù)庫連接引擎，并使用它創(chuàng)建了一個 Session 類，用于執(zhí)行數(shù)據(jù)庫操作。接著，我們創(chuàng)建了一個 Session 實例，并在一個 with session.begin() 的上下文管理器中開始了一個事務(wù)。在事務(wù)中，我們通過 session.execute() 方法執(zhí)行了兩個 SQL 語句，一個是插入語句，一個是更新語句。在執(zhí)行完所有 SQL 語句后，我們調(diào)用了 session.commit() 方法提交事務(wù)，這將使所有的更改永久保存到數(shù)據(jù)庫中。如果在事務(wù)中出現(xiàn)了異常或錯誤，session.rollback() 將在 finally 塊中被調(diào)用，這將使所有更改被撤消，數(shù)據(jù)庫狀態(tài)回歸到事務(wù)開始時的狀態(tài)。

總之，SQLAlchemy提供了強大的事務(wù)管理機制，可以確保所有的數(shù)據(jù)操作都可以安全地執(zhí)行，并且能夠自動處理異常情況及回滾。這使得使用SQLAlchemy進行數(shù)據(jù)庫操作變得更加可靠和方便。

元數(shù)據(jù)管理

SQLAlchemy是一個Python的ORM（對象關(guān)系映射）庫，用于將面向?qū)ο蟮腜ython代碼映射到關(guān)系型數(shù)據(jù)庫中的數(shù)據(jù)，同時還提供了各種管理和控制數(shù)據(jù)庫元數(shù)據(jù)的功能。

元數(shù)據(jù)是關(guān)于數(shù)據(jù)庫結(jié)構(gòu)的描述信息，包括表、列、關(guān)系和索引等。在SQLAlchemy中，元數(shù)據(jù)可以通過創(chuàng)建一個MetaData對象來進行管理。

以下是使用SQLAlchemy管理元數(shù)據(jù)的主要步驟：

1. 創(chuàng)建MetaData對象

from sqlalchemy import MetaData
metadata = MetaData()

1. 定義表結(jié)構(gòu)

from sqlalchemy import Table, Column, Integer, String

# 定義一個users表，包含id和name兩個字段
users = Table('users', metadata,
    Column('id', Integer, primary_key=True),
    Column('name', String(50))
)

1. 創(chuàng)建表

metadata.create_all(engine)

其中，engine是連接數(shù)據(jù)庫的引擎。

1. 查詢表結(jié)構(gòu)

metadata.reflect(bind=engine)

for table in metadata.tables.values():
    print(table.name)
    for column in table.columns:
        print(column.name)

1. 修改表結(jié)構(gòu)

# 添加一個age列
age = Column('age', Integer)
age.create(users)

# 刪除一個name列
users.c.name.drop()

1. 刪除表

users.drop(engine)

除了以上操作，SQLAlchemy還提供了很多其他有用的元數(shù)據(jù)管理功能，例如定義外鍵關(guān)系、設(shè)置索引等。對于需要進行數(shù)據(jù)庫開發(fā)和管理的開發(fā)人員，元數(shù)據(jù)管理是很重要的一部分，它可以實現(xiàn)數(shù)據(jù)庫的高效、靈活和可維護的管理。

查詢性能優(yōu)化

在SQLAlchemy中進行查詢性能優(yōu)化可以采取以下幾種方法：

1. 減少查詢數(shù)量

查詢數(shù)量越多，數(shù)據(jù)庫的負擔越大。因此，可以通過合并多個查詢，使用JOIN語句減少查詢的數(shù)量。同時，可以使用子查詢或者公共表表達式（CTE）將多個查詢合并成一個查詢。

1. 添加索引

SQLAlchemy使用ORM技術(shù)，不需要手動添加索引，但是可以通過定義模型的索引及屬性，讓SQLAlchemy自動創(chuàng)建索引。

1. 使用正確的數(shù)據(jù)類型

使用正確的數(shù)據(jù)類型可以有效提高查詢效率。例如，對于大量數(shù)值計算的操作，可以使用INTEGER或者FLOAT類型，而不是字符串類型。

1. 使用外鍵約束

使用外鍵約束可以確保數(shù)據(jù)的完整性，同時也可以提高查詢性能。外鍵約束可以加速JOIN操作，以及一些復雜查詢的執(zhí)行速度。

1. 使用緩存

對于重復的查詢結(jié)果，可以使用緩存來存儲結(jié)果，減少對數(shù)據(jù)庫的訪問。可以使用SQLAlchemy的內(nèi)置緩存機制，或者使用第三方的緩存庫，如Memcached、Redis等。

1. 批量操作

對于大量數(shù)據(jù)的操作，可以使用批量操作來提高性能。例如，可以使用批量插入來一次性插入多條記錄，而不是分別插入每條記錄。

需要注意的是，以上方法并非絕對適用，具體的優(yōu)化方式需要結(jié)合實際場景進行分析和調(diào)整。同時，也需要對查詢語句進行優(yōu)化，使用合適的查詢語句可以提高數(shù)據(jù)庫查詢的效率。

使用案例

Flask和SQLAlchemy的集成

Flask和SQLAlchemy是兩個非常流行的Python庫，用于開發(fā)Web應(yīng)用程序和操作數(shù)據(jù)庫。Flask是一個輕量級的Web框架，提供了基本的功能來構(gòu)建Web應(yīng)用程序，而SQLAlchemy則是一個強大的ORM（對象關(guān)系映射）框架，可以輕松地進行數(shù)據(jù)庫操作。在結(jié)合使用Flask和SQLAlchemy時，可以更輕松地操作數(shù)據(jù)庫，并且可以避免一些常見的數(shù)據(jù)庫安全問題。

要在Flask應(yīng)用程序中使用SQLAlchemy，需要安裝SQLAlchemy庫?？梢允褂胮ip命令來安裝它：

pip install sqlalchemy

然后，需要在Flask應(yīng)用程序中導入SQLAlchemy：

from flask_sqlalchemy import SQLAlchemy

接下來，需要配置SQLAlchemy連接到數(shù)據(jù)庫。在Flask應(yīng)用程序中，可以在應(yīng)用程序?qū)嵗瘯r進行配置。需要在應(yīng)用程序中設(shè)置數(shù)據(jù)庫URL和其他選項，例如跟蹤數(shù)據(jù)庫修改：

app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://user:password@localhost/database_name'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

上述代碼中的URL是指連接到MySQL數(shù)據(jù)庫的URL，可以根據(jù)需要進行修改以連接到其他類型的數(shù)據(jù)庫。SQLALCHEMY_TRACK_MODIFICATIONS選項被設(shè)置為False，以避免一些常見的數(shù)據(jù)庫安全問題。如果需要使用SQLAlchemy的修改跟蹤功能，需要將其設(shè)置為True。

完成配置后，需要創(chuàng)建SQLAlchemy對象并將其添加到應(yīng)用程序中：

db = SQLAlchemy(app)

現(xiàn)在，可以定義模型類來映射數(shù)據(jù)庫中的表。模型類應(yīng)該繼承db.Model類，并定義它們所映射表的列。例如，以下代碼定義了一個名為User的模型，它將映射到數(shù)據(jù)庫中的users表：

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True, nullable=False)
    password = db.Column(db.String(120), nullable=False)

    def __repr__(self):
        return '<User %r>' % self.username

接下來，可以在應(yīng)用程序中執(zhí)行各種數(shù)據(jù)庫操作，例如插入、查詢和更新。例如，以下代碼插入一個名為John的新用戶，并將其保存到數(shù)據(jù)庫中：

john = User(username='john', password='password123')
db.session.add(john)
db.session.commit()

可以使用查詢語句來從數(shù)據(jù)庫中檢索數(shù)據(jù)。例如，以下代碼檢索名為John的用戶：

user = User.query.filter_by(username='john').first()

可以根據(jù)需要執(zhí)行許多其他SQLAlchemy操作，例如刪除和更新行、排序和分頁結(jié)果等。詳細信息可以在SQLAlchemy的文檔中找到。

Django和SQLAlchemy的集成

Django和SQLAlchemy都是流行的Python庫，但它們在處理數(shù)據(jù)庫方面有一些不同的方法和哲學。Django提供了自己的ORM（對象關(guān)系映射）工具，它是設(shè)計為將Python對象映射到關(guān)系數(shù)據(jù)庫表格的接口。相比之下，SQLAlchemy基于SQL，通過提供Pythonic的API來管理關(guān)系數(shù)據(jù)庫。

雖然Django具有自己的ORM，但它有一些不足之處，例如限制了使用SQL查詢的能力，它是依靠Django的ORM生成器來完成數(shù)據(jù)庫查詢語句的。SQLAlchemy提供了更靈活的操作數(shù)據(jù)庫的方式，因此有時候需要在Django項目中集成SQLAlchemy。

集成Django和SQLAlchemy需要注意以下幾點：

1.配置數(shù)據(jù)庫：Django使用settings.py文件來提供數(shù)據(jù)庫設(shè)置。在集成SQLAlchemy時，需要在該文件中添加與SQLAlchemy相關(guān)的數(shù)據(jù)庫配置。

2.創(chuàng)建數(shù)據(jù)庫連接：Django在運行時自動創(chuàng)建數(shù)據(jù)庫連接，而SQLAlchemy需要顯式地創(chuàng)建?？梢栽贒jango應(yīng)用程序的settings.py文件中創(chuàng)建全局變量，并使用該變量來創(chuàng)建SQLAlchemy引擎和會話。

3.數(shù)據(jù)模型：Django和SQLAlchemy對數(shù)據(jù)模型的處理方式不同。Django使用ORM，用Python類來表示數(shù)據(jù)庫表格。SQLAlchemy更接近SQL，并通過Python類表示表格和數(shù)據(jù)結(jié)構(gòu)。

4.查詢語言：Django ORM和SQLAlchemy都提供了查詢API，但由于兩者的設(shè)計不同，查詢語言可能也有所不同。在集成時需要注意，并嘗試使用適合自身需求的API。

通過以上步驟，可以成功集成Django和SQLAlchemy，并使用SQLAlchemy的方法來管理數(shù)據(jù)庫。在實踐中，可能還需要不斷地對代碼進行調(diào)整和測試，以達到最佳的集成效果。

SQLAlchemy在大型企業(yè)應(yīng)用中的應(yīng)用實踐

SQLAlchemy是一個在Python中使用的流行ORM（Object-Relational Mapping，對象關(guān)系映射）框架。它提供了一個靈活的API，讓開發(fā)人員可以輕松地將Python對象映射到關(guān)系數(shù)據(jù)庫中的表。

在大型企業(yè)應(yīng)用中，SQLAlchemy可以幫助開發(fā)人員處理復雜的數(shù)據(jù)存儲需求，并實現(xiàn)高效的數(shù)據(jù)訪問和管理。以下是SQLAlchemy在大型企業(yè)應(yīng)用中的應(yīng)用實踐：

1. 數(shù)據(jù)庫連接管理

大型企業(yè)應(yīng)用通常需要連接多個數(shù)據(jù)庫，有時還需要使用多個不同的數(shù)據(jù)庫引擎。SQLAlchemy提供了一個連接管理器，使開發(fā)人員可以輕松地管理數(shù)據(jù)庫連接。

1. 數(shù)據(jù)庫遷移

隨著應(yīng)用不斷發(fā)展，數(shù)據(jù)庫架構(gòu)可能需要進行更改。SQLAlchemy提供了靈活的數(shù)據(jù)庫遷移工具，可以幫助開發(fā)人員快速更新數(shù)據(jù)庫結(jié)構(gòu)。

1. 事務(wù)處理

SQLAlchemy提供了強大的事務(wù)管理支持。當數(shù)據(jù)庫操作需要確保一組操作原子性時，使用事務(wù)來保證多個數(shù)據(jù)庫操作的原子性非常方便。

1. 查詢優(yōu)化

SQLAlchemy提供了多種查詢優(yōu)化工具，可以幫助開發(fā)人員快速查找和優(yōu)化查詢性能瓶頸。例如，使用ORM查詢的時候可以預加載相關(guān)數(shù)據(jù)，使用基于緩存的查詢等。

1. 擴展性

SQLAlchemy具有強大的擴展機制，可以使用插件和定制的類型系統(tǒng)，方便的處理各種數(shù)據(jù)庫操作。對于大型企業(yè)應(yīng)用，這個優(yōu)勢非常顯著，因為大量的定制化需求需要處理。

總的來說，SQLAlchemy是一個功能強大的ORM框架，它可以幫助開發(fā)人員開發(fā)高效、穩(wěn)定和可擴展的企業(yè)應(yīng)用。 在大型企業(yè)應(yīng)用中使用SQLAlchemy可以處理各種數(shù)據(jù)庫操作，從而使應(yīng)用更容易維護和擴展。

總結(jié)

SQLAchemy的優(yōu)缺點

SQLAlchemy是一種用Python編寫的開源SQL工具包，它提供了一種高級的，面向?qū)ο蟮姆绞絹聿僮麝P(guān)系型數(shù)據(jù)庫。下面是SQLAlchemy的優(yōu)點和缺點：

優(yōu)點：

1. 簡化數(shù)據(jù)庫操作：SQLAlchemy封裝了許多傳統(tǒng)SQL數(shù)據(jù)庫的復雜性，并提供了一種簡單高效的方式來操作數(shù)據(jù)庫，從而使得開發(fā)人員可以更輕松地管理和處理數(shù)據(jù)。
2. ORM技術(shù)支持：SQLAlchemy提供了ORM技術(shù)支持，這意味著它可以將數(shù)據(jù)的關(guān)系映射到Python對象和方法之間，使得開發(fā)人員可以在代碼中使用更高層次的數(shù)據(jù)抽象，而不必直接與數(shù)據(jù)庫交互。
3. 支持多種數(shù)據(jù)庫：SQLAlchemy支持許多流行的關(guān)系型數(shù)據(jù)庫，包括MySQL、PostgreSQL、Oracle、SQLite等等，而且具有非常靈活的連接和配置選項。
4. 安全性：SQLAlchemy提供了多種安全措施來保護數(shù)據(jù)庫免受SQL注入攻擊等安全風險。
5. 可擴展性：SQLAlchemy是一個可擴展的框架，通過它可以輕松地添加新的模型和模塊來滿足不同的應(yīng)用程序需求。
6. 可讀性高：SQLAlchemy的代碼易于理解和閱讀，這使得后續(xù)的維護和開發(fā)變得更加容易。

缺點：

1. 學習成本高：學習SQLAlchemy需要花費一些時間和精力，特別是對于那些沒有任何ORM經(jīng)驗的開發(fā)人員而言。
2. 性能問題：SQLAlchemy的ORM技術(shù)存在一些性能問題，可能導致在一些復雜查詢場景下的效率低下，因此需要編寫手動SQL語句以提高性能。
3. 繁瑣的配置：SQLAlchemy的連接和配置選項比較繁瑣，可能需要一些額外的工作來完成。
4. 過渡封裝：某些情況下，SQLAlchemy的ORM抽象可能過度封裝自底層數(shù)據(jù)庫，這可能會限制一些自定義數(shù)據(jù)庫的特定操作。

總體來說，SQLAlchemy是一個功能強大的SQL工具包，可以簡化開發(fā)人員的數(shù)據(jù)庫操作，并提供了可擴展和安全的選項。但是，使用SQLAlchemy也需要考慮到其學習成本以及可能存在的性能和配置問題。

SQLAchemy的未來發(fā)展方向

SQLAlchemy是Python中最廣泛使用的ORM框架之一，其未來的發(fā)展方向?qū)⑹浅掷m(xù)改進和優(yōu)化其核心功能、增強生態(tài)系統(tǒng)和提供更好的性能。

以下是SQLAlchemy未來發(fā)展的一些方向：

1. 改進核心功能：SQLAlchemy將繼續(xù)改進其核心功能，以確保其穩(wěn)定性和可靠性。這包括更好的錯誤處理、更好的日志記錄、更好的線程/進程支持、更好的數(shù)據(jù)類型支持、更好的性能和更好的API設(shè)計。
2. 增強生態(tài)系統(tǒng)：SQLAlchemy已經(jīng)擁有一個廣泛的社區(qū)和生態(tài)系統(tǒng)，包括Flask、Django、FastAPI等流行的框架。SQLAlchemy將繼續(xù)增強這個生態(tài)系統(tǒng)，提供更好的集成、更好的文檔和更好的工具。
3. 引入新功能：SQLAlchemy將引入新的功能來滿足不斷變化的需求。這可能包括更好的連接池管理、更好的查詢優(yōu)化、更好的分布式查詢支持、更好的NoSQL支持等。
4. 支持新的數(shù)據(jù)庫：SQLAlchemy已經(jīng)支持了許多數(shù)據(jù)庫，包括PostgreSQL、MySQL、Oracle、SQLite等。SQLAlchemy將繼續(xù)支持新的數(shù)據(jù)庫，包括支持新型數(shù)據(jù)庫的新特性和新方法。
5. 提升性能：SQLAlchemy將繼續(xù)優(yōu)化其性能，從而提供更好的工作效率和更快的速度。這可能包括引入更好的查詢優(yōu)化、更好的緩存管理、更好的并發(fā)處理等技術(shù)。

總的來說，SQLAlchemy的未來發(fā)展方向?qū)⑹浅掷m(xù)改進和優(yōu)化，以確保其在Python生態(tài)系統(tǒng)中保持領(lǐng)先地位。

如何學習SQLAchemy？

學習SQLAlchemy需要掌握基本的Python編程知識和數(shù)據(jù)庫的一些基礎(chǔ)知識。下面是一些學習SQLAlchemy的方法：

1. 基礎(chǔ)知識：首先，你需要了解關(guān)系數(shù)據(jù)庫的基礎(chǔ)概念，如表、列、主鍵、外鍵、索引等。此外，SQLAlchemy還提供了ORM，學習ORM概念和基本用法也是必要的。
2. 官方文檔：SQLAlchemy提供了非常詳盡的官方文檔，其中包含了所有的類、方法、API等。閱讀官方文檔，可以更好地了解該框架的特性和使用方法。
3. 學習范例：掌握基本概念之后，可以尋找一些SQLAlchemy的學習范例，例如通過編寫實際的代碼來學習常見任務(wù)，如創(chuàng)建數(shù)據(jù)表、插入數(shù)據(jù)、查詢數(shù)據(jù)等。
4. 學習視頻：還可以通過觀看一些SQLAlchemy的學習視頻，了解該框架的使用方法和最佳實踐。
5. 社區(qū)參與：SQLAlchemy擁有龐大的社區(qū)，可以通過參與社區(qū)來了解其他開發(fā)者的應(yīng)用經(jīng)驗和技巧?？梢酝ㄟ^Google Groups、Stack Overflow、GitHub等社區(qū)平臺來獲取幫助和分享經(jīng)驗。

最重要的是，SQLAlchemy是一個非常靈活和強大的框架，可以幫助開發(fā)者處理各種數(shù)據(jù)庫任務(wù)。只有通過不斷的實踐和嘗試，才能更深入地了解和掌握該框架的使用，從而為開發(fā)更好的應(yīng)用程序提供支持。

總結(jié)

?? ?? ?? ?? ?? ???? ? ?? ??

如果你對這篇文章感興趣，歡迎在評論區(qū)留言，分享你的想法和建議。如果你喜歡我的博客，請記得點贊、收藏和關(guān)注我，我會持續(xù)更新更多有用的網(wǎng)頁技巧和教程。謝謝大家！

更多寶藏

??????????????????????
項目倉庫看這里??：
https://github.com/w-x-x-w
https://gitee.com/w-_-x
公眾號名稱??：編程啟航
博客文章看這里??：
https://blog.csdn.net/weixin_62650212
視頻推送看這里??：
https://space.bilibili.com/1909782963文章來源地址http://www.zghlxwxcb.cn/news/detail-757177.html

到了這里，關(guān)于簡單易用，靈活強大：用SQLAlchemy實現(xiàn)Python操作數(shù)據(jù)庫的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！