首先，你的核心需求是摆脱全局的engine、Base、Session这些变量，让数据库操作更模块化、可复用，这在中大型项目里是非常合理的做法。下面逐个解答你的疑问：

1. 是否可以按需创建数据库连接，使用后关闭，需要时再重新创建？ #

完全可以，而且这是推荐的实践之一。SQLAlchemy的Engine本身自带连接池（默认开启），它会自动管理连接的创建、复用和回收，你不需要手动去创建/关闭底层的数据库连接。

对于会话（Session），你可以在需要操作数据库的时候创建实例，用完后调用session.close()释放资源；更优雅的方式是使用上下文管理器（with语句），它会自动帮你关闭会话：

session = Session()
try:
    # 执行数据库操作
    session.add(User(name="Alice"))
    session.commit()
finally:
    session.close()

# 或者用with语句更简洁
with Session() as session:
    session.add(User(name="Bob"))
    session.commit()

如果你需要完全重新初始化连接，只需要重新调用create_engine生成新的Engine实例即可，但一般来说复用同一个Engine更高效，因为连接池会帮你节省重复创建连接的开销。

2. 项目中通常如何使用SQLAlchemy？ #

在实际项目里，我们一般会这么组织：

• 分离配置与逻辑：把数据库URL、连接池参数等配置放在单独的配置文件（比如config.py或者环境变量），而不是硬编码在代码里。
• 模块化模型定义：创建一个单独的models模块，在里面定义所有的数据库模型，统一继承一个全局的Base实例（这个Base只在models模块里定义一次，不是全局到处引用）。
• 封装会话与引擎：用一个工具类或函数来初始化Engine和Session工厂，比如在database.py里封装这些逻辑，其他模块按需导入使用。
• 按需创建会话：在需要操作数据库的地方，从Session工厂生成会话实例，用完及时关闭（或用上下文管理器）。

举个简单的项目结构例子：

my_project/
├── config.py       # 数据库配置
├── database.py     # 引擎、会话初始化
├── models/
│   └── __init__.py # 模型定义
└── main.py         # 业务逻辑

config.py：

DATABASE_URL = "sqlite:///fixedDBName.db"

database.py：

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from config import DATABASE_URL

engine = create_engine(DATABASE_URL, echo=True)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

# 供其他模块导入的会话生成函数
def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

models/__init__.py：

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)
    fullname = Column(String)
    nickname = Column(String)

    def __repr__(self):
        return f"<User(name='{self.name}', fullname='{self.fullname}', nickname='{self.nickname}')>"

main.py里使用：

from database import get_db
from models import User, Base
from database import engine

# 初始化表（只需要执行一次）
Base.metadata.create_all(bind=engine)

# 使用会话
db = next(get_db())
try:
    user = User(name="Charlie", fullname="Charlie Brown", nickname="CharlieB")
    db.add(user)
    db.commit()
    db.refresh(user)
    print(user)
finally:
    db.close()

3. 封装到类中的写法修正 #

你的类写法报错是因为Base是__init__方法里的局部变量，createTables方法无法访问到它；另外你在定义User类时，__repr__里的self是User的实例，这个是没问题的。

修正后的类写法应该把Base和User都作为实例属性保存，这样类的其他方法就能访问到：

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

class SQLConnector:
    def __init__(self, databaseName):
        self.engine = create_engine(f'sqlite:///{databaseName}', echo=True)
        self.Session = sessionmaker(bind=self.engine)
        # 把Base作为实例属性
        self.Base = declarative_base()
        
        # 定义User类，继承self.Base
        class User(self.Base):
            __tablename__ = 'users'
            id = Column(Integer, primary_key=True)
            name = Column(String)
            fullname = Column(String)
            nickname = Column(String)
            
            def __repr__(self):
                return f"<User(name='{self.name}', fullname='{self.fullname}', nickname='{self.nickname}')>"
        
        # 把User类也保存为实例属性，方便外部访问
        self.User = User

    def createTables(self):
        # 使用self.Base访问Base实例
        self.Base.metadata.create_all(self.engine)

# 使用示例
db_connector = SQLConnector("test.db")
db_connector.createTables()

# 创建会话并操作
session = db_connector.Session()
new_user = db_connector.User(name="David", fullname="David Smith", nickname="Dave")
session.add(new_user)
session.commit()
session.close()

不过要注意：这种把模型类定义在类内部的写法，在多实例场景下会生成多个不同的User类（每个SQLConnector实例对应一个），如果你的项目需要多个数据库实例，这没问题；但如果只是单数据库，更推荐把模型类单独抽出来。

4. 封装到函数中的写法优化 #

你的函数写法问题是没有返回需要的对象，所以调用后无法获取Session、User这些对象来操作。可以让函数返回Engine、Session工厂和User类，这样调用函数后就能解构这些对象：

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

def init_sqlcon(databaseName):
    engine = create_engine(f'sqlite:///{databaseName}', echo=True)
    Base = declarative_base()
    
    class User(Base):
        __tablename__ = 'users'
        id = Column(Integer, primary_key=True)
        name = Column(String)
        fullname = Column(String)
        nickname = Column(String)
        
        def __repr__(self):
            return f"<User(name='{self.name}', fullname='{self.fullname}', nickname='{self.nickname}')>"
    
    Base.metadata.create_all(engine)
    Session = sessionmaker(bind=engine)
    # 返回需要的对象
    return engine, Session, User

# 使用示例
databaseName = "test_3.db"
engine, Session, User = init_sqlcon(databaseName)

# 创建会话操作
session = Session()
session.add(User(name="Eve", fullname="Eve Adams", nickname="EveA"))
session.commit()
session.close()

这种写法适合简单的脚本或者小型项目，函数调用一次就拿到所有需要的组件，非常直观。

内容的提问来源于stack exchange，提问作者Nils