Python-Redis模塊

時間 2019-11-08

原文原文鏈接

數據緩存系統

mongodb：是直接持久化，直接存儲於硬盤的緩存系統
redis：半持久化，存儲於內存和硬盤
memcache：數據只能存儲在內存裏的緩存系統

redis介紹

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

一、使用Redis有哪些好處？

速度快，由於數據存在內存中，相似於HashMap，HashMap的優點就是查找和操做的時間複雜度都是O(1)
支持豐富數據類型，支持string，list，set，sorted set，hash
支持事務，操做都是原子性，所謂的原子性就是對數據的更改要麼所有執行，要麼所有不執行
豐富的特性：可用於緩存，消息，按key設置過時時間，過時後將會自動刪除

2.、redis相比memcached有哪些優點？

memcached全部的值均是簡單的字符串，redis做爲其替代者，支持更爲豐富的數據類型
redis的速度比memcached快不少
redis能夠持久化其數據

三、redis常見性能問題和解決方案：

Master最好不要作任何持久化工做，如RDB內存快照和AOF日誌文件
若是數據比較重要，某個Slave開啓AOF備份數據，策略設置爲每秒同步一次
爲了主從複製的速度和鏈接的穩定性，Master和Slave最好在同一個局域網內
儘可能避免在壓力很大的主庫上增長從庫
主從複製不要用圖狀結構，用單向鏈表結構更爲穩定，即：Master <- Slave1 <- Slave2 <- Slave3... 這樣的結構方便解決單點故障問題，實現Slave對Master的替換。若是Master掛了，能夠馬上啓用Slave1作Master，其餘不變。

四、MySQL裏有2000w數據，redis中只存20w的數據，如何保證redis中的數據都是熱點數據

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

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（驅逐）：禁止驅逐數據

五、 Memcache與Redis的區別都有哪些？

1）存儲方式github

Memecache把數據所有存在內存之中，斷電後會掛掉，數據不能超過內存大小。
Redis有部份存在硬盤上，這樣能保證數據的持久性。

2）數據支持類型redis

Memcache對數據類型支持相對簡單。
Redis有複雜的數據類型。

3）value大小mongodb

redis最大能夠達到1GB，而memcache只有1MB

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

Master寫內存快照，save命令調度rdbSave函數，會阻塞主線程的工做，當快照比較大時對性能影響是很是大的，會間斷性暫停服務，因此Master最好不要寫內存快照。
Master AOF持久化，若是不重寫AOF文件，這個持久化方式對性能的影響是最小的，可是AOF文件會不斷增大，AOF文件過大會影響Master重啓的恢復速度。Master最好不要作任何持久化工做，包括內存快照和AOF日誌文件，特別是不要啓用內存快照作持久化,若是數據比較關鍵，某個Slave開啓AOF備份數據，策略爲每秒同步一次。
Master調用BGREWRITEAOF重寫AOF文件，AOF在重寫的時候會佔大量的CPU和內存資源，致使服務load太高，出現短暫服務暫停現象。
Redis主從複製的性能問題，爲了主從複製的速度和鏈接的穩定性，Slave和Master最好在同一個局域網內

7, redis 最適合的場景數據庫

Redis最適合全部數據in-momory的場景，雖然Redis也提供持久化功能，但實際更多的是一個disk-backed的功能，跟傳統意義上的持久化有比較大的差異，那麼可能你們就會有疑問，彷佛Redis更像一個增強版的Memcached，那麼什麼時候使用Memcached,什麼時候使用Redis呢? 若是簡單地比較Redis與Memcached的區別，大多數都會獲得如下觀點：windows

Redis不只僅支持簡單的k/v類型的數據，同時還提供list，set，zset，hash等數據結構的存儲。
Redis支持數據的備份，即master-slave模式的數據備份。
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提供的全部特性中，我感受這個是喜歡的人最少的一個，雖然它爲用戶提供若是此多功能。

Redis安裝

windows：

下載連接：https://github.com/MicrosoftArchive/redis/releases

Python操做Redis

詳見：https://github.com/WoLpH/redis-py

sudo pip install redis
or
sudo easy_install redis
or
源碼安裝

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"

API的使用

redis-py 的API的使用能夠分類爲：

鏈接方式
鏈接池
操做
1. String 操做
2. Hash 操做
3. List 操做
4. Set 操做
5. Sort Set 操做
管道
發佈訂閱

鏈接方式

redis-py提供兩個類Redis和StrictRedis用於實現Redis的命令，StrictRedis用於實現大部分官方的命令，並使用官方的語法和命令，Redis是StrictRedis的子類，用於向後兼容舊版本的redis-py。

#!/usr/bin/env python
# -*- coding:utf-8 -*-
 
import redis
 
r = redis.Redis(host='10.211.55.4', port=6379)
r.set('foo', 'Bar')
print （r.get('foo')）

鏈接池

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

import redis
 
pool = redis.ConnectionPool(host='10.211.55.4', port=6379)
 
r = redis.Redis(connection_pool=pool)
r.set('foo', 'Bar')
print （r.get('foo')）

操做

String操做

redis中的String在在內存中按照一個name對應一個value來存儲

name 　　　　　　　　value

name1 ---------------> value1

name2 ----------------> 　value2

