环境：Ubuntu 15.10 64-bit
SQLAlchemy 是 Python 的 ORM 框架，它的理念是：数据库的量级和性能重要于对象集合，而对象集合的抽象又重要于表和行。
安装
直接通过 pip 安装：
$ pip install sqlalchemy
打开 Python，测试是否安装成功：
>>> import sqlalchemy>>> sqlalchemy.__version__'1.0.9'
创建引擎
SQLite
首先以 SQLite 为例，因为它比较简单。
from sqlalchemy import create_engine, MetaDataengine = create_engine('sqlite:///foo.db', echo=True)metadata = MetaData(engine) 参数 sqlite:///foo.db 解释为：
sqlite:///
其中foo.db是相对路径。也可写成：
sqlite:///./foo.db
SQLAlchemy 缺省使用 Python 内建的 sqlite3 模块来连接或创建 SQLite 数据库。执行完 create_engine 后，可以发现当前目录多了 foo.db 文件，不妨用 sqlite 打开看看。
$ sqlite3 foo.dbSQLite version 3.8.11.1 2015-07-29 20:00:57Enter ".help" for usage hints.sqlite> .tables
注意这里用的是 sqlite3 而非 sqlite，因为 foo.db 是经由 Python 内建的 sqlite3 模块创建的。
MySQL
再来看看连接 MySQL 时怎么创建引擎。
本文后续示例全部基于 MySQL，这是与官方文档不同的地方。先在MySQL里创建一个测试数据库：sa_test，后续示例都将基于这个数据库。mysql> CREATE DATABASE sa_test DEFAULT CHARACTER SET UTF8;
from sqlalchemy import create_engine, MetaDataengine = create_engine('mysql+mysqldb://root:******@localhost/sa_test', echo=True)metadata = MetaData(engine) 这里的参数看上去就比较复杂了，完整的格式为：
dialect+driver://username:password@host:port/database
这里 driver 用了 mysqldb，详见：
引擎配置的详细信息可参考官方文档：
MetaData
前面在创建 MetaData 时绑定了引擎：
metadata = MetaData(engine)
当然也可以不绑定。绑定的好处是，后续很多调用 （比如 MetaData.create_all()，Table.create()，等等）就不用指定引擎了。
创建表
创建两张表，user 和 address，address 表里有一个 user id 的外键。
from sqlalchemy import create_engine, MetaData,\ Table, Column, Integer, String, ForeignKeyengine = create_engine('mysql+mysqldb://root:******@localhost/sa_test', echo=True)metadata = MetaData(engine) user_table = Table('user', metadata, Column('id', Integer, primary_key=True), Column('name', String(50)), Column('fullname', String(100)) )address_table = Table('address', metadata, Column('id', Integer, primary_key=True), Column('user_id', None, ForeignKey('user.id')), Column('email', String(128), nullable=False) )metadata.create_all() 执行完 metadata.create_all() 这一句，两张表就创建好了，可以在 MySQL 里立即查看。
MetaData.create_all() 可以多次调用，不会报错，它在内部会检查表是否已经创建。
MetaData 创建时已经绑定了引擎，所以此处 create_all() 就不必再指定了，否则得写成： metadata.create_all(engine)
创建引擎时，echo 参数为 True，程序运行时便有很多调试信息打印出来。在这些调试信息中，可以看到如下两条 MySQL的CREATE TABLE 语句：
CREATE TABLE user ( id INTEGER NOT NULL AUTO_INCREMENT, name VARCHAR(50), fullname VARCHAR(100), PRIMARY KEY (id))CREATE TABLE address ( id INTEGER NOT NULL AUTO_INCREMENT, user_id INTEGER, email VARCHAR(128) NOT NULL, PRIMARY KEY (id), FOREIGN KEY(user_id) REFERENCES user (id))
除了 metadata.create_all()，Table 自己也有 create 方法：
create(bind=None, checkfirst=False)
参数 bind 一般就是指引擎。
checkfirst 表示是否检查表已经存在。为 True 时，若表已经存在，不报错，只是什么也不做；为False 时，若表已经存在，则将引发异常。使用这个方法来创建这两张表： user_table.create(checkfirst=True)address_table.create(checkfirst=True)
这里忽略了 bind 参数，因为创建 MetaData 对象时已经绑定了引擎，而创建表对象时又传入了 metadata，所以顺藤摸瓜，表自己是知道引擎的。
address 表里有一个 user 表的外键，而这时候 user 表还没创建呢。所以，还是建议使用 MetaData.create_all() 吧，毕竟它也会检查表是否已经存在。 表的反射（Table Reflection）
表创建好了，一般也就不动了。所以实际应用时，往往表都已经存在，并不需要创建，只需把它们”导入”进来即可，这时就得使用 autoload 参数。
from sqlalchemy import create_engine, MetaData, Tableengine = create_engine('mysql+mysqldb://root:******@localhost/sa_test', echo=False)metadata = MetaData(engine)user_table = Table('user', metadata, autoload=True)print 'user' in metadata.tablesprint [c.name for c in user_table.columns]address_table = Table('address', metadata, autoload=True)print 'address' in metadata.tables 输出：
True['id', 'name', 'fullname']True
如果 MetaData 没有绑定引擎，则另需指定 autoload_with 参数：
user_table = Table('user', metadata, autoload=True, autoload_with=engine) 如果被反射的表外键引用了另一个表，那么被引用的表也会一并被反射。比如只反射 address 表，user 表也一并被反射了。
from sqlalchemy import create_engine, MetaData, Tableengine = create_engine('mysql+mysqldb://root:******@localhost/sa_test', echo=False)metadata = MetaData(engine)address_table = Table('address', metadata, autoload=True)print 'user' in metadata.tablesprint 'address' in metadata.tables 输出：
TrueTrue
插入数据
插入数据之前，必须要有表对象，不管是新创建的，还是通过反射导入的。
Insert 对象
要往表里插数据，先创建一个 Insert 对象：
ins = user_table.insert()print ins
打印这个 Insert 对象，可以看到它所对应的 SQL 语句：
INSERT INTO user (id, name, fullname) VALUES (%s, %s, %s)
如果连接的数据库不是 MySQL 而是 SQLite，那输出可能就是下面这样：
INSERT INTO user (id, name, fullname) VALUES (?, ?, ?)
可见 SQLAlchemy 帮我们封装了不同数据库之间语法的差异。
如果MetaData 创建时没有绑定引擎，那么输出会略有不同： INSERT INTO "user" (id, name, fullname) VALUES (:id, :name, :fullname)
这时 SQLAlchemy 还不知道具体的数据库语法，表名加了引号（"user"），列名也改用为:id之类一般性的格式。
user 表里的每一列，而id在插入时一般是不需要指定的，可以通过Insert.values() 方法加以限制： ins = ins.values(name='adam', fullname='Adam Gu')print ins
限制后，id 列已经没有了：
INSERT INTO user (name, fullname) VALUES (%s, %s)
可见 values() 方法限制了 INSERT 语句所包含的列。但是我们指定的 name 和 fullname 的值并没有打印出来，这两个值保存在 Insert 对象里，只有等到执行时才会用到。
执行
我们一直在说的引擎，可以理解成一个数据库连接对象的仓库，通过连接对象可以往数据库发送具体的 SQL 语句。调用引擎的 connect() 方法可以获取一个连接：
conn = engine.connect()
现在把前面的 Insert 对象丢给它来执行：
result = conn.execute(ins)
由调试信息可见具体的 INSERT 语句：
INSERT INTO user (name, fullname) VALUES (%s, %s)('adam', 'Adam Gu')COMMIT 返回值 result 是一个 ResultProxy 对象，ResultProxy 是对 DB-API 中 cursor 的封装。插入语句的结果并不常用，但是查询语句肯定是要用到它的。
mysql> select * from user;+----+------+----------+| id | name | fullname |+----+------+----------+| 1 | adam | Adam Gu |+----+------+----------+1 row in set (0.00 sec)
执行多条语句
还记得前面的 Insert 对象使用 values() 方法来限制列吗？
ins = ins.values(name='adam', fullname='Adam Gu')
这种方式其实不利于 Insert 对象的复用，更好的做法是把参数通过 execute() 方法传进去：
ins = user_table.insert()conn.execute(ins, name='adam', fullname='Adam Gu')
Insert 对象本身还是会包含所有列，最终 INSERT 语句里的列由 execute() 的参数决定。由调试信息可见具体的 INSERT 语句：
INSERT INTO user (name, fullname) VALUES (%s, %s)('adam', 'Adam Gu')COMMIT 一次插入多条记录也很简单，只要传一个字典列表（每个字典的键必须一致）给 execute() 即可。
conn.execute(address_table.insert(), [ { 'user_id': 1, 'email': 'sprinfall@gmail.com' }, { 'user_id': 1, 'email': 'sprinfall@hotmail.com' }, ]) 调试信息里具体的 INSERT 语句：
INSERT INTO address (user_id, email) VALUES (%s, %s)((1, 'sprinfall@gmail.com'), (1, 'sprinfall@hotmail.com'))COMMIT
在 MySQL 里看一下插入的地址：
mysql> select * from address;+----+---------+-----------------------+| id | user_id | email |+----+---------+-----------------------+| 1 | 1 | sprinfall@gmail.com || 2 | 1 | sprinfall@hotmail.com |+----+---------+-----------------------+2 rows in set (0.00 sec)
第一部分到此结束。