Redis初識01 (簡介、安裝、使用)

一、Reids介紹 redis是一個key-value存儲系統。和Memcached類似，它支持存儲的value類型相對更多，包括string(字元串)、list(鏈表)、set(集合)、zset(sorted set --有序集合)和hash（哈希類型）。這些數據類型都支持push/pop、add ...

一、Reids介紹

　　redis是一個key-value存儲系統。和Memcached類似，它支持存儲的value類型相對更多，包括string(字元串)、list(鏈表)、set(集合)、zset(sorted set --有序集合)和hash（哈希類型）。這些數據類型都支持push/pop、add/remove及取交集並集和差集及更豐富的操作，而且這些操作都是原子性的。在此基礎上，redis支持各種不同方式的排序。與memcached一樣，為了保證效率，數據都是緩存在記憶體中。區別的是redis會周期性的把更新的數據寫入磁碟或者把修改操作寫入追加的記錄文件，並且在此基礎上實現了master-slave(主從)同步

1. 使用Redis有哪些好處？

(1) 速度快，因為數據存在記憶體中，類似於HashMap，HashMap的優勢就是查找和操作的時間複雜度都是O(1)

(2) 支持豐富數據類型，支持string，list，set，sorted，hash

5大數據類型
　　k1:'123', 字元串
　　k2:[1,2,3,4], 列表/數組
　　k3:{1,2,3,4} 集合：去重，爬蟲去重
　　k4:{name:lqz,age:12} 字典/哈希表
　　k5:{('lqz',18),('egon',33)} 有序集合：游戲排行榜

(3) 支持事務，操作都是原子性，所謂的原子性就是對數據的更改要麼全部執行，要麼全部不執行

(4) 豐富的特性：可用於緩存，消息，按key設置過期時間，過期後將會自動刪除

2. redis相比memcached有哪些優勢？

(1) memcached所有的值均是簡單的字元串，redis作為其替代者，支持更為豐富的數據類型

(2) redis的速度比memcached快很多

(3) redis可以持久化其數據

3. Memcache與Redis的區別都有哪些？

(1) 、存儲方式

Memecache把數據全部存在記憶體之中，斷電後會掛掉，數據不能超過記憶體大小。

Redis有部份存在硬碟上，這樣能保證數據的持久性。

(2) 、數據支持類型

Memcache對數據類型支持相對簡單。

Redis有複雜的數據類型。

(3) ，value大小

redis最大可以達到1GB，而memcache只有1MB

其它：

(1) Master最好不要做任何持久化工作，如RDB記憶體快照和AOF日誌文件

(2) 如果數據比較重要，某個Slave開啟AOF備份數據，策略設置為每秒同步一次

(3) 為了主從複製的速度和連接的穩定性，Master和Slave最好在同一個區域網內

(4) 儘量避免在壓力很大的主庫上增加從庫

(5) 主從複製不要用圖狀結構，用單向鏈表結構更為穩定，即：Master <- Slave1 <- Slave2 <- Slave3...

這樣的結構方便解決單點故障問題，實現Slave對Master的替換。如果Master掛了，可以立刻啟用Slave1做Master，其他不變。

4. redis常見性能問題和解決方案：

1).Master寫記憶體快照，save命令調度rdbSave函數，會阻塞主線程的工作，當快照比較大時對性能影響是非常大的，會間斷性暫停服務，所以Master最好不要寫記憶體快照。


2).Master AOF持久化，如果不重寫AOF文件，這個持久化方式對性能的影響是最小的，但是AOF文件會不斷增大，AOF文件過大會影響Master重啟的恢復速度。Master最好不要做任何持久化工作，包括記憶體快照和AOF日誌文件，特別是不要啟用記憶體快照做持久化,如果數據比較關鍵，某個Slave開啟AOF備份數據，策略為每秒同步一次。

 
3).Master調用BGREWRITEAOF重寫AOF文件，AOF在重寫的時候會占大量的CPU和記憶體資源，導致服務load過高，出現短暫服務暫停現象。

4). Redis主從複製的性能問題，為了主從複製的速度和連接的穩定性，Slave和Master最好在同一個區域網內

5. Redis 常見的性能問題都有哪些？如何解決？

