Redis

Redis

官網：點擊

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

1、Redis特色：

• Redis支持數據的持久化，能夠將內存中的數據保存在磁盤中，重啓的時候能夠再次加載進行使用。
• Redis支持五種數據類型。
• Redis支持數據庫備份。

2、Redis優點：

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

3、Redis配置：

• 能夠經過redis-cli 進入交互模式，使用config命令查看或設置配置項。也能夠進入配置文件用vim編輯器進行修改。

#一、命令行連接
redis-cli

redis-cli -h host -p port -a password

#二、基本操做
默認有16個數據庫，編號從0-15
select 1 #切換到1號庫

keys *  #查看全部的key
keys n* #查看全部n開頭的key

flushdb #清空redis

set key value #添加key=value

randomkey #隨機取出一個key

type key  #查看key的類型

命令行基本操做

# 獲取全部配置項
reids 127.0.0.1:6379> config get *
# 獲取單個配置項
redis 127.0.0.1:6379> config get loglevel
# 編輯配置
redis 127.0.0.1:6379> config set loglevel "notice"

View Code

4、Redis數據類型：

1. String 字符串: redis的string能夠包含任何數據，包括圖片以及序列化的對象，一個鍵最大能存儲512MB。
2. Hash 哈希: redis的hash是一個String類型的key和value的映射表，hash特別適合存儲對象，類比python字典。
3. List 列表: redis的list是簡單的字符串列表，按照插入順序排序，能夠從兩端進行添加，相似於雙向鏈表，列表還能夠進行阻塞。
4. Set 集合: redis的set是字符串類型的無序且不重複集合。集合是經過哈希表實現的，因此添加，刪除，查找的時間複雜度都是O(1)。
5. Zset 有序集合: redis的zset和set同樣，不一樣的是每一個元素都會關聯一個double類型的分數，redis正是經過對分數的排序對集合進行有序存儲。

5、Redis的基本命令

#一、set(name, value, ex=None, px=None, nx=False, xx=False)
在Redis中設置值，默認，不存在則建立，存在則修改
參數：
    ex，過時時間（秒）
    px，過時時間（毫秒）
    nx，若是設置爲True，則只有name不存在時，當前set操做才執行
    xx，若是設置爲True，則只有name存在時，崗前set操做才執行


#二、setnx(name, value)
設置值，只有name不存在時，執行設置操做（添加）


#三、setex(name, value, time)
設置值
參數：
    time，過時時間（數字秒 或 timedelta對象）
     
     
#四、psetex(name, time_ms, value)
設置值
參數：
    time_ms，過時時間（數字毫秒 或 timedelta對象）

      
#五、mset(*args, **kwargs)
批量設置值
如：
    mset(k1='v1', k2='v2')
    或
    mset({'k1': 'v1', 'k2': 'v2'})

    
#六、get(name)
獲取值


#七、mget(keys, *args)
批量獲取
如：
    mget('k1', 'k2')
    或
    r.mget(['k1', 'k2'])
    

#八、getset(name, value)
設置新值並獲取原來的值


#九、getrange(key, start, end)
獲取子序列（根據字節獲取，非字符）
參數：
    name，Redis 的 name
    start，起始位置（字節）
    end，結束位置（字節）
    如： "林海峯" ，0-2表示 "林"


#十、setrange(name, offset, value)
修改字符串內容，從指定字符串索引開始向後替換（新值太長時，則向後添加）
參數：
    offset，字符串的索引，字節（一個漢字三個字節）
    value，要設置的值

    client.set('name','林海峯')
    client.setrange('name',3,'大海')
    print(client.get('name').decode('utf-8')) #林大海
    
    
#十一、strlen(name)
返回name對應值的字節長度（一個漢字3個字節）


#十二、incr(self, name, amount=1)
自增 name="1" 對應的值，當name不存在時，則建立name＝amount，不然，則自增。
參數：
    name,Redis的name
    amount,自增數（必須是整數）
    注：同incrby


