redis的使用

一.概述.

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

使用Redis有哪些好处？

1 (1) 速度快，因为数据存在内存中，类似于HashMap，HashMap的优势就是查找和操作的时间复杂度都是O
2 (2) 支持丰富数据类型，支持string，list，set，sorted set，hash
3 (3) 支持事务，操作都是原子性，所谓的原子性就是对数据的更改要么全部执行，要么全部不执行
4 (4) 丰富的特性：可用于缓存，消息，按key设置过期时间，过期后将会自动删除

下载地址:http://www.runoob.com/redis/redis-install.html

二.操作

1.连接池

1 import redis
2 pool = redis.ConnectionPool(host='10.211.55.4', port=6379,decode_responses=True)
3 #decode_responses参数,显示的时候不显示字节的形式
4 r = redis.Redis(connection_pool=pool)

1 import redis
2 r = redis.Redis()

2.string操作

  1 set(name, value, ex=None, px=None, nx=False, xx=False)
  2     在Redis中设置值，默认，不存在则创建，存在则修改
  3     参数：
  4          ex，过期时间（秒）
  5          px，过期时间（毫秒）
  6          nx，如果设置为True，则只有name不存在时，当前set操作才执行
  7          xx，如果设置为True，则只有name存在时，岗前set操作才执行
  8 
  9 setnx(name, value)     
 10     设置值，只有name不存在时，执行设置操作（添加）
 11 
 12 setex(name, value, time)
 13     # 设置值
 14     # 参数：
 15         # time，过期时间（数字秒 或 timedelta对象）
 16 
 17 psetex(name, time_ms, value)
 18     # 设置值
 19     # 参数：
 20         # time_ms，过期时间（数字毫秒 或 timedelta对象）
 21 
 22 mset(*args, **kwargs)
 23     批量设置值
 24     如：
 25         mset(k1='v1', k2='v2')
 26         或
 27         mget({'k1': 'v1', 'k2': 'v2'})
 28 
 29 get(name)
 30     获取值
 31 
 32 mget(keys, *args)    
 33     批量获取
 34     如：
 35         mget('ylr', 'wupeiqi')
 36         或
 37         r.mget(['ylr', 'wupeiqi'])
 38 
 39 getset(name, value)    
 40     设置新值并获取原来的值
 41 
 42 getrange(key, start, end)    
 43     # 获取子序列（根据字节获取，非字符）
 44     # 参数：
 45         # name，Redis 的 name
 46         # start，起始位置（字节）
 47         # end，结束位置（字节）
 48 
 49 setrange(name, offset, value)    
 50     # 修改字符串内容，从指定字符串索引开始向后替换（新值太长时，则向后添加）
 51     # 参数：
 52         # offset，字符串的索引，字节（一个汉字三个字节）
 53         # value，要设置的值    
 54 
 55 setbit(name, offset, value)    
 56     # 对name对应值的二进制表示的位进行操作
 57  
 58     # 参数：
 59         # name，redis的name
 60         # offset，位的索引（将值变换成二进制后再进行索引）
 61         # value，值只能是 1 或 0
 62  
 63     # 注：如果在Redis中有一个对应： n1 = "foo"，
 64             那么字符串foo的二进制表示为：01100110 01101111 01101111
 65         所以，如果执行 setbit('n1', 7, 1)，则就会将第7位设置为1，
 66             那么最终二进制则变成 01100111 01101111 01101111，即："goo"
 67  
 68     # 扩展，转换二进制表示：
 69  
 70         # source = "武沛齐"
 71         source = "foo"
 72  
 73         for i in source:
 74             num = ord(i)
 75             print bin(num).replace('b','')
 76  
 77                         沛                           齐    
 78 
 79 getbit(name, offset)    
 80     # 获取name对应的值的二进制表示中的某位的值 （0或1）
 81 
 82 bitcount(key, start=None, end=None)    
 83     # 获取name对应的值的二进制表示中 1 的个数
 84     # 参数：
 85         # key，Redis的name
 86         # start，位起始位置
 87         # end，位结束位置
 88 
 89 bitop(operation, dest, *keys)    
 90     # 获取多个值，并将值做位运算，将最后的结果保存至新的name对应的值
 91  
 92     # 参数：
 93         # operation,AND（并） 、 OR（或） 、 NOT（非） 、 XOR（异或）
 94         # dest, 新的Redis的name
 95         # *keys,要查找的Redis的name
 96  
 97     # 如：
 98         bitop("AND", 'new_name', 'n1', 'n2', 'n3')
 99         # 获取Redis中n1,n2,n3对应的值，然后讲所有的值做位运算（求并集），然后将结果保存 new_name 对应的值中
