一. Python对MySQL的操作

(1) 安装模块
pip install pymysql
(2) 操作mysql的八步

(1) 连接MySQL数据库
db = pymysql.connect("主机名", "用户名", "密码", "数据库名")
(2) 设置字符集
db.set_charset("utf8")  # 注意为utf8
(3) 创建游标对象
cursor = db.cursor()
(4) 编写sql语句
sql = "select * from  表名 ~~~~"
(5) 执行sql语句
cursor.execute(sql)  # 注意：执行插入删除操作要提交事务,调用db.commit()
(6) 处理结果集
cursor.fetchall()   # 获取所有数据，返回元组
cursor.fetchone()  # 获取一条数据
cursor.fetchmany(size)   # 获取size条
(7) 当前sql语句执行受影响条目
curosr.rowcount
(8) 关闭数据库的连接
db.close()

二. Python对MongoDB的操作

(1) 安装模块
pip install pymongo
(2) 操作MongoDB的五步

(1) 导入pymongo
from pymongo import MongoClient

(2) 连接服务器 端口号27017
con = MongoClient("localhost")
con = MongoClient("localhost", port=27017)  # 指定端口号

(3) 选择数据库
db = con.数据库名称  # 如果数据库中不存在则会创建
db = con['数据库名称']  # ok 同上
# 获取集合
collenction = db.集合名
# 例如：  db = con.FirstDB     选择数据库中的集合   col = db.User

(4) 对数据的CRUD
==============================================
4.1) 插入数据
==============================================
db.集合名.insert({文档})  # 插入一条文档 返回id
db.集合名.insert([{文档1}, {文档2}, ..])  # 插入多条文档，传入的类型必须是列表，以列表的形式返回多个id
# 3.x以后推荐的方法
db.集合名.insert_one({文档}) 
db.集合名.insert_many([{文档1}, {文档2}...])
例子：
user1 = {"name":'zs', "age": 18, 'gender': 'w', phone: '123456..'}
user2 = {"name":'ls', "age": 28, 'gender': 'm', phone: '123456..'}
db.集合名.insert(user1)
db.集合名.insert([user1, user2])
db.集合名.insert_one(user2)
db.集合名.insert_many([user1, user2])

==============================================
4.2) 查询数据
==============================================
cursor = db.集合名.find()  # 查询所有, 返回cursor 对象 可以使用next()方法进行取值
db.集合名.find({条件})
db.集合名.find_one()  # 查询一条记录
db.集合名.find_one({条件})  # 添加过滤，直接返回结果
# 带id的查询
from bson.objectid import ObjectId
res = db.集合名.find({"_id": ObjectId("5a601623.....")})
# 模糊查询
import re
res = db.集合名.find({"name": '/张/'})  # error   如果这样写，查询的是  /张/ 字符串
res = db.集合名.find({"name": re.compile("张")})
print(res)  # ok 查询包含张的记录
# sort limit skip count查询
# sort排序
res = db.集合名.find().sort('age', 1)  # 按照年龄升序排序
res = db.集合名.find().sort('age', -1)  # 按照年龄降序排序
# limit取值
res = db.集合名.find().sort('age', -1).limit(2)
# skip
db.集合名.find().skip()
# count统计
db.集合名.find().count()

==============================================
 4.3) 修改数据
==============================================
db.集合名.update(条件, {"$set":{}})  # 重新赋值
db.集合名.update(条件, {"$inc":{}})  # 在原来值基础上增加
例如: res = db.user.update({'age':18},{'$set':{'age':100}})
返回修改的结果 {'n': 1, 'nModified': 1, 'ok': 1.0,'updatedExisting': True}
# update_one() 修改一条
db.集合名.update_one({'name':'zs'}, {'$set':{'age':10}})  # 返回对象obj
# update_many() 修改多条
db.collection.update_many({'name':'张三'},{'$set':{'sex':'男'}})
获取匹配的条数和修改的条数(只有3.x以后推荐的形式返回结果才为对象)
obj.matched_count   # 匹配条数
obj.modified_count   # 修改条数

