python下操作redis数据库的基本方法

1. 环境。

• Python：3.6.1
• Python IDE：pycharm
• 系统：win7

2. Redis简要说明

• redis是一个key-value存储系统，为了保证效率，数据都是缓存在内存中。它支持存储的value类型很多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set 有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove，取交集并集和差集，以及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。而且redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave（主从）同步。
• redis库安装：pip install Redis
• 简单示例：

# 打开win7 下redis-cli.exe 进入redis cli 窗口
> set name abc    # 给变量name设置值abc
OK
> set age 25
OK
> keys *      # 列出当前所有key，变量是key-value对
1) "age"
2) "name"
> set sex m ex 5     # 给变量sex设置值m，并且设置这个变量只存活5秒
OK
> get sex        # 获取变量的值
"m"
> flushdb       # 清空当前db下的所有键值
OK
> flushall  # 清空所有db下的键值
OK

3. python下Redis库的基本操作

• 官方中文文档地址：http://redisdoc.com/

3.1. 操作模式

• redis.py提供两个类用于实现Redis的命令：Redis和StrictRedis。
• 其中StrictRedis用于实现大部分官方的命令，并使用官方的语法和命令。
• Redis是StrictRedis的子类，用于向后兼容旧版本的redis.py。

import redis
rClient = redis.Redis(host='127.0.0.1', port=6379)
rClient.set('name', 'Zhou')
print (rClient.get('name'))

3.2. 连接池

• redis.py采用Connection Pool来管理对一个Redis Server的所有连接，这样就能避免每次建立、释放连接的开销。默认情况下，每个Redis实例都会维护一个自己的连接池。为了减少开销，可以直接建立一个连接池，然后作为共享参数redisPool，这样就可以实现多个Redis实例共享这一个连接池。

import redis
redisPool = redis.ConnectionPool(host='127.0.0.1', port=6379)
rClient = redis.Redis(connection_pool=redisPool)
rClient.set('name', 'Zhou')
print rClient.get('name')

3.3. 基本的数据操作

3.3.1. string操作

• 设置值：set（name, value, ex=None, px=None, nx=False, xx=False）
• 拓展：setnx 、 setex 、 psetex

set
在Redis中设置值，默认，不存在则创建，存在则修改
参数：
     ex，过期时间（秒）
     px，过期时间（毫秒）
     nx，如果设置为True，则只有name不存在时，当前set操作才执行
     xx，如果设置为True，则只有name存在时，当前set操作才执行

• 批量设置值：mset(*args, **kwargs)

mset 批量设置值，MSET key value [key value …]
示例：mset name1 Zhou name2 wen

• mget(keys, *args)

批量获取：mget name1 name2

• getset(name, value)

设置新值并获取原来的值： getset name1 Qi

• getrange(name, start, end)

获取子序列（根据字节获取，非字符）
name：Redis 的 key，变量名
start：起始位置（字节）
end：结束位置（字节）
从0开始计数，前后闭包
> set name Zhou
> getrange name 2 3
> "ou"

• setrange(name, offset, value)

修改字符串内容，从指定字符串索引开始向后替换（如果新值太长时，则向后添加）
offset，字符串的索引，字节（一个汉字三个字节）
value，要设置的值
> set name Zhou
> setrange name 1 we
> get name
"Zweu"

• setbit(name, offset, value)

对name对应值的二进制进行位操作。
name：redis的key,变量
offset：位的索引（将值变换成二进制后再进行索引）
value：值只能是 1 或 0
> set name abcd  # 我们对值内a进行修改
OK
> setbit name 6 1
(integer) 0
> get name
"cbcd"  # 改b的话，从第8位开始数
----------------------------------------------
# python IDE下
>>> ord('a')
97
>>> bin(97)    # 把a改成c，97 ——> 99
'0b1100001'    # 0110 0001 ——> 0110 0011 （第6位改为1）
----------------------------------------------
# setbit还有个特性，不会溢出，超出的部分会自动增长
> setbit name a
> setbit name 10 1   # 虽然a一个字节只有8位，但是这里没有限制。
(integer) 0
> setbit name 11 1
(integer) 0
> get name
"a0"

• bitcount(key, start=None, end=None)

获取变量key对应的值的二进制表示中 1 的个数
> set name a     # a ——> 0110 0001
OK
> bitcount name  # 3个1
(integer) 3

• 这个功能有个经典的应用场景：
  当用户量巨大，统计在线用户数有多少个时，如果用数据库去存谁在线，不仅占用大量空间，统计时的效率也不高。

