ModuleNotFoundError: No module named 'sqlalchemy'

时间: 2023-10-13 16:26:14 浏览: 95

sqlalchemy

The SQLAlchemy Object Relational Mapper presents a method of associating user-defined Python classes with database tables, and instances of those classes (objects) with rows in their corresponding tables. It includes a sys- tem that transparently synchronizes all changes in state between objects and their related rows, called a unit of work, as well as a system for expressing database queries in terms of the user defined classes and their defined relationships between each other. The ORM is in contrast to the SQLAlchemy Expression Language, upon which the ORM is constructed. Whereas the SQL Expression Language, introduced in SQL Expression Language Tutorial, presents a system of representing the primitive constructs of the relational database directly without opinion, the ORM presents a high level and abstracted pattern of usage, which itself is an example of applied usage of the Expression Language. While there is overlap among the usage patterns of the ORM and the Expression Language, the similarities are more superficial than they may at first appear. One approaches the structure and content of data from the perspective of a user-defined domain model which is transparently persisted and refreshed from its underlying storage model. The other approaches it from the perspective of literal schema and SQL expression representations which are explicitly composed into messages consumed individually by the database. A successful application may be constructed using the Object Relational Mapper exclusively. In advanced situations, an application constructed with the ORM may make occasional usage of the Expression Language directly in certain areas where specific database interactions are required. The following tutorial is in doctest format, meaning each >>> line represents something you can type at a Python command prompt, and the following text represents the expected return value. ### SQLAlchemy：对象关系映射（ORM）详解 #### 概述 SQLAlchemy 是一个 Python 的 SQL 工具包和 ORM（对象关系映射），它提供了一种方式将自定义的 Python 类与数据库表关联起来，并将这些类的实例（对象）与其对应的表中的行进行映射。SQLAlchemy 包含了一个称为“单元工作”（unit of work）的系统，该系统可以透明地同步所有对象与其相关行之间的状态变化；此外还包括了一个基于用户定义的类及其定义的关系来表达数据库查询的系统。 ORM 和 SQLAlchemy 的表达式语言（Expression Language）不同，后者是 ORM 的基础。表达式语言是一种直接表示关系数据库原始构造的方法，不带有任何预设的意见或模式；而 ORM 提供了一个高层次且抽象化的使用模式，这本身是表达式语言的一种应用实例。虽然 ORM 和表达式语言在使用模式上有一定的重叠，但它们之间的相似之处更多的是表面性的。一个成功的应用程序可以仅使用对象关系映射器来构建。在高级情况下，使用 ORM 构建的应用程序可能偶尔会直接使用表达式语言来进行特定的数据库交互操作。以下教程采用 doctest 格式，即每行 `>>>` 表示可以在 Python 命令提示符下输入的内容，随后的文本代表预期的返回值。 #### SQLAlchemy 文档概览 **版本**：0.7.4 **作者**：Mike Bayer **发布日期**：2012 年 1 月 28 日 ### SQLAlchemy ORM 入门指南 #### 对象关系映射教程 ##### 版本检查在开始之前，确认安装的 SQLAlchemy 版本是否满足需求： ```python >>> import sqlalchemy >>> sqlalchemy.__version__ '0.7.4' ``` ##### 连接数据库使用 SQLAlchemy 连接到数据库需要创建一个 `create_engine` 实例，指定数据库类型、主机名、用户名、密码以及数据库名称。 ```python >>> from sqlalchemy import create_engine >>> engine = create_engine("postgresql://scott:tiger@localhost/mydatabase") ``` ##### 声明映射定义一个 Python 类并使用 `declarative_base()` 来声明一个基类，该基类将包含一个 `__tablename__` 属性，该属性定义了数据库表的名称。同时，需要导入 `Column` 和数据类型如 `Integer` 和 `String`。 ```python >>> from sqlalchemy.ext.declarative import declarative_base >>> from sqlalchemy import Column, Integer, String >>> Base = declarative_base() >>> class User(Base): ... __tablename__ = 'users' ... id = Column(Integer, primary_key=True) ... name = Column(String(50)) ... fullname = Column(String(50)) ... password = Column(String(12)) ... ``` ##### 创建实例创建基类的实例即为创建数据库表的行。每个实例代表一个具体的对象。 ```python >>> ed_user = User(name='ed', fullname='Ed Jones', password='edspassword') ``` ##### 创建会话为了与数据库交互，需要创建一个 `Session`。`Session` 是一个用于管理所有数据库操作的上下文。 ```python >>> from sqlalchemy.orm import sessionmaker >>> Session = sessionmaker(bind=engine) >>> session = Session() ``` ##### 添加新对象使用 `session.add()` 方法添加新对象到数据库。`commit()` 方法用于提交更改。 ```python >>> session.add(ed_user) >>> session.commit() ``` ##### 回滚如果在事务中发生错误，可以使用 `session.rollback()` 来撤销所有更改。 ```python >>> fake_user = User(name='fakeuser', fullname='Invalid', password='12345') >>> session.add(fake_user) >>> session.commit() # 假设此处出现异常 Traceback (most recent call last): ... >>> session.rollback() ``` ##### 查询使用 `session.query()` 发起查询。查询结果默认按列表形式返回。 ```python >>> users = session.query(User).all() >>> for u in users: ... print(u.name) ... ed fakeuser ``` ##### 使用过滤器可以使用多种过滤器来筛选查询结果。 ```python >>> for u in session.query(User).filter(User.name == 'ed'): ... print(u.fullname) ... Ed Jones ``` ##### 返回列表和标量可以指定查询返回的对象类型。 ```python >>> names = session.query(User.name).all() >>> print(names) [('ed',), ('fakeuser',)] ``` ##### 使用纯 SQL 有时可能需要执行更复杂的 SQL 查询，可以通过 `text()` 函数实现。 ```python >>> from sqlalchemy import text >>> stmt = text("SELECT * FROM users WHERE name=:name") >>> ed_user = session.query(User).from_statement(stmt).params(name='ed').first() >>> print(ed_user.name) ed ``` ##### 计数使用 `func.count()` 函数来获取记录数量。 ```python >>> from sqlalchemy import func >>> count = session.query(func.count(User.id)).scalar() >>> print(count) 2 ``` ##### 建立关系通过定义 `relationship` 来建立类之间的关系。 ```python >>> from sqlalchemy import ForeignKey >>> from sqlalchemy.orm import relationship >>> class Address(Base): ... __tablename__ = 'addresses' ... id = Column(Integer, primary_key=True) ... email_address = Column(String(50), nullable=False) ... user_id = Column(Integer, ForeignKey('users.id')) ... user = relationship("User", back_populates="addresses") ... def __repr__(self): ... return "<Address(email_address='%s')>" % self.email_address ... ``` ##### 处理相关对象当一个对象与另一个对象关联时，可以方便地访问和修改相关对象。 ```python >>> jack = User(name='jack', fullname='Jack Bean', addresses=[Address(email_address='jack@google.com')]) >>> session.add(jack) >>> session.commit() >>> jack.addresses [<Address(email_address='jack@google.com')>] ``` ##### 使用连接查询通过 `join()` 方法来处理涉及多个表的查询。 ```python >>> for u, a in session.query(User, Address).filter(User.id==Address.user_id).filter(Address.email_address=='jack@google.com').all(): ... print(u) ... jack ``` ##### 使用别名可以为表创建别名来简化多表查询。 ```python >>> from sqlalchemy.orm import aliased >>> address_alias = aliased(Address) >>> for u, a1, a2 in session.query(User, address_alias, Address).\ ... filter(User.id==address_alias.user_id).\ ... filter(User.id==Address.user_id).\ ... filter(address_alias.email_address=='jack@google.com').\ ... filter(Address.email_address=='jack@yahoo.com').all(): ... print(u) ... jack ``` ##### 使用子查询子查询可以嵌入主查询中，以提取特定的数据集。 ```python >>> from sqlalchemy import select >>> stmt = select([Address]).where(Address.email_address == 'jack@google.com') >>> query = session.query(User).filter(User.addresses.any(stmt)) >>> query.all() [<User(name='jack', fullname='Jack Bean', addresses=[<Address(email_address='jack@google.com')>])>] ``` ##### 从子查询选择实体可以使用子查询的结果作为主查询的一部分。 ```python >>> subq = session.query(Address.user_id, Address.email_address).subquery() >>> query = session.query(User.name, subq.c.email_address).join(subq, User.id==subq.c.user_id).order_by(User.name) >>> query.all() [('jack', 'jack@google.com')] ``` ##### 使用 EXISTS 检查是否存在满足条件的记录。 ```python >>> from sqlalchemy import exists >>> session.query(exists().where(User.name == 'jack')).scalar() True ``` ##### 常用关系操作符 SQLAlchemy 支持多种关系操作符，包括 `any()` 和 `contains()` 等。 ```python >>> session.query(User).filter(User.addresses.any(Address.email_address == 'jack@google.com')).all() [<User(name='jack', fullname='Jack Bean', addresses=[<Address(email_address='jack@google.com')>])>] ``` ##### 贪婪加载在查询时，可以预先加载相关对象，以减少后续的查询次数。 ```python >>> from sqlalchemy.orm import joinedload >>> user = session.query(User).options(joinedload(User.addresses)).filter(User.name == 'jack').one() >>> user.addresses [<Address(email_address='jack@google.com')>] ``` ##### 删除使用 `delete()` 方法从数据库中删除对象。 ```python >>> session.delete(user) >>> session.commit() ``` ##### 配置级联删除可以配置级联删除选项，以便当父对象被删除时，其相关的子对象也会被自动删除。 ```python >>> session.query(User).filter(User.name == 'jack').delete(synchronize_session='fetch') ``` ##### 建立多对多关系多对多关系通常需要一个关联表来维护两个类之间的关系。 ```python >>> from sqlalchemy import Table >>> user_keywords = Table('user_keywords', Base.metadata, ... Column('user_id', Integer, ForeignKey('users.id')), ... Column('keyword_id', Integer, ForeignKey('keywords.id')) ... ) >>> class Keyword(Base): ... __tablename__ = 'keywords' ... id = Column(Integer, primary_key=True) ... keyword = Column(String(50)) ... def __init__(self, keyword): ... self.keyword = keyword ... def __repr__(self): ... return "<Keyword(keyword='%s')>" % self.keyword ... >>> User.keywords = relationship("Keyword", ... secondary=user_keywords, ... backref=backref("users", lazy="dynamic") ... ) ``` #### 映射配置 ##### 经典映射经典映射允许手动指定类与表之间的映射关系，提供了更多的灵活性。 ```python >>> from sqlalchemy.orm import mapper >>> class User(object): ... pass ... >>> mapper(User, User.__table__) ``` ##### 自定义列属性可以自定义列属性，例如改变列名或添加额外的行为。 ```python >>> from sqlalchemy.orm import column_property >>> user_table = Table('users', Base.metadata, ... Column('id', Integer, primary_key=True), ... Column('name', String(50)), ... Column('fullname', String(50)), ... Column('password', String(12)) ... ) >>> class User(object): ... def __init__(self, name, fullname, password): ... self.name = name ... self.fullname = fullname ... self.password = password ... def __repr__(self): ... return "<User('%s','%s', '%s')>" % (self.name, self.fullname, self.password) ... >>> mapper(User, user_table, properties={ ... 'name': user_table.c.name, ... 'fullname': user_table.c.fullname, ... 'password': user_table.c.password, ... 'username': column_property(user_table.c.name + '_username') ... }) ``` ##### 延迟加载可以配置某些属性为延迟加载，这意味着除非明确请求，否则不会加载这些属性。 ```python >>> from sqlalchemy.orm import deferred >>> mapper(User, user_table, properties={ ... 'name': deferred(user_table.c.name) ... }) ``` ##### SQL 表达式作为映射属性可以将 SQL 表达式映射为类的属性。 ```python >>> from sqlalchemy.sql.expression import func >>> mapper(User, user_table, properties={ ... 'lower_name': column_property(func.lower(user_table.c.name)) ... }) ``` ##### 改变属性行为可以通过各种方法改变属性的行为，例如使用验证器、混合类或自定义比较器等。 ```python >>> from sqlalchemy.orm import validates >>> class User(object): ... @validates('name') ... def validate_name(self, key, name): ... if not name.isalpha(): ... raise ValueError("Name must contain only letters") ... return name ... >>> mapper(User, user_table) ``` ##### 复合列类型可以使用复合类型来存储复杂的数据结构。 ```python >>> from sqlalchemy.ext.declarative import declared_attr >>> class Address(object): ... @declared_attr ... def id(cls): ... return Column(Integer, primary_key=True) ... email_address = Column(String(50), nullable=False) ... user_id = Column(Integer, ForeignKey('users.id')) ... user = relationship("User", back_populates="addresses") ... >>> class CompositeType(Base): ... __tablename__ = 'composite_type' ... id = Column(Integer, primary_key=True) ... data = Column(PickleType) ... ``` ##### 映射多个表一个类可以映射到多个表，这适用于复杂的数据模型。 ```python >>> class Person(object): ... pass ... >>> person_table = Table('person', Base.metadata, ... Column('id', Integer, primary_key=True), ... Column('name', String(50)), ... Column('type', String(50)) ... ) >>> mapper(Person, person_table) >>> class Engineer(Person): ... pass ... >>> engineer_table = Table('engineer', Base.metadata, ... Column('person_id', Integer, ForeignKey('person.id'), primary_key=True), ... Column('status', String(30)), ... Column('engineer_name', String(50)), ... Column('primary_language', String(50)) ... ) >>> mapper(Engineer, engineer_table, inherits=mapper(Person)) ``` 以上内容介绍了 SQLAlchemy ORM 的基本概念和常见用法，通过上述示例和解释，开发者可以快速掌握如何使用 SQLAlchemy 来实现数据库操作，并了解 ORM 的优势和适用场景。