#1三、incrbyfloat(self, name, amount=1.0)
自增 name對應的值，當name不存在時，則建立name＝amount，不然，則自增。
參數：
    name,Redis的name
    amount,自增數（浮點型）
    
    
#1四、decr(self, name, amount=1)
自減 name對應的值，當name不存在時，則建立name＝amount，不然，則自減。
參數：
    name,Redis的name
    amount,自減數（整數）
    

#1五、append(key, value)
在redis name對應的值後面追加內容
參數：
    key, redis的name
    value, 要追加的字符串

Redis命令之String

#一、hset(name, key, value)
name對應的hash中設置一個鍵值對（不存在，則建立；不然，修改）
 
參數：
    name，redis的name
    key，name對應的hash中的key
    value，name對應的hash中的value
 
注：
    hsetnx(name, key, value),當name對應的hash中不存在當前key時則建立（至關於添加）

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

    
#三、hget(name,key)
在name對應的hash中獲取根據key獲取value


#四、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


#十、hdel(name,*keys)
將name對應的hash中指定key的鍵值對刪除


#十一、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


#1三、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時，表示數據已經經過分片獲取完畢
    
    
#1四、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


#1五、補充scan(match=None, count=None)
一點一點查出當前庫下的全部的keys，詳細請看以下文檔
http://redisdoc.com/key/scan.html#scan

Redis命令之Hash

#一、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，索引結束位置

    
#十、ltrim(name, start, end)
在name對應的列表中移除沒有在start-end索引之間的值

參數：
    name，redis的name
    start，索引的起始位置
    end，索引結束位置

    
#十一、rpoplpush(src, dst)
從一個列表取出最右邊的元素，同時將其添加至另外一個列表的最左邊

參數：
    src，要取數據的列表的name
    dst，要添加數據的列表的name

    
#十二、blpop(keys, timeout)
keys=["k1","k2"]，按照從左到右去pop對應列表的元素
 
參數：
    keys，redis的name的集合
    timeout，超時時間，當元素全部列表的元素獲取完以後，阻塞等待列表內有數據的時間（秒）, 0 表示永遠阻塞

舉例：
    client.flushdb()
    client.lpush('list1',11,22,33) #33,22,11
    client.lpush('list2','a','b','c') #c b a

    print(client.blpop(["list1","list2"])) #先從左側取乾淨list1，再從左側取乾淨list2，...，阻塞
    print(client.blpop(["list1","list2"]))
    print(client.blpop(["list1","list2"]))
    print(client.blpop(["list1","list2"]))
    print(client.blpop(["list1","list2"]))
    print(client.blpop(["list1","list2"]))
    print(client.blpop(["list1","list2"],timeout=3)) #阻塞3秒，返回None
    
更多：
    r.brpop(keys, timeout)，從右向左獲取數據

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

#1四、自定義增量迭代
因爲redis類庫中沒有提供對列表元素的增量迭代，若是想要循環name對應的列表的全部元素，那麼就須要：
    1、獲取name對應的全部列表
    2、循環列表
可是，若是列表很是大，那麼就有可能在第一步時就將程序的內存撐爆，全部有必要自定義一個增量迭代的功能：

def list_iter(name):
    """
    自定義redis列表增量迭代
    :param name: redis中的name，即：迭代name對應的列表
    :return: yield 返回 列表元素
    """
    list_count = r.llen(name)
    for index in range(list_count):
        yield r.lindex(name, index)


# 使用
for item in list_iter('list1'):
    print(item)

Redis命令之List

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


#1三、sunion(keys, *args)
獲取多一個name對應的集合的並集


#1四、sunionstore(dest,keys, *args)
獲取多一個name對應的集合的並集，並將結果保存到dest對應的集合中


#1五、sscan(name, cursor=0, match=None, count=None)
#1六、sscan_iter(name, match=None, count=None)
同字符串的操做，用於增量迭代分批獲取元素，避免內存消耗太大

Redis命令之Set

#一、zadd(name, *args, **kwargs)
在name對應的有序集合中添加元素