一般在存储用户时，每个用户都有一个大整数ID，ID是唯一的。那么我们可以分配出一个大空间（大字符串），按位标记，在线则标记对应的bit位为1，不在线则为0，最后用bitcount计算在线用户数量。计算一下，按位来存，2亿用户，只占用2亿个位空间。
> setbit user 1000 1    # 假如用户ID 1000登录
> setbit user 27 1
> setbit user 6000 1
> bitcount user  # 查看在线用户
(integer) 3
> getbit user 27  # 查看用户在不在线，1说明用户在线
(integer) 1
> getbit user 28  # 0 说明用户不在线
(integer) 0

• incr(self, name, amount=1)

自增name对应的值，当name不存在时，则创建name＝amount（默认值是1），否则，则自增，比如原来name=6，自增后则变成7。
name,Redis的name，变量
amount,自增数（必须是整数）
注：同incrby

• decr(self, name, amount=1)

自减name对应的值，当name不存在时，则创建name＝amount，否则，则自减。
name,Redis的name
amount,自减数（整数）
> incr users
(integer) 1
> incr users
(integer) 2
> decr users
(integer) 1
> decr users
(integer) 0

• incrbyfloat(self, name, amount=1.0)

自增name对应的值，当name不存在时，则创建name＝amount，否则，则自增amount的数值。
name,Redis的name
amount,自增数（浮点型）
> incrbyfloat floatnum 1.1   # 变量floatnum不存在则创建
"1.1"
> incrbyfloat floatnum 1.2   # 变量存在则增长
"2.3"

• append(key, value)

在变量对应的值后面追加内容
key, redis的变量
value, 要追加的字符串
> set name zhou
OK
> get name
"zhou"
> append name wen
(integer) 7
> get name
"zhouwen"

3.3.2. Hash操作

• Redis里的Hash和我们平时所了解的hash不同，类似于字典包含字典的关系。我们看上面的string操作，如果变量特别多，而变量与变量（例如：name和age）之间没有关系，变量特别特别多的情况下，使用者就混乱了，而事实上name和age是同属于一个的属性，那么就可以将其归类。
• 我们先看一下，Redis中Hash在内存中的存储格式，如下图所示：
  
• hset(name, key, value)

name对应的hash中设置一个键值对（不存在，则创建；否则，修改）
# name，redis的name,也就是变量
# key，变量name对应的hash中的key
# value，变量name对应的hash中的value
# 注：hsetnx(name, key, value),当name对应的hash中不存在当前key时则创建（相当于添加）
> hset user1 name zhou
(integer) 1
> hset user age 28
(integer) 1
> hgetall user  # 查看user对应hash下所有key和value
1) "name"
2) "zhou"
3) "age"
4) "28"
> hkeys user  # 查看user对应hash下所有key
1) "name"
2) "age"
> hvals user  # 查看user对应hash下所有value
1) "zhou"
2) "28"

• hmset(name, mapping)
• *hmget(name, keys, args)
• hlen(name)

hmset：在变量name对应的hash中批量设置键值对
hmget：在name对应的hash中获取多个key的值
hlen：获取name对应的hash中键值对的个数
# name，redis的name
# mapping，字典形式，如：{'k1':'v1', 'k2': 'v2'}
> hmset user name zhou age 2
> hmget user name age
1) "zhou"
2) "2"
> hlen(user)
(integer) 2

• hexists(name, key)

检查name对应的hash是否存在当前传入的key
> hexists user name
(integer) 1
> hexists user sex
(integer) 0

• hdel(name,*keys)：将name对应的hash中指定key的键值对删除
• hincrby(name, key, amount=1)
• 类似的：hincrbyfloat(name, key, amount=1.0)

自增name对应的hash中的指定key的值，不存在则创建key=amount
name，redis中的name
key， hash对应的key
amount，自增数（整数）
> hincrby user grade 1
(integer) 1
> hincrby user grade 1
(integer) 2

• hscan(name, cursor=0, match=None, count=None) 过滤

增量式迭代获取，对于数据大的数据非常有用，hscan可以实现分片的获取数据，
并非一次性将数据全部获取完，从而放置内存被撑爆
# name，redis的name
# cursor，游标（基于游标分批取获取数据）
# match，匹配指定key，默认None 表示所有的key
# count，每次分片最少获取个数，默认None表示采用Redis的默认分片个数
> hscan user 0 match a*   # *代表泛匹配
1) "0"
2) 1) "age"
   2) "28"

• hscan_iter(name, match=None, count=None)

