[关闭]
@Scrazy 2017-03-27T08:43:10.000000Z 字数 4890 阅读 1280

Python与数据库

python

数据持久化通常有一下几种方式：
1. 文件
2. 数据库系统
3. 其他

接下来，我们就专注于第二种方式：数据库

MySQL

MySQL 是目前应用最广泛的数据库。开源、免费、操作方便使得它很流行。

安装 MySQL

首先安装 MySQL

$ sudo pacman -S mysql

选择 MariaDB 的实现版本，也是 Arch 官方仓库推荐的。安装完成后要执行一句：

mysql_install_db --user=mysql --basedir=/usr --datadir=/var/lib/mysql

启动其守护进程

  1. $ systemctl start mysqld
  2. $ mysql_secure_installation
  3. $ systemctl restart mysqld

安装 MySQL 驱动

MySQL 的 Python 驱动有好几个，我们选用 MySQLdb:

$ pip install mysqlclient

mysqlclient 是 MySQLdb 的 Python3 版本。

设置数据库和用户以及权限

接下来，我们执行以下步骤：
1. 创建一个用户 名为 lambda 密码为 plus。
2. 创建一个数据库 d。
3. 设置用户权限，赋予用户 lambda 对数据库 d 有全部权限。 

  1. $︎︎ mysql -u root -p
  2. MariaDB [(none)]> create User 'lambda'@'localhost' identified by 'plus';
  3. Query OK, 0 rows affected (0.00 sec)
  5. MariaDB [(none)]> create database d;
  6. Query OK, 1 row affected (0.00 sec)
  8. MariaDB [(none)]> grant ALl privileges on d.* To 'lambda'@'localhost';
  9. Query OK, 0 rows affected (0.00 sec)
  11. MariaDB [(none)]> quit
  12. Bye

使用 MySQL 写原生语句

下面。我们把常量放到一个独立的文件 consts.py 中：

  1. # coding=utf-8
  2. HOSTNAME = ''
  3. DATABASE = 'd'
  4. USERNAME = 'lambda'
  5. PASSWORD = 'plus'
  6. DB_URL = 'mysql://{}:{}@{}/{}'.format(
  7.         USERNAME, PASSWORD, HOSTNAME, DATABASE)
  1. In [22]: import MySQLdb
  3. In [10]: from consts import HOSTNAME, USERNAME, PASSWORD, DATABASE
  5. In [23]: conn = MySQLdb.connect(HOSTNAME, USERNAME, PASSWORD, DATABASE)
  7. In [24]: cur = conn.cursor()
  9. In [25]: cur.execute('create table user (id varchar(20) primary key, name varchar(20))')
  10. Out[25]: 0
  12. In [26]: cur.execute('insert into user (id, name) values (%s, %s)', ['1', 'Lambda'])
  13. Out[26]: 1
  15. In [27]: cur.rowcount
  16. Out[27]: 1
  18. In [35]: cur = conn.cursor()
  20. In [36]: cur.execute('select * from user where id = %s',('1',))
  21. Out[36]: 1
  23. In [37]: values = cur.fetchall()
  25. In [38]: values
  26. Out[38]: (('1', 'Lambda'),)
  28. In [39]: cur.close()
  30. In [40]: conn.close()

数据库操作主要以 CRUD 为主。CRUD 是 Create 、Read、Update 和 Delete 的缩写。看一个例子 crud.py ：

  1. # coding=utf-8
  2. import MySQLdb
  3. from consts import USERNAME, HOSTNAME, DATABASE, PASSWORD
  6. conn = MySQLdb.connect(HOSTNAME, USERNAME, PASSWORD, DATABASE)
  8. with conn as cur:
  9.     cur.execute('drop table if exists users')
  10.     cur.execute('create table users (id int primary key auto_increment, '
  11.             'name varchar(20))')
  12.     cur.execute('insert into users(name) values ("haohao")')
  13.     cur.execute('insert into users(name) values ("haha")')
  15.     rows = cur.fetchall()
  16.     for row in rows:
  17.         print(row)
  19.     cur.execute('update users set name=%s where id=%s', ('hao', 1))
  20.     print('Number of rows updated:', cur.rowcount)
  22.     cur = conn.cursor()
  23.     cur.execute('select * from users')
  25.     rows = cur.fetchall()
  26.     for row in rows:
  27.         print(row[0], row[1])

ORM

ORM 全称对象关系映射 (Object Relational Mapping),其可以让我们用 Python 类的方式做数据库开发，不需要写 SQL 语句。

上面的例子中，返回的结果用 Python 的数据结构表示出来的话，可以用一个 list 表示多行，list 的每一个元素是 tuple，表示一行记录。也就是下面这种形式：

  1. [
  2.     ('1', 'hao'),
  3.     ('2', 'ha'),
  4. ]

