redis一覽

redis一覽

Redis 簡介

Redis 是徹底開源免費的，遵照BSD協議，是一個高性能的key-value數據庫。

Redis 與其餘 key - value 緩存產品有如下三個特色：

• Redis支持數據的持久化，能夠將內存中的數據保存在磁盤中，重啓的時候能夠再次加載進行使用。
• Redis不只僅支持簡單的key-value類型的數據，同時還提供list，set，zset，hash等數據結構的存儲。
• Redis支持數據的備份，即master-slave模式的數據備份。

---

Redis 優點

• 性能極高 – Redis能讀的速度是110000次/s,寫的速度是81000次/s 。
• 豐富的數據類型 – Redis支持二進制案例的 Strings, Lists, Hashes, Sets 及 Ordered Sets 數據類型操做。
• 原子 – Redis的全部操做都是原子性的，意思就是要麼成功執行要麼失敗徹底不執行。單個操做是原子性的。多個操做也支持事務，即原子性，經過MULTI和EXEC指令包起來。
• 豐富的特性 – Redis還支持 publish/subscribe, 通知, key 過時等等特性。

---

一、安裝redis

Redis與其餘key-value存儲有什麼不一樣？

• Redis有着更爲複雜的數據結構而且提供對他們的原子性操做，這是一個不一樣於其餘數據庫的進化路徑。Redis的數據類型都是基於基本數據結構的同時對程序員透明，無需進行額外的抽象。

• Redis運行在內存中可是能夠持久化到磁盤，因此在對不一樣數據集進行高速讀寫時須要權衡內存，由於數據量不能大於硬件內存。在內存數據庫方面的另外一個優勢是，相比在磁盤上相同的複雜的數據結構，在內存中操做起來很是簡單，這樣Redis能夠作不少內部複雜性很強的事情。同時，在磁盤格式方面他們是緊湊的以追加的方式產生的，由於他們並不須要進行隨機訪問。

 

來源： http://www.runoob.com/redis/redis-intro.html

Window 下安裝

下載地址：https://github.com/MSOpenTech/redis/releases。

下載的爲.msc後綴的，只需一頓下一步便可！

目前只是將redis安裝在win環境下的，由於如今的對linux不是很熟悉！

二、Python操做redis

1 pip3 install redis

a、建立鏈接

一、普通鏈接

1 import redis
2 
3 
4 conn = redis.Redis(host='127.0.0.1', port=6379)
5 conn.set('animal', 'cat')
6 val = conn.get('animal')
7 print(val)

二、基於鏈接池

1 import redis
2 
3 POOL = redis.ConnectionPool(host='127.0.0.1', port=6379, max_connections=1000)    # 建立鏈接池
4 conn = redis.Redis(connection_pool=POOL)
5 
6 conn.set("key", "cat")
7 val = conn.get("key")
8 print(val)

b、redis經常使用操做

在涉及到操做以前能夠先來了解下redis支持的數據結構

1. String：字符串
2. Hash：散列（字典）
3. List：列表
4. Set：集合（去重）
5. Sorted Set：有序集合

1 # redis 就至關與內存中的一個字典。（session？？）
2 redis = {
3     k1: 'hello',                                            # String
4     k2: [1, 2, 3, 5, 4, 5, 2],                              # List
5     k3: {1, 2, 3, 4},                                       # Set
6     k4: {name: 'pontoon', age: 19},                         # Dict/Hash
7     k5: {('pontoon': 65), ('god_v': 75), ('dandy': 85)}     # SortedSet
8 }

一、字典的操做

 

 

 1 import redis
 2 
 3 POOL = redis.ConnectionPool(host='127.0.0.1', port=6379, max_connections=1000)
 4 conn = redis.Redis(connection_pool=POOL)
 5 
 6 # conn.set("key", "cat")
 7 # val = conn.get("key")
 8 # print(val)
 9 
