Python3-访问数据库

#请编写函数，在 Sqlite 中根据分数段查找指定的名字： 2 3 # -*- coding: utf-8 -*- 4 import os, sqlite3 5 db_file = os.path.join(os.path.dirname(__file__), ‘test.db‘) 6 if os.path.isfile(db_file): 7 os.remove(db_file) 8 # 初始数据: 9 conn = sqlite3.connect(db_file) 10 cursor = conn.cursor() 11 cursor.execute(‘create table user(id varchar(20) primary key, name varchar(20), score int)‘) 12 cursor.execute(r"insert into user values (‘A-001‘, ‘Adam‘, 95)") 13 cursor.execute(r"insert into user values (‘A-002‘, ‘Bart‘, 62)") 14 cursor.execute(r"insert into user values (‘A-003‘, ‘Lisa‘, 78)") 15 cursor.close() 16 conn.commit() 17 conn.close() 18 def get_score_in(low, high): 19 #返回指定分数区间的名字，按分数从低到高排序 ‘ 20 conn = sqlite3.connect(db_file) 21 cursor = conn.cursor() 22 cursor.execute(‘select name from user where score between ? and ? order by score asc‘,(low,high)) 23 values = cursor.fetchall() 24 name= [x[0]for x in values] 25 cursor.close() 26 conn.close() 27 #print(name) 28 return name 29 30 31 # 测试: 32 assert get_score_in(80, 95) == [‘Adam‘], get_score_in(80, 95) 33 assert get_score_in(60, 80) == [‘Bart‘, ‘Lisa‘], get_score_in(60, 80) 34 assert get_score_in(60, 100) == [‘Bart‘, ‘Lisa‘, ‘Adam‘],get_score_in(60, 100) 35 print(‘Pass‘)

 

 

---

使用 MySQL

MySQL 是Web 世界中使用最广泛的数据库服务器。

SQLite 的特点是量级、可嵌入，但不能承受高并发访问，适合桌面和移动应用。

而MySQL是为服务器端设计的数据库，能承受高并发访问，同时占用的内存也远 远大于 SQLite。

此外，MySQL 内部有多种数据库引擎，最常用的引擎是支持数据库事务的 InnoDB。

MySQL安装：

https://www.cnblogs.com/jpga/p/12566697.html

在Mysql的官网上https://dev.mysql.com/doc/connector-python/en/connector-python-versions.html查看对应关系：

 

安装驱动：（我用的第二个，第一个报错说没有--allow-external操作）

　　$ pip install mysql-connector-python --allow-external mysql-connector-python 或 $ pip install mysql-connector

　　第二个驱动装好后使用过程中还是报错，重装了一个pymysql,用法改一下就行

 

#书中源码

# 导入 MySQL 驱动:
>>> import mysql.connector 
# 注意把 password 设为你的 root 口令: 
>>> conn = mysql.connector.connect(user=‘root‘, password=‘password‘, database=‘test‘)
>>> cursor = conn.cursor() 
# 创建 user 表: 
>>> cursor.execute(‘create table user (id varchar(20) primary key, name varchar(20))‘) 
# 插入一行记录，注意 MySQL 的占位符是%s:
>>> cursor.execute(‘insert into user (id, name) values (%s, %s)‘, [‘1‘, ‘Michael‘])
>>> cursor.rowcount 1 
# 提交事务:
>>> conn.commit() 
>>> cursor.close() 
# 运行查询:
>>> cursor = conn.cursor()
>>> cursor.execute(‘select * from user where id = %s‘, [‘1‘])
>>> values = cursor.fetchall() 
>>> values
[(‘1‘, ‘Michael‘)] 
# 关闭 Cursor 和 Connection:
>>> cursor.close() True
>>> conn.close() 


#由于 Python 的DB-API 定义都是通用的，所以，操作MySQL的数据库 代码和 SQLite 类似。

#修改后

import pymysql
conn = pymysql.connect(‘localhost‘,‘root‘, ‘password‘, ‘test‘)
cursor = conn.cursor()
#创建 user 表:
cursor.execute(‘create table user1 (id varchar(20) primary key, name varchar(20))‘)
#插入一行记录，注意 MySQL 的占位符是%s:
cursor.execute(‘insert into user1 (id, name) values (%s, %s)‘, [‘1‘, ‘Michael‘])
print(cursor.rowcount)
conn.commit()
cursor.close()

#运行查询
cursor = conn.cursor()
cursor.execute(‘select * from user1 where id = %s‘, [‘1‘])
values = cursor.fetchall()#[(‘1‘, ‘Michael‘)]
# 关闭 Cursor 和 Connection: >>> cursor.close() True
conn.close()

连接的test数据库需要事先在mysql中创建

 

 其他常用操作：

show databases;    　　　　# 显示所有数据库
create database t1; 　　　　# 创建数据库t1
use database t1;   　　　　#指定当前操作的数据库为t1
drop database t1;  　　　　#删除数据库t1

mysql-connector使用案例：

https://www.cnblogs.com/vathe/p/6964086.html

---

使用 SQL Alchemy

数据库表是一个二维表，包含多行多列。

 

　　按 Python 的 数据结构：list 表示多行，list 的每一个元素是 tuple，表示一行记录，例如包含 id 和 name 的 user 表：[(‘1‘, ‘Michael‘), (‘2‘, ‘Bob‘), (‘3‘, ‘Adam‘)]

　　但是用 tuple 表示一行表的结构不明显，用 class 实例来表示，会更清晰：

 