如：
     zadd('score', 'alex', 50, 'wxx', 60,'yxx', 70)
     或
     zadd('score', alex=50, wxx=60, yxx=70)


#二、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，對分數進行數據轉換的函數
    例如：
        client.zrange('score', 0, 2, desc=True, withscores=True, score_cast_func=int)
        結果：[(b'yxx', 70), (b'wxx', 60), (b'alex', 50)]
        
更多：
    從大到小排序
    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 對應的分數


#1三、zinterstore(dest, keys, aggregate=None)
獲取兩個有序集合的交集，若是遇到相同值不一樣分數，則按照aggregate進行操做
aggregate的值爲:  SUM  MIN  MAX

例如：
client.flushdb()
client.zadd('score1', 'alex', 50, 'wxx', 60,'yxx', 70)
client.zadd('score2', 'alex', 60, 'wxx', 60,)

#先求名字的交集，再對同一名字對應的值進行SUM聚合操做
client.zinterstore('score_sum',keys=['score1','score2'],aggregate="SUM")
print(client.zscore('score_sum','alex')) #110.0
print(client.zscore('score_sum','wxx')) #120.0
print(client.zscore('score_sum','yxx')) #None
    

#1四、zunionstore(dest, keys, aggregate=None)
獲取兩個有序集合的並集，若是遇到相同值不一樣分數，則按照aggregate進行操做
aggregate的值爲:  SUM  MIN  MAX


#1五、zscan(name, cursor=0, match=None, count=None, score_cast_func=float)
#1六、zscan_iter(name, match=None, count=None,score_cast_func=float)
同字符串類似，相較於字符串新增score_cast_func，用來對分數進行操做

Redis命令之Sort Set

#一、delete(*names)
根據name刪除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對應值的類型


#九、scan(cursor=0, match=None, count=None)
#十、scan_iter(match=None, count=None)
同字符串操做，用於增量迭代獲取key

其餘經常使用操做

#一、默認狀況下是執行一個操做就向服務端提交一次
#二、能夠將一系列操做放入一個管道內，而後一次性提交給服務端，這樣作有效地減小開銷
#三、transaction=True表明多個操做構成一個事務（原子性操做）

import redis

pool=redis.ConnectionPool(host='127.0.0.1',port=6379,max_connections=100)
client=redis.Redis(connection_pool=pool)

pipe=client.pipeline(transaction=True)

pipe.set('name','alex')
pipe.set('role','sb')

pipe.execute()

管道

memcached與redis

1、相同點

• NoSQl數據庫，數據存到內存，讀取速度快
• 應用場景：頁面緩存
• 好處：
  1. 減小數據庫壓力，提高訪問速度
  2. 在數據掛掉的狀況下，仍能保證業務正常運行一段時間，提高安全性

2、不一樣點

• 類型：
  1. memcached：類型單一，只能存字符串"key爲字符串"="value也爲字符串"
  2. redis：支持五大類型 string(字符串)、list(鏈表)、set(集合)、zset(sorted set --有序集合)、hash（哈希類型）
• 持久化：
  1. memcached：斷電數據丟失
  2. redis：支持持久化，單獨開一個進程完成持久化，要保持性能就須要關閉持久化，不少公司並不使用持久化功能

Python 操做Redis

1、下載

• pip3 install redis 官網
• redis默認不正式支持windows，到這裏下載windows版本點擊

2、鏈接

• Redis提供兩個類Redis和StrictRedis用於實現Redis的命令，StrictRedis用於實現大部分官方的命令，並使用官方的語法和命令，
• Redis是StrictRedis的子類，用於向後兼容舊版本的redis-py。
• Redis鏈接實例是線程安全的，能夠直接將redis鏈接實例設置爲一個全局變量，直接使用。
• 若是須要另外一個Redis實例（or Redis數據庫）時，就須要從新建立redis鏈接實例來獲取一個新的鏈接
• 鏈接redis，加上decode_responses=True，寫入的鍵值對中的value爲str類型，不加這個參數寫入的則爲字節類型。