10 # 一、hset(name, key, value)    # 設置單個值
11 conn.hset("k1", "animal", "dog")
12 
13 # 二、hget(name,key)            # 取單個值
14 val = conn.hget("k1", "animal")
15 print(val)    # b'dog'  
16 
17 # 三、hmset(name, mapping)      # 設置多個值
18 conn.hmset("k2", {"animal1": "cat", "animal2": "dog"})
19 
20 # 四、hmger(name, keys, *args)  # 取多個值
21 val = conn.hmget("k2", "animal1", "animal2")
22 print(val)    # [b'cat', b'dog']
23 
24 # 五、hgetall(name)             # 獲取name對應的全部值
25 val = conn.hgetall("k2")
26 print(val)    # {b'animal1': b'cat', b'animal2': b'dog'}
27 
28 # 六、hlen(name)                # 獲取個數
29 val = conn.hlen("k2")
30 print(val)    # 2
31 
32 # 七、hkeys(name)               # 獲取key
33 
34 # 八、hvals(name)               # 獲取value
35 
36 # 九、hexists(name, key)        # 判斷是否存在
37 val = conn.hexists("k2", "animal1")
38 print(val)    # True
39 
40 # 十、hdel(name,*keys)         # 刪除指定key中的鍵值對
41 
42 # 十一、hincrby(name, key, amount=1)  # 自增name對應的hash中的指定key的值，不存在則建立key=amount
43 
44 # 十二、hscan(name, cursor=0, match=None, count=None)
45 """
46     增量式迭代獲取，對於數據大的數據很是有用，hscan能夠實現分片的獲取數據，並不是一次性將數據所有獲取完，從而放置內存被撐爆
47     參數：
48         name，redis的name
49         cursor，遊標（基於遊標分批取獲取數據）
50         match，匹配指定key，默認None 表示全部的key
51         count，每次分片最少獲取個數，默認None表示採用Redis的默認分片個數
52      如：
53         第一次：cursor1, data1 = r.hscan('xx', cursor=0, match=None, count=None)
54         第二次：cursor2, data1 = r.hscan('xx', cursor=cursor1, match=None, count=None)
55         ...
56         直到返回值cursor的值爲0時，表示數據已經經過分片獲取完畢
57 """
58 
59 # 1三、hscan_iter(name, match=None, count=None)
60 """
61     利用yield封裝hscan建立生成器，實現分批去redis中獲取數據
62     
63     參數：
64         match，匹配指定key，默認None 表示全部的key
65         count，每次分片最少獲取個數，默認None表示採用Redis的默認分片個數
66     
67      如：
68         for item in r.hscan_iter('xx'):
69             print item
70 """

redis字典的操做

關於第13條的一個補充：

1 # 對於13的補充：
2 假設redis中有name=k4的一個字典，這個字典中有10個G的數據，咱們該如何取值？
3 ret = conn.hscan_iter("k4", count=10000)  # 建立一個生成器對象，每次取1W條數據
4 for i in range(1000):    1000x10000 ≈ 10G
5     for item in ret:
6         print(item)

hscan_iter的源碼

 1   def hscan_iter(self, name, match=None, count=None):
 2         """
 3         Make an iterator using the HSCAN command so that the client doesn't
 4         need to remember the cursor position.
 5 
 6         ``match`` allows for filtering the keys by pattern
 7 
 8         ``count`` allows for hint the minimum number of returns
 9         """
10         # cursor表示遊標 指明瞭count就至關於指明瞭cursor的數量
11         cursor = '0'
12         # 假如count=10000， 那麼下一次迭代cursor='10000'
13         while cursor != 0:
14             cursor, data = self.hscan(name, cursor=cursor, match=match, count=count)
15             for item in data.items():
16                 yield item

二、列表的操做

 

 1 import redis
 2 
 3 
 4 pool = redis.ConnectionPool(host='127.0.0.1', port=6379, max_connections=1000)  # 設置最大鏈接數量爲1000
 5 conn = redis.Redis(connection_pool=pool)  # 鏈接鏈接池
 6 
 7 # 一、lpush(name,values)     # 列表的左側添加數據
 8 
 9 # 二、rpush(name, values)    # 列表的右側添加數據