name3 ---------------> value3

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')
或
mget({'k1': 'v1', 'k2': 'v2'})
get(name)
獲取值
mget(keys, *args)
批量獲取
如：
mget('ylr', 'lee')
或
r.mget(['ylr', 'lee'])
getset(name, value)
設置新值並獲取原來的值
getrange(key, start, end)
獲取子序列（根據字節獲取，非字符）
參數：
name，Redis 的 name
start，起始位置（字節）
end，結束位置（字節）
如：「武沛齊」，0-3表示「武」
setrange(name, offset, value)
修改字符串內容，從指定字符串索引開始向後替換（新值太長時，則向後添加）
參數：
offset，字符串的索引，字節（一個漢字三個字節）
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"
 
# 擴展，轉換二進制表示：
 
    # source = "武沛齊"
    source = "foo"
 
    for i in source:
        num = ord(i)
        print bin(num).replace('b','')
 
    特別的，若是source是漢字 "武沛齊"怎麼辦？
    答：對於utf-8，每個漢字佔 3 個字節，那麼 "武沛齊" 則有 9個字節
       對於漢字，for循環時候會按照 字節 迭代，那麼在迭代時，將每個字節轉換 十進制數，而後再將十進制數轉換成二進制
        11100110 10101101 10100110 11100110 10110010 10011011 11101001 10111101 10010000

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,自增數（必須是整數）
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操做

redis中Hash在內存中的存儲格式以下:

name　　　　　　　　hash

　　　　　　　　　　k1 ---------> v1

name1 ---------->　　k2 --------> v2

　　　　　　　　　　k3 --------> v3

name2-----------> k9 ----------> v9

　　　　　　　　　　kx ----------> vx

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的值，不存在則建立
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操做

redis中的List在在內存中按照一個name對應一個List來存儲

name　　　　　　　　List

name1 ---------->　　[v1,v2,v3]

name2-----------> [v1,v2,v3...]

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)
將多個列表排列，按照從左到右去pop對應列表的元素
參數：
keys，redis的name的集合
timeout，超時時間，當元素全部列表的元素獲取完以後，阻塞等待列表內有數據的時間（秒）, 0 表示永遠阻塞
更多：
r.brpop(keys, timeout)，從右向左獲取數據
brpoplpush(src, dst, timeout=0)
從一個列表的右側移除一個元素並將其添加到另外一個列表的左側
參數：
src，取出並要移除元素的列表對應的name
dst，要插入元素的列表對應的name
timeout，當src對應的列表中沒有數據時，阻塞等待其有數據的超時時間（秒），0 表示永遠阻塞
自定義增量迭代

# 因爲redis類庫中沒有提供對列表元素的增量迭代，若是想要循環name對應的列表的全部元素，那麼就須要：
    # 一、獲取name對應的全部列表
    # 二、循環列表
# 可是，若是列表很是大，那麼就有可能在第一步時就將程序的內容撐爆，全部有必要自定義一個增量迭代的功能：
 
def list_iter(name):
    """
    自定義redis列表增量迭代
    :param name: redis中的name，即：迭代name對應的列表
    :return: yield 返回 列表元素
    """
    list_count = r.llen(name)
    for index in xrange(list_count):
        yield r.lindex(name, index)
 
# 使用
for item in list_iter('pp'):
    print（item）

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對應的集合中刪除某些值
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 hllo 匹配 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=False)
pipe = r.pipeline(transaction=True)
pipe.multi()
pipe.set('name', 'bar')
pipe.set('role', 'foo')
 
pipe.execute()

實現計數器
`import redis

conn = redis.Redis(host=‘192.168.1.41’,port=6379)

conn.set(‘count’,1000)

with conn.pipeline() as pipe:

# 先監視，本身的值沒有被修改過
conn.watch('count')

# 事務開始
pipe.multi()
old_count = conn.get('count')
count = int(old_count)
if count > 0:  # 有庫存
    pipe.set('count', count - 1)

# 執行，把全部命令一次性推送過去
pipe.execute()

發佈訂閱

import redis


class RedisHelper:

    def __init__(self):
        self.__conn = redis.Redis(host='10.211.55.4')
        self.chan_sub = 'fm104.5'
        self.chan_pub = 'fm104.5'

    def public(self, msg):
        self.__conn.publish(self.chan_pub, msg)
        return True

    def subscribe(self):
        pub = self.__conn.pubsub()
        pub.subscribe(self.chan_sub)
        pub.parse_response()
        return pub

訂閱者

from monitor.RedisHelper import RedisHelper
 
obj = RedisHelper()
redis_sub = obj.subscribe()
 
while True:
    msg= redis_sub.parse_response()
    print msg

發佈者

from monitor.RedisHelper import RedisHelper
 
obj = RedisHelper()
obj.public('hello')

sentinel

redis中的sentinel主要用於在redis主從複製中，若是master顧上，則自動將slave替換成master

from redis.sentinel import Sentinel
 
# 鏈接哨兵服務器(主機名也能夠用域名)
sentinel = Sentinel([('10.211.55.20', 26379),
                     ('10.211.55.20', 26380),
                     ],
                    socket_timeout=0.5)
 
# # 獲取主服務器地址
# master = sentinel.discover_master('mymaster')
# print(master)
#
# # # 獲取從服務器地址
# slave = sentinel.discover_slaves('mymaster')
# print(slave)
#
#
# # # 獲取主服務器進行寫入
# master = sentinel.master_for('mymaster')
# master.set('foo', 'bar')
 
 
 
# # # # 獲取從服務器進行讀取（默認是round-roubin）
# slave = sentinel.slave_for('mymaster', password='redis_auth_pass')
# r_ret = slave.get('foo')
# print(r_ret)