import redis
conn = redis.Redis(host="127.0.0.1",port=6379,password="",decode_responses=True) #decode_responses=True 設置取出的數據是字符，不是字節

conn.set("n1","v1")
print(type(conn.get("n1")))  # <class 'str'>

conn.hset("n2","k2","v2")
#redis={n2:{k2:v2}}
conn.hmset("n3",{"k3":"v3","k4":"v4"})

ret1=conn.get("xxxx")       #  沒有xxxx 返回值是None  
ret2=conn.hget("n2","k2") #v2
ret3=conn.hget("n3","k3") #v3
ret4=conn.hget("n4","k4") #v4
ret5=conn.hgetall("n3")   #{"k3":"v3","k4":"v4"}

鏈接

3、鏈接池

• 使用connection pool來管理對一個redis server的全部鏈接，避免每次創建、釋放鏈接的開銷。
• 默認，每一個Redis實例都會維護一個本身的鏈接池。能夠直接創建一個鏈接池，
• 而後做爲參數傳給Redis實例，這樣就能夠實現多個Redis實例共享一個鏈接池。

import redis
pool = redis.ConnectionPool(host="127.0.0.1", port=6379, password="",decode_responses=True, max_connections=10)
conn = redis.Redis(connection_pool=pool)
conn.set("n1",22)
ret = conn.get("n1")
print(ret)

鏈接池

import redis
pool = redis.ConnectionPool(host="127.0.0.1", port=6379, password="",decode_responses=True, max_connections=100)
conn = redis.Redis(connection_pool=pool)
conn.execute_command('select 1') #選擇數據庫 

選擇數據庫

4、發佈訂閱者模式

redis的發佈和訂閱者模式就像是廣播發消息是同樣的

import redis
conn = redis.Redis(host="127.0.0.1", port=6379, decode_responses=True)
conn.publish("gaoxin333", "18")

redis發佈者

import redis
conn = redis.Redis(host="127.0.0.1", port=6379, decode_responses=True)
# 第一步 生成一個訂閱者對象
pubsub = conn.pubsub()
# 第二步 訂閱一個消息 實際上就是監聽這個鍵
pubsub.subscribe("gaoxin333")
# 第三步 死循環一直等待監聽結果
while True:
    print("working~~~")
    msg = pubsub.parse_response()
    print(msg)

redis訂閱者

# monitor.py
import redis

class RedisHelper:

    def __init__(self):
        self.__conn = redis.Redis(host='127.0.0.1',port=6379)
        self.chan_pub = 'fm97.8' #發佈信息的頻道名
        self.chan_sub = 'fm97.8' #訂閱信息的頻道名

    def public(self, msg):
        self.__conn.publish(self.chan_pub, msg) #向發佈頻道發佈消息
        return True

    def subscribe(self):
        pub = self.__conn.pubsub() #拿到pub對象
        pub.subscribe(self.chan_sub) #向訂閱頻道請求消息
        pub.parse_response() #解析響應的信息
        return pub

#發佈者們

#!/usr/bin/env python
# -*- coding:utf-8 -*-

from monitor import RedisHelper
import time

obj = RedisHelper()

while True:
    obj.public('hello1')
    time.sleep(5)

#訂閱者們

#!/usr/bin/env python
# -*- coding:utf-8 -*-

from monitor import RedisHelper

obj = RedisHelper()
redis_sub = obj.subscribe()

while True:
    msg = redis_sub.parse_response()
    print(msg)

fm97.8

5、Redis可視化工具

點擊

Django配置Redis

1、下載

• django項目中配置redis做爲cache緩存，須要先安裝django-redis模塊
• pip3 install django-redis

2、配置

在settings.py中，按以下配置CACHE鏈接的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": "密碼",
            "DECODE_RESPONSES":True
        }
    },
}

settings

3、使用

先獲取redis鏈接：
import django_redis
CACHE = django_redis.get_redis_connection()


在視圖中
...
CACHE.set(key, value)
...

View Code