10 conn.lpush("l1", "v1")
11 conn.lpush("l1", "v2")
12 conn.rpush("l1", "v3")
13 
14 ret = conn.lrange("l1", 0, 100)  # 範圍取值，取前100條數據
15 print(ret)  # [b'v2', b'v1', b'v3']
16 
17 # 三、lpushx(name, value)    # 當name存在時，向列表左側添加數據
18 
19 # 四、rpushx(name, value)    # 當name存在時，向列表右側添加數據  
20 
21 # 五、lpop(name)             # 列表的左側彈出數據
22 
23 # 六、rpop(name)             # 列表的右側彈出數據
24 val = conn.lpop("l1")
25 print(val)  # b'v1'
26 
27 val = conn.rpop("l1")
28 print(val)  # b'v3'
29 
30 
31 # 七、llen(name)             # name對應的list元素的個數
32 
33 # 八、linsert(name, before/after, refvalue, value))    # 在name對應的列表的某一個值前或後插入一個新值
34 conn.linsert("l1", "before", "v2", "v3")  # 在列表內找到第一個元素v2，在它前面插入v3
35 
36 ret = conn.lrange("l1", 0, 100)
37 print(ret)
38 
39 # 九、lset(name, index, value)  # 對list中的某一個索引位置從新賦值
40 conn.lset("l1", 0, "v4")  # 將索引爲0的值從新賦值v4
41 
42 ret = conn.lrange("l1", 0, 100)
43 print(ret)
44 
45 # 十、lrem(name, num, value)  
46 ''' 參數：
47     name:  redis的name   
48     num:   num=0 刪除列表中全部的指定值；
49            num=2 從前到後，刪除2個；
50            num=-2 從後向前，刪除2個
51     value: 要刪除的值       
52 '''
53 # 這裏要注意lrem在最新版本的redis中用法改了，將num與value調換位置了。（難怪我對着網上的博客寫一致會報錯~）
54 
55 # 十一、ltrim(name, start, end)  # 在name對應的列表中移除沒有在start-end索引之間的值
56 conn.ltrim("l1", 0, 0)  # 移除第一個以後的全部值
57 
58 ret = conn.lrange("l1", 0, 100)
59 print(ret)
60 
61 # 十二、rpoplpush(src, dst)  # 從一個列表取出最右邊的元素，同時將其添加至另外一個列表的最左邊
62 """
63 參數：
64     src，要取數據的列表的name
65     st，要添加數據的列表的name
66 """
67 conn.lpush("l2", '11', '22', '33')
68 conn.lpush("l3", '44', '55', '66')
69 conn.rpoplpush("l2", "l3")
70 
71 ret = conn.lrange("l3", 0, 100)
72 print(ret)
73 
74 # redis都是玩的一些什麼操做啊？花裏胡哨~還有一部分反向操做的就不列出來了。要吐血了

redis列表的操做

 三、集合的操做 

 

 1 # 一、sadd(name,values)      # ame對應的集合中添加元素
 2 
 3 # 二、smembers(name)         # 獲取name對應的集合的全部成員
 4 pool = redis.ConnectionPool(host='127.0.0.1', port=6379, max_connections=1000)  # 設置最大鏈接數量爲1000
 5 conn = redis.Redis(connection_pool=pool)  # 鏈接鏈接池
 6 
 7 conn.sadd("s1", "v1")
 8 conn.sadd("s1", "v1", "v2", "v3", "v4", "v5")
 9 
