Python操作Redis（二）

List操作

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

1. lpush(name,values)
2. # 在name对应的list中添加元素，每个新的元素都添加到列表的最左边
3. # 如：
4.    # r.lpush('oo', 11,22,33)
5.    # 保存顺序为: 33,22,11
6. # 扩展：
7.    # rpush(name, values) 表示从右向左操作
9. lpushx(name,value)
10. # 在name对应的list中添加元素，只有name已经存在时，值添加到列表的最左边
11. # 更多：
12.    # rpushx(name, value) 表示从右向左操作
14. llen(name)
15. # name对应的list元素的个数
17. linsert(name, where, refvalue, value))
18. # 在name对应的列表的某一个值前或后插入一个新值
19. # 参数：
20.    # name，redis的name
21.    # where，BEFORE或AFTER
22.    # refvalue，标杆值，即：在它前后插入数据
23.    # value，要插入的数据
25. r.lset(name, index, value)
26. # 对name对应的list中的某一个索引位置重新赋值
27. # 参数：
28.    # name，redis的name
29.    # index，list的索引位置
30.    # value，要设置的值
32. r.lrem(name, value, num)
33. # 在name对应的list中删除指定的值
34. # 参数：
35.    # name，redis的name
36.    # value，要删除的值
37.    # num，  num=0，删除列表中所有的指定值；
38.           # num=2,从前到后，删除2个；
39.           # num=-2,从后向前，删除2个
41. lpop(name)
42. # 在name对应的列表的左侧获取第一个元素并在列表中移除，返回值则是第一个元素
43. # 更多：
44.    # rpop(name) 表示从右向左操作
46. lindex(name, index)
47. 在name对应的列表中根据索引获取列表元素
49. lrange(name, start, end)
50. # 在name对应的列表分片获取数据
51. # 参数：
52.    # name，redis的name
53.    # start，索引的起始位置
54.    # end，索引结束位置
56. ltrim(name, start, end)
57. # 在name对应的列表中移除没有在start-end索引之间的值
58. # 参数：
59.    # name，redis的name
60.    # start，索引的起始位置
61.    # end，索引结束位置
63. rpoplpush(src, dst)
64. # 从一个列表取出最右边的元素，同时将其添加至另一个列表的最左边
65. # 参数：
66.    # src，要取数据的列表的name
67.    # dst，要添加数据的列表的name
69. blpop(keys, timeout)
70. # 将多个列表排列，按照从左到右去pop对应列表的元素
71. # 参数：
72.    # keys，redis的name的集合
73.    # timeout，超时时间，当元素所有列表的元素获取完之后，阻塞等待列表内有数据的时间（秒）, 0 表示永远阻塞
74. # 更多：
75.    # r.brpop(keys, timeout)，从右向左获取数据
77. brpoplpush(src, dst, timeout=0)
78. # 从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧
79. # 参数：
80.    # src，取出并要移除元素的列表对应的name
81.    # dst，要插入元素的列表对应的name
82.    # timeout，当src对应的列表中没有数据时，阻塞等待其有数据的超时时间（秒），0 表示永远阻塞
84. 定义增量迭代
85. # 由于redis类库中没有提供对列表元素的增量迭代，如果想要循环name对应的列表的所有元素，那么就需要：
86.    # 1、获取name对应的所有列表
87.    # 2、循环列表
88. # 但是，如果列表非常大，那么就有可能在第一步时就将程序的内容撑爆，所有有必要自定义一个增量迭代的功能：
90. def list_iter(name):
91.    """
92.    自定义redis列表增量迭代
93.    :param name: redis中的name，即：迭代name对应的列表
94.    :return: yield 返回 列表元素
95.    """
96.    list_count = r.llen(name)
97.    for index in xrange(list_count):
98.        yield r.lindex(name, index)
100. # 使用
101. for item in list_iter('pp'):
102.    print item

Set操作

Set集合就是不允许重复的列表