Redis最適合所有數據in-momory的場景，雖然Redis也提供持久化功能，但實際更多的是一個disk-backed的功能，跟傳統意義上的持久化有比較大的差別，那麼可能大家就會有疑問，似乎Redis更像一個加強版的Memcached，那麼何時使用Memcached,何時使用Redis呢?

       如果簡單地比較Redis與Memcached的區別，大多數都會得到以下觀點：

     1 、Redis不僅僅支持簡單的k/v類型的數據，同時還提供list，set，zset，hash等數據結構的存儲。
     2 、Redis支持數據的備份，即master-slave模式的數據備份。
     3 、Redis支持數據的持久化，可以將記憶體中的數據保持在磁碟中，重啟的時候可以再次載入進行使用。

（1）、會話緩存（Session Cache）

最常用的一種使用Redis的情景是會話緩存（session cache）。用Redis緩存會話比其他存儲（如Memcached）的優勢在於：Redis提供持久化。當維護一個不是嚴格要求一致性的緩存時，如果用戶的購物車信息全部丟失，大部分人都會不高興的，現在，他們還會這樣嗎？

幸運的是，隨著 Redis 這些年的改進，很容易找到怎麼恰當的使用Redis來緩存會話的文檔。甚至廣為人知的商業平臺Magento也提供Redis的插件。

（2）、全頁緩存（FPC）

除基本的會話token之外，Redis還提供很簡便的FPC平臺。回到一致性問題，即使重啟了Redis實例，因為有磁碟的持久化，用戶也不會看到頁面載入速度的下降，這是一個極大改進，類似PHP本地FPC。

再次以Magento為例，Magento提供一個插件來使用Redis作為全頁緩存後端。

此外，對WordPress的用戶來說，Pantheon有一個非常好的插件  wp-redis，這個插件能幫助你以最快速度載入你曾瀏覽過的頁面。

（3）、隊列

Reids在記憶體存儲引擎領域的一大優點是提供 list 和 set 操作，這使得Redis能作為一個很好的消息隊列平臺來使用。Redis作為隊列使用的操作，就類似於本地程式語言（如Python）對 list 的 push/pop 操作。

如果你快速的在Google中搜索“Redis queues”，你馬上就能找到大量的開源項目，這些項目的目的就是利用Redis創建非常好的後端工具，以滿足各種隊列需求。例如，Celery有一個後臺就是使用Redis作為broker，你可以從這裡去查看。

（4），排行榜/計數器

Redis在記憶體中對數字進行遞增或遞減的操作實現的非常好。集合（Set）和有序集合（Sorted Set）也使得我們在執行這些操作的時候變的非常簡單，Redis只是正好提供了這兩種數據結構。所以，我們要從排序集合中獲取到排名最靠前的10個用戶–我們稱之為“user_scores”，我們只需要像下麵一樣執行即可：

當然，這是假定你是根據你用戶的分數做遞增的排序。如果你想返回用戶及用戶的分數，你需要這樣執行：

ZRANGE user_scores 0 10 WITHSCORES

Agora Games就是一個很好的例子，用Ruby實現的，它的排行榜就是使用Redis來存儲數據的，你可以在這裡看到。

（5）、發佈/訂閱

最後（但肯定不是最不重要的）是Redis的發佈/訂閱功能。發佈/訂閱的使用場景確實非常多。我已看見人們在社交網路連接中使用，還可作為基於發佈/訂閱的腳本觸發器，甚至用Redis的發佈/訂閱功能來建立聊天系統！（不，這是真的，你可以去核實）。

Redis提供的所有特性中，我感覺這個是喜歡的人最少的一個，雖然它為用戶提供如果此多功能。

6. redis 最適合的場景

 相關知識：redis 記憶體數據集大小上升到一定大小的時候，就會施行數據淘汰策略。redis 提供 6種數據淘汰策略：

voltile-lru：從已設置過期時間的數據集（server.db[i].expires）中挑選最近最少使用的數據淘汰

volatile-ttl：從已設置過期時間的數據集（server.db[i].expires）中挑選將要過期的數據淘汰

volatile-random：從已設置過期時間的數據集（server.db[i].expires）中任意選擇數據淘汰

allkeys-lru：從數據集（server.db[i].dict）中挑選最近最少使用的數據淘汰

