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         # 一、獲取name對應的全部列表
 97         # 二、循環列表
 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