1. sadd(name,values)
2. # name对应的集合中添加元素
3. scard(name)
4. 获取name对应的集合中元素个数
6. sdiff(keys, *args)
7. 在第一个name对应的集合中且不在其他name对应的集合的元素集合
9. sdiffstore(dest, keys, *args)
10. # 获取第一个name对应的集合中且不在其他name对应的集合，再将其新加入到dest对应的集合中
12. sinter(keys, *args)
13. # 获取多一个name对应集合的并集
15. sinterstore(dest, keys, *args)
16. # 获取多一个name对应集合的并集，再讲其加入到dest对应的集合中
18. sismember(name, value)
19. # 检查value是否是name对应的集合的成员
21. smembers(name)
22. # 获取name对应的集合的所有成员
24. smove(src, dst, value)
25. # 将某个成员从一个集合中移动到另外一个集合
27. spop(name)
28. # 从集合的右侧（尾部）移除一个成员，并将其返回
30. srandmember(name, numbers)
31. # 从name对应的集合中随机获取 numbers 个元素
33. srem(name, values)
34. # 在name对应的集合中删除某些值
36. sunion(keys, *args)
37. # 获取多一个name对应的集合的并集
39. sunionstore(dest,keys, *args)
40. # 获取多一个name对应的集合的并集，并将结果保存到dest对应的集合中
42. sscan(name, cursor=0, match=None, count=None)
43. sscan_iter(name, match=None, count=None)
44. # 同字符串的操作，用于增量迭代分批获取元素，避免内存消耗太大

有序集合

在集合的基础上，为每元素排序；元素的排序需要根据另外一个值来进行比较，所以，对于有序集合，每一个元素有两个值，即：值和分数，分数专门用来做排序。

1. zadd(name, *args, **kwargs)
2. # 在name对应的有序集合中添加元素
3. # 如：
4.     # zadd('zz', 'n1', 1, 'n2', 2)
5.     # 或
6.     # zadd('zz', n1=11, n2=22)
8. zcard(name)
9. # 获取name对应的有序集合元素的数量
11. zcount(name, min, max)
12. # 获取name对应的有序集合中分数 在 [min,max] 之间的个数
14. zincrby(name, value, amount)
15. # 自增name对应的有序集合的 name 对应的分数
17. r.zrange( name, start, end, desc=False, withscores=False, score_cast_func=float)
18. # 按照索引范围获取name对应的有序集合的元素
20. # 参数：
21.    # name，redis的name
22.    # start，有序集合索引起始位置（非分数）
23.    # end，有序集合索引结束位置（非分数）
24.    # desc，排序规则，默认按照分数从小到大排序
25.    # withscores，是否获取元素的分数，默认只获取元素的值
26.    # score_cast_func，对分数进行数据转换的函数
28. # 更多：
29.    # 从大到小排序
30.    # zrevrange(name, start, end, withscores=False, 
32. score_cast_func=float)
33.    # 按照分数范围获取name对应的有序集合的元素
34.    # zrangebyscore(name, min, max, start=None, num=None, withscores=False, score_cast_func=float)
35.    # 从大到小排序
36.    # zrevrangebyscore(name, max, min, start=None, num=None, withscores=False, score_cast_func=float)
38. zrank(name, value)
39. # 获取某个值在 name对应的有序集合中的排行（从 0 开始）
40. # 更多：
41.    # zrevrank(name, value)，从大到小排序
43. zrangebylex(name, min, max, start=None, num=None)
44. # 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的 值 （lexicographical ordering）来进行排序，而这个命令则可以返回给定的有序集合键 key 中， 元素的值介于 min 和 max 之间的成员
45. # 对集合中的每个成员进行逐个字节的对比（byte-by-byte compare）， 并按照从低到高的顺序， 返回排序后的集合成员。 如果两个字符串有一部分内容是相同的话， 那么命令会认为较长的字符串比较短的字符串要大
46. # 参数：
47.    # name，redis的name
48.    # min，左区间（值）。 + 表示正无限； - 表示负无限； ( 表示开区间； [ 则表示闭区间
49.    # min，右区间（值）
50.    # start，对结果进行分片处理，索引位置
51.    # num，对结果进行分片处理，索引后面的num个元素
53. # 如：
54.    # ZADD myzset 0 aa 0 ba 0 ca 0 da 0 ea 0 fa 0 ga
55.    # r.zrangebylex('myzset', "-", "[ca") 结果为：['aa', 'ba', 'ca']
57. # 更多：
58.    # 从大到小排序
59.    # zrevrangebylex(name, max, min, start=None, num=None)
61. zrem(name, values)
62. # 删除name对应的有序集合中值是values的成员
63. # 如：zrem('zz', ['s1', 's2'])
65. zremrangebyrank(name, min, max)
66. # 根据排行范围删除
68. zremrangebyscore(name, min, max)
69. # 根据分数范围删除
71. zremrangebylex(name, min, max)
72. # 根据值返回删除
74. zscore(name, value)
75. # 获取name对应有序集合中 value 对应的分数
77. zinterstore(dest, keys, aggregate=None)
78. # 获取两个有序集合的交集，如果遇到相同值不同分数，则按照aggregate进行操作
79. # aggregate的值为:  SUM  MIN  MAX
81. zunionstore(dest, keys, aggregate=None)
82. # 获取两个有序集合的并集，如果遇到相同值不同分数，则按照aggregate进行操作
83. # aggregate的值为:  SUM  MIN  MAX
85. zscan(name, cursor=0, match=None, count=None, score_cast_func=float)
86. zscan_iter(name, match=None, count=None,score_cast_func=float)
87. # 同字符串相似，相较于字符串新增score_cast_func，用来对分数进行操作

