資料庫之Redis的簡單使用

阿新 • • 發佈：2018-12-27

一、redis

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

可以持久化
單執行緒，單程序

1.使用

import redis

r = redis.Redis(host='127.0.0.1', port=6379)

r.set()
# 注：
# decode_responses：預設為False,redis中的資料是位元組型，取出來的也是位元組型，如果設定為Ture,存在redis的是字元型，取出來的也是字元型
# redis支援5大資料型別,只支援第一層,也就是說字典的value值,必須是字串, 如果value值想存字典格式,必須用json轉換一下,轉成字串

2.連結池

import redis
# 建立一個連結池
pool = redis.ConnectionPool(host='127.0.0.1', port=6379)
# 取出一個連結
r = redis.Redis(connection_pool=pool)
r.set('foo', 'Bar')
print(r.get('foo'))

# redis-py使用connection pool來管理對一個redis server的所有連線，避免每次建立、釋放連線的開銷。預設，每個Redis例項都會維護一個自己的連線池。可以直接建立一個連線池，然後作為引數Redis，這樣就可以實現多個Redis例項共享一個連線池


# 連結池最好用單例，是為了保障整個專案只有一個連結池

二、redis之字串操作

redis{
    'name':'value'
}

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

set('name','value')


在Redis中設定值，預設，不存在則建立，存在則修改
引數：
     ex，過期時間（秒）
     px，過期時間（毫秒）
     nx，預設為False，不存在則建立，存在則修改；為True時，只有name不存在是才執行
     xx，預設為False，不存在則建立，存在則修改；為True時，只有name存在是才執行

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'})

get(name)

# 獲取
get('k1')

mget(keys, *args)

# 批量獲取
print(conn.mget('k1', 'k2'))
# 或
print(conn.mget(['k1', 'k2']))

getset(name, value)

設定新值並獲取原來的值

getrange(key, start, end)

# 獲取子序列（根據位元組獲取，非字元）
# 引數：
    # name，Redis 的 name
    # start，起始位置（位元組）
    # end，結束位置（位元組）
# 注：是閉區間，左右都取得到
# 如一箇中文是3位元組，0-2就是第一個字
conn.set('m1','徐誠琦')
print(conn.getrange('m1',0,2)) # b'\xe5\xbe\x90'
print(conn.getrange('m1',0,2).decode('utf-8')) # 徐

setrange(name, offset, value)

# 修改字串內容，從指定字串索引開始向後替換（新值太長時，則向後新增）
# 引數：
    # offset，字串的索引，位元組（一個漢字三個位元組）
    # value，要設定的值
conn.set('m1','123')
conn.setrange('m1',0,'4567')
print(conn.get('m1'))   # b'4567'

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 對應的值中

strlen(name)

# 返回name對應值的位元組長度（一個漢字3個位元組）

incr(self, name, amount=1)

# 自增 name對應的值，當name不存在時，則建立name＝amount，否則，則自增。
 
# 引數：
    # name,Redis的name
    # amount,自增數（必須是整數）,預設為1
 
# 注：同incrby
conn.set('m1','123')
conn.incr('m1')
print(conn.get('m1')) # b'124'

conn.set('m1','123')
conn.incr('m1',amount=-1) #如果為-1，會自減
print(conn.get('m1')) # b'122'

incrbyfloat(self, name, amount=1.0)

# 自增 name對應的值，當name不存在時，則建立name＝amount，否則，則自增。
 
# 引數：
    # name,Redis的name
    # amount,自增數（浮點型）預設為1.0
    
conn.set('m1','123')
conn.incrbyfloat('m1',amount=1.1)
print(conn.get('m1')) # b'124.09999999999999'

conn.set('m1','123')
conn.incr('m1',amount=-1.1) #如果為-，會自減
print(conn.get('m1')) # b'121.90000000000001'

decr(self, name, amount=1)

# 自減 name對應的值，當name不存在時，則建立name＝amount，否則，則自減。
 
# 引數：
    # name,Redis的name
    # amount,自減數（整數）預設為1
    
conn.set('m1','123')
conn.decr('m1')
print(conn.get('m1')) # b'122'


conn.set('m1','123')
conn.decr('m1',amount=-1)# 減-1，就是加1
print(conn.get('m1'))# b'124'

append(key, value)

# 在redis name對應的值後面追加內容
 
# 引數：
    # key, redis的name
    # value, 要追加的字串
    
conn.set('m1','123')
conn.append('m1',456)
print(conn.get('m1')) # b'123456'

三、redis之Hash(無序字典)

redis{
    'name':{
        'key1':'value1'
    }
}

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的所有鍵值
# 獲取所有
conn.hmset('xx', {'k1':'v1', 'k2': 'v2'})
print(conn.hgetall('xx')) #{b'k1': b'v1', b'k2': b'v2'}