这个错误通常是因为你没有安装 `sqlalchemy` 模块。你可以通过在终端或命令提示符中运行以下命令来安装该模块： ``` pip install sqlalchemy ``` 如果你使用的是 Anaconda 环境，则可以使用以下命令安装： ``` conda install -c anaconda sqlalchemy ``` 安装完成后，你应该能够成功导入这个模块。

阅读全文

ModuleNotFoundError: No module named 'sqlalchemy'

相关推荐

浅谈pycharm下找不到sqlalchemy的问题

ModuleNotFoundError: No module named sqlalchemy

python ModuleNotFoundError: No module named sqlalchemy

modulenotfounderror: no module named 'sqlalchemy'

ModuleNotFoundError: No module named flask_sqlalchemy

python ModuleNotFoundError: No module named 'sqlalchemy'

ModuleNotFoundError: No module named 'flask_sqlalchemy'

sqlalchemy没有ModuleNotFoundError: No module named 'MySQLdb'

from flask_sqlalchemy import SQLAlchemy ModuleNotFoundError: No module named 'flask_sqlalchemy'

sqlalchemy连接mysql数据库ModuleNotFoundError: No module named 'MySQLdb'

ModuleNotFoundError: No module named 'sqlalchemy.ext.asyncio'

ModuleNotFoundError: No module named 'sqlalchemy.sql.default_comparator