allkeys-random：從數據集（server.db[i].dict）中任意選擇數據淘汰

no-enviction（驅逐）：禁止驅逐數據

7. MySQL里有2000w數據，redis中只存20w的數據，如何保證redis中的數據都是熱點數據

支持的數據類型（5大數據類型）：string、list、 set、 zset、 hash

redis={
        k1:'123',       字元串
        k2:[1,2,3,4],   列表/數組
        k3:{1,2,3,4}    集合
        k4:{name:lqz,age:12}         字典/哈希表
        k5:{('lqz',18),('egon',33)}  有序集合
}

特點：

可以持久化

單線程，單進程

二、Redis安裝和使用

Windows下安裝

①下載安裝包：

獲取安裝包。Windows的Redis安裝包需要到以下GitHub鏈接找到。鏈接：https://github.com/MSOpenTech/redis。打開網站後，找到Release，點擊前往下載頁面。

②安裝

一路點擊下一步，該預設就預設不變就ok。

安裝完畢後，需要先做一些設定工作，以便服務啟動後能正常運行。使用文本編輯器，這裡使用Notepad++，打開Redis服務配置文件。註意：不要找錯了，通常為redis.windows-service.conf，而不是redis.windows.conf。後者是以非系統服務方式啟動程式使用的配置文件。

找到含有requirepass字樣的地方，追加一行，輸入requirepass 12345。這是訪問Redis時所需的密碼，一般測試情況下可以不用設定密碼。不過，即使是作為本地訪問，也建議設定一個密碼。此處以簡單的12345來演示。(記住要保存一下)

點擊“開始”>右擊“電腦”>選擇“管理”。在左側欄中依次找到並點擊“電腦管理（本地）”>服務和應用程式>服務。再在右側找到Redis名稱的服務，查看啟動情況。如未啟動，則手動啟動之。正常情況下，服務應該正常啟動並運行了。

最後來測試一下Redis是否正常提供服務。進入Redis的目錄，cd C:\Program Files\Redis。輸入redis-cli並回車。（redis-cli是客戶端程式）如圖正常提示進入，並顯示正確埠號，則表示服務已經啟動。

使用服務前需要先通過密碼驗證。輸入“auth 12345”並回車（12345是之前設定的密碼）。返回提示OK表示驗證通過。

實際測試一下讀寫。輸入set k1 "Hello World!”並回車，用來保存一個鍵值。再輸入get k1，獲取剛纔保存的鍵值。

Redis的安裝和簡單使用測試完成，可以看出，它的原生操作是在cmd命令行操作的，應該會有圖形化操作界面工具可使用：

RedisDesktopManager

它是Redis可視化工具

可以自行下載，附分享下載地址：(安裝和使用略過)

 鏈接: https://pan.baidu.com/s/1uuCubuYkapJKeUNFbrvekA 提取碼: 6gpk

下載地址

linux下安裝

wget http://download.redis.io/releases/redis-3.0.6.tar.gz
tar xzf redis-3.0.6.tar.gz
cd redis-3.0.6
make

# 啟動服務端
src/redis-server

# 啟動客戶端
src/redis-cli
redis> set foo bar
OK
redis> get foo
"bar"

三、Pycharm下操作Redis

 安裝：pip3 install redis

使用Redis連接池：

string操作

String操作，redis中的String在在記憶體中按照一個name對應一個value來存儲

set(name, value, ex=None, px=None, nx=False, xx=False)

在Redis中設置值，預設，不存在則創建，存在則修改
參數：
     ex，過期時間（秒）
     px，過期時間（毫秒）
     nx，如果設置為True，則只有name不存在時，當前set操作才執行,值存在，就修改不了，執行沒效果
     xx，如果設置為True，則只有name存在時，當前set操作才執行，值存在才能修改，值不存在，不會設置新值

get(name)

獲取key值對應的value值
如果取不到返回None

setnx(name, value)

設置值，只有name不存在時，執行設置操作（添加）,如果存在，不會修改

setex(name, time, value)

# 設置值
# 參數：
    # time，過期時間（數字秒 或 timedelta對象）

psetex(name, time_ms, value) 過期時間單位為毫秒

# 設置值
# 參數：
    # time_ms，過期時間（數字毫秒 或 timedelta對象

