Python之数据库使用

---

mysql

安装启动mariadb

$ yum install mariadb-server mariadb -y
$ systemctl start mariadb 
$ systemctl is-active mariadb
$ ps -ef |grep mysql	# mariadb是mysql不开源后的分支，基本和mysql差不多，所以查找进程使用的都是mysql
1
2
3
4

因为root默认只能本地登录，而且为了更贴合实际使用情况，我们需要创建一个库和一个用户，连接时连接到这个用户和库

建库建用户

root@(none) 10:38  mysql>create database zh
    -> ;
Query OK, 1 row affected (0.00 sec)

root@(none) 10:40  mysql>grant all on zh.* to 'zh'@'%' identified by '123456';  
Query OK, 0 rows affected (0.00 sec)

root@(none) 10:57  mysql>select user,host from mysql.user;
+------+-----------+
| user | host      |
+------+-----------+
| zh   | %         |
| root | 127.0.0.1 |
| root | ::1       |
|      | localhost |
| root | localhost |
|      | zh-ali    |
| root | zh-ali    |
+------+-----------+
7 rows in set (0.00 sec)

root@(none) 10:58  mysql>drop user ''@'localhost';
Query OK, 0 rows affected (0.00 sec)

root@(none) 10:58  mysql>drop user ''@'zh-ali';
Query OK, 0 rows affected (0.00 sec)

[root@zh-ali ~]# mysql -uzh -p'123456'
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

python连接mysql

参考链接：Python3 MySQL 数据库连接 – PyMySQL 驱动 | 菜鸟教程 (runoob.com)

import pymysql

# 打开数据库连接
'''
host:数据库服务器，目标主机
port:指定连接端口，默认3306
user：连接mysql的用户
database：连接的数据库
'''
db = pymysql.connect(host='47.120.37.21',
                     port=3306,
                     user='zh',
                     password='123456',
                     database='zh')

# 使用 cursor() 方法创建一个游标对象 cursor，游标对象可以保存数据集，方便后续处理，不然数据集只会输出到屏幕无法保存
cursor = db.cursor()

# 使用 execute()  方法执行 SQL 查询
cursor.execute("SELECT VERSION()")

# 使用 fetchone() 方法获取单条数据，类型为元组.	fetchall获取所有数据，类型为嵌套元组
data = cursor.fetchone()

print("Database version : %s " % data)

# 关闭数据库连接
db.close()

# -----输出------
Database version : 5.5.68-MariaDB 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

redis

基于内存的key-value型数据库，用作缓存数据库、消息中间件；当然也可以持久化，是非关系型数据库

安装redis

[root@zh-ali ~]# yum install redis -y
[root@zh-ali ~]# rpm -qa |grep redis
redis-3.2.12-2.el7.x86_64
[root@zh-ali ~]# systemctl start redis	# 启动redis
[root@zh-ali ~]# ps -ef|grep [r]edis
redis    24319     1  0 11:30 ?        00:00:00 /usr/bin/redis-server 127.0.0.1:6379
1
2
3
4
5
6

可以看到redis端口默认绑定到127.0.0.1端口上，这样的话外网无法访问该服务，所以我们要修改配置文件

[root@zh-ali ~]# vim /etc/redis.conf
bind 127.0.0.1 --> bind 0.0.0.0		# 改为0.0.0.0代表本机上的任意ip

[root@zh-ali ~]# systemctl restart redis	# 重启redis服务
[root@zh-ali ~]# ps -ef|grep [r]edis    
redis    24842     1  0 11:40 ?        00:00:00 /usr/bin/redis-server 0.0.0.0:6379
1
2
3
4
5
6

登录redis

[root@zh-ali ~]# redis-cli		# 登录，目前无配置所以可以直接登

1
2

使用

参考链接：Redis 教程 | 菜鸟教程 (runoob.com)

切换数据库

127.0.0.1:6379> select 1		# 默认创建了16个数据库，默认在0号库
OK
127.0.0.1:6379[1]> select 2		# 通过select index来切换
OK
127.0.0.1:6379[2]> select 15
OK
127.0.0.1:6379[15]> select 16	# 不存在16号库
(error) ERR invalid DB index
1
2
3
4
5
6
7
8

增、查

127.0.0.1:6379[15]> select 1
OK
127.0.0.1:6379[1]> set zh 123	# 增加数据 key-value
OK
127.0.0.1:6379[1]> set zh2 456
OK