利用yield封装hscan创建生成器，实现分批去redis中获取数据
# name，redis的name
# match，匹配指定key，默认None 表示所有的key
# count，每次分片最少获取个数，默认None表示采用Redis的默认分片个数
# 如：
for item in rClient.hscan_iter(user):
    print item

3.3.3. 列表操作

> lpush nameLst zhou li zhang  # 左边放入三个值
(integer) 3
> lrange nameLst 0 -1     # 先入后出，类似堆栈排序
1) "zhang"
2) "li"
3) "zhou"
> rpush nameLst A B C  # 右边放入三个值
(integer) 6
127.0.0.1:6379> lrange nameLst 0 -1
1) "zhang"
2) "li"
3) "zhou"
4) "A"
5) "B"
6) "C"

• lpushx(name,value)
  在name对应的list中添加元素，只有name已经存在时，值添加到列表的最左边
• llen(name)
  name对应的list元素的个数
• linsert(name, where, refvalue, value))

在name对应的列表的某一个值前或后插入一个新值
# name，redis的name
# where，BEFORE或AFTER
# refvalue，标杆值，即：在它前后插入数据
# value，要插入的数据
> linsert nameLst before C D
(integer) 7
> lrange nameLst 4 -1
1) "B"
2) "D"
3) "C"

• r.lset(name, index, value)
  对name对应的list中的某一个索引位置重新赋值
• r.lrem(name, value, num)
  在name对应的list中删除指定的值
• lpop(name)
  在name对应的列表的左侧获取第一个元素并在列表中移除，返回值则是第一个元素
• lindex(name, index)
  在name对应的列表中根据索引获取列表元素
• ltrim(name, start, end)

保留start-end索引之的值，移除其他值
> ltrim nameLst 0 2
OK
> lrange nameLst 0 -1
1) "zhang"
2) "li"
3) "zhou"

• rpoplpush(src, dst)

# 从一个列表取出最右边的元素，同时将其添加至另一个列表的最左边
# src，要取数据的列表的name
# dst，要添加数据的列表的name
> rpush nameLst2 AB
(integer) 1
> rpoplpush nameLst nameLst2
"zhou"
> lrange nameLst 0 -1
1) "zhang"
2) "li"
> lrange nameLst2 0 -1
1) "zhou"
2) "AB"

• blpop(keys, timeout)
  从左到右去删除对应列表的元素，无元素则等待设置的超时时间
• brpoplpush(src, dst, timeout=0)
  从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧

3.3.4. 集合操作

• sadd(name,values)

# name对应的集合中添加元素
> sadd nameSet zhou a b b
(integer) 3
> smembers nameSet
1) "zhou"
2) "b"
3) "a"

• scard(name)
  获取name对应的集合中元素个数
• sdiff(keys, *args)

# 在第一个name对应的集合中且不在其他name对应的集合的元素集合
> sadd nameSet1 b c d
(integer) 3
> sdiff nameSet nameSet1
1) "zhou"
2) "a"

• sdiffstore(dest, keys, *args)
  获取第一个name对应的集合中且不在其他name对应的集合，再将其新加入到dest对应的集合中
• sinter(keys, *args)
  获取多一个name对应集合的交集
• sinterstore(dest, keys, *args)
  获取多一个name对应集合的并集，再讲其加入到dest对应的集合中
• sismember(name, value)
  检查value是否是name对应的集合的成员
• smembers(name)
  获取name对应的集合的所有成员
• smove(src, dst, value)
  将某个成员从一个集合中移动到另外一个集合
• spop(name)
  从集合的右侧（尾部）移除一个成员，并将其返回
• srandmember(name, numbers)
  从name对应的集合中随机获取 numbers 个元素
• srem(name, values)
  在name对应的集合中删除某些值
• sunion(keys, *args)
  获取多一个name对应的集合的并集
• sunionstore(dest,keys, *args)
  获取多一个name对应的集合的并集，并将结果保存到dest对应的集合中

3.3.5. 有序集合

• zadd(name, *args, **kwargs)

# 在name对应的有序集合中添加元素
> zadd z1 10 fgf 7 fzh 2 js  5 ajs
(integer) 3
> zrange z1 0 -1
1) "js"
2) "ajs"
3) "fzh"
4) "fgf"
> zrange z1 0 -1 withscores
1) "js"
2) "2"
3) "ajs"
4) "5"
5) "fzh"
6) "7"
7) "fgf"
8) "10"

• zcount(name, min, max)