100 
101 strlen(name)    
102     # 返回name对应值的字节长度（一个汉字3个字节）
103 
104 incr(self, name, amount=1)    
105     # 自增 name对应的值，当name不存在时，则创建name＝amount，否则，则自增。
106  
107     # 参数：
108         # name,Redis的name
109         # amount,自增数（必须是整数）
110 
111 incrbyfloat(self, name, amount=1.0)    
112     # 自增 name对应的值，当name不存在时，则创建name＝amount，否则，则自增。
113  
114     # 参数：
115         # name,Redis的name
116         # amount,自增数（浮点型）
117 
118 decr(self, name, amount=1)    
119     # 自减 name对应的值，当name不存在时，则创建name＝amount，否则，则自减。
120  
121     # 参数：
122         # name,Redis的name
123         # amount,自减数（整数）
124 
125 append(key, value)    
126     # 在redis name对应的值后面追加内容
127  
128     # 参数：
129         key, redis的name
130         value, 要追加的字符串

3.list操作

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

4.清除所有

1 r.delete(*r.key())

5.hash操作

 1 hset(name, key, value)
 2     # name对应的hash中设置一个键值对（不存在，则创建；否则，修改）
 3  
 4     # 参数：
 5         # name，redis的name
 6         # key，name对应的hash中的key
 7         # value，name对应的hash中的value
 8  
 9     # 注：
10         # hsetnx(name, key, value),当name对应的hash中不存在当前key时则创建（相当于添加）
11 
12 hmset(name, mapping)
13     # name对应的hash中设置一个键值对（不存在，则创建；否则，修改）
14      
15     # 参数：
16         # name，redis的name
17         # key，name对应的hash中的key
18         # value，name对应的hash中的value
19  
20     # 注：
21         # hsetnx(name, key, value),当name对应的hash中不存在当前key时则创建（相当于添加）
22 hget(name,key)
23     # 在name对应的hash中获取根据key获取value
24 hmget(name, keys, *args)
25     # 在name对应的hash中获取多个key的值
26  
27     # 参数：
28         # name，reids对应的name
29         # keys，要获取key集合，如：['k1', 'k2', 'k3']
30         # *args，要获取的key，如：k1,k2,k3
31  
32     # 如：
33         # r.mget('xx', ['k1', 'k2'])
34         # 或
35         # print r.hmget('xx', 'k1', 'k2')        
36 hgetall(name)
37     #获取name对应hash的所有键值
38 hlen(name)
39     # 获取name对应的hash中键值对的个数    
40 hkeys(name)        
41     # 获取name对应的hash中所有的key的值    
42 hvals(name)        
43     # 获取name对应的hash中所有的value的值    
44 hexists(name, key)        
45     # 检查name对应的hash是否存在当前传入的key    
46 hdel(name,*keys)        
47     # 将name对应的hash中指定key的键值对删除    
48 hincrby(name, key, amount=1)        
49      # 自增name对应的hash中的指定key的值，不存在则创建key=amount
50     # 参数：
51         # name，redis中的name
52         # key， hash对应的key
53         # amount，自增数（整数）   
54 hincrbyfloat(name, key, amount=1.0)
55     # 自增name对应的hash中的指定key的值，不存在则创建key=amount
56  
57     # 参数：
58         # name，redis中的name
59         # key， hash对应的key
60         # amount，自增数（浮点数）
61  
62     # 自增name对应的hash中的指定key的值，不存在则创建key=amount
63 hscan(name, cursor=0, match=None, count=None)
64     # 增量式迭代获取，对于数据大的数据非常有用，hscan可以实现分片的获取数据，并非一次性将数据全部获取完，从而放置内存被撑爆
65  
66     # 参数：
67         # name，redis的name
68         # cursor，游标（基于游标分批取获取数据）
69         # match，匹配指定key，默认None 表示所有的key
70         # count，每次分片最少获取个数，默认None表示采用Redis的默认分片个数
71  
72     # 如：
73         # 第一次：cursor1, data1 = r.hscan('xx', cursor=0, match=None, count=None)
74         # 第二次：cursor2, data1 = r.hscan('xx', cursor=cursor1, match=None, count=None)
75         # ...
76         # 直到返回值cursor的值为0时，表示数据已经通过分片获取完毕
77 hscan_iter(name, match=None, count=None)
78     # 利用yield封装hscan创建生成器，实现分批去redis中获取数据
79  
80     # 参数：
81         # match，匹配指定key，默认None 表示所有的key
82         # count，每次分片最少获取个数，默认None表示采用Redis的默认分片个数
83  
84     # 如：
85         # for item in r.hscan_iter('xx'):
86         #     print item        
87