# 獲取所有並篩選
conn.hmset('xx', {'k1':'v1', 'k2': 'v2'})
print(conn.hgetall('xx').get(b'k1'))

hlen(name)

# 獲取name對應的hash中鍵值對的個數
print(conn.hlen('xx')) # 2  有兩對鍵值對

hkeys(name)

# 獲取name對應的hash中所有的key的值
print(conn.hkeys('xx')) # [b'k1', b'k2']

hvals(name)

# 獲取name對應的hash中所有的value的值
print(conn.hvals('xx')) # [b'v1', b'v2']

hexists(name, key)

# 檢查name對應的hash是否存在當前傳入的key
print(conn.hexists('xx','key1')) #Flase
print(conn.hexists('xx','k1'))  # True

hdel(name,*keys)

# 將name對應的hash中指定key的鍵值對刪除
print(conn.hdel('xx','k1'))
# 可刪除多個
print(conn.hdel('xx','k1'，'k2'))

hincrby(name, key, amount=1)

# 自增name對應的hash中的指定key的值，不存在則建立key=amount
# 引數：
    # name，redis中的name
    # key， hash對應的key
    # amount，自增數（整數）
# 可用於一個東西的頻繁增加，比如說網站訪問量，每來一個人就自增，可以寫一個定時任務，每晚24點，可以把當天的訪問量同步到資料庫中
 
conn.hset('xx','k1','1')
conn.hincrby('xx','k1')
print(conn.hget('xx','k1')) # b'2'


conn.hset('xx','k1','1')
conn.hincrby('xx','k1',amount=-1)
print(conn.hget('xx','k1')) # b'0'

hincrbyfloat(name, key, amount=1.0)

# 自增name對應的hash中的指定key的值，不存在則建立key=amount
 
# 引數：
    # name，redis中的name
    # key， hash對應的key
    # amount，自增數（浮點數）
 
# 自增name對應的hash中的指定key的值，不存在則建立key=amount
conn.hset('xx','k1','1')
conn.hincrbyfloat('xx','k1',amount=0.1) 
print(conn.hget('xx','k1'))# b'1.1'


conn.hset('xx','k1','1')
conn.hincrbyfloat('xx','k1',amount=-0.1)
print(conn.hget('xx','k1')) # b'0.9'

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_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
    
# 問:我redis中字典有10000w條資料,全部打印出來
for i in range(1000):
    conn.hset('m2','key%s'%i,'value%s'%i)
# hscan_iter：指定每次取10條,直到取完
ret=conn.hscan_iter('m2',count=10)
# ret:<generator object Redis.hscan_iter at 0x00000271BDCDF0F8>
# ret是一個生成器(演算法)，迴圈ret實時生成資料，ret每次只有一條資料
for i in ret:
    print(i)
    
# hgetall：不要用這種方式,對記憶體的壓力過大
# ret:有1000條資料
ret=conn.hgetall('m2')

# 原始碼
    def hscan_iter(self, name, match=None, count=None):
        cursor = '0'
        while cursor != 0:
            # hscan：獲得count條資料，給data
            cursor, data = self.hscan(name, cursor=cursor,
                                      match=match, count=count)
            # 把data迴圈給item，for迴圈結束，再去執行while迴圈，再獲得count條資料
            # 迴圈到最後，返回可一個生成器
            for item in data.items():
                yield item

四、redis之list(有序列表)

redis{
    'name':['1',2,'a']
}

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，索引結束位置  
# 獲得0到100的101條資料
print(re.lrange('aa',0,100)    
# 獲得aa的所有資料
print(re.lrange('aa',0,re.llen('aa')))

ltrim(name, start, end)

# 在name對應的列表中移除沒有在start-end索引之間的值
# 引數：
    # name，redis的name
    # start，索引的起始位置
    # end，索引結束位置（大於列表長度，則代表不移除任何）

rpoplpush(src, dst)

# 從一個列表取出最右邊的元素，同時將其新增至另一個列表的最左邊
# 引數：
    # src，要取資料的列表的name
    # dst，要新增資料的列表的name

blpop(keys, timeout)

# 將多個列表排列，按照從左到右去pop對應列表的元素，如果沒有值了，整個程式就會hang住，也就是阻塞，只有列表再次新增值時，才會再次執行。
 
# 引數：
    # keys，redis的name的集合
    # timeout，超時時間，當元素所有列表的元素獲取完之後，阻塞等待列表內有資料的時間（秒）, 0 表示永遠阻塞
 
# 更多：
    # r.brpop(keys, timeout)，從右向左獲取資料
    
# 爬蟲實現簡單分散式：多個url放到列表裡，往裡不停放URL，程式迴圈取值，但是隻能一臺機器執行取值，可以把url放到redis中，多臺機器從redis中取值，爬取資料，實現簡單分散式

# 實現生產者與消費者模型，生產者生成資料放到redis列表裡，消費者使用blpop不斷獲取資料

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])