mset(*args, **kwargs)和mget(keys, *args)

批量設置值
如：mget({'k1': 'v1', 'k2': 'v2'})

批量獲取
如：
    mget('k1', 'k2')
    或
    r.mget(['k3', 'k4'])

getset(name, value)

設置新值並獲取老值

getrange(key, start, end)

# 獲取子序列（根據位元組獲取，非字元）
# 參數：
    # name，Redis 的 key
    # start，起始位置（位元組）
    # end，結束位置（位元組）
    # 前閉後閉
# 如： "王大錘" ，0-2表示 "王"

setrange(name, offset, value)

# 修改字元串內容，從指定字元串索引開始向後替換(替換的字元如果太長則擴張)
# 參數
    # offset，字元串的索引，位元組（一個漢字三個位元組）
    # value，要設置的值

strlen(name)

# 返回key值對應的位元組長度(一個漢字占3個位元組)

incr(name, amount=1)

# 自增 name對應的值，當name不存在時，則創建name＝amount，否則，則自增。
 
# 參數：
    # name,Redis的name
    # amount,自增數（必須是整數），為負數就是自減
 
# 註：同incrby

incrbyfloat(name, amount=1.0)

# 自增 name對應的值，當name不存在時，則創建name＝amount，否則，則自增。
 
# 參數：
    # name,Redis的name
    # amount,自增數（浮點型）

decr(self, name, amount=1)

# 自減 name對應的值，當name不存在時，則創建name＝amount（取負數），否則，則自減。
 
# 參數：
    # name,Redis的name
    # amount,自減數（整數），可以是負數，如果是負數則變成自增性質

append(key, value)

# 在redis name對應的值後面追加內容
 
# 參數：
    key, redis的name
    value, 要追加的字元串

其它不常用的：

setbit(name, offset, value)

# 對name對應值的二進位表示的位進行操作
 
# 參數：
    # name，redis的name
    # offset，位的索引（將值變換成二進位後再進行索引）
    # value，值只能是 1 或 0
 
# 註：如果在Redis中有一個對應： n1 = "foo"，
        那麼字元串foo的二進位表示為：01100110 01101111 01101111
    所以，如果執行 setbit('n1', 7, 1)，則就會將第7位設置為1，
        那麼最終二進位則變成 01100111 01101111 01101111，即："goo"

getbit(name, offset)

# 獲取name對應的值的二進位表示中的某位的值 （0或1）

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

# 獲取name對應的值的二進位表示中 1 的個數
# 參數：
    # key，Redis的name
    # start，位起始位置
    # end，位結束位置

bitop(operation, dest, *keys)

# 獲取多個值，並將值做位運算，將最後的結果保存至新的name對應的值
 
# 參數：
    # operation,AND（並） 、 OR（或） 、 NOT（非） 、 XOR（異或）
    # dest, 新的Redis的name
    # *keys,要查找的Redis的name
 
# 如：
    bitop("AND", 'new_name', 'n1', 'n2', 'n3')
    # 獲取Redis中n1,n2,n3對應的值，然後講所有的值做位運算（求並集），然後將結果保存 new_name 對應的值中

Hash操作

Hash操作，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時則創建（相當於添加）

hget(name,key)

# 在name對應的hash中獲取根據key獲取value

hmset(name, mapping)

# 在name對應的hash中批量設置鍵值對
 
# 參數：
    # name，redis的name
    # mapping，字典，如：{'k1':'v1', 'k2': 'v2'}
 
# 如：
    # r.hmset('xx', {'k1':'v1', 'k2': 'v2'})

**hmget(name, keys, *args)**

# 在name對應的hash中獲取多個key的值，返回的是列表
 
# 參數：
    # name，reids對應的name
    # keys，要獲取key集合，如：['k1', 'k2', 'k3']
    # *args，要獲取的key，如：k1,k2,k3
 
# 如：
    # r.mget('xx', ['k1', 'k2'])
    # 或
    # print r.hmget('xx', 'k1', 'k2')

hgetall(name)

# 獲取name對應hash的所有鍵值，返回一個鍵值對的字典，如果取不到返回{}空字典

hlen(name)

# 獲取name對應的hash中鍵值對的個數

hkeys(name)

# 獲取name對應的hash中所有的key的值，返回一個列表