==============================================
4.4) remove删除数据
==============================================
# 按条件删除
db.集合名.remove({条件})
# 删除全部
db.集合名.remove()
# 删除匹配的第一条数据
db.集合名.delete_one()
#  delete_many() 删除匹配到的数据(删除多条)
db.集合名.delete_many({条件})
# 获取3.x以后新版本删除数据的条数
obj.deleted_count

(5) 关闭数据库
con.close()

三. Python对Redis的操作

(1) 安装模块

pip install redis

(2) 连接方式

连接redis提供了两个类, 其中StrictRedis实现了大部分官方的方法, 并使用官方的语法和命令;
Redis是StrictRedis的子类, 用于兼容旧版本的redis。
连接实例：

res = redis.StrictRedis(host="127.0.0.1", port=6379, password='123', db=0, decode_response=True)  # 默认选择0号数据库, 加上decode_response, 写入数据库为字符串类型, 不加写入数据库为字节类型
res = redis.Redis(host="127.0.0.1", port=6379, password='123', db=0, decode_response=True)

(3) 使用连接池连接

管理redis server的所有连接, 避免每次建立连接, 释放连接的开销, 用于实现多个redis实例共享一个连接池。
连接实例：

pool = redis.ConnectionPool(host="127.0.0.1", port=6379, password='123', db=0, decode_response=True)
re = redis.StrictRedis(connection_pool=pool)
re = redis.Redis(pool)

(4) 数据库相关操作

1. re.keys(pattern="*")  # 根据通配符获取对应的keys
例如:
print(re.keys())  # 默认获取所有name
print(re.keys('h?llo'))  # ? 只存在一个任意字符(不同正则), * 匹配任意个字符(可有可无)

2. re.delete(*names)  # 根据name删除redis的任意key
例如:
re.delete('name')  # string类型的name
re.delete('myHash')  # hash类型
re.delete('myList', 'mySet')  # 同时删除多个key

3. re.exists(name)  # 根据key是否存在
例如:
re.exists('mySet')  # True

4. re.expire(name, time)  # 为某个key设置超时时间
例如:
re.expire('myzset', 10)  # 单位10秒

5. re.rename(src, dst)  # 对某个key重命名
例如:
re.rename('myHash', 'newMyHash')

6. re.move(name, db)  # 将某个key移动到指定的db(0-15)下
例如:
re.move('myHash', 1)

7. re.randomkey()  # 随机返回一个key
例如:
print(re.randomkey())

8. re.type(name)  # 获取key对应值的类型
例如:
print(re.type('myhash'))

9. re.flushdb()  # 清空数据库
例如:
re.flushdb()

10. re.flushall()  # 清空所有数据库
例如:
re.flushall()

(5) String字符串相关操作

1. re.set(name,value,ex=None,px=None,nx=False,xx=False)  # 设置键值
参数：
ex:过期时间（秒）
px:过期时间（毫秒）
nx:如果设置为True,则只有name不存在时，set操作才执行，类似setnx(name, value)
xx:如果设置为True, 只有name存在时, 当前set操作才执行
例如:
re.set('name', 'zhangsan') 

2. re.get(key, value)  # 获取值
例如:
re.get('name') 

3. re.mset(*args, **kwargs)  # 批量设置值
例如:
re.mset({'name', 'zhangsan', 'age': 18})  # 以字典的形式传入
re.mset(name='zhangsan', name2='lisi')  # 以关键字参数的形式传入

4. re.mget(key1, key2,...)   # 批量获取值
例如:
print(re.mget('name', 'age'))

5. re.getset(key, value)  # 设置新值返回原值
例如:
print(re.getset('name', 'wangwu'))  # 输出zhangsan
print(re.get('name'))  # 重新打印name的值  wangwu

6. r.getrange(key, start, end)  # 获取子字符串(子序列)
例如:
re.set('name', 'zhangsan')
print(re.getrange('name', 0, 3))  # 输出zhan