10 print(conn.smembers("s1"))
11 >>>{b'v4', b'v5', b'v2', b'v1', b'v3'}    # 獲得一個無序集合
12 
13 三、scard(name)              # 獲取name對應的集合中的元素個數
14 
15 四、sdiff(keys, *args)       # 在第一個name對應的集合中且不在其餘name對應的集合的元素集合(差集)
16 conn.sadd("s2", "aa", "bb")
17 conn.sadd("s3", "bb", "cc")
18 conn.sadd("s4", "bb", "cc", "dd")
19 
20 print(conn.sdiff("s2", "s3", "s4"))  
21 >>>{b'aa'}
22 
23 五、sinter(keys, *args)      # 獲取多個name對應集合的交集
24 conn.sadd("s2", "aa", "bb")
25 conn.sadd("s3", "bb", "cc")
26 conn.sadd("s4", "bb", "cc", "dd")
27 
28 print(conn.sinter("s2", "s3", "s4"))
29 >>>{b'bb'}
30 
31 六、sinterstore(dest, keys, *args)  # 獲取兩個name對應集合的交集，並將結果存入第三個集合中
32 conn.sadd("s3", "bb", "cc")
33 conn.sadd("s4", "bb", "cc", "dd")
34 
35 print(conn.sinterstore("s2", "s3", "s4")）  # s2爲一個空的store存儲s3,s4的交集，返回數字
36 print(conn.smembers("s2"))  # 返回集合中的值
37 
38 七、sunion(keys, *args)      # 並集，獲取多個name對應的集合的並集
39 
40 8、smove(src, dst, value)
41 conn.smove("s2", "s3", 'aa')
42 print(conn.smembers("s3"))
43 >>>{b'cc', b'aa', b'bb'}
44 
45 九、sismember(name, value)   # 判斷是不是集合的成員 相似in
46 
47 十、spop(name)              # 刪除--隨機刪除而且返回被刪除值
48 
49 十一、srem(name, values)      # 刪除--指定值刪除  
50 
51 # 集合的操做相對最簡單。      

View Code

3.一、有序集合的操做

 1 # 注意個人redis版本爲3.2.1，python在操做有序集合中的部分源碼已經改了，網上的一些博客抄來抄去，本身也不動手實踐下，錯的地方都同樣。
 2 
 3 一、zadd(name, mapping, nx=False, xx=False, ch=False, incr=False)  # zadd的源碼改了，網上大部分的博客都是舊的。因此輸出的時候會報錯
 4 pool = redis.ConnectionPool(host='127.0.0.1', port=6379, max_connections=1000)  # 設置最大鏈接數量爲1000
 5 conn = redis.Redis(connection_pool=pool)  # 鏈接鏈接池
 6 
 7 conn.zadd("z1", {"v11": 1, "v2": 2})
 8 print(conn.zrange("z1", 0, -1))   # 獲取有序集合中全部元素
 9 >>>[b'v11', b'v2']  # 返回一個列表
10 
11 二、zcard(name)                  # 獲取name對應的有序集合元素的數量
12 print(conn.zcard("z1"))
13 >>>2
14 
15 三、zcount(name, min, max)       # 獲取name對應的有序集合中分數 在 [min,max] 之間的個數 
16 
17 四、zrange( name, start, end, desc=False, withscores=False, score_cast_func=float)  # 按照索引範圍獲取name對應的有序集合的元素
18 """
19 參數:
20     name，redis的name
21     start，有序集合索引發始位置（非分數）    # 注意是索引
22     end，有序集合索引結束位置（非分數）
23     desc，排序規則，默認按照分數從小到大排序
24     withscores，是否獲取元素的分數，默認只獲取元素的值
25     score_cast_func，對分數進行數據轉換的函數
26 """
27 
28 4.一、zrevrange(name, start, end, withscores=False, score_cast_func=float)  # 從大到小排序(同zrange，集合是從大到小排序的)
29 4.二、zrangebyscore(name, min, max, start=None, num=None, withscores=False, score_cast_func=float)  # 按照分數範圍獲取name對應的有序集合的元素
30 4.三、zrevrangebyscore(name, max, min, start=None, num=None, withscores=False, score_cast_func=float)  # 按照分數範圍獲取有序集合的元素並排序（默認從大到小排序）
31 
32 五、zscan(name, cursor=0, match=None, count=None, score_cast_func=float)  # 獲取全部元素--默認按照分數順序排序
33 print(conn.zscan("z1"))
34 >>>(0, [(b'n1', 1.0), (b'v11', 1.0), (b'v2', 2.0)])
35 
36 5.一、zscan_iter(name, match=None, count=None,score_cast_func=float)  # 獲取全部元素--迭代器（這個很是有用）
37 print(conn.zscan_iter("z1"))
38 for i in conn.zscan_iter("z1"):
39     print(i)
40 
41 >>><generator object Redis.zscan_iter at 0x00000010F26047D8>
42 (b'n1', 1.0)
43 (b'v11', 1.0)
44 (b'v2', 2.0)
45 
46 六、zrem(name, values)  # 刪除--指定值刪除
47 
48 七、zremrangebyrank(name, min, max)  # 刪除--根據排行範圍刪除，按照索引號來刪除
49 
50 八、zscore(name, value)  # 獲取值對應的分數

redis有序集合的操做

四、一些相關的補充