hvals(name)

# 獲取name對應的hash中所有的value的值，返回一個列表

hexists(name, key)

# 檢查name對應的hash是否存在當前傳入的key，返回True和False

**hdel(name,*keys)**

# 將name對應的hash中指定key的鍵值對刪除，返回1或0

hincrby(name, key, amount=1)

# 自增name對應的hash中的指定key的值，不存在則創建key=amount
# 參數：
    # name，redis中的name
    # key， hash對應的key
    # amount，自增數（整數）

hincrbyfloat(name, key, amount=1.0)

# 自增name對應的hash中的指定key的值，不存在則創建key=amount
 
# 參數：
    # name，redis中的name
    # key， hash對應的key
    # amount，自增數（浮點數）
 
# 自增name對應的hash中的指定key的值，不存在則創建key=amount

hscan(name, cursor=0, match=None, count=None)

# 增量式迭代獲取，對於數據大的數據非常有用，hscan可以實現分片的獲取數據，並非一次性將數據全部獲取完，從而放置記憶體被撐爆
 
# 參數：
    # name，redis的name
    # cursor，游標（基於游標分批取獲取數據）
    # match，匹配指定key，預設None 表示所有的key
    # count，每次分片最少獲取個數，預設None表示採用Redis的預設分片個數
 
# 如：
    # 第一次：cursor1, data1 = r.hscan('xx', cursor=0, match=None, count=None)
    # 第二次：cursor2, data1 = r.hscan('xx', cursor=cursor1, match=None, count=None)
    # ...
    # 直到返回值cursor的值為0時，表示數據已經通過分片獲取完畢

hscan是每次取出一定量的數據，然後可以根據獲取的游標繼續再獲取剩餘的。

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

# 利用yield封裝hscan創建生成器，實現分批去redis中獲取數據
 
# 參數：
    # match，匹配指定key，預設None 表示所有的key
    # count，每次分片最少獲取個數，預設None表示採用Redis的預設分片個數
 
# 如：
    # for item in r.hscan_iter('xx'):
    #     print item

count參數是控制一次從Redis中取出的值的個數，比如count=10，是一次取10個，迭代完了再去Redis中取，如果count不傳值，就會全部取出來

list操作

List操作，redis中的List在在記憶體中按照一個name對應一個List來存儲。如圖：

lpush(name,values)

# 在name對應的list中添加元素，每個新的元素都添加到列表的最左邊
 
# 如：
    # r.lpush('oo', 11,22,33)
    # 保存順序為: 33,22,11
 
# 擴展：
    # rpush(name, values) 表示從右向左操作

lpushx(name,value)

# 在name對應的list中添加元素，只有name已經存在時，值添加到列表的最左邊，否則不做任何操作
 
# 更多：
    # rpushx(name, value) 表示從右向左操作

llen(name)

# name對應的list元素的個數

linsert(name, where, refvalue, value))

# 在name對應的列表的某一個值前或後插入一個新值
 
# 參數：
    # name，redis的name
    # where，BEFORE或AFTER(小寫也可以)
    # refvalue，標桿值，即：在它前後插入數據（如果存在多個標桿值，以找到的第一個為準）
    # value，要插入的數據

r.lset(name, index, value)

# 對name對應的list中的某一個索引位置重新賦值
 
# 參數：
    # name，redis的name
    # index，list的索引位置
    # value，要設置的值

r.lrem(name, value, num)

# 在name對應的list中刪除指定的值
 
# 參數：
    # name，redis的name
    # value，要刪除的值
    # num，  num=0，刪除列表中所有的指定值；
           # num=2,從前到後，刪除2個；
           # num=-2,從後向前，刪除2個

lpop(name)

# 在name對應的列表的左側獲取第一個元素併在列表中移除，返回值則是第一個元素
 
# 更多：
    # rpop(name) 表示從右向左操作

lindex(name, index)

在name對應的列表中根據索引獲取列表元素

lrange(name, start, end)

# 在name對應的列表分片獲取數據
# 參數：
    # name，redis的name
    # start，索引的起始位置
    # end，索引結束位置  print(re.lrange('aa',0,re.llen('aa')))

blpop(keys, timeout)

# 將多個列表排列，按照從左到右去pop對應列表的元素
 