ModuleNotFoundError: No module named 'sqlalchemy.sql.default_comparator'

File "app.py", line 5, in <module> from sqlalchemy.orm import sessionmaker ModuleNotFoundError: No module named 'sqlalchemy'

在使用pyinstaller打包过程中，出现ModuleNotFoundError: No module named 'flask_sqlalchemy'错误

flask_sqlalchemy模块明明已经导入，但还是报错ModuleNotFoundError: No module named 'flask_sqlalchemy'。可能原因有哪些？

ModuleNotFoundError: No module named 'unrar'

Traceback (most recent call last): File "D:\workspace\dwbi\ods\ods_beisen\beisenapi.py", line 9, in <module> from sqlalchemy import engine_from_config, MetaData, Table ModuleNotFoundError: No module named 'sqlalchemy'

ModuleNotFoundError: No module named 'flask.ext

最新推荐

基于Java的家庭理财系统设计与开发-金融管理-家庭财产管理-实用性强

探索数据转换实验平台在设备装置中的应用

管理建模和仿真的文件

ggflags包的国际化问题：多语言标签处理与显示的权威指南

如何使用MATLAB实现电力系统潮流计算中的节点导纳矩阵构建和阻抗矩阵转换，并解释这两种矩阵在潮流计算中的作用和差异？

使用git-log-to-tikz.py将Git日志转换为TIKZ图形

"互动学习：行动中的多样性与论文攻读经历"

ggflags包的定制化主题与调色板：个性化数据可视化打造秘籍

如何使用Matlab进行风电场风速模拟，并结合Weibull分布和智能优化算法预测风速？

小栗子源码2.9.3版本发布