但是用 tuple 表示一行很难看出表的结构。如果把一个 tuple 用 class 实例来表示，就可以更容易地看出表的结构来：

  1. class User(object):
  3.     def __init__(self, id, name):
  4.         self.id = id
  5.         self.name = name
  7. [
  8.     User('1', 'hao'),
  9.     User('2', 'ha'),
  10. ]

所谓的 对象关系映射 把关系数据库的表结构映射到对象上。

而且：

因为随着项目的增大会暴露出一些问题：
1. SQL 语句重复利用率不高
2. 很多 SQL 语句是在业务逻辑中拼接出来的，数据库的改动，需要对这些逻辑非常了解。

况且：

ORM 还有以下优点：
1. 易用性。有效减少重复 SQL 语句出现的概率，写出的模型直观、清晰
2. 性能损耗低。使用 ORM 会有些许的性能损失，但相对于其便利性，大多数情况下大可以忽略
3. 可移植。比如 SQLAlchemy 支持多个数据库引擎，比如 MySQL、Postgresql 和 SQLite 等。切换数据库很方便。
4. 设计灵活。可以轻松的实现复杂的数据查询。

使用 SQLAlchemy

Python 中，最流行的 ORM 框架非 SQLAlchemy 莫属了。我们就使用它，首先来安装 SQLAlchemy ：

$ pip install sqlalchemy

看例子：

  1. # coding=utf-8
  2. from sqlalchemy import create_engine, Column, Integer, String, ForeignKey
  3. from sqlalchemy.orm import sessionmaker, relationship
  4. from sqlalchemy.ext.declarative import declarative_base
  6. from consts import DB_URL
  8. engine = create_engine(DB_URL)
  10. Base = declarative_base()
  13. class Author(Base):
  14.     __tablename__ = 'author'
  16.     id = Column(Integer, primary_key=True, autoincrement=True)
  17.     name = Column(String(50))
  20. class Book(Base):
  21.     __tablename__ = 'book'
  23.     id = Column(Integer, primary_key=True, autoincrement=True)
  24.     title = Column(String(100), nullable=False)
  25.     author_id = Column(Integer, ForeignKey('author.id'))
  26.     author = relationship('Author')
  29. Author.books = relationship('Book', order_by=Book.id)
  31. Base.metadata.drop_all(bind=engine)
  32. Base.metadata.create_all(bind=engine)
  34. Session = sessionmaker(bind=engine)
  35. session = Session()
  37. author_haohao = Author(name='hahao')
  38. author_duoduo = Author(name='duoduo')
  40. author_haohao.books = [Book(title=u'Python Web 开发实战', author_id=author_haohao.id),
  41.                        Book(title=u'Flask Web Development', author_id=author_haohao.id),
  42.                        Book(title=u'HTTP: The Definitive Guide', author_id=author_haohao.id)]
  44. author_duoduo.books = [Book(title=u'一条狗的修养', author_id=author_duoduo.id),
  45.                        Book(title=u'忠犬八公', author_id=author_duoduo.id),
  46.                        Book(title=u'一条狗的使命', author_id=author_duoduo.id)]
  48. session.add_all([author_haohao, author_duoduo])
  49. session.commit()

Book 表的 author_id 就是 Author 的 id 字段，使用 ForeignKey 关联之后，就不需要在 Book 上独立存储一份 user_id 数据了。我们接着验证：

$ ipython -i mysql_pre/orm_sql.py --profile=web_develop

  1. In [7]: session.query(Book).join(Author).filter(Book.id.in_([3])).all()[0].title
  2. Out[7]: 'HTTP: The Definitive Guide'
  3. In [14]: session.query(Author).join(Book).filter(Book.title=='一条狗的修养').first().name
  4. Out[14]: 'duoduo'
  6. In [17]: for a, b in session.query(Author, Book).\
  7.     ...:     filter(Author.id==Book.author_id).\
  8.     ...:     filter(Book.title=='一条狗的使命').all():
  9.     ...:     print('Author ID: {}'.format(a.id))
  10.     ...:     print('Book title: {}'.format(b.title))
  11.     ...:     
  12. Author ID: 2
  13. Book title: 一条狗的使命

所有文件都在 mysql_pre 目录下：

  1. $︎︎ tree mysql_pre/
  2. mysql_pre/
  3. ├── consts.py
  4. ├── curd.py
  5. └── orm_sql.py
  7. 0 directories, 3 files

参考：
[1] Arch Wiki
[2] 董伟明. Python Web 开发实战. 北京：电子工业出版社，2016
[3] 廖雪峰的网站
[4] SQLAlchemy

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注