其他常用操作

1. delete(*names)
2. # 根据删除redis中的任意数据类型
4. exists(name)
5. # 检测redis的name是否存在
7. keys(pattern='*')
8. # 根据模型获取redis的name
9. # 更多：
10.    # KEYS * 匹配数据库中所有 key 。
11.    # KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。
12.    # KEYS h*llo 匹配 hllo 和 heeeeello 等。
13.    # KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo
15. expire(name ,time)
16. # 为某个redis的某个name设置超时时间
18. rename(src, dst)
19. # 对redis的name重命名为
21. move(name, db))
22. # 将redis的某个值移动到指定的db下
24. randomkey()
25. # 随机获取一个redis的name（不删除）
27. type(name)
28. # 获取name对应值的类型
30. scan(cursor=0, match=None, count=None)
31. scan_iter(match=None, count=None)
32. # 同字符串操作，用于增量迭代获取key

管道

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

1. #!/usr/bin/env python
2. # -*- coding:utf-8 -*-
3. import redis
4. pool = redis.ConnectionPool(host='10.211.55.4', port=6379)
5. r = redis.Redis(connection_pool=pool)
6. # pipe = r.pipeline(transaction=False)
7. pipe = r.pipeline(transaction=True)
8. pipe.multi()
9. pipe.set('name', 'alex')
10. pipe.set('role', 'sb')
11. pipe.execute()

实现计数器

1. #!/usr/bin/env python
2. # -*- coding:utf-8 -*-
3. import redis
4. conn = redis.Redis(host='192.168.1.41',port=6379)
5. conn.set('count',1000)
6. with conn.pipeline() as pipe:
8.    # 先监视，自己的值没有被修改过
9.    conn.watch('count')
11.    # 事务开始
12.    pipe.multi()
13.    old_count = conn.get('count')
14.    count = int(old_count)
15.    if count > 0:  # 有库存
16.        pipe.set('count', count - 1)
18.    # 执行，把所有命令一次性推送过去
19.    pipe.execute()

发布订阅

发布者：服务器

订阅者：Dashboad和数据处理

Demo如下：

1. #!/usr/bin/env python
2. # -*- coding:utf-8 -*-
3. import redis
4. class RedisHelper:
6.    def __init__(self):
7.        self.__conn = redis.Redis(host='10.211.55.4')
8.        self.chan_sub = 'fm104.5'
9.        self.chan_pub = 'fm104.5'
11.    def public(self, msg):
12.        self.__conn.publish(self.chan_pub, msg)
13.        return True
15.    def subscribe(self):
16.        pub = self.__conn.pubsub()
17.        pub.subscribe(self.chan_sub)
18.        pub.parse_response()
19.        return pub

订阅者：

1. #!/usr/bin/env python
2. # -*- coding:utf-8 -*-
3. from monitor.RedisHelper import RedisHelper
4. obj = RedisHelper()
5. redis_sub = obj.subscribe()
6. while True:
7.    msg= redis_sub.parse_response()
8.    print msg

发布者：

1. #!/usr/bin/env python
2. # -*- coding:utf-8 -*-
3. from monitor.RedisHelper import RedisHelper
4. obj = RedisHelper()
5. obj.public('hello')

sentinel

redis中的sentinel主要用于在redis主从复制中，如果master顾上，则自动将slave替换成master

1. #!/usr/bin/env python
2. # -*- coding:utf-8 -*-
3. from redis.sentinel import Sentinel
4. # 连接哨兵服务器(主机名也可以用域名)
5. sentinel = Sentinel([('10.211.55.20', 26379),
6.                     ('10.211.55.20', 26380),
7.                     ],
8.                    socket_timeout=0.5)
9. # # 获取主服务器地址
10. # master = sentinel.discover_master('mymaster')
11. # print(master)
12. #
13. # # # 获取从服务器地址
14. # slave = sentinel.discover_slaves('mymaster')
15. # print(slave)
16. #
17. # # # 获取主服务器进行写入
18. # master = sentinel.master_for('mymaster')
19. # master.set('foo', 'bar')
21. # # # # 获取从服务器进行读取（默认是round-roubin）
22. # slave = sentinel.slave_for('mymaster', password='redis_auth_pass')
23. # r_ret = slave.get('foo')
24. # print(r_ret)

---

识别图中二维码,领取python全套视频资料