SQLAlchemy 数据库炼金师-ORM模式

SQLAlchemy 简介

SQLAlchemy 数据库炼金师-ORM模式 - 图1

SQLAlchemy 是目前最流行的 Python 语言的SQL工具箱，它为开发人员提供了 SQL 的全部功能同时保留了 Python 的灵活性。

SQLAlchemy 以对象关系映射（ORM）而闻名，使用它可以将 Python 的类映射到数据库，从而允许对象模型和数据库模式从一开始就以一种完全分离的方式分别进行架构。 对象模型可以无需考虑使用什么数据库来存储, 这样给项目开发带来了极大的便利.

开始之前, 先收下几个有用的网址

什么是ORM？

ORM（对象关系映射）是一种编程技术，用于在面向对象的编程语言中将对象与数据库表进行映射, 从而简化开发过程。

在ORM系统中，每个类都映射到数据库中的表。 使用了 ORM 技术的项目不必在编写繁琐的数据库接口代码， 而是由 ORM 技术自动来解决增删改查这些与数据库相关的操作，因而开发者可以更专注于实现项目的核心功能。

SQLAlchemy 的两种使用模式

SQLAlchemy 由两个主要的模块组成, 分别是 核心模式 与 ORM 模式

核心模式: 是功能齐全的 SQL 语言的抽象工具包，对于熟悉 SQL 语言的开发者来说, 使用 SQLAlchemy 的核心模式可以快速的上手, 而又无需考虑数据库之间的 SQL 方言差异

ORM 模式: 每个类都映射到数据库中的表, 开发者无需在编写繁琐的数据库接口代码, 可以更专注于实现项目的核心功能

课程内容简介

本课程主要讲解 SQLAlchemy 的ORM模式开发，主要围绕着图书管理系统来进行设计，数据包含以下内容
图书表 books

  1. +----+--------+--------------------------+-------+
  2. | id | cat_id | name                     | price |
  3. +----+--------+--------------------------+-------+
  4. |  1 |      1 | 生死疲劳                 | 40.40 |
  5. |  2 |      1 | 皮囊                     | 31.80 |
  6. |  3 |      2 | 半小时漫画中国史          | 33.60 |
  7. |  4 |      2 | 耶路撒冷三千年            | 55.60 |
  8. |  5 |      2 | 国家宝藏                 | 52.80 |
  9. |  6 |      3 | 时间简史                 | 31.10 |
  10. |  7 |      3 | 宇宙简史                 | 22.10 |
  11. |  8 |      3 | 自然史                   | 26.10 |
  12. |  9 |      3 | 人类简史                 | 40.80 |
  13. | 10 |      3 | 万物简史                 | 33.20 |
  14. +----+--------+--------------------------+-------+

_
分类表 categories

  1. +----+--------------+
  2. | id | name         |
  3. +----+--------------+
  4. |  1 | 文学         |
  5. |  2 | 人文社科     |
  6. |  3 | 科技         |
  7. +----+--------------+

第一关 ORM模式快速案例

接下来我们用一个简短的案例用 SQLAlchemy 实现对数据库的增删改查操作

  1. #coding:utf8
  2. from sqlalchemy import create_engine
  3. # 连接到 SQLite 数据库，通常加上 echo = True 用于调试， 这样 SQLAlchemy 会输出自动生成的 SQL 语句
  4. engine = create_engine('sqlite:///sqlalchemy.db', echo = True )
  5. # 这个时候还没有连接数据， 还需要对 engine 对象调用 connect 方法
  6. cn = engine.connect()
  7. # declarative_base是sqlalchemy内部封装的一个方法，通过其构造一个基类，这个基类和它的子类，可以将Python类和数据库表关联映射起来
  8. from sqlalchemy.ext.declarative import declarative_base
  9. Base = declarative_base()
  10. # ORM的重要特点，我们操作表的时候，就需要通过操作对象来实现，现在我们创建一个类，以用户表为例
  11. from sqlalchemy import Column, Integer, String
  12. # 数据库表模型类通过__tablename__和表关联起来，Column表示数据表的列。
  13. class Users(Base):
  14.     __tablename__ = "users"
  15.     #通过primary_key设置为主键
  16.     id = Column(Integer, primary_key=True)
  17.     #unique设置为不重复
  18.     name = Column(String(64), unique=True)
  19.     email = Column(String(64))
  20.     #初始化设置值
  21.     def __init__(self, name, email):
  22.         self.name = name
  23.         self.email = email
  24. #创建表 如果表存在则忽略，执行以下代码发现在db中创建了users表
  25. Base.metadata.create_all(engine)
  26. #sqlalchemy中使用session用于创建程序和数据库之间的会话，所有对象的载入和保存都需要通过session对象 。
  27. from sqlalchemy.orm import sessionmaker
  28. # 创建session
  29. DbSession = sessionmaker(bind=engine)
  30. session = DbSession()
  31. #增
  32. add_user = Users("test", "test123@qq.com")
  33. session.add(add_user)
  34. session.commit()
  35. #查
  36. users = session.query(Users).filter_by(id=1).all()
  37. for item in users:
  38.     print(item.name)
  39. #改
  40. session.query(Users).filter_by(id=1).update({'name': "Jack"})
  41. #删
  42. delete_users = session.query(Users).filter(Users.name == "test").first()
  43. if delete_users:
  44.     session.delete(delete_users)
  45.     session.commit()