def scan_list(name,count=2):
    index=0
    while True:
        # 0到2+0-1，取兩個
        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)

五、redis之set(無序集合)

redis{
    'name':('1','2')
}
# set會把新增的資料去重

scard(name)

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

sdiff(keys, *args)

# 在第一個name對應的集合中且不在其他name對應的集合的元素集合
# 差集
conn.sadd('set',1,2,3)
conn.sadd('set1',3,4,5)
print(conn.sdiff('set','set1')) #{b'2', b'1'}

sdiffstore(dest, keys, *args)

# 獲取第一個name對應的集合中且不在其他name對應的集合，再將其新加入到dest對應的集合中
# 獲得差集，並放到一個新生成的集合中
conn.sadd('set',1,2,3)
conn.sadd('set1',3,4,5)
conn.sdiffstore('set2','set','set1')

sinter(keys, *args)

# 獲取多一個name對應集合的並集
# 交集
conn.sadd('set',1,2,3)
conn.sadd('set1',3,4,5)
print(conn.sinter('set','set1'))    # {b'3'}

sinterstore(dest, keys, *args)

# 獲取多一個name對應集合的並集，再講其加入到dest對應的集合中
# 獲得交集，並放到一個新生成的集合中
conn.sadd('set',1,2,3)
conn.sadd('set1',3,4,5)
conn.sinterstore('set2','set','set1')

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)

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

六、redis之zset(有序集合)

# 有序集合，在集合的基礎上，為每元素排序；元素的排序需要根據另外一個值來進行比較，所以，對於有序集合，每一個元素有兩個值，即：值和分數，分數專門用來做排序。
redis{
    'name':{ 'n1': 1, 'n2':2}
}

zadd(name, *args, kwargs)**

# 在name對應的有序集合中新增元素
# 如：
conn.zadd('zz',{ 'n1': 1, 'n2':2})

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，用來對分數進行操作

七、redis之其他操作

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對應值的型別

scan(cursor=0, match=None, count=None)
scan_iter(match=None, count=None)

# 同字串操作，用於增量迭代獲取key

八、管道

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=True)
pipe.multi()
pipe.set('name', 'alex')
pipe.set('role', 'sb')
pipe.execute()

九、django中使用redis

方式一

# redis_pool.py
import redis
POOL = redis.ConnectionPool(host='127.0.0.1', port=6379,max_connections=1000)

# views.py
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裡配置：

# setting裡的redis配置
# 配置以後，所有的快取都會存到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
# default:setting裡的配置名
conn = get_redis_connection('default')

資料庫之Redis的簡單使用

一、redis

1.使用

2.連結池

二、redis之字串操作

三、redis之Hash(無序字典)

四、redis之list(有序列表)

五、redis之set(無序集合)

六、redis之zset(有序集合)

七、redis之其他操作

八、管道

九、django中使用redis

方式一

方式二

資料庫之redis篇（1）—— redis資料庫安裝，簡單使用

資料庫之Redis的簡單使用

資料庫之redis篇（2）—— redis配置檔案，常用命令，效能測試工具

資料庫之---redis叢集

MyBatis 快取之Redis簡單實現

NoSQL 資料庫之 Redis 學習總結

04_NoSQL資料庫之Redis資料庫：set型別和zset型別

三十七、python學習之Redis資料庫

數據庫之redis篇（1）—— redis數據庫安裝，簡單使用

Redis資料庫之主從複製和叢集部署

python操作三大主流資料庫(11)redis的安裝和簡單使用

$Django 路飛之redis記憶體資料庫安裝,python中使用，與Memcached,mongodb的區別

非關係型資料庫NoSQL之Redis

第十四招 PHP之Redis資料庫

Unity3D遊戲開發之SQLite讓資料庫開發更簡單

JAVA之 Redis 學習筆記（二） Redis的連線IP、埠號、連線密碼的修改以及與JAVA簡單互動

資料庫系列之————redis遠端連線

redis資料庫之rdb持久化

redis資料庫之主從複製

檔案資料庫之sqlite 與記憶體資料庫 redis

資料庫之Redis的簡單使用

一、redis

1.使用

2.連結池

二、redis之字串操作

三、redis之Hash(無序字典)

四、redis之list(有序列表)

五、redis之set(無序集合)

六、redis之zset(有序集合)

七、redis之其他操作

八、管道

九、django中使用redis

方式一

方式二

相關推薦