127.0.0.1:6379[1]> get zh		# 查
"123"
127.0.0.1:6379[1]> get zh2
"456"

127.0.0.1:6379[1]> keys *		# 查所有key
1) "zh2"
2) "zh"
127.0.0.1:6379[1]> keys zh*
1) "zh2"
2) "zh"

127.0.0.1:6379[1]> lpush lst xw		# lpush，存放一个或多个数据进列表
(integer) 1
127.0.0.1:6379[1]> lpush lst ly
(integer) 2
127.0.0.1:6379[1]> lpush lst xzx
(integer) 3
127.0.0.1:6379[1]> lpush lst clb
(integer) 4
127.0.0.1:6379[1]> lrange lst 0 10	# lrange，查看指定范围内列表数据
1) "clb"
2) "xzx"
3) "ly"
4) "xw"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

还可以存字符串、哈希、字典、集合等等

python操作redis

# 登录
r = redis.Redis(host='47.120.37.21',port=6379,db=1, decode_responses=True)
# 读写
print(r.get('zh'))	# get、set以key-value类型存值
r.set("zh3","789")
print(r.get("zh3"))
print(r.get("zh4"))	# 对不存在的key取值时返回None
1
2
3
4
5
6
7

hget(主键，key，value),对唯一主键可以重复添加多个键值对，hash keys

hset(主键，key)，取特定key的value

redis的持久化策略

参考链接：Redis持久化策略_sermonlizhi的博客-CSDN博客

RDB(默认)

快照形式的持久化，默认会将内存数据快照保存到名字为dump.rdb的二进制文件中，可以在redis.conf文件中通过dbfilename参数进行配置

下面是默认的触发时机（三个策略）：

//格式：save m n
save 900 1			//900秒内至少有一个key发生改动就保存一次数据
save 300 10			//300秒内至少有10个kèy发生改动就保存一次数据
save 60 10000		//60秒内只有有10000个key发生改动就保存一次数据
1
2
3
4

每个策略表示m秒内数据集至少有n个改动时，就会触发一次持久化。

可以修改策略参数和策略数量，而关闭RDB持久化的方法就是将所有save策略注释掉

也可以手动生成快照：

使用save或bgsave命令就会生成xxx.rdb文件，会覆盖原来的rdb文件

生成快照时，对于正在写入的数据，内存中会将正在被修改的部分进行复制，改动在副本上进行，所以快照持久化过程中的内存并不会发生改变。

持久化任务由fork的子进程去进行，父进程继续为客户端提供服务

AOF

RDB这种持久化方式当Redis因为某些原因造成系统宕机后，服务器将会丢失最近写入内存但未保存到快照中的一部分数据，为了尽量少了丢失，可以将持久化的频率增加，但RDB是一种全量持久化的方式，如果数据量比较大时，频繁进行持久化也是不可取的。

AOF持久化(append-only file)，一种完全耐久的持久化方式

将修改的每一条指令增量记录到appendonly.aof文件中，先写入操作系统的缓存(os cache)，每隔一段时间fsync到磁盘。

Redis的配置默认使用的是RDB持久化方式，可以通过修改配置文件的参数开启AOF功能

配置和更多机制可查看参考链接

应用

对于要查询的同学信息，在给定同学id后先到redis上查找，查找不到再去mysql查找，并将查找到的值写入到redis。

当然更高级也更合适的写法是将redis部分写成一个装饰器，对需要redis做缓存的函数或类进行修饰（具体实现查看装饰器文章）

import redis
import pymysql

r = redis.Redis(host='47.120.37.21',port=6379,db=1, decode_responses=True)

db = pymysql.connect(host='47.120.37.21',
                     user='zh',
                     password='123456',
                     database='zh')
# 创建游标对象
cursor = db.cursor()

id = input("输入你要查询的同学id：")
if r.hkeys(id):					# hkeys()方法返回该主键下包含的所有key
    print("通过redis查询：")
    print(f"同学姓名：{r.hget(id,'name')}")
    print(f"同学年龄：{r.hget(id,'age')}")
    print(f"同学成绩：{r.hget(id,'grade')}")
else:
    cursor.execute(f"select * from stu where id={id}")
    data = cursor.fetchone()
    print("通过mysql查询：")
    print(data)
    r.hset(id,"name",data[1])
    r.hset(id,"age",data[2])
    r.hset(id,"grade",data[3])

# 关闭数据库连接
db.close()
r.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30