同学当你阅读完这个代码以后，你会发现 咦~，没有SQL语句了。嗯，是的，这个就是ORM的魅力所在，只要你掌握了类与对象的概念，即可进行数据的操作了，整个ORM里面，通过操作Users这个类即可数据进行增删改查的操作，完全不依赖SQL语句，对于刚接触不久的你，无疑是发现了一块新大陆。哦也！不用在记那些繁琐的sql语句喽！接下来我们愉快的系统的进行学习ORM框架，进入ORM全新世界。

第二关 连接数据库

首先学习使用 SQLAlchemy 连接数据库

SQLAlchemy 用 create_engine 方法新建一个 Engine 对象, 通过 Engine 对象可以连接数据库,

数据库连接语法: dialect+driver://username:password@host:port/database , 下面通过几个案例讲解如何连接各种类型的数据库

  1. # 连接 SQLite
  2. engine = create_engine('sqlite:///sqlalchemy.db')
  4. # Windows 指定路径
  5. engine = create_engine('sqlite:///C:\\path\\to\\sqlalchemy.db')
  7. # Linux/Unix/Mac 指定路径
  8. engine = create_engine('sqlite:////path/to/sqlalchemy.db')
  10. # MySQL : 缺省驱动 mysql-python
  11. engine = create_engine('mysql://scott:tiger@localhost/foo')
  13. # MySQL : 使用 pymysql 连接
  14. engine = create_engine('mysql+pymysql://scott:tiger@localhost/foo')
  16. # PostgreSQL : 缺省驱动 psycopg2
  17. engine = create_engine('postgresql://scott:tiger@localhost/mydatabase')

重要参数:

  • echo = True : 用于调试， 这样 SQLAlchemy 会输出自动生成的 SQL 语句和其他一些调试信息
  • encoding = ‘utf-8’ : 指定字符串类型的编码, 缺省值就是 utf-8
  • pool_size = 10 : 指定数据库连接池内保持活跃连接的数量，sqlite不支持数据库连接池

创建了 Engine 对象后, 还没有实际连接数据库, 还需要调用 connect 方法连接数据库

  1. # 连接数据库, 返回连接赋值给 cn
  2. cn = engine.connect()

Engine 与数据库连接池: 由于连接数据库是一个较为耗时的操作, 因此 Engine 内部实现了数据库连接池, 当我们创建 Engine 对象的时候, 使用 pool_size 告诉 Engine 对象数据库连接池需要保持多少个活跃连接. 当我们需要连接数据库时, 从连接池中取用一个现成的连接使用即可, SQLAlchemy 将这一切复杂的逻辑为我们封装在 Engine 对象中

  1. # SQLite 不支持连接池, 这里使用 MySQL 数据库进行演示
  2. engine = create_engine('mysql+pymysql://pandas:pandas@localhost/pandas', pool_size= 5, echo=True)

第三关 建表

为了适应不同数据库建表技术的不同之处 , SQLAlchemy 实现了自己的建表方式: MetaData 元数据类,
通过工厂模式declarative_base创建MetaData元数据类，declarative_base是sqlalchemy内部封装的一个方法，通过其构造一个基类，这个基类和它的子类，可以将Python类和数据库表关联映射起来

  1. 创建基类Base用于将Python类和数据库表关联映射
  2. from sqlalchemy.ext.declarative import declarative_base
  3. Base = declarative_base()

