一 簡介
redis是一個key-value存儲系統。和Memcached相似，它支持存儲的value類型相對更多，包括string(字符串)、list(鏈表)、set(集合)、zset(sorted set --有序集合)和hash（哈希類型）。這些數據類型都支持push/pop、add/remove及取交集並集和差集及更豐富的操做，並且這些操做都是原子性的。在此基礎上，redis支持各類不一樣方式的排序。與memcached同樣，爲了保證效率，數據都是緩存在內存中。區別的是redis會週期性的把更新的數據寫入磁盤或者把修改操做寫入追加的記錄文件，而且在此基礎上實現了master-slave(主從)同步。html
1. 使用Redis有哪些好處？ (1) 速度快，由於數據存在內存中，相似於HashMap，HashMap的優點就是查找和操做的時間複雜度都是O(1) (2) 支持豐富數據類型，支持string，list，set，sorted set，hash (3) 支持事務，操做都是原子性，所謂的原子性就是對數據的更改要麼所有執行，要麼所有不執行 (4) 豐富的特性：可用於緩存，消息，按key設置過時時間，過時後將會自動刪除 2. redis相比memcached有哪些優點？ (1) memcached全部的值均是簡單的字符串，redis做爲其替代者，支持更爲豐富的數據類型 (2) redis的速度比memcached快不少 (3) redis能夠持久化其數據 3. redis常見性能問題和解決方案： (1) Master最好不要作任何持久化工做，如RDB內存快照和AOF日誌文件 (2) 若是數據比較重要，某個Slave開啓AOF備份數據，策略設置爲每秒同步一次 (3) 爲了主從複製的速度和鏈接的穩定性，Master和Slave最好在同一個局域網內 (4) 儘可能避免在壓力很大的主庫上增長從庫 (5) 主從複製不要用圖狀結構，用單向鏈表結構更爲穩定，即：Master <- Slave1 <- Slave2 <- Slave3... 這樣的結構方便解決單點故障問題，實現Slave對Master的替換。若是Master掛了，能夠馬上啓用Slave1作Master，其餘不變。 4. MySQL裏有2000w數據，redis中只存20w的數據，如何保證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（驅逐）：禁止驅逐數據 5. Memcache與Redis的區別都有哪些？ 1)、存儲方式 Memecache把數據所有存在內存之中，斷電後會掛掉，數據不能超過內存大小。 Redis有部份存在硬盤上，這樣能保證數據的持久性。 2)、數據支持類型 Memcache對數據類型支持相對簡單。 Redis有複雜的數據類型。 3），value大小 redis最大能夠達到1GB，而memcache只有1MB 6. 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最好在同一個局域網內 7, 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提供的全部特性中，我感受這個是喜歡的人最少的一個，雖然它爲用戶提供若是此多功能。
支持的數據類型（5大數據類型）python
redis={ k1:'123', 字符串 k2:[1,2,3,4], 列表/數組 k3:{1,2,3,4} 集合 k4:{name:lqz,age:12} 字典/哈希表 k5:{('lqz',18),('egon',33)} 有序集合 }
特色：linux
能夠持久化，redis提供兩種持久化的方案
單線程，單進程
- Redis中取出的數據均是byte二進制字符串格式！！！須要時要先decode解碼。
- 只支持一層的5大數據類型：也就是說字典的value值只能是字符串，列表的value值只能是字符串。若是想要它們value也是字典或者列表，能夠外部先將它們序列爲json字符串。
- mget、hmget等方法返回的都是一個列表。
二 redis的安裝和使用
2.1 linux下安裝redis
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
啓動客戶端django
src/redis-cli redis> set foo bar OK redis> get foo "bar"
2.2 Windows下安裝json
可見該連接 http://www.javashuo.com/article/p-ptzvubdb-cx.html2.3 安裝redis模塊後端
pip3 install redis數組
三 Python操做Redis之普通鏈接
redis-py提供兩個類Redis和StrictRedis用於實現Redis的命令，StrictRedis用於實現大部分官方的命令，並使用官方的語法和命令，Redis是StrictRedis的子類，用於向後兼容舊版本的redis-py。緩存
import redis r = redis.Redis(host='127.0.0.1', port=6379) r.set('foo', 'Bar') print(r.get('foo'))
四 Python操做Redis之鏈接池
redis-py使用connection pool來管理對一個redis server的全部鏈接，避免每次創建、釋放鏈接的開銷。默認，每一個Redis實例都會維護一個本身的鏈接池。能夠直接創建一個鏈接池，而後做爲參數Redis，這樣就能夠實現多個Redis實例共享一個鏈接池。同時爲了保證鏈接池的惟一，還須要用到單例，將鏈接池單獨寫入一個py文件中。
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'))
五 操做之String操做
String操做，redis中的String在在內存中按照一個name對應一個value來存儲。如圖：
set(name, value, ex=None, px=None, nx=False, xx=False)
def set(self, name, value, ex=None, px=None, nx=False, xx=False): """ Set the value at key ``name`` to ``value`` ``ex`` sets an expire flag on key ``name`` for ``ex`` seconds. ``px`` sets an expire flag on key ``name`` for ``px`` milliseconds. ``nx`` if set to True, set the value at key ``name`` to ``value`` only if it does not exist. ``xx`` if set to True, set the value at key ``name`` to ``value`` only if it already exists. """ pieces = [name, value] if ex is not None: pieces.append('EX') if isinstance(ex, datetime.timedelta): ex = int(ex.total_seconds()) pieces.append(ex) if px is not None: pieces.append('PX') if isinstance(px, datetime.timedelta): px = int(px.total_seconds() * 1000) pieces.append(px) if nx: pieces.append('NX') if xx: pieces.append('XX') return self.execute_command('SET', *pieces)
在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)
def mset(self, mapping): """ Sets key/values based on a mapping. Mapping is a dictionary of key/value pairs. Both keys and values should be strings or types that can be cast to a string via str(). """ items = [] for pair in iteritems(mapping): items.extend(pair) return self.execute_command('MSET', *items)
#批量設置值 mget({'k1': 'v1', 'k2': 'v2'})
get(name)
獲取值
mget(keys, *args)
def mget(self, keys, *args): """ Returns a list of values ordered identically to ``keys`` """ args = list_or_args(keys, args) options = {} if not args: options[EMPTY_RESPONSE] = [] return self.execute_command('MGET', *args, **options)
r.mget(['k3', 'k4'])
getset(name, value)
設置新值並獲取原來的值
getrange(key, start, end)
# 獲取子序列（根據字節獲取，非字符），跟python的列表切片不一樣，Redis中是顧頭顧尾的 # 參數： # name，Redis 的 name # start，起始位置（字節） # end，結束位置（字節） # 如： "波妞" ，0-3表示 "波"
setrange(name, offset, value)
# 修改字符串內容，從指定字符串索引開始向後替換（新值太長時，則向後添加） # 參數： # offset，字符串的索引，字節（一個漢字三個字節） # value，要設置的值 conn.setrange('name', 2, 'hello') # egon --> eghello conn.setrange('name', 2, 'on') # eghello --> egonllo
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，不然，則自增。 conn.incr('age1', amount=2) # age 2 # 參數： # name,Redis的name # amount,自增數（必須是整數） # 注：同incrby conn.incr('age') # age 18-->19 conn.incr('age', amount=-1) # age 19-->18
incrbyfloat(self, 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, 要追加的字符串
六 操做之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時則建立（至關於添加），存在時更新
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的全部鍵值 print(re.hgetall('xxx').get(b'name'))
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的鍵值對刪除
print(re.hdel('xxx','sex','name'))
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_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
七 操做之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，標杆值，即：在它先後插入數據（若是存在多個標杆值，以找到的第一個爲準），
若是標杆不存在，則不作任何操做，標杆值寫'1'與b'1'是同樣的 # value，要插入的數據
lset(name, index, value)
# 對name對應的list中的某一個索引位置從新賦值 # 參數： # name，redis的name # index，list的索引位置 # value，要設置的值
lrem(name, count, value)
# 在name對應的list中刪除指定的值 # 參數： # name，redis的name # value，要刪除的值 # count， count=0，刪除列表中全部的指定值； # count=2,從前到後，刪除2個； # count=-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')))
ltrim(name, start, end)
# 在name對應的列表中移除沒有在start-end索引之間的值 # 參數： # name，redis的name # start，索引的起始位置 # end，索引結束位置（大於列表長度，則表明不移除任何）
rpoplpush(src, dst)
# 從一個列表取出最右邊的元素，同時將其添加至另外一個列表的最左邊 # 參數： # src，要取數據的列表的name # dst，要添加數據的列表的name
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對應的列表的全部元素，那麼就須要： # 一、獲取name對應的全部列表 # 二、循環列表 # 可是，若是列表很是大，那麼就有可能在第一步時就將程序的內容撐爆，全部有必要自定義一個增量迭代的功能： 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 對應的分數
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是否存在，存在返回1，不然返回0
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對應值的類型， 返回的是byte類型的數據：好比 b'list'
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=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'))
在視圖函數中能夠不使用django_redis，可使用cache模塊：
from django.core.cache import cache