# 获取name对应的有序集合中分数 在 [min,max] 之间的个数
> zcount z1 5 10
(integer) 3

• zincrby(name, value, amount)
  自增name对应的有序集合的 name 对应的分数
• zrank(name, value)

# 获取某个值在 name对应的有序集合中的排行（从 0 开始）
> zrank z1 fgf
(integer) 3
> zrank z1 ajs
(integer) 1

• zrem(name, values)
  删除name对应的有序集合中值是values的成员
• zremrangebyrank(name, min, max)

# 根据排行范围删除
> zremrangebyrank z1 1 3
(integer) 3

• zremrangebyscore(name, min, max)
  根据分数范围删除
• zremrangebylex(name, min, max)
  根据值返回删除
• zscore(name, value)
  获取name对应有序集合中 value 对应的分数
• zinterstore(dest, keys, aggregate=None)

# 获取两个有序集合的交集
# aggregate的值为:  SUM  MIN  MAX
127.0.0.1:6379> zadd z2 98 fgf 100 fzh 90 js
(integer) 3
127.0.0.1:6379> zadd z3 88 fgf 89 fzh 92 js
(integer) 3
127.0.0.1:6379> ZINTERSTORE z4 2 z2 z3  # 2 指后边2个集合的交集
(integer) 3
127.0.0.1:6379> zrange z2 0 -1 withscores
1) "js"
2) "90"
3) "fgf"
4) "98"
5) "fzh"
6) "100"
127.0.0.1:6379> zrange z3 0 -1 withscores
1) "fgf"
2) "88"
3) "fzh"
4) "89"
5) "js"
6) "92"
127.0.0.1:6379> zrange z4 0 -1 withscores
1) "js"
2) "182"
3) "fgf"
4) "186"
5) "fzh"
6) "189"

• zunionstore(dest, keys, aggregate=None)
  获取两个有序集合的并集

3.3.6. 其他常用操作

del(*names)
# 根据删除redis中的任意数据类型

exists(name)
# 检测redis的name是否存在

keys(pattern='*')
# 根据模型获取redis的name
# KEYS * 匹配数据库中所有 key 。
# KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。
# KEYS h*llo 匹配 hllo 和 heeeeello 等。
# KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo

expire(name ,time)
# 为某个redis的某个name设置超时时间

rename(src, dst)
# 对redis的name重命名

move(name, db))
# 将redis的某个值移动到指定的db下，若有则不移动

select db_name
# 切换到其他db，redis有16个db

randomkey()
# 随机获取一个redis的name（不删除）

type(name)
# 获取name对应值的类型

scan(cursor=0, match=None, count=None)
scan_iter(match=None, count=None)
# 同字符串操作，用于增量迭代获取key

3.4. 管道

• redis.py默认在执行每次请求都会创建（连接池申请连接）和断开（归还连接池）一次连接操作，如果想要在一次请求中指定多个命令，则可以使用管道（pipeline）实现一次请求指定多个命令，并且默认情况下一次pipeline 是原子性操作，要么所有命令都执行成功，要么一个命令都不执行。

import redis
import time

poolClient = redis.ConnectionPool(host='127.0.0.1', port=6379, db=5)
rClient = redis.Redis(connection_pool=poolClient)
# pipeClient = rClient.pipeline(transaction=False)
pipeClient = rClient.pipeline(transaction=True)
pipeClient.set('name', 'zhou')
time.sleep(100)
pipeClient.set('age', '28')
pipeClient.execute()

3.5. 发布订阅

• 收音机举例发布订阅

# 文件：redishelper.py
import redis

class RedisHelper:
    def __init__(self):
        self.__conn = redis.Redis(host='127.0.0.1')
        self.chan_sub = 'fm104.5'
        self.chan_pub = 'fm104.5'

    def public(self, msg):
        self.__conn.publish(self.chan_pub, msg)
        return True

    def subscribe(self):
        pub = self.__conn.pubsub()     # 打开收音机
        pub.subscribe(self.chan_sub)   # 调频道
        pub.parse_response()           # 准备接收
        return pub

• 订阅方

from RedisHelper import RedisHelper
obj = RedisHelper()
redis_sub = obj.subscribe()

while True:
    msg= redis_sub.parse_response()
    print (msg)

• 发布消息方

from RedisHelper import RedisHelper

obj = RedisHelper()
obj.public('hello，nihao')

参考文章：

• http://redisdoc.com/
• https://github.com/andymccurdy/redis-py/
• http://doc.redisfans.com/
• http://blog.csdn.net/fgf00/article/details/52917154