建表: 用 Category对象新建数据库表, 用 Column 对象映射数据库表的每个字段，值得注意的是sqlalchemy要求每个表是必须有主键值的，无主键值会报错

  1. # 导入需要用的类
  2. from sqlalchemy import Table, Column, Integer, Numeric, String, DateTime
  3. # 数据库表模型类通过__tablename__和表关联起来，Column表示数据表的列。
  4. class Category(Base):
  5.     __tablename__ = 'categories'
  6.     id = Column(Integer, primary_key=True)
  7.     name = Column('name', String(30))
  8.     def __init__(self,name):
  9.         self.name=name
  10. #创建表 如果表存在则忽略，执行以下代码发现在db中创建了users表
  11. Base.metadata.create_all(engine)

建表输出语句

  1. CREATE TABLE categories (
  2.     id INTEGER NOT NULL, 
  3.     name VARCHAR(30), 
  4.     PRIMARY KEY (id)
  5. )

建立了数据表以后, Category 对象还有大用处, 可以进行增删改查, 所以如果使用 SQLAlchemy 的ORM模式开发项目, 首先就要建立 ORM 对象。

下面列出了 SQLAlchemy 提供的常用数据类型, 供参考使用

  • BigInteger
  • Boolean
  • Date/Time/DateTime
  • Enum
  • Float
  • Integer/SmallInteger
  • LargeBinary
  • Numeric
  • String/Unicode
  • Text/UnicodeText

SQLAlchemy 还有一些数据类型是只有部分数据库才支持的, 要了解这些数据类型请参考官方文档 https://docs.sqlalchemy.org/en/13/core/type_basics.html

ForeignKey 外键： 在关系型数据库设计中， 外键是一个重要的特性， 即数据表中的其中一个字段的数据来自于另一个数据表的字段， 通常来自于另一个数据表的主键。 上面我们设计了一个 categories 表， 现在设计一个 books 表， 其中的一个字段 cat_id 来自于 Category 表的主键

  1. from sqlalchemy import create_engine, Numeric
  3. # 连接到 SQLite 数据库通常加上 echo = True 用于调试， 这样 SQLAlchemy 会输出自动生成的 SQL 语句
  4. engine = create_engine('sqlite:///sqlalchemy.db', echo = True )
  5. # 这个时候还没有连接数据， 还需要对 engine 对象调用 connect 方法
  6. cn = engine.connect()
  7. # declarative_base是sqlalchemy内部封装的一个方法，通过其构造一个基类，这个基类和它的子类，可以将Python类和数据库表关联映射起来
  8. from sqlalchemy.ext.declarative import declarative_base
  9. Base = declarative_base()
  10. # ORM的重要特点，我们操作表的时候，就需要通过操作对象来实现，现在我们创建一个类，以用户表为例
  11. from sqlalchemy import Column, Integer, String,ForeignKey
  12. # 数据库表模型类通过__tablename__和表关联起来，Column表示数据表的列。
  13. class Category(Base):
  14.     __tablename__ = 'categories'
  15.     id = Column(Integer, primary_key=True)
  16.     name = Column('name', String(30))
  17.     def __init__(self,name):
  18.         self.name=name
  19. class Book(Base):
  20.     __tablename__ = 'books'
  22.     id = Column(Integer, primary_key=True)
  23.     cat_id = Column(Integer,ForeignKey("categories.id"))
  24.     name = Column('name', String(120))
  25.     price = Column('price', Numeric)
  26.     def __init__(self,cat_id,name,price):
  27.         self.cat_id=cat_id
  28.         self.name=name
  29.         self.price=price
  30. #创建表 如果表存在则忽略，执行以下代码发现在db中创建了users表
  31. Base.metadata.create_all(engine)

建表输出:

  1. CREATE TABLE books (
  2.     id INTEGER NOT NULL, 
  3.     cat_id INTEGER, 
  4.     name VARCHAR(120), 
  5.     price NUMERIC, 
  6.     PRIMARY KEY (id), 
  7.     FOREIGN KEY(cat_id) REFERENCES categories (id)
  8. )

上面有2个表，为什么这里只输出了一个表呢？原因是Base.metadata.create_all方法是如果没有表创建表，如果有表，就不在进行创建表

磨刀不误砍柴工，为了方便后续打印数据，对数据做一个封装

  1. def to_dict(self):
  2.     return {c.name: getattr(self, c.name, None)
  3.             for c in self.__table__.columns}
  4. Base.to_dict = to_dict

第四关 增删改

1. 创建会话