# 參數：
    # keys，redis的name的集合
    # timeout，超時時間，當元素所有列表的元素獲取完之後，阻塞等待列表內有數據的時間（秒）, 0 表示永遠阻塞
 
# 更多：
    # r.brpop(keys, timeout)，從右向左獲取數據
爬蟲實現簡單分散式：多個url放到列表裡，往裡不停放URL，程式迴圈取值，但是只能一臺機器運行取值，可以把url放到redis中，多台機器從redis中取值，爬取數據，實現簡單分散式

brpoplpush(src, dst, timeout=0)

# 從一個列表的右側移除一個元素並將其添加到另一個列表的左側
 
# 參數：
    # src，取出並要移除元素的列表對應的name
    # dst，要插入元素的列表對應的name
    # timeout，當src對應的列表中沒有數據時，阻塞等待其有數據的超時時間（秒），0 表示永遠阻塞

自定義增量迭代

# 由於redis類庫中沒有提供對列表元素的增量迭代，如果想要迴圈name對應的列表的所有元素，那麼就需要：
    # 1、獲取name對應的所有列表
    # 2、迴圈列表
# 但是，如果列表非常大，那麼就有可能在第一步時就將程式的內容撐爆，所有有必要自定義一個增量迭代的功能：
import redis
conn=redis.Redis(host='127.0.0.1',port=6379)
# conn.lpush('test',*[1,2,3,4,45,5,6,7,7,8,43,5,6,768,89,9,65,4,23,54,6757,8,68])
# conn.flushall()
def scan_list(name,count=2):
    index=0
    while True:
        data_list=conn.lrange(name,index,count+index-1)
        if not data_list:
            return
        index+=count
        for item in data_list:
            yield item
print(conn.lrange('test',0,100))
for item in scan_list('test',5):
    print('---')
    print(item)

set操作

待編輯...

Set操作，Set集合就是不允許重覆的列表

sadd(name,values)

# name對應的集合中添加元素

scard(name)

獲取name對應的集合中元素個數

sdiff(keys, *args)

在第一個name對應的集合中且不在其他name對應的集合的元素集合

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對應的集合中刪除某些值

srem(name, values)

# 在name對應的集合中刪除某些值

sunion(keys, *args)

# 獲取多一個name對應的集合的並集

sunionstore(dest,keys, *args)

# 獲取多一個name對應的集合的並集，並將結果保存到dest對應的集合中

sscan(name, cursor=0, match=None, count=None)
sscan_iter(name, match=None, count=None)

# 同字元串的操作，用於增量迭代分批獲取元素，避免記憶體消耗太大

有序集合，在集合的基礎上，為每元素排序；元素的排序需要根據另外一個值來進行比較，所以，對於有序集合，每一個元素有兩個值，即：值和分數，分數專門用來做排序。

zadd(name, *args, **kwargs)

# 在name對應的有序集合中添加元素
# 如：
     # zadd('zz', 'n1', 1, 'n2', 2)
     # 或
     # zadd('zz', n1=11, n2=22)

zcard(name)

# 獲取name對應的有序集合元素的數量

zcount(name, min, max)

# 獲取name對應的有序集合中分數 在 [min,max] 之間的個數

zincrby(name, value, amount)

# 自增name對應的有序集合的 name 對應的分數

r.zrange( name, start, end, desc=False, withscores=False, score_cast_func=float)

# 按照索引範圍獲取name對應的有序集合的元素
 
# 參數：
    # name，redis的name
    # start，有序集合索引起始位置（非分數）
    # end，有序集合索引結束位置（非分數）
    # desc，排序規則，預設按照分數從小到大排序
    # withscores，是否獲取元素的分數，預設只獲取元素的值
    # score_cast_func，對分數進行數據轉換的函數
 
# 更多：
    # 從大到小排序
    # zrevrange(name, start, end, withscores=False, score_cast_func=float)
 
    # 按照分數範圍獲取name對應的有序集合的元素
    # zrangebyscore(name, min, max, start=None, num=None, withscores=False, score_cast_func=float)
    # 從大到小排序
    # zrevrangebyscore(name, max, min, start=None, num=None, withscores=False, score_cast_func=float)

zrank(name, value)