1 class User(object):
2 　　def __init__(self, id, name):
3 　　　　self.id = id
4 　　　　self.name = name
5 
6 [User(‘1‘, ‘Michael‘), User(‘2‘, ‘Bob‘), User(‘3‘, ‘Adam‘)]

ORM技术：Object-Relational Mapping，把关系数据库的表结构映射到对象上。

ORM框架可完成此转换。在 Python 中，最有名的ORM框架是 SQLAlchemy。

SQLAlchemy 的用法如下。

1. 首先通过 pip 安装 SQLAlchemy： $ pip install sqlalchemy
2. 然后，利用上次我们在MySQL的test 数据库中创建的 user表，用 SQLAlchemy 来试试：

以下代码完成 SQLAlchemy 的初始化和具体每个表的 class 定义。

 1 # 导入:
 2 from sqlalchemy import Column, String, create_engine
 3 from sqlalchemy.orm import sessionmaker 
 4 from sqlalchemy.ext.declarative import declarative_base
 5 
 6 # 创建对象的基类: 
 7 Base = declarative_base()
 8 
 9 # 定义 User 对象: 
10 class User(Base): 
11     # 表的名字:
12     __tablename__ = ‘user‘
13    
14      # 表的结构: 
15     id = Column(String(20), primary_key=True) 
16     name = Column(String(20))
17 
18 # 初始化数据库连接:
19 engine =
20 create_engine(‘mysql+mysqlconnector://root:password@localhost:3306/test‘) # 创建 DBSession 类型:
21 DBSession = sessionmaker(bind=engine)

如果 有多个表，就继续定义其他 class，例如 School：

class School(Base):
　　__tablename__ = ‘school‘

　　id = ...

　　 name = ...

create_engine()用来初始化数据库连接。

SQLAlchemy 用一个字符串表示连接信息：

　　 ‘数据库类型+数据库驱动名称://用户名:口令@机器地址:端口号/数据库名‘

你只需要根据需要替换掉用户名、口令等信息即可。 下面，我们看看如何向数据库表中添加一行记录。 由于有了ORM，我们向数据库表中添加一行记录，可以视为添加一个 User 对象：

 1 # 创建 session 对象:
 2 session = DBSession() 
 3 # 创建新 User 对象:
 4 new_user = User(id=‘5‘, name=‘Bob‘) 
 5 # 添加到 session: 
 6 session.add(new_user) 
 7 # 提交即保存到数据库: 
 8 session.commit() 
 9 # 关闭 session: 
10 session.close()

 

可见，关键是获取 session，然后把对象添加到 session，最后提交并关 闭。DBSession 对象可视为当前数据库连接。
如何从数据库表中查询数据呢？有了ORM，查询出来的可以不再是 tuple，而是 User对象。SQLAlchemy 提供的查询接口如下：

 

 1 # 创建 Session:
 2 session = DBSession() 
 3 # 创建 Query 查询，filter 是 where 条件，最后调用 one()返回唯一行，如果调用 all()则返回所有行:
 4 user = session.query(User).filter(User.id==‘5‘).one()
 5 # 打印类型和对象的 name 属性:
 6 print(‘type:‘, type(user)) 
 7 print(‘name:‘, user.name) 
 8 # 关闭 Session: 
 9 session.close()
10 
11 运行结果如下：
12 type: <class ‘__main__.User‘> 
13 name: Bob

 

 1 session = DBSession()
 2 # 创建Query查询，filter是where条件，最后调用one()返回唯一行，如果调用all()则返回所有行:
 3 user = session.query(User).filter(User.name==‘Bob‘).all()
 4 # 打印类型和对象的name属性:
 5 print(‘type:‘, type(user))
 6 for row in user:
 7     print(‘id: %s , name: %s‘%(row.id, row.name))
 8 
 9 type: <class ‘list‘>
10 id: 10 , name: Bob
11 id: 111 , name: Bob
12 id: 112 , name: Bob
13 id: 132 , name: Bob
14 id: 138 , name: Bob
15 id: 14 , name: Bob
16 id: 5 , name: Bob
17 id: 6 , name: Bob
18 id: 8 , name: Bob
19 id: 9 , name: Bob

 

基本使用：

https://www.jianshu.com/p/cf77beef7a25

 

可见，ORM就是把数据库表的行与相应的对象建立关联，互相转换。
由于关系数据库的多个表还可以用外键实现一对多、多对多等关联，相 应地，ORM框架也可以提供两个对象之间的一对多、多对多等功能。 例如，如果一个User 拥有多个Book，就可以定义一对多关系如下：

 1 #例如，如果一个User 拥有多个Book，就可以定义一对多关系如下：
 2 class User(Base):
 3     __tablename__ = ‘user‘
 4     id = Column(String(20), primary_key=True) 
 5     name = Column(String(20)) 
 6     # 一对多:
 7     books = relationship(‘Book‘) 
 8 
 9 class Book(Base): 
10     __tablename__ = ‘book‘
11     id = Column(String(20), primary_key=True) 
12     name = Column(String(20)) 
13     # “多”的一方的 book 表是通过外键关联到 user 表的: 
14     user_id = Column(String(20), ForeignKey(‘user.id‘))        

 

当我们查询一个User 对象时，该对象的 books 属性将返回一个包含若 干个Book 对象的 list。 小结 ORM框架的作用就是把数据库表的一行记录与一个对象互相做自动转 换。
正确使用ORM的前提是了解关系数据库的原理。

 

　　

Python3-访问数据库

标签：michael   引擎   blog   嵌入式   高并发   定制   make   显示   arc