创建了数据表以后, 接下来对数据表进行增删改操作. 使用session会话进行增删改查的操作，我们使用上一关卡创建的engine

  1. #sqlalchemy中使用session用于创建程序和数据库之间的会话，所有对象的载入和保存都需要通过session对象 。
  2. from sqlalchemy.orm import sessionmaker
  3. # 创建session
  4. DbSession = sessionmaker(bind=engine)
  5. session = DbSession()

2. 插入数据

在前面建表关卡， 我们建立了 categories 和 books 数据表, 并分别使用 metadata.create_all 方法,创建了数据表, 下面我们创建categories对象使用session的内置add增加数据

  1. c1=Category('文学')
  2. session.add(c1)
  3. session.commit()

三行代码，就解决了增加数据步骤，怎么样，是不是很惊喜！

在整个操作中，我们会发现id没有设置值，id设置的是主键，获取增加数据后自动生成的主键值

插入数据输出

  1. INSERT INTO categories (name, email) VALUES (?, ?)

如果要添加多个数据

  1. c2=Category('人文社科')
  2. c3=Category('科技')
  3. session.add_all([c2,c3])
  4. session.commit()
  7. #添加数据
  8. book=Book(1,'生死疲劳',40.40)
  9. book1=Book(1,'皮囊',31.80)
  10. book2=Book(2,'半小时漫画中国史',33.60)
  11. book3=Book(2,'耶路撒冷三千年',55.60)
  12. book4=Book(2,'国家宝藏',52.80)
  13. book5=Book(3,'时间简史',31.10)
  14. book6=Book(3,'宇宙简史',22.10)
  15. book7=Book(3,'自然史',26.10)
  16. book8=Book(3,'人类简史',40.80)
  17. book9=Book(3,'万物简史',32.20)
  18. session.add_all([book,book1,book2,book3,book4,book5,book6,book7,book8,book9])
  19. session.commit()

3. 查看数据

查看数据: 使用session的query语句作为查询，使用 Book 类指定查询表，使用filter_by作为查询条件，通过all返回所有符合查询条件的结果，根据返回值遍历，得到每一行数据的内容

  1. book = session.query(Book).filter(Book.id == 1).first()
  2. print(book.to_dict())

查询数据语句输出

  1. SELECT books.id AS books_id, books.cat_id AS books_cat_id, books.name AS books_name, books.price AS books_price 
  2. FROM books 
  3. WHERE books.id = ?
  4.  LIMIT ? OFFSET ?

得到的返回数据如下
{‘id’: 1, ‘cat_id’: 1, ‘name’: ‘生死疲劳’, ‘price’: Decimal(‘40.4000000000’)}

4. 修改数据

查看数据: 使用session的query语句作为查询，使用 Book 类指定查询表，使用filter_by作为查询条件，通过update设置要修改的内容，里面的参数使用字段

  1. session.query(Book).filter_by(id=1).update({'name': "Jack"})

5. 删除数据

删除数据: 使用seesion的query查找的对象，查找对象使用的是Book用于指定是查找哪个表，filter设置查找的内容，first返回的是查找的第一个对象，若这个对象有，则使用session的delete进行删除数据

  1. delete_book = session.query(Users).filter(Book.name == "宇宙简史").first()
  2. if delete_book:
  3.     session.delete(delete_book)
  4.     session.commit()

第五关 查询数据

上一关中使用了简单的查询语句，查询语句有多种多样的语句来满足不同的应用场景，接下来来看看还有哪些查询场景

1、单条件查询

通过query进行查询，filter进行设置条件，first取出第一个值来进行查询，返回的是单个对象

  1. book = session.query(Book).filter(Book.id == 1).first()
  2. print(book.to_dict())

输出结果如下

  1. {'id': 1, 'cat_id': 1, 'name': '生死疲劳', 'price': Decimal('40.4000000000')}

2、多条件查询

通过query进行查询，filter进行设置条件，使用all返回所有内容，接收的数据结构为一个列表类型

  1. books = session.query(Book).filter(Book.cat_id == 1,Book.price > 35).all()
  2. print([v.to_dict() for v in books])

输出结果如下

  1. [{'id': 1, 'cat_id': 1, 'name': 'Jack', 'price': Decimal('40.4000000000')}]

3、返回记录条数

调用count函数，来获得返回的数据数量

  1. count = session.query(Book).filter(Book.cat_id == 3).count()
  2. print(count)

输出结果如下

  1. 5

4、限制返回的记录条数