# 獲取某個值在 name對應的有序集合中的排行（從 0 開始）
 
# 更多：
    # zrevrank(name, value)，從大到小排序

zrangebylex(name, min, max, start=None, num=None)

# 當有序集合的所有成員都具有相同的分值時，有序集合的元素會根據成員的 值 （lexicographical ordering）來進行排序，而這個命令則可以返回給定的有序集合鍵 key 中， 元素的值介於 min 和 max 之間的成員
# 對集合中的每個成員進行逐個位元組的對比（byte-by-byte compare）， 並按照從低到高的順序， 返回排序後的集合成員。 如果兩個字元串有一部分內容是相同的話， 那麼命令會認為較長的字元串比較短的字元串要大
 
# 參數：
    # name，redis的name
    # min，左區間（值）。 + 表示正無限； - 表示負無限； ( 表示開區間； [ 則表示閉區間
    # min，右區間（值）
    # start，對結果進行分片處理，索引位置
    # num，對結果進行分片處理，索引後面的num個元素
 
# 如：
    # ZADD myzset 0 aa 0 ba 0 ca 0 da 0 ea 0 fa 0 ga
    # r.zrangebylex('myzset', "-", "[ca") 結果為：['aa', 'ba', 'ca']
 
# 更多：
    # 從大到小排序
    # zrevrangebylex(name, max, min, start=None, num=None)

zrem(name, values)

# 刪除name對應的有序集合中值是values的成員
 
# 如：zrem('zz', ['s1', 's2'])

zremrangebyrank(name, min, max)

# 根據排行範圍刪除

zremrangebyscore(name, min, max)

# 根據分數範圍刪除

zremrangebylex(name, min, max)

# 根據值返回刪除

zscore(name, value)

# 獲取name對應有序集合中 value 對應的分數

zinterstore(dest, keys, aggregate=None)

# 獲取兩個有序集合的交集，如果遇到相同值不同分數，則按照aggregate進行操作
# aggregate的值為:  SUM  MIN  MAX

zunionstore(dest, keys, aggregate=None)

# 獲取兩個有序集合的並集，如果遇到相同值不同分數，則按照aggregate進行操作
# aggregate的值為:  SUM  MIN  MAX

zscan(name, cursor=0, match=None, count=None, score_cast_func=float)
zscan_iter(name, match=None, count=None,score_cast_func=float)

# 同字元串相似，相較於字元串新增score_cast_func，用來對分數進行操作

其它常見的操作

delete(*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下

randomkey()

# 隨機獲取一個redis的name（不刪除）

type(name)

# 獲取name對應值的類型

四、管道

redis-py預設在執行每次請求都會創建（連接池申請連接）和斷開（歸還連接池）一次連接操作，如果想要在一次請求中指定多個命令，則可以使用pipline實現一次請求指定多個命令，並且預設情況下一次pipline 是原子性操作。

import redis
 
pool = redis.ConnectionPool(host='10.211.55.4', port=6379)
 
r = redis.Redis(connection_pool=pool)
 
# pipe = r.pipeline(transaction=False)
pipe = r.pipeline(transaction=True)
pipe.multi()
pipe.set('name', 'alex')
pipe.set('role', 'sb')
 
pipe.execute()

五、Django中的Redis

方式一：

utils文件夾下，建立redis_pool.py

import redis
POOL = redis.ConnectionPool(host='127.0.0.1', port=6379,password='1234',max_connections=1000)

視圖函數中使用：

import redis
from django.shortcuts import render,HttpResponse
from utils.redis_pool import POOL

def index(request):
    conn = redis.Redis(connection_pool=POOL)
    conn.hset('kkk','age',18)

    return HttpResponse('設置成功')
def order(request):
    conn = redis.Redis(connection_pool=POOL)
    conn.hget('kkk','age')

    return HttpResponse('獲取成功')

方式二：

安裝django-redis模塊

pip3 install django-redis

setting里配置：

# redis配置
CACHES = {
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": "redis://127.0.0.1:6379",
        "OPTIONS": {
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
            "CONNECTION_POOL_KWARGS": {"max_connections": 100}
            # "PASSWORD": "123",
        }
    }
}

視圖函數：

from django_redis import get_redis_connection
conn = get_redis_connection('default')
print(conn.hgetall('xxx'))