7. re.setrange(key, offset, value)  # 对字符串进行覆盖，根据指定的偏移量开始向后替换, 索引从0开始
例如:
re.set('name', 'zhangsan')
re.setrange('name', 5, 'lisi')
print(re.getrange('name'))  # zhanglisi

8. re.strlen(key)  # 获取值的长度
例如:
re.set('name', 'zhangsan')
print(re.strlen('name'))  # 8

9. re.incr(key, amount=1)  # 值的累加，amount为累加的值，默认为1
例如:
print(re.incr('age', amount=2))  # 如果age不存在，则执行完后age创建并赋值为2
print(re.incr('age'))  # 3 自增加1
print(re.incr('age', amount=6))  # 9 ，结果增加6

10. re.append(key, value)  # 在值后面追加值，返回追加后值的长度
例如:
re.set('name', 'AAA')
re.append('name', 'BBB')
print(re.get('name'))  # AAABBB

(6) Hash操作

1. re.hset(name, key, value)  # 在name对应的hash中设置一个键值对（不存在则创建，存在则修改）
例如:
re.hset('myHash', 'name', 'zhangsan')

2. re.hget(name, key)  # 在name对应的hash中根据key获取value
例如:
print(re.hget('myHash', 'name'))  # zhangsan

3. re.hgetall(name)  # 获取name对应的hash的所有键和值返回字典
例如:
print(re.getall('myHash'))  

4. re.hmset(name, mapping)  # 在name对应的hash中批量设置键值对， mapping:字典
例如:
myDict = {'name':'lisi', 'age': 20, 'gender': 'w'}
re.hmset('myHash', myDict )

5. re.hmget(name, keys, *args)  # 在name对应的hash中获取多个key对应的值
例如:
mylist = ['name', 'gender']
print(re.hmget('myHash', mylist))  # 传入列表
print(re.hmget('myHash', 'name', 'age'))  # 传入多个参数

6. re.hlen(name)  # 获取hash中键值对的个数。其中re.hkeys(name) 获取hash中所有key。 re.hvals()获取hash中所有value
例如:
print(re.hlen('myHash')) 
print(re.hkeys('myHash'))
print(re.hvals('myHash'))

7. re.hexists(name, key)  # 检查name对应的hash是否存在传入的key
例如:
print(re.hexists('myHash', 'name'))  # True

8. re.hdel(name, *keys)  # 删除指定name对应的key所在的键值对
例如:
re.hdel('myHash', 'name')

9. re.hincrby(name, key, amount=1)  # 自增hash中key对应的值，不存在则创建对应key
例如:
print(re.hincrby('myHash', 'age', amount=2))  # 若age不存在则创建并age=2， 存在则加2 

10. re.hincrbyfloat(name, key, amount=1.0)  # 自增hash中key对应的值，不存在则创建
例如:
print(re.hincrby('myHash', 'score', amount=98.01))  # 若score不存在则创建并score=98.01，存在则加98.01

(7) List操作

redis中的List在内存中按照一个name对应一个List来存储。

1. re.lpush(name, values)  # 在name对应的list中添加元素，头插入
例如:
re.lpush('mylist', 'zhangsan', 18,'w')   # 在列表中的顺序为 w 18 zhangsan

2. re.rpush(name, values)  # 在name对应的list中添加元素，尾插入
例如:
re.rpush('mylist', 'zhangsan', 18,'w')   # 在列表中的顺序为 zhangsan 18  w 

3. re.lpushx(name, value)  # 在list中头插入，列表存在时候才插入
例如:
re.lpushx('mylist', 'zhangsan')

4. re.rpushx(name, value)  #  在list中尾插入，列表存在时候才插入
例如:
re.rpushx('mylist', 'zhangsan')

5. re.llen(name)  # 获取name对应的键中的元素个数
例如:
print(re.llen('mylist'))

6. re.linsert(name, where, refvalue, value)  # 在name对应的列表的某一个值的前或后插入一个新值
参数：
  where: BEFORE（前）或AFTER（后）
  refvalue: 列表内的值
例如:
re.linsert('mylist','before',  'zhangsan', '01')  # 在张三前插入序号01