通过limit来进行限制返回数据的条数

  1. #limit() 限制返回的记录条数
  2. books = session.query(Book).filter(Book.cat_id == 3).limit(3).all()
  3. print([v.to_dict() for v in books])

输出结果如下

  1. [{'id': 6, 'cat_id': 3, 'name': '时间简史', 'price': Decimal('31.1000000000')}, 
  2.  {'id': 7, 'cat_id': 3, 'name': '宇宙简史', 'price': Decimal('22.1000000000')}, 
  3.  {'id': 8, 'cat_id': 3, 'name': '自然史', 'price': Decimal('26.1000000000')}]

5、将记录按照某个字段进行排序

使用order_by设置排序，desc进行设置是依据、哪个字段进行正向排序还是逆向排序

  1. # 图书按 ID 降序排列
  2. # 如果要升序排列，去掉 .desc() 即可
  3. books = session.query(Book.id, Book.name).filter(Book.id > 8).order_by(Book.id.desc()).all()
  4. print([dict(zip(v.keys(), v)) for v in books])

输出结果如下

  1. [{'cat_id': 1}, {'cat_id': 2}, {'cat_id': 3}]

6、查看记录是否存在

查看这个数据是否存在

  1. from sqlalchemy.sql import exists
  2. is_exist = session.query(exists().where(Book.id > 10)).scalar()
  3. print(is_exist)

输出结果如下

  1. False

第六关 事务处理

SQLAlchemy 对于事务处理其实和 DB-API 一样, 因为事务处理的套路是一样的, 就是利用 with 语法

  1. # 连接数据库
  2. engine = create_engine('sqlite:///sqlalchemy.db', echo = True)
  4. # 使用 with 启动一个事务
  5. with engine.begin() as cn:
  6.     users = session.query(Users).filter_by(id=1).all()
  7.     for item in users:
  8.         print(item.name)

第七关 相关拓展-联表查询

什么是联表查询，联表查询是把2个表按照一定关系进行组合后进行查询，比如图书管理系统中，使用Book时候无法直观的看到这个图书的具体分类，但是通过联表查询，就可以把结果比较直观的显示图书的数据分类

联表查询分为内连接和外链接
内连接：（inner join）内连接是把两张表相同的地方匹配出来
外连接：外连接是以左边或右边的表作为主表，把主表的内容显示出来，从表没有的内容置为空处理

1、内连接

使用内连接我们来查询一下分类为科技的并且价格大于40的图书

  1. #内连接 获取分类为「科技」，且价格大于 40 的图书
  2. # 如果 ORM 对象中定义有外键关系
  3. # 那么 join() 中可以不指定关联关系
  4. # 否则，必须要
  5. books = session .query(Book.id,
  6.            Book.name.label('book_name'),
  7.            Category.name.label('cat_name')) \
  8.     .join(Category, Book.cat_id == Category.id) \
  9.     .filter(Category.name == '科技',
  10.             Book.price > 40) \
  11.     .all()
  12. print([dict(zip(v.keys(), v)) for v in books])


输出结果：_

  1. [{'id': 9, 'book_name': '人类简史', 'cat_name': '科技'}]

统计各个分类的图书的数量

  1. # 统计各个分类的图书的数量
  2. from sqlalchemy import func
  3. books = session \
  4.     .query(Category.name.label('cat_name'),
  5.            func.count(Book.id).label('book_num')) \
  6.     .join(Book, Category.id == Book.cat_id) \
  7.     .group_by(Category.id) \
  8.     .all()
  9. print([dict(zip(v.keys(), v)) for v in books])

_
输出结果

  1. [{'cat_name': '文学', 'book_num': 2}, 
  2.  {'cat_name': '人文社科', 'book_num': 3}, 
  3.  {'cat_name': '科技', 'book_num': 5}]

2、外连接

  1. #为方便说明，我们仅在这一小节中向 books 表中加入如下数据
  2. # +----+--------+-----------------+-------+
  3. # | id | cat_id | name            | price |
  4. # +----+--------+-----------------+-------+
  5. # | 11 |      3 | 人性的弱点       | 54.40 |
  6. # +----+--------+-----------------+-------+
  7. # outerjoin 默认是左连接# 如果 ORM 对象中定义有外键关系
  8. # 那么 outerjoin() 中可以不指定关联关系
  9. # 否则，必须要
  10. books = session \
  11.     .query(Book.id.label('book_id'),
  12.            Book.name.label('book_name'),
  13.            Category.id.label('cat_id'),
  14.            Category.name.label('cat_name')) \
  15.     .outerjoin(Category, Book.cat_id == Category.id) \
  16.     .filter(Book.id >= 9) \
  17.     .all()
  18. print([dict(zip(v.keys(), v)) for v in books])

_
输出结果

  1. [{'book_id': 9, 'book_name': '人类简史', 'cat_id': 3, 'cat_name': '科技'}, 
  2.  {'book_id': 10, 'book_name': '万物简史', 'cat_id': 3, 'cat_name': '科技'}]

课程练习

设计一个项目 project 的数据库，要求包含以下字段：

  • id 整数类型主键自增1
  • name 字符串类型

本项目使用了一个 流行歌手的数据集 artist.csv , 其中数据非常简单只有两列: id, name , 刚好与我们设计的 project 数据库一样. 接下来使用数据库实现以下操作：

Step1：将 artist.csv 导入项目数据库，并删除掉前 3 个数据；

Step2：搜索数据库，打印出数据库 id = 10 的数据；

Step3：将数据导出为 project_data.csv 文件中。

好了，利用我们本课程已经学习的知识，动手完成这个小练习吧！

参考答案：

  1. #coding:utf8
  2. # 导入 SQLAlchemy
  3. from sqlalchemy import create_engine, MetaData, Table, Integer, String, Column
  4. # 连接数据库
  5. engine = create_engine('sqlite:///project.db', echo = True)
  6. # 使用 MetaData/Table 建表
  7. # declarative_base是sqlalchemy内部封装的一个方法，通过其构造一个基类，这个基类和它的子类，可以将Python类和数据库表关联映射起来
  8. from sqlalchemy.ext.declarative import declarative_base
  9. Base = declarative_base()
  10. class Project(Base):
  11.     __tablename__='project'
  13.     id=Column(Integer, primary_key=True)
  14.     # unique设置为不重复
  15.     name=Column(String(255))
  17.     def __init__(self,name):
  18.         self.name=name
  19. Base.metadata.create_all(engine)
  20. # 从 CSV 文件读取数据到列表对象
  21. # 定义一个列表对象
  22. projects = []
  23. # 导入 csv  模块
  24. import csv
  25. # 用 with 语法, 打开文件
  26. with open('artist.csv', newline='') as csvfile:
  27.     # 用 DictReader 类, 方便开发
  28.     reader = csv.DictReader(csvfile)
  29.     # 按行遍历csv 文件
  30.     for row in reader:
  31.         try:
  32.             projects.append({"id": row['id'], "name": row['name'] } )
  33.         except Exception as e:
  34.             print(e)
  35. print(projects)
  36. #sqlalchemy中使用session用于创建程序和数据库之间的会话，所有对象的载入和保存都需要通过session对象 。
  37. from sqlalchemy.orm import sessionmaker
  38. # 创建session
  39. DbSession = sessionmaker(bind=engine)
  40. session = DbSession()
  41. for i in projects:
  42.     print(i['name'])
  43.     add_project = Project(i['name'])
  44.     add_project.id=int(i['id'])
  45.     session.add(add_project)
  46. session.commit()
  47. print(" 成功导入 CSV 数据" )
  48. # 删除掉前3个数据
  49. delete_projects = session.query(Project).filter(Project.id <3).all()
  50. if len(delete_projects)>0:
  51.     for i in delete_projects:
  52.         session.delete(i)
  53.     session.commit()
  54. # 打印 id = 10 的数据
  55. project_10 = session.query(Project).filter_by(id=10).first()
  56. print(project_10)
  57. # 将数据导出为 project_data.csv
  58. with open("project_data.csv", 'w') as csvfile:
  59.     header= False
  60.     pro_all = session.query(Project).all()
  61.     for i in pro_all:
  62.         csvfile.write('%d,%s\r\n'%(i.id,i.name))
  63. print(" 成功写入 CSV 文件")

SQLAlchemy 是目前最为流行的 Python 数据库模块, 在本课程中主要讲解了如何使用 SQLAlchemy 的ORM模式操作数据库, 只需要创建对象进行操作即可，对于刚接触程序的你，非常友好

SQLAlchemy 的ORM模式建立在对象的理解上，只要掌握了对象初始化和调用函数即可完成

SQLAlchemy 的核心开发模式和ORM开发模式各有千秋，适应不同人群，根据自身掌握程度，在开发时候除了公司明确要求你使用哪种，剩下的就根据自己最熟悉的来进行使用