7. re.lset(name, index, value)  # 对list中的某一个索引位置重新赋值
例如:
re.lset('myset', 0, '02')  #  将索引下标为0的位置的值修改为02

8. re.lrem(name, count, value)  # 删除name对应的list中的指定元素，count为删除个数
参数：
  count:  count=0 删除列表中所有的指定值
          count>0 从前到后删除与值相等的元素
          count<0 从后向前删除与值相等的元素时
例如:
r.lrem('mylist', 1 ,'02')

9. re.lpop(name) / re.rpop(name)  # 移除列表的左侧第一个元素，并返回
例如:
print(re.lpop('mylist'))

10. re.lindex(name, index)  # 根据索引获取列表中的元素
例如:
print(re.lindex('mylist'， 1)) # zhangsan 

11. re.lrange(name, start, end)  # 分片获取元素
例如:
print(re.lrange('mylist', 0, -1))  # 获取列表总全部内容

12. re.ltrim(name, start, end)  # 移除列表中没有在该索引范围内的值（裁剪）返回列表
例如:
print(re.ltrim('mylist', 0, 2))  # 包含索引下标为2，输出[02, zhangsan 18]

13. re.rpoplpush(src, dst)  # 从一个列表中最右端取值(并删除), 添加到另一个列表的左端
例如:
re.lpush('myList1', 'a')
re.lpush('myList2', 'b')
re.rpoplpush('myList1', 'myList2')
print(r.lrange('mylist2',0,-1))  #  a b 

(8) Set无序集合操作

1. re.sadd(name, *values)  # 给name对应的集合添加元素
例如:
re.sadd('myset', 'a')  # 添加a
re.sadd('myset', 'a', 'b')  # 添加多个值

2. re.smembers(name)  # 获取name对应的集合中的所有成员
例如:
print(re.smembers('myset')) 

3. re.scard(name)  # 获取name对应集合中的元素个数
例如:
print(re.scard('myset'))

4. re.sdiff(key, *args)  # 获取在第一个name对应的集合中且不再其他集合中的元素(差集)
例如:
re.sdiff('myset1', 'a', 'b')
re.sdiff('myset2', 'b', 'c')
print(r.sdiff('myset1','myset2'))  # 输出 a

5. re.sinter(key, *args)  # 获取多个集合的并集
例如:
re.sadd("myset1","a","b")
re.sadd("myset2","b","c")
print(r.sinter('myset1','myset2'))  # 输出 a b c

6. re.sismember(name, value) # 检查value是否是name对应的集合内的元素，返回bool
例如:
print(sismember('myset','a'))  # True

7. re.smove(src, dst, value)  # 将某一个值从一个集合移动到另一个集合，原集合中的值删除
例如:
re.sadd('myset','a','b','c')
re.sadd('myset1','a','c','d')
print(r.smove('myset','myset1','b'))  # True
print(r.smembers('myset1'))  #  {'a', 'b', 'd', 'c'} 结果无序

8. re.spop(name)  # 从集合中最右侧移除一个元素(随机) 并返回
例如:
print(re.spop('a'))

9. re.srandmember(name, number=None)  # 从name对应的集合中随机返回number个元素默认返回一个
例如:
print(re.srandmember('myset', 2))  # 随机返回两个元素以列表形式返回

10. re.srem(name, *values)  # 删除name对应的集合中的某一些值，返回删除的个数
例如:
print(re.srem('myset', 'a', 'b'))

11. re.sunion(key, *args)  # 获取多个name对应的集合的并集
例如:
print(re.sunion("myset", 'myset1')) 

12. re.sunionstore(dest, keys, *args)  # 获取多个name对应集合的并集，并将结果保存到dest对应的集合中
例如:
re.sadd('myset','a','b','c')
re.sadd('myset1','a','c','d')
print(r.sunionstore('myset2','myset','myset1'))  # {'d', 'e', 'b', 'c', 'a'} 返回dest集合中元素的个数5

(9) Zset操作

有序集合: 在集合的基础上,为每个元素排序,元素排序需要根据另外一个值来进行比较(score权重)。

1. re.zadd(name, \*args, \*\*kwargs)  # 在name对应的有序结合中添加元素
例如:
re.zadd('myzset', 1, 'a', 3, 'c', 2, 'b')  # 添加三个元素
re.zadd('myzset', a=1, b=2)  # 以关键字参数的形式添加元素

2. re.zcard(name)  # 获取有序集合内元素的个数
例如:
print(re.zcard('myzset')) 

3. re.zcount(name, min, max)  # 获取有序集合中score在min和max之间的个数包含（min和max）
例如:
print(re.zcount('myzset', 0, 5))  # 3 

4. re.zincrby(name, value, amount=1)  # 自增有序集合中value对应的分数
例如:
re.zincrby('myzset', 'a', 3)  # 将a的权重值加3

5. re.zrange(name, start, end, desc=False, withscores=False, score_cast_func=float)  # 按照索引范围获取name对应的有序集合的元素
参数:
  start: 索引的开始位置
  end: 索引的结束位置
  desc: 排序规则，默认从小到大排序
  withscores: 是否获取权重, 默认只打印元素
  score_cast_func: 对分数进行数据转换的函数
例如:
print(re.zrange('myzset', 0, -1))

6. re.zrevrange(name, start, end, desc=False, withscores=False, score_cast_func=float) # 按照索引范围获取name对应的有序集合的元素, 集合是从大到小排序的(上一个方法的逆置)
例如:
print(re.zrange('myzset',0,-1,desc=True,withscores=True))  # 带权重的返回按从大到小 [('a', 4.0), ('b', 2.0), ('c', 3.0)]
print(re.zrevrange('myzset',0,-1,withscores=True))  # 同上 按权重从大到小排序  [('a', 4.0), ('b', 2.0), ('c', 3.0)]

7. re.zrank(name,value) / zrevrank(name, value) # 获取value值在name对应的有序集合中的排行位置（从0开始）
例如:
print(re.zrank("myzset", "a"))  # 默认从小到大排序
print(re.zrevrank("myzset", "a"))  # 从大到小排序(逆置)

8. re.zscore(name,value) # 获取name对有序集合中 value对应的权重
例如:
print(re.zscore('myzset','a'))

9. re.zrem(name,*values) # 删除name对应的有序集合中的值
例如:
re.zrem('myzset','a','b')  # 删除与a b 匹配的值

10. re.zremrangebyrank(name,min,max) # 根据排行范围删除
例如：
re.zadd('myzset', 1, 'a', 3, 'c', 2, 'b')  # 添加三个元素
print(re.zremrangebyrank('myzset',0,1))  # 将排行0-1的删除
print(re.zrange('myzset',0,-1))  # ['c']

11. re.zremrangebyscore(name,min,max) # 根据权重范围删除
例如：
re.zadd('myzset', 1, 'a', 3, 'c', 2, 'b')  # 添加三个元素
print(re.zremrangebyscore('myzset',0,1))  # 权重为0-1的删除  
print(re.zrange('myzset',0,-1))  # ['b', 'c']

12. re.zinterstore(dest,keys,arrregate=None) 
获取两个有序集合的交集并放入dest集合，如果遇到相同值不同权重，则按照aggregate(SUM / MIN / MAX)进行操作。
默认使用的参数 SUM ，可以将成员的 score 值之 和 作为结果集中该成员的 score 值；使用参数 MIN ，可以将成员的 最小 score 值作为结果集中该成员的 score 值；而参数 MAX 则是将成员的 最大 score 值作为结果集中该成员的 score 值。
例如：
re.zinterstore("dest_myzset",("myzset1","myzset2"),aggregate="MAX")  # 获取并集
print(r.zrange('myzset2',0,-1))

13. re.zunionstore(dest,keys,arrregate=None) # 获取两个有序集合的并集并放入dest集合，其他同zinterstore
例如：
print(r.zunionstore('myzset2',('myzset','myzset1'),aggregate='MAX'))      
print(r.zrange('myzset2',0,-1))