python中使用redis

時間 2019-11-07

標籤 python 使用 redis 欄目 Python 简体版

原文原文鏈接

準備

安裝redis服務

安裝依賴包

pip install redis

使用

import redis

建立鏈接

一、普通鏈接：redis

conn = redis.Redis(host='127.0.0.1',port=6379,password='1234')

二、鏈接池：算法

conn_pool = redis.ConnectionPool(host='127.0.0.1',port=6379,password='1234')  
conn = redis.Redis(connection_pool=conn_pool)

String（字符串）操做

Redis 中的 String 在在內存中按照一個 name 對應一個 value 來存儲。數據庫

set

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

將字符串值 value 關聯到 name 。若是 name 已經持有其餘值，就覆寫舊值，無視類型。

可選參數：
    ex ：設置鍵的過時時間爲 second 秒。
    px ：設置鍵的過時時間爲 millisecond 毫秒。
    nx ：只在鍵不存在時，纔對鍵進行設置操做。
    xx ：只在鍵已經存在時，纔對鍵進行設置操做。
返回值：
    在 Redis 2.6.12 版本之前， set 命令老是返回 True 。
    從 Redis 2.6.12 版本開始， set 在設置操做成功完成時，才返回 True 。
    若是設置了 nx 或者 xx ，但由於條件沒達到而形成設置操做未執行，那麼命令返回 None 。

setnx
```
conn.setnx(name, value)
```
將 key 的值設爲 value ，當且僅當 key 不存在。若給定的 key 已經存在，則 setnx 不作任何動做。
```
返回值：
    設置成功，返回 True 。
    設置失敗，返回 False 。
```
setex
```
conn.setex(name, time, value)
```
將值 value 關聯到 key ，並將 key 的生存時間設爲 time (以秒爲單位)。若是 key 已經存在， setex 命令將覆寫舊值。這個命令相似於如下兩個命令：
```
conn.set(name,value)
conn.expire(name,time)
```
不一樣之處是，它是一個原子性(atomic)操做，關聯值和設置生存時間兩個動做會在同一時間內完成，該命令在 Redis 用做緩存時，很是實用。
```
返回值：
    設置成功時返回 OK 。
    當 time 參數不合法時，返回一個錯誤。
```
psetex
```
conn.psetex(name, time_ms, value)
```
這個命令和 setex 命令類似，但它以毫秒爲單位設置 name 的生存時間，而不是像 setx 命令那樣，以秒爲單位。
```
返回值：
    設置成功時返回 OK 。
```
mset
```
conn.mset(mapping)
例：
    conn.mset(k1='v1', k2='v2')
    conn.mset({'k1': 'v1', 'k2': 'v2'})
```
同時設置一個或多個 key-value 對。數組

若是某個給定 key 已經存在，那麼 mset 會用新值覆蓋原來的舊值，若是這不是你所但願的效果，請考慮使用 msetnx 命令：它只會在全部給定 key 都不存在的狀況下進行設置操做。緩存

mset 是一個原子性(atomic)操做，全部給定 key 都會在同一時間內被設置，某些給定 key 被更新而另外一些給定 key 沒有改變的狀況，不可能發生。安全
```
返回值：
    老是返回 True (由於 mset 不可能失敗)。
```
msetnx
```
conn.msetnx(mapping)
```
同時設置一個或多個 key-value 對，當且僅當全部給定 key 都不存在。服務器

即便只有一個給定 key 已存在， msetnx 也會拒絕執行全部給定 key 的設置操做。數據結構

msetnx 是原子性的，所以它能夠用做設置多個不一樣 key 表示不一樣字段(field)的惟一性邏輯對象(unique logic object)，全部字段要麼全被設置，要麼全不被設置。併發
```
返回值：
    當全部 key 都成功設置，返回 True 。
    若是全部給定 key 都設置失敗(至少有一個 key 已經存在)，那麼返回 False 。
```
get
```
conn.get(name)
```
返回 name 所關聯的字符串的字節形式。
若是 name 不存在那麼返回特殊值 None 。

假如 name 儲存的值不是字符串類型，返回一個錯誤，由於 GET 只能用於處理字符串值。
```
返回值：
    當 name 不存在時，返回 None ，不然，返回 name 的值。
    若是 name 不是字符串類型，那麼返回一個錯誤。
```

mget

conn.mget(keys, *args)
例：
    value_list = conn.mget('k1','k2')
    或
    value_list = conn.mget(['k1','k2'])
    # [b'v1', b'v2']

返回全部(一個或多個)給定 name 的值。

若是給定的 name 裏面，有某個 name 不存在，那麼這個 name 返回特殊值 None 。所以，該命令永不失敗。

返回值：
    一個包含全部給定 name 的值的列表。

getset

conn.getset(name,value)

將給定 name 的值設爲 value ，並返回 name 的舊值(old value)。

當 name 存在但不是字符串類型時，返回一個錯誤。

返回值：
    返回給定 name 的舊值。
    當 name 沒有舊值時，也便是， name 不存在時，返回 None 。

getrange
```
conn.getrange(key, start, end)
例：
    conn.set('str', 'helloworld')
    print(conn.getrange('str', 0, 3))  # b'hell'
```
返回 key 中字符串值的子字符串，字符串的截取範圍由 start 和 end 兩個偏移量決定(包括 start 和 end 在內)。
負數偏移量表示從字符串最後開始計數， -1 表示最後一個字符， -2 表示倒數第二個，以此類推。
```
返回值：
    截取得出的子字符串。
```
setrange
```
conn.setrange(name, offset, value)
例：
    conn.set('str1', 'hello')
    conn.set('str2', 'hello')
    conn.setrange('str1', 5, ' zze')
    print(conn.get('str1'))  # b'hello zze'
    conn.setrange('str2', 6, 'world')
    print(conn.get('str2'))  # b'hello\x00world'
```
用 value 參數覆寫(overwrite)給定 name 所儲存的字符串值，從偏移量 offset 開始。
不存在的 name 看成空白字符串處理。

setrange 命令會確保字符串足夠長以便將 value 設置在指定的偏移量上，若是給定 name 原來儲存的字符串長度比偏移量小(好比字符串只有 5 個字符長，但你設置的 offset 是 10 )，那麼原字符和偏移量之間的空白將用零字節(zerobytes, "\x00" )來填充。

注意你能使用的最大偏移量是 2^29-1(536870911) ，由於 Redis 字符串的大小被限制在 512 兆(megabytes)之內。若是你須要使用比這更大的空間，你可使用多個 key 。
```
返回值：
    被 setrange 修改以後，字符串的長度。
```
setbit
```
conn.setbit(name, offset, value)
```
```
例：
    注：若是在Redis中有一個對應： n1 = "foo"，
    那麼字符串foo的二進制表示爲：01100110 01101111 01101111
    因此，若是執行 setbit('n1', 7, 1)，則就會將第7位設置爲1，
    那麼最終二進制則變成 01100111 01101111 01101111，即："goo"
```
對name對應值的二進制表示的位進行操做。

對 name 所儲存的字符串值，設置或清除指定偏移量上的位(bit)。

位的設置或清除取決於 value 參數，能夠是 0 也能夠是 1 。

當 name 不存在時，自動生成一個新的字符串值。

字符串會進行伸展(grown)以確保它能夠將 value 保存在指定的偏移量上。當字符串值進行伸展時，空白位置以 0 填充。

offset 參數必須大於或等於 0 ，小於 2^32 (bit 映射被限制在 512 MB 以內)。
```
返回值：
    指定偏移量原來儲存的位。
```
getbit
```
conn.getbit(name, offset)
```
獲取name對應的值的二進制表示中的某位的值（0或1）。

對 key 所儲存的字符串值，獲取指定偏移量上的位(bit)。

當 offset 比字符串值的長度大，或者 key 不存在時，返回 0 。
```
返回值：
    字符串值指定偏移量上的位(bit)。
```

bitcount

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

計算給定字符串中，被設置爲 1 的比特位的數量。

通常狀況下，給定的整個字符串都會被進行計數，經過指定額外的 start 或 end 參數，可讓計數只在特定的位上進行。

start 和 end 參數的設置和 getrange 命令相似，均可以使用負數值：好比 -1 表示最後一個字節， -2 表示倒數第二個字節，以此類推。

不存在的 key 被當成是空字符串來處理，所以對一個不存在的 key 進行 bitcount 操做，結果爲 0 。

返回值：
　　被設置爲 1 的位的數量。

Bitmap 對於一些特定類型的計算很是有效。

假設如今咱們但願記錄本身網站上的用戶的上線頻率，好比說，計算用戶 A 上線了多少天，用戶 B 上線了多少天，諸如此類，以此做爲數據，從而決定讓哪些用戶參加 beta 測試等活動 —— 這個模式可使用 SETBIT 和 BITCOUNT 來實現。

好比說，每當用戶在某一天上線的時候，咱們就使用 SETBIT ，以用戶名做爲 key ，將那天所表明的網站的上線日做爲 offset 參數，並將這個 offset 上的爲設置爲 1 。

舉個例子，若是今天是網站上線的第 100 天，而用戶 peter 在今天閱覽過網站，那麼執行命令 SETBIT peter 100 1 ；若是明天 peter 也繼續閱覽網站，那麼執行命令 SETBIT peter 101 1 ，以此類推。

當要計算 peter 總共以來的上線次數時，就使用 BITCOUNT 命令：執行 BITCOUNT peter ，得出的結果就是 peter 上線的總天數。

應用：使用 bitmap 實現用戶上線次數統計

strlen
```
conn.strlen(name)
```
返回 name 所儲存的字符串值的長度。

當 name 儲存的不是字符串值時，返回一個錯誤。
```
返回值：
    字符串值的長度。
    當 name 不存在時，返回 0 。
```
incr
```
conn.incr(self, name, amount=1)
```
將 name 中儲存的數字值增 amount。

若是 name 不存在，那麼 name 的值會先被初始化爲 0 ，而後再執行 incr 操做。

若是值包含錯誤的類型，或字符串類型的值不能表示爲數字，那麼返回一個錯誤。

本操做的值限制在 64 位(bit)有符號數字表示以內。
```
返回值：
    執行 incr 命令以後 name 的值。
```
incrbyfloat
```
conn.incrbyfloat(self, name, amount=1.0)
```
爲 name 中所儲存的值加上浮點數增量 amount 。

若是 name 不存在，那麼 incrbyfloat 會先將 key 的值設爲 0 ，再執行加法操做。

若是命令執行成功，那麼 name 的值會被更新爲（執行加法以後的）新值，而且新值會以字符串的形式返回給調用者。

不管是 name 的值，仍是增量 amount ，均可以使用像 2.0e7 、 3e5 、 90e-2 那樣的指數符號(exponential notation)來表示，可是，執行 incrbyfloat 命令以後的值老是以一樣的形式儲存，也便是，它們老是由一個數字，一個（可選的）小數點和一個任意位的小數部分組成（好比 3.14 、 69.768 ，諸如此類)，小數部分尾隨的 0 會被移除，若是有須要的話，還會將浮點數改成整數（好比 3.0 會被保存成 3 ）。

除此以外，不管加法計算所得的浮點數的實際精度有多長， incrbyfloat 的計算結果也最多隻能表示小數點的後十七位。

當如下任意一個條件發生時，返回一個錯誤：
- name 的值不是字符串類型(由於 Redis 中的數字和浮點數都以字符串的形式保存，因此它們都屬於字符串類型）
- name 當前的值或者給定的增量 amount 不能解釋(parse)爲雙精度浮點數(double precision floating point number）
```
返回值：
　　執行命令以後 key 的值。
```
decr
```
conn.decr(self, name, amount=1)
```
將 name 中儲存的數字值減 amount 。

若是 name 不存在，那麼 key 的值會先被初始化爲 0 ，而後再執行 decr 操做。

若是值包含錯誤的類型，或字符串類型的值不能表示爲數字，那麼返回一個錯誤。

本操做的值限制在 64 位(bit)有符號數字表示以內。
```
返回值：
    執行 DECR 命令以後 key 的值。
```
append
```
conn.ppend(key, value)
```
若是 key 已經存在而且是一個字符串， append 命令將 value 追加到 key 原來的值的末尾。

若是 key 不存在， append 就簡單地將給定 key 設爲 value 。
```
返回值：
    追加 value 以後， key 中字符串的長度。
```

Hash（哈希）操做

hash 表現形式上有些像 pyhton 中的字典 ,能夠存儲一組關聯性較強的數據。

hset

conn.hset(name, key, value)

將 name 對應的 hash 域中 key 值設爲 value 。

若是 name 不存在，一個新的哈希表將被建立並進行 hset 操做。

若是域 key 已經存在於哈希表中，舊值將被覆蓋。

返回值：
    若是 key 是哈希表中的一個新建域，而且值設置成功，返回 True 。
    若是哈希表中域 key 已經存在且舊值已被新值覆蓋，返回 False 。

hmset

conn.hmset(name, mapping) 
例：
　　conn.hmset('xx', {'k1':'v1', 'k2': 'v2'})

同時將多個 key-value (鍵-值)對設置到哈希表 name 中。

此命令會覆蓋哈希表中已存在的域。

若是 name 不存在，一個空哈希表被建立並執行 hmset 操做。

返回值：
    若是命令執行成功，返回 True 。
    當 key 不是哈希表(hash)類型時，返回一個錯誤。

hget

conn.hget(name,key)

返回哈希表 name 中給定域 key 的值。

返回值：
    給定域的值。
    當給定域不存在或是給定 name 不存在時，返回 None 。

hmget
```
conn.hmget(name, keys, *args)
例：
    r.mget('xx', ['k1', 'k2'])
    或
    r.hmget('xx', 'k1', 'k2')
```
返回哈希表 name 中，一個或多個給定域的值。

若是給定的域不存在於哈希表，那麼返回一個 None 。

由於不存在的 name 被看成一個空哈希表來處理，因此對一個不存在的 name 進行 hmget 操做將返回一個只帶有 None 值的表。
```
返回值：
    一個包含多個給定域的關聯值的表，表值的排列順序和給定域參數的請求順序同樣。
```

hgetall

conn.hgetall(name)

返回哈希表 name 中，全部的域和值。

返回值：
    以字典形式返回哈希表的域和域的值。
    若 name 不存在，返回空字典。

hlen

conn.hlen(name)

返回哈希表 name 中域的數量。

返回值：
    哈希表中域的數量。
    當 name 不存在時，返回 0 。

hkeys

conn.hkeys(name)

返回哈希表 key 中的全部域。

返回值：
    一個包含哈希表中全部域的列表。
    當 key 不存在時，返回一個空列表。

hvals

conn.hvals(name)

返回哈希表 name 中全部域的值。

返回值：
    一個包含哈希表中全部值的列表。
    當 name 不存在時，返回一個空列表表。

hexists

conn.hexists(name, key)

查看哈希表 name 中，給定域 key 是否存在。

返回值：
    若是哈希表含有給定域，返回 1 。
    若是哈希表不含有給定域，或 name 不存在，返回 0 。

hdel

conn.hdel(name,*keys)

刪除哈希表 name 中的一個或多個指定域，不存在的域將被忽略。

返回值:
    被成功移除的域的數量，不包括被忽略的域。

hincrby
```
conn.hincrby(name, key, amount=1)
```
爲哈希表 name 中的域 key 的值加上增量 amount 。

增量也能夠爲負數，至關於對給定域進行減法操做。

若是 name 不存在，一個新的哈希表被建立並執行 hincrby 命令。

若是域 key 不存在，那麼在執行命令前，域的值被初始化爲 0 。

對一個儲存字符串值的域 key 執行 hincrby 命令將形成一個錯誤。

本操做的值被限制在 64 位(bit)有符號數字表示以內。
```
返回值：
    執行 hincrby 命令以後，哈希表 name 中域 key 的值。
```
hincrbyfloat
```
conn.hincrbyfloat(name, key, amount=1.0)
```
爲哈希表 name 中的域 key 加上浮點數增量 amount 。

若是哈希表中沒有域 key ，那麼 hincrbyfloat 會先將域 key 的值設爲 0 ，而後再執行加法操做。

若是鍵 name 不存在，那麼 hincrbyfloat 會先建立一個哈希表，再建立域 key ，最後再執行加法操做。

當如下任意一個條件發生時，返回一個錯誤：
- 域 key 的值不是字符串類型(由於 Redis 中的數字和浮點數都以字符串的形式保存，因此它們都屬於字符串類型）
- 域 key 當前的值或給定的增量 increment 不能解釋(parse)爲雙精度浮點數(double precision floating point number)

hscan

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

增量式迭代獲取，對於數據大的數據很是有用，hscan能夠實現分片的獲取數據，並不是一次性將數據所有獲取完，從而放置內存被撐爆。

可選參數：
    cursor ：遊標（基於遊標分批取獲取數據）。
    match ：匹配指定 key ，默認 None 表示全部的 key 。
    count ：每次分片最少獲取個數，默認 None 表示採用 Redis 的默認分片個數
返回值：
　　返回一個包含兩個元素的元組，第一個元素是一個數字（測試時一直返回 0 ，不知道是什麼意思），第二個元素爲域和值做爲鍵值對的一個字典。

hscan_iter
```
conn.hscan_iter(name, match=None, count=None)
```
利用 yield 封裝 hscan 建立生成器，實現分批去 redis 中獲取數據。
```
參數和返回值參考 hscan 。
```
hsetnx
```
conn.hsetnx(name, key, value)
```
將哈希表 name 中的域 key 的值設置爲 value ，當且僅當域 key 不存在。

若域 key 已經存在，該操做無效。

若是 name 不存在，一個新哈希表被建立並執行 hsetnx 命令。
```
返回值：
    設置成功，返回 1 。
    若是給定域已經存在且沒有操做被執行，返回 0 。
```
hstrlen
```
conn.hstrlen(name, key):
```
返回哈希表 name 中，與給定域 key 相關聯的值的字符串長度（string length）。

若是給定的鍵或者域不存在，那麼命令返回 False 。
```
返回值：
    一個整數。
```

List（列表）操做

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

lpush

conn.lpush(name, *values)
例：
　　若是有多個 value 值，那麼各個 value 值按從左到右的順序依次插入到表頭。 好比說，對空列表 mylist 執行命令 lpush('mylist','a','b','c') ，

　　列表的值將是 'c','b','a'，這等同於原子性地執行 lpush('mylist','a') 、 lpush('mylist','b') 和 lpush('mylist','c') 三個命令。

將一個或多個值 value 插入到列表 name 的表頭。

若是 name 不存在，一個空列表會被建立並執行 LPUSH 操做。

當 name存在但不是列表類型時，返回一個錯誤。

返回值：
    執行 lpush 命令後，列表的長度。

rpush

conn.rpush(name, *values):
例：
　　若是有多個 value 值，那麼各個 value 值按從左到右的順序依次插入到表尾：好比對一個空列表 mylist 執行 rpush('mylist','a','b','c')，
　　得出的結果列表爲 'a','b','c' ，等同於執行命令 rpush('mylist','a')、rpush('mylist','b') 和 rpush('mylist','c') 。

將一個或多個值 value 插入到列表 key 的表尾(最右邊)。

若是 name 不存在，一個空列表會被建立並執行 rpush 操做。

當 name 存在但不是列表類型時，返回一個錯誤。

返回值：
    執行 rpush 操做後，表的長度。

lpushx
```
conn.lpushx(name, value)
```
將值 value 插入到列表 name 的表頭，當且僅當 name 存在而且是一個列表。

和 lpush 命令相反，當 name 不存在時， lpushx 命令什麼也不作。
```
返回值：
    lpushx 命令執行以後，表的長度。
```
rpushx
```
conn.rpushx(name, value):
```
將值 value 插入到列表 name 的表尾，當且僅當 name 存在而且是一個列表。

和 rpush 命令相反，當 name 不存在時， rpushx 命令什麼也不作。
```
返回值：
    rpushx 命令執行以後，表的長度。
```
llen
```
conn.llen(name):
```
返回列表 name 的長度。

若是 name 不存在，則 name 被解釋爲一個空列表，返回 0 。

若是 name 不是列表類型，返回一個錯誤。
```
返回值：
    列表 key 的長度。
```

linsert

conn.linsert(name, where, refvalue, value):

將值 value 插入到列表 name 當中，位於值 refvalue 以前或以後。

當 refvalue 不存在於列表 name 時，不執行任何操做。

當 name 不存在時， name 被視爲空列表，不執行任何操做。

若是 name 不是列表類型，返回一個錯誤。

參數：
    where ：BEFORE或AFTER。
    refvalue ：標杆值，即：在它先後插入數據。
    value ：要插入的數據。
返回值：
    若是命令執行成功，返回插入操做完成以後，列表的長度。
    若是沒有找到 refvalue ，返回 -1 。
    若是 key 不存在或爲空列表，返回 0 。

lset
```
conn.lset(name, index, value):
```
將列表 name 下標爲 index 的元素的值設置爲 value 。

當 index 參數超出範圍，或對一個空列表( name 不存在)進行 lset 時，返回一個錯誤。
```
返回值：
    操做成功返回 True ，不然返回錯誤信息。    
```
lrem
```
conn.lrem(name, count, value)
```
根據參數 count 的值，移除列表中與參數 value 相等的元素。

count 的值能夠是如下幾種：
- count > 0 : 從表頭開始向表尾搜索，移除與 value 相等的元素，數量爲 count 。
- count < 0 : 從表尾開始向表頭搜索，移除與 value 相等的元素，數量爲 count 的絕對值。
- count = 0 : 移除表中全部與 value 相等的值。
```
返回值：
    被移除元素的數量。
    由於不存在的 name 被視做空表(empty list)，因此當 name 不存在時， lrem 命令老是返回 0 。
```

lpop

conn.lpop(name):

移除並返回列表 name 的頭元素。

返回值：
    列表的頭元素。
    當 name 不存在時，返回 None 。

lindex
```
conn.lindex(name, index)
```
返回列表 name 中，下標爲 index 的元素。

下標(index)參數 start 和 stop 都以 0 爲底，也就是說，以 0 表示列表的第一個元素，以 1 表示列表的第二個元素，以此類推。

你也可使用負數下標，以 -1 表示列表的最後一個元素， -2 表示列表的倒數第二個元素，以此類推。

若是 key 不是列表類型，返回一個錯誤。
```
返回值:
    列表中下標爲 index 的元素。
    若是 index 參數的值不在列表的區間範圍內(out of range)，返回 None 。
```
lrange
```
conn.lrange(name, start, end)
```
返回列表 name 中指定區間內的元素，區間以偏移量 start 和 end 指定。

下標(index)參數 start 和 end 都以 0 爲底，也就是說，以 0 表示列表的第一個元素，以 1 表示列表的第二個元素，以此類推。

你也可使用負數下標，以 -1 表示列表的最後一個元素， -2 表示列表的倒數第二個元素，以此類推。
```
超出範圍的下標：
    超出範圍的下標值不會引發錯誤。
    若是 start 下標比列表的最大下標( llen('list')-1 )還要大，那麼 lrange 返回一個空列表。
    若是 end 下標比最大下標還要大，Redis將最大下標的值設置爲 end 。
返回值:
    一個列表，包含指定區間內的元素。    
```
ltrim
```
conn.ltrim(name, start, end)
```
對一個列表進行修剪(trim)，就是說，讓列表只保留指定區間內的元素，不在指定區間以內的元素都將被刪除。

舉個例子，執行命令 ltrim('list',0,2) ，表示只保留列表 list 的前三個元素，其他元素所有刪除。

下標(index)參數 start 和 end 都以 0 爲底，也就是說，以 0 表示列表的第一個元素，以 1 表示列表的第二個元素，以此類推。

你也可使用負數下標，以 -1 表示列表的最後一個元素， -2 表示列表的倒數第二個元素，以此類推。

當 key 不是列表類型時，返回一個錯誤。
```
超出範圍的下標：
    超出範圍的下標值不會引發錯誤。
    若是 start 下標比列表的最大下標( llen('list')-1 )還要大，或者 start > end ， ltrim 返回一個空列表(由於 ltrim 已經將整個列表清空)。
    若是 end 下標比最大下標還要大，Redis將最大下標的值設置爲 end 。
返回值:
    命令執行成功時，返回 True 。
```
rpoplpush
```
conn.rpoplpush(src, dst)
```
命令 rpoplpush 在一個原子時間內，執行如下兩個動做：
- 將列表 src 中的最後一個元素(尾元素)彈出，並返回給客戶端。
- 將 src 彈出的元素插入到列表 dst ，做爲 dst 列表的的頭元素。
舉個例子，你有兩個列表 src 和 dst ， src 列表有元素 'a','b','c' ， destination 列表有元素 'x','y','z' ，執行 rpoplpush('src','dst') 以後， src 列表包含元素 'a','b' ， destination 列表包含元素 'c','x','y','z' ，而且元素 'c' 會被返回給客戶端。

若是 src 不存在，值 None 被返回，而且不執行其餘動做。

若是 src 和 dst 相同，則列表中的表尾元素被移動到表頭，並返回該元素，能夠把這種特殊狀況視做列表的旋轉(rotation)操做。
```
返回值：
    被彈出的元素。
```

blpop

conn.blpop(keys, timeout=0)

blpop 是列表的阻塞式(blocking)彈出。

它是 lpop 命令的阻塞版本，當給定列表內沒有任何元素可供彈出的時候，鏈接將被 blpop 命令阻塞，直到等待超時或發現可彈出元素爲止。

當給定多個 key 參數時，按參數 key 的前後順序依次檢查各個列表，彈出第一個非空列表的頭元素。

非阻塞行爲：
    當 blpop 被調用時，若是給定 key 內至少有一個非空列表，那麼彈出遇到的第一個非空列表的頭元素，並和被彈出元素所屬的列表的名字一塊兒，組成結果返回給調用者。
    當存在多個給定 key 時， blpop 按給定 key 參數排列的前後順序，依次檢查各個列表。
阻塞行爲：
    若是全部給定 key 都不存在或包含空列表，那麼 blpop 命令將阻塞鏈接，直到等待超時，或有另外一個客戶端對給定 key 的任意一個執行 lpush 或 rpush 命令爲止。
    超時參數 timeout 接受一個以秒爲單位的數字做爲值。超時參數設爲 0 表示阻塞時間能夠無限期延長(block indefinitely) 。
相同的key被多個客戶端同時阻塞：
相同的 key 能夠被多個客戶端同時阻塞。
不一樣的客戶端被放進一個隊列中，按『先阻塞先服務』(first-BLPOP，first-served)的順序爲 key 執行 blpop 命令。
在MULTI/EXEC事務中的blpop：
    blpop 能夠用於流水線(pipline,批量地發送多個命令並讀入多個回覆)，但把它用在 MULTI / EXEC 塊當中沒有意義。由於這要求整個服務器被阻塞以保證塊執行時的原子性，該行爲阻止了其餘客戶端執行 lpush 或 rpush 命令。
    所以，一個被包裹在 MULTI / EXEC 塊內的 blpop 命令，行爲表現得就像 lpop 同樣，對空列表返回 None ，對非空列表彈出列表元素，不進行任何阻塞操做。
返回值：
    若是列表爲空，返回一個 None 。
    不然，返回一個含有兩個元素的元組，第一個元素是被彈出元素所屬的 key ，第二個元素是被彈出元素的值。

brpoplpush
```
conn.brpoplpush(src, dst, timeout=0):
```
brpoplpush 是 brpoplpush 的阻塞版本，當給定列表 source 不爲空時， brpoplpush 的表現和 brpoplpush 同樣。

當列表 src 爲空時， brpoplpush 命令將阻塞鏈接，直到等待超時，或有另外一個客戶端對 src 執行 lpush 或 rpush 命令爲止。

超時參數 timeout 接受一個以秒爲單位的數字做爲值。超時參數設爲 0 表示阻塞時間能夠無限期延長(block indefinitely) 。
```
返回值：
    假如在指定時間內沒有任何元素被彈出，則返回一個 None 和等待時長。
    反之，返回一個含有兩個元素的列表，第一個元素是被彈出元素的值，第二個元素是等待時長。
```

Set（集合）操做

Set操做，Set集合就是不容許重複的列表。

sadd
```
conn.sadd(name, *values):
```
將一個或多個 value 元素加入到集合 name 當中，已經存在於集合的 value 元素將被忽略。

假如 name 不存在，則建立一個只包含 value 元素做成員的集合。

當 name 不是集合類型時，返回一個錯誤。
```
返回值:
    被添加到集合中的新元素的數量，不包括被忽略的元素。
```

scard

conn.scard(name)

返回集合 key 的基數(集合中元素的數量)。

返回值：
    集合的基數。
    當 key 不存在時，返回 0 。

sdiff
```
conn.sdiff(keys, *args)
```
返回一個集合的所有成員，該集合是全部給定集合之間的差集。

不存在的 key 被視爲空集。
```
返回值:
    一個包含差集成員的列表。
```
sdiffstore
```
conn.sdiffstore(dest, keys, *args)
```
這個命令的做用和 sdiff 相似，但它將結果保存到 dest 集合，而不是簡單地返回結果集。
若是 dest 集合已經存在，則將其覆蓋。
dest 能夠是 key 自己。
```
返回值:
    結果集中的元素數量。
```
sinter
```
conn.sinter(keys, *args)
```
返回一個集合的所有成員，該集合是全部給定集合的交集。

不存在的 key 被視爲空集。

當給定集合當中有一個空集時，結果也爲空集(根據集合運算定律)。
```
返回值:
    交集成員的列表。
```
sinterstore
```
conn.sinterstore(dest, keys, *args)
```
這個命令相似於 sinter 命令，但它將結果保存到 dest 集合，而不是簡單地返回結果集。

若是 dest 集合已經存在，則將其覆蓋。

dest 能夠是 key 自己。
```
返回值:
    結果集中的成員數量。
```

sismember

conn.sismember(name, value)

判斷 value 元素是否集合 name 的成員。

返回值:
    若是 value 元素是集合的成員，返回 1 。
    若是 value 元素不是集合的成員，或 name 不存在，返回 0 。

smembers
```
conn.smembers(name)
```
返回集合 name 中的全部成員。

不存在的 name 被視爲空集合。
```
返回值:
    集合中的全部成員。
```
smove
```
conn.smove(src, dst, value)
```
將 value 元素從 src 集合移動到 dst 集合。

smove 是原子性操做。

若是 src 集合不存在或不包含指定的 value 元素，則 smove 命令不執行任何操做，僅返回 0 。不然， value 元素從 src 集合中被移除，並添加到 dst 集合中去。

當 dst 集合已經包含 value 元素時， smove 命令只是簡單地將 src 集合中的 value 元素刪除。

當 src 或 dst 不是集合類型時，返回一個錯誤。
```
返回值:
    若是 value 元素被成功移除，返回 1 。
    若是 value 元素不是 src 集合的成員，而且沒有任何操做對 dst 集合執行，那麼返回 0 。
```
spop
```
conn.spop(name, count=None)
```
移除並返回集合中的一個隨機元素。

若是隻想獲取一個隨機元素，但不想該元素從集合中被移除的話，可使用 srandmember 命令。
```
返回值:
    被移除的隨機元素。
    當 name 不存在或 name 是空集時，返回 None 。
```
srandmember
```
conn.srandmember(name, number=None)
```
若是命令執行時，只提供了 name 參數，那麼返回集合中的一個隨機元素。

從 Redis 2.6 版本開始， srandmember 命令接受可選的 number 參數：
- 若是 number 爲正數，且小於集合基數，那麼命令返回一個包含 number 個元素的數組，數組中的元素各不相同。若是 number 大於等於集合基數，那麼返回整個集合。
- 若是 number 爲負數，那麼命令返回一個數組，數組中的元素可能會重複出現屢次，而數組的長度爲 number 的絕對值。
該操做和 spop 類似，但 spop 將隨機元素從集合中移除並返回，而 srandmember 則僅僅返回隨機元素，而不對集合進行任何改動。
```
返回值:
    只提供 name 參數時，返回一個元素；若是集合爲空，返回 None 。
    若是提供了 number 參數，那麼返回一個數組；若是集合爲空，返回空數組。
```
srem
```
conn.srem(name, *values)
```
移除集合 name 中的一個或多個 value 元素，不存在的 value 元素會被忽略。

當 name 不是集合類型，返回一個錯誤。
```
返回值:
    被成功移除的元素的數量，不包括被忽略的元素。
```
sunion
```
conn.sunion(keys, *args)
```
返回一個集合的所有成員，該集合是全部給定集合的並集。

不存在的 key 被視爲空集。
```
返回值:
    並集成員的列表。
```
sunionstore
```
conn.sunionstore(dest, keys, *args)
```
這個命令相似於 sunion 命令，但它將結果保存到 dest 集合，而不是簡單地返回結果集。

若是 dest 已經存在，則將其覆蓋。

dest 能夠是 key 自己。
```
返回值:
    結果集中的元素數量。    
```

sscan

conn.sscan(name, cursor=0, match=None, count=None)

用於迭代集合鍵中的元素。

返回值：
    返回的每一個元素都是一個集合成員。

sscan_iter
```
sscan_iter(name, match=None, count=None)
```
利用 yield 封裝 hscan 建立生成器，實現分批去 redis 中獲取數據。
```
返回值參考 sscan 。
```

SortSet（有序集合）操做

在集合的基礎上，爲元素排序；元素的排序須要根據另一個值來進行比較，因此，對於有序集合，每個元素有兩個值，即：值和分數，分數專門用來作排序。

zadd
```
conn.zadd(name, mapping, nx=False, xx=False, ch=False, incr=False)
```
將一個或多個 member 元素及其 score 值加入到有序集 key 當中。

若是某個 member 已是有序集的成員，那麼更新這個 member 的 score 值，並經過從新插入這個 member 元素，來保證該 member 在正確的位置上。

score 值能夠是整數值或雙精度浮點數。

若是 key 不存在，則建立一個空的有序集並執行 zadd 操做。

當 key 存在但不是有序集類型時，返回一個錯誤。
```
返回值:
    被成功添加的新成員的數量，不包括那些被更新的、已經存在的成員。
```

zcard

conn.zcard(name)

返回有序集 name 的基數。

返回值:
    當 name 存在且是有序集類型時，返回有序集的基數。
    當 name 不存在時，返回 0 。

zcount
```
conn.zcount(name, min, max)
```
返回有序集 name 中， score 值在 min 和 max 之間(默認包括 score 值等於 min 或 max )的成員的數量。
```
返回值:
    score 值在 min 和 max 之間的成員的數量。
```
zincrby
```
conn.zincrby(name, amount, value)
```
爲有序集 name 的成員 value 的 score 值加上增量 amount 。

能夠經過傳遞一個負數值 amount ，讓 score 減去相應的值，好比 zincrby(name, -5, value) ，就是讓 value 的 score 值減去 5 。

當 name 不存在，或 value 不是 name 的成員時， zincrby(name, amount, value) 等同於 conn.zadd(name,{value:amount}) 。

當 name 不是有序集類型時，返回一個錯誤。

amount 值能夠是整數值或雙精度浮點數。
```
返回值:
    value 成員的新 score 值，以字符串形式表示。
```
zrange
```
conn.zrange(name, start, end, desc=False, withscores=False, score_cast_func=float)
```
返回有序集 name 中，指定區間內的成員。

其中成員的位置默認按 score 值遞增(從小到大)來排序，經過 desc 參數就可讓其反序。

具備相同 score 值的成員按字典序(lexicographical order )來排列。

下標參數 start 和 end 都以 0 爲底，也就是說，以 0 表示有序集第一個成員，以 1 表示有序集第二個成員，以此類推。

你也可使用負數下標，以 -1 表示最後一個成員， -2 表示倒數第二個成員，以此類推。
超出範圍的下標並不會引發錯誤。
好比說，當 start 的值比有序集的最大下標還要大，或是 start > end 時， zrange 命令只是簡單地返回一個空列表。

另外一方面，假如 end 參數的值比有序集的最大下標還要大，那麼 Redis 將 end 看成最大下標來處理。

能夠經過使用 withscores 選項，來讓成員和它的 score 值一併返回，返回一個填充元組的列表，元組的第一個元素是對應值，第二個元素是元素 score。

能夠經過參數 score_cast_func 指定返回的 score 的表現形式，默認是 float ，表示爲小數。
```
返回值:
    指定區間內，帶有 score 值(可選)的有序集成員的列表。
```
zrank
```
conn.zrank(name, value)
```
返回有序集 name 中成員 value 的排名。其中有序集成員按 score 值遞增(從小到大)順序排列。

排名以 0 爲底，也就是說， score 值最小的成員排名爲 0 。
```
返回值:
    若是 value 是有序集 name 的成員，返回 value 的排名。
    若是 value 不是有序集 name 的成員，返回 None 。
```
zrem
```
conn.zrem(name, *values)
```
移除有序集 name 中的一個或多個成員，不存在的成員將被忽略。

當 name 存在但不是有序集類型時，返回一個錯誤。
```
返回值:
    被成功移除的成員的數量，不包括被忽略的成員。
```
zremrangebyrank
```
conn.zremrangebyrank(name, min, max)
```
移除有序集 name 中，指定排名(rank)區間內的全部成員。

區間分別如下標參數 min 和 max 指出，包含 min 和 max 在內。

下標參數 min 和 max 都以 0 爲底，也就是說，以 0 表示有序集第一個成員，以 1 表示有序集第二個成員，以此類推。

你也可使用負數下標，以 -1 表示最後一個成員， -2 表示倒數第二個成員，以此類推。
```
返回值:
    被移除成員的數量。
```
zremrangebyscore
```
conn.zremrangebyscore(name, min, max)
```
移除有序集 key 中，全部 score 值介於 min 和 max 之間(包括等於 min 或 max )的成員。

自版本2.1.6開始， score 值等於 min 或 max 的成員也能夠不包括在內。
```
返回值:
    被移除成員的數量。
```
zscore
```
conn.zscore(name, value)
```
返回有序集 name 中，成員 value 的 score 值。

若是 value 元素不是有序集 key 的成員，或 key 不存在，返回 None 。
```
返回值:
    value 成員的 score 值，以字符串形式表示。
```
zinterstore
```
conn.zinterstore(dest, keys, aggregate=None)
```
計算給定的一個或多個有序集的交集，並將該交集(結果集)儲存到 dest 。

默認狀況下，結果集中某個成員的 score 值是全部給定集下該成員 score 值之和。
```
返回值:
    保存到 dest 的結果集的基數。
```

zunionstore

conn.zunionstore(dest, keys, aggregate=None)

計算給定的一個或多個有序集的並集，並將該並集(結果集)儲存到 dest 。

默認狀況下，結果集中某個成員的 score 值是全部給定集下該成員 score 值之和。

aggregate
    使用 aggregate 選項，你能夠指定並集的結果集的聚合方式。
    默認使用的參數 SUM ，能夠將全部集合中某個成員的 score 值之 和 做爲結果集中該成員的 score 值；使用參數 MIN ，能夠將全部集合中某個成員的 最小 score 值做爲結果集中該成員的 score 值；而參數 MAX 則是將全部集合中某個成員的 最大 score 值做爲結果集中該成員的 score 值。
返回值:
    保存到 dest 的結果集的基數。

zscan

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

用於迭代集合鍵中的元素。

返回值：
    返回的每一個元素都是一個集合成員。

zsacniter

conn.zscan_iter(name, match=None, count=None, score_cast_func=float)

利用 yield 封裝 zscan 建立生成器，實現分批去 redis 中獲取數據。

返回值參考 zscan 。

Key（鍵）操做

delete
```
conn.delete(*names)
```
刪除給定的一個或多個 key 。

不存在的 key 會被忽略。
```
返回值：
    被刪除 name 的數量。
```
dump
```
conn.dump(name)
```
序列化給定 name ，並返回被序列化的值，使用 restore 命令能夠將這個值反序列化爲 Redis 鍵。

序列化生成的值有如下幾個特色：
- 它帶有 64 位的校驗和，用於檢測錯誤， restore 在進行反序列化以前會先檢查校驗和。
- 值的編碼格式和 RDB 文件保持一致。
- RDB 版本會被編碼在序列化值當中，若是由於 Redis 的版本不一樣形成 RDB 格式不兼容，那麼 Redis 會拒絕對這個值進行反序列化操做。
序列化的值不包括任何生存時間信息。
```
返回值：
    若是 key 不存在，那麼返回 None 。
    不然，返回序列化以後的值。
```

exists

conn.exists(*names)

檢查給定 key 是否存在。

返回值：
    存在 key 的數量 ，沒有則返回 0 。

expire
```
conn.expire(name, time)
```
爲給定 name 設置生存時間，當 name 過時時(生存時間爲 0 )，它會被自動刪除。

在 Redis 中，帶有生存時間的 name 被稱爲『易失的』(volatile)。

生存時間能夠經過使用 delete 命令來刪除整個 name 來移除，或者被 set 和 getset 命令覆寫(overwrite)，這意味着，若是一個命令只是修改(alter)一個帶生存時間的 name 的值而不是用一個新的 name 值來代替(replace)它的話，那麼生存時間不會被改變。

好比說，對一個 name 執行 incr 命令，對一個列表進行 lpush 命令，或者對一個哈希表執行 hset 命令，這類操做都不會修改 key 自己的生存時間。

另外一方面，若是使用 rename 對一個 name 進行更名，那麼更名後的 name 的生存時間和更名前同樣。

rename 命令的另外一種多是，嘗試將一個帶生存時間的 name 更名成另外一個帶生存時間的 another_name ，這時舊的 another_name (以及它的生存時間)會被刪除，而後舊的 name 會更名爲 another_name ，所以，新的 another_name 的生存時間也和本來的 name 同樣。

使用 persist 命令能夠在不刪除 name 的狀況下，移除 name 的生存時間，讓 name 從新成爲一個『持久的』(persistent) name 。
```
更新生存時間：
    能夠對一個已經帶有生存時間的 name 執行 expire 命令，新指定的生存時間會取代舊的生存時間。
過時時間的精確度：
    在 Redis 2.4 版本中，過時時間的延遲在 1 秒鐘以內 —— 也便是，就算 name 已通過期，但它仍是可能在過時以後一秒鐘以內被訪問到，而在新的 Redis 2.6 版本中，延遲被下降到 1 毫秒以內。
Redis 2.1.3 以前的不一樣之處：
    在 Redis 2.1.3 以前的版本中，修改一個帶有生存時間的 name 會致使整個 name 被刪除，這一行爲是受當時複製(replication)層的限制而做出的，如今這一限制已經被修復。
返回值：
    設置成功返回 1 。
    當 name 不存在或者不能爲 name 設置生存時間時(好比在低於 2.1.3 版本的 Redis 中你嘗試更新 key 的生存時間)，返回 0 。
```
expireat
```
conn.expireat(name, when)
```
expireat 的做用和 expire 相似，都用於爲 key 設置生存時間。

不一樣在於 expireat 命令接受的時間參數是時間戳(timestamp)。
```
返回值：
    若是生存時間設置成功，返回 1 。
    當 key 不存在或沒辦法設置生存時間，返回 0 。
```
keys
```
conn.keys(pattern='*')
```
查找全部符合給定模式 pattern 的 key 。

keys('*') 匹配數據庫中全部 key 。

keys('h?llo') 匹配 hello ， hallo 和 hxllo 等。

keys('h*llo') 匹配 hllo 和 heeeeello 等。

keys('h[ae]llo') 匹配 hello 和 hallo ，但不匹配 hillo 。

特殊符號用 \ 隔開。
```
返回值：
    符合給定模式的 key 列表。
```
migrate
```
conn.migrate(self, host, port, keys, destination_db, timeout, copy=False, replace=False, auth=None)
```
將 key 原子性地從當前實例傳送到目標實例的指定數據庫上，一旦傳送成功， key 保證會出如今目標實例上，而當前實例上的 key 會被刪除。

這個命令是一個原子操做，它在執行的時候會阻塞進行遷移的兩個實例，直到如下任意結果發生：遷移成功，遷移失敗，等待超時。

命令的內部實現是這樣的：它在當前實例對給定 key 執行 dump 命令，將它序列化，而後傳送到目標實例，目標實例再使用 restore 對數據進行反序列化，並將反序列化所得的數據添加到數據庫中；當前實例就像目標實例的客戶端那樣，只要看到 restore 命令返回 OK ，它就會調用 delete 刪除本身數據庫上的 key 。

timeout 參數以毫秒爲格式，指定當前實例和目標實例進行溝通的最大間隔時間。這說明操做並不必定要在 timeout 毫秒內完成，只是說數據傳送的時間不能超過這個 timeout 數。

migrate 命令須要在給定的時間規定內完成 IO 操做。若是在傳送數據時發生 IO 錯誤，或者達到了超時時間，那麼命令會中止執行，並返回一個特殊的錯誤： IOERR 。

當 IOERR 出現時，有如下兩種可能：
- key 可能存在於兩個實例。
- key 可能只存在於當前實例。
惟一不可能發生的狀況就是丟失 key ，所以，若是一個客戶端執行 migrate 命令，而且不幸趕上 IOERR 錯誤，那麼這個客戶端惟一要作的就是檢查本身數據庫上的 key 是否已經被正確地刪除。

若是有其餘錯誤發生，那麼 migrate 保證 key 只會出如今當前實例中。（固然，目標實例的給定數據庫上可能有和 key 同名的鍵，不過這和 migrate 命令沒有關係）。
```
可選項：
    copy ：不移除源實例上的 key 。
    replace ：替換目標實例上已存在的 key 。
返回值：
    遷移成功時返回 True ，不然返回相應的錯誤。
```
move
```
move(name, db)
```
將當前數據庫的 name 移動到給定的數據庫 db 當中。

若是當前數據庫(源數據庫)和給定數據庫(目標數據庫)有相同名字的給定 name ，或者 name 不存在於當前數據庫，那麼 move 沒有任何效果。

所以，也能夠利用這一特性，將 move 看成鎖(locking)原語(primitive)。
```
返回值：
    移動成功返回 1 ，失敗則返回 0 。
```
persist
```
conn.persist(name)
```
移除給定 name 的生存時間，將這個 name 從『易失的』(帶生存時間 name )轉換成『持久的』(一個不帶生存時間、永不過時的 name )。
```
返回值：
    當生存時間移除成功時，返回 1 。
    若是 key 不存在或 key 沒有設置生存時間，返回 0 。
```
pexpire
```
conn.pexpire(name, time)
```
這個命令和 expire 命令的做用相似，可是它以毫秒爲單位設置 name 的生存時間，而不像 expire 命令那樣，以秒爲單位。
```
返回值：
    設置成功，返回 1。
    key 不存在或設置失敗，返回 0 。 
```

pexpireat

conn.pexpireat(name, when)

這個命令和 expireat 命令相似，但它以毫秒爲單位設置 name 的過時時間戳，而不是像 expireat 那樣，以秒爲單位。

返回值：
    若是生存時間設置成功，返回 1 。
    當 name 不存在或沒辦法設置生存時間時，返回 0 。(查看 expire 命令獲取更多信息)

pttl

conn.pttl(name)

這個命令相似於 ttl 命令，但它以毫秒爲單位返回 name 的剩餘生存時間，而不是像 ttl 命令那樣，以秒爲單位。

返回值：
    當 name 不存在時，返回 -2 。
    當 name 存在但沒有設置剩餘生存時間時，返回 -1 。
    不然，以毫秒爲單位，返回 name 的剩餘生存時間。

randomkey

conn.randomkey()

從當前數據庫中隨機返回(不刪除)一個 key 。

返回值：
    當數據庫不爲空時，返回一個 key 。
    當數據庫爲空時，返回 None 。

rename
```
conn.rename(src, dst)
```
將 src 更名爲 dst 。

當 src 和 dst 相同，或者 src 不存在時，返回一個錯誤。

當 dest 已經存在時， rename 命令將覆蓋舊值。
```
返回值：
    更名成功時提示 True ，失敗時候返回一個錯誤。
```

renamenx

conn.renamenx(src, dst)

當且僅當 dst 不存在時，將 src 更名爲 dst 。

當 src 不存在時，返回一個錯誤。

返回值：
    修改爲功時，返回 1 。
    若是 dst 已經存在，返回 0 。

restore
```
conn.restore(name, ttl, value, replace=False)
```
反序列化給定的序列化值，並將它和給定的 name 關聯。

參數 ttl 以毫秒爲單位爲 name 設置生存時間；若是 ttl 爲 0 ，那麼不設置生存時間。

restore 在執行反序列化以前會先對序列化值的 RDB 版本和數據校驗和進行檢查，若是 RDB 版本不相同或者數據不完整的話，那麼 restore 會拒絕進行反序列化，並返回一個錯誤。

若是鍵 name 已經存在，而且給定了 replace 選項，那麼使用反序列化得出的值來代替鍵 name 原有的值；相反地，若是鍵 name 已經存在，可是沒有給定 replace 選項，那麼命令返回一個錯誤。
```
返回值：
    若是反序列化成功那麼返回 True ，不然返回一個錯誤。
```

sort

conn.sort(name, start=None, num=None, by=None, get=None, desc=False, alpha=False, store=None, groups=False)

返回或保存給定列表、集合、有序集合 key 中通過排序的元素。

排序默認以數字做爲對象，值被解釋爲雙精度浮點數，而後進行比較。

返回值：
    沒有使用 store 參數，返回列表形式的排序結果。
    使用 store 參數，返回排序結果的元素數量。

ttl

conn.ttl(name)

以秒爲單位，返回給定 name 的剩餘生存時間(TTL, time to live)。

返回值：
    當 name 不存在時，返回 -2 。
    當 name 存在但沒有設置剩餘生存時間時，返回 -1 。
    不然，以秒爲單位，返回 name 的剩餘生存時間。

type

conn.type(name)

返回 key 所儲存的值的類型。

返回值：
    none (key不存在)
    string (字符串)
    list (列表)
    set (集合)
    zset (有序集)
    hash (哈希表)

scan

conn.scan(cursor=0, match=None, count=None)

scan 命令及其相關的 sscan 命令、 hscan 命令和 zscan 命令都用於增量地迭代（incrementally iterate）一集元素（a collection of elements）：

scan 命令用於迭代當前數據庫中的數據庫鍵。
sscan 命令用於迭代集合鍵中的元素。
hscan 命令用於迭代哈希鍵中的鍵值對。
zscan 命令用於迭代有序集合中的元素（包括元素成員和元素分值）。

以上列出的四個命令都支持增量式迭代，它們每次執行都只會返回少許元素，因此這些命令能夠用於生產環境，而不會出現像 key 命令、 smembers 命令帶來的問題 —— 當 keys 命令被用於處理一個大的數據庫時，又或者 smembers 命令被用於處理一個大的集合鍵時，它們可能會阻塞服務器達數秒之久。

不過，增量式迭代命令也不是沒有缺點的：舉個例子，使用 smembers 命令能夠返回集合鍵當前包含的全部元素，可是對於 scan 這類增量式迭代命令來講，由於在對鍵進行增量式迭代的過程當中，鍵可能會被修改，因此增量式迭代命令只能對被返回的元素提供有限的保證（offer limited guarantees about the returned elements）。

由於 scan 、 sscan 、 hscan 和 zscan 四個命令的工做方式都很是類似，因此這個文檔會一併介紹這四個命令，可是要記住：

sscan 命令、 hscan 命令和 zscan 命令的第一個參數老是一個數據庫鍵。
而 scan 命令則不須要在第一個參數提供任何數據庫鍵 —— 由於它迭代的是當前數據庫中的全部數據庫鍵。

scan 命令的基本用法
    scan 命令是一個基於遊標的迭代器（cursor based iterator）： scan 命令每次被調用以後， 都會向用戶返回一個新的遊標， 用戶在下次迭代時須要使用這個新遊標做爲 scan 命令的遊標參數， 以此來延續以前的迭代過程。
    當 scan 命令的遊標參數被設置爲 0 時， 服務器將開始一次新的迭代， 而當服務器向用戶返回值爲 0 的遊標時， 表示迭代已結束。
    如下是一個 scan 命令的迭代過程示例：

    redis 127.0.0.1:6379> scan 0
    1) "17"
    2)  1) "key:12"
        2) "key:8"
        3) "key:4"
        4) "key:14"
        5) "key:16"
        6) "key:17"
        7) "key:15"
        8) "key:10"
        9) "key:3"
        10) "key:7"
        11) "key:1"

    redis 127.0.0.1:6379> scan 17
    1) "0"
    2) 1) "key:5"
       2) "key:18"
       3) "key:0"
       4) "key:2"
       5) "key:19"
       6) "key:13"
       7) "key:6"
       8) "key:9"
       9) "key:11"
在上面這個例子中， 第一次迭代使用 0 做爲遊標， 表示開始一次新的迭代。
第二次迭代使用的是第一次迭代時返回的遊標， 也便是命令回覆第一個元素的值 —— 17 。
從上面的示例能夠看到， scan 命令的回覆是一個包含兩個元素的數組， 第一個數組元素是用於進行下一次迭代的新遊標， 而第二個數組元素則是一個數組， 這個數組中包含了全部被迭代的元素。
在第二次調用 scan 命令時， 命令返回了遊標 0 ， 這表示迭代已經結束， 整個數據集（collection）已經被完整遍歷過了。
以 0 做爲遊標開始一次新的迭代， 一直調用 scan 命令， 直到命令返回遊標 0 ， 咱們稱這個過程爲一次完整遍歷（full iteration）。

scan 命令的保證（guarantees）
    scan 命令， 以及其餘增量式迭代命令， 在進行完整遍歷的狀況下能夠爲用戶帶來如下保證： 從完整遍歷開始直到完整遍歷結束期間， 一直存在於數據集內的全部元素都會被完整遍歷返回； 這意味着， 若是有一個元素， 它從遍歷開始直到遍歷結束期間都存在於被遍歷的數據集當中， 那麼 SCAN 命令總會在某次迭代中將這個元素返回給用戶。
    然而由於增量式命令僅僅使用遊標來記錄迭代狀態， 因此這些命令帶有如下缺點：
    同一個元素可能會被返回屢次。 處理重複元素的工做交由應用程序負責， 好比說， 能夠考慮將迭代返回的元素僅僅用於能夠安全地重複執行屢次的操做上。
    若是一個元素是在迭代過程當中被添加到數據集的， 又或者是在迭代過程當中從數據集中被刪除的， 那麼這個元素可能會被返回， 也可能不會， 這是未定義的（undefined）。

scan 命令每次執行返回的元素數量
    增量式迭代命令並不保證每次執行都返回某個給定數量的元素。
    增量式命令甚至可能會返回零個元素， 但只要命令返回的遊標不是 0 ， 應用程序就不該該將迭代視做結束。
    不過命令返回的元素數量老是符合必定規則的， 在實際中：
    對於一個大數據集來講， 增量式迭代命令每次最多可能會返回數十個元素；
    而對於一個足夠小的數據集來講， 若是這個數據集的底層表示爲編碼數據結構（encoded data structure，適用因而小集合鍵、小哈希鍵和小有序集合鍵）， 那麼增量迭代命令將在一次調用中返回數據集中的全部元素。
    最後， 用戶能夠經過增量式迭代命令提供的 count 選項來指定每次迭代返回元素的最大值。

count 選項
    雖然增量式迭代命令不保證每次迭代所返回的元素數量， 但咱們可使用 count 選項， 對命令的行爲進行必定程度上的調整。
    基本上， count 選項的做用就是讓用戶告知迭代命令， 在每次迭代中應該從數據集裏返回多少元素。
    雖然 count 選項只是對增量式迭代命令的一種提示（hint）， 可是在大多數狀況下， 這種提示都是有效的。

count 參數的默認值爲 10
    在迭代一個足夠大的、由哈希表實現的數據庫、集合鍵、哈希鍵或者有序集合鍵時， 若是用戶沒有使用 match 選項， 那麼命令返回的元素數量一般和 count 選項指定的同樣， 或者比 count 選項指定的數量稍多一些。
    在迭代一個編碼爲整數集合（intset，一個只由整數值構成的小集合）、 或者編碼爲壓縮列表（ziplist，由不一樣值構成的一個小哈希或者一個小有序集合）時， 增量式迭代命令一般會無視 count 選項指定的值， 在第一次迭代就將數據集包含的全部元素都返回給用戶。
    並不是每次迭代都要使用相同的 count 值。
    用戶能夠在每次迭代中按本身的須要隨意改變 count 值， 只要記得將上次迭代返回的遊標用到下次迭代裏面就能夠了。

match 選項
    和 keys 命令同樣， 增量式迭代命令也能夠經過提供一個 glob 風格的模式參數， 讓命令只返回和給定模式相匹配的元素， 這一點能夠經過在執行增量式迭代命令時， 經過給定 match <pattern> 參數來實現。
    如下是一個使用 match 選項進行迭代的示例：

    redis 127.0.0.1:6379> sadd myset 1 2 3 foo foobar feelsgood
    (integer) 6

    redis 127.0.0.1:6379> sscan myset 0 match f*
    1) "0"
    2) 1) "foo"
       2) "feelsgood"
       3) "foobar"
    須要注意的是， 對元素的模式匹配工做是在命令從數據集中取出元素以後， 向客戶端返回元素以前的這段時間內進行的， 因此若是被迭代的數據集中只有少許元素和模式相匹配， 那麼迭代命令或許會在屢次執行中都不返回任何元素。
    如下是這種狀況的一個例子：

    redis 127.0.0.1:6379> scan 0 MATCH *11*
    1) "288"
    2) 1) "key:911"

    redis 127.0.0.1:6379> scan 288 MATCH *11*
    1) "224"
    2) (empty list or set)

    redis 127.0.0.1:6379> scan 224 MATCH *11*
    1) "80"
    2) (empty list or set)

    redis 127.0.0.1:6379> scan 80 MATCH *11*
    1) "176"
    2) (empty list or set)

    redis 127.0.0.1:6379> scan 176 MATCH *11* COUNT 1000
    1) "0"
    2)  1) "key:611"
        2) "key:711"
        3) "key:118"
        4) "key:117"
        5) "key:311"
        6) "key:112"
        7) "key:111"
        8) "key:110"
        9) "key:113"
       10) "key:211"
       11) "key:411"
       12) "key:115"
       13) "key:116"
       14) "key:114"
       15) "key:119"
       16) "key:811"
       17) "key:511"
       18) "key:11"
    如你所見， 以上的大部分迭代都不返回任何元素。
    在最後一次迭代， 咱們經過將 count 選項的參數設置爲 1000 ， 強制命令爲本次迭代掃描更多元素， 從而使得命令返回的元素也變多了。
    併發執行多個迭代
    在同一時間， 能夠有任意多個客戶端對同一數據集進行迭代， 客戶端每次執行迭代都須要傳入一個遊標， 並在迭代執行以後得到一個新的遊標， 而這個遊標就包含了迭代的全部狀態， 所以， 服務器無須爲迭代記錄任何狀態。

中途中止迭代
    由於迭代的全部狀態都保存在遊標裏面， 而服務器無須爲迭代保存任何狀態， 因此客戶端能夠在中途中止一個迭代， 而無須對服務器進行任何通知。
    即便有任意數量的迭代在中途中止， 也不會產生任何問題。

使用錯誤的遊標進行增量式迭代
    使用間斷的（broken）、負數、超出範圍或者其餘非正常的遊標來執行增量式迭代並不會形成服務器崩潰， 但可能會讓命令產生未定義的行爲。
    未定義行爲指的是， 增量式命令對返回值所作的保證可能會再也不爲真。

只有兩種遊標是合法的：
    在開始一個新的迭代時， 遊標必須爲 0 。
    增量式迭代命令在執行以後返回的， 用於延續（continue）迭代過程的遊標。
迭代終結的保證
    增量式迭代命令所使用的算法只保證在數據集的大小有界（bounded）的狀況下， 迭代纔會中止， 換句話說， 若是被迭代數據集的大小不斷地增加的話， 增量式迭代命令可能永遠也沒法完成一次完整迭代。
    從直覺上能夠看出， 當一個數據集不斷地變大時， 想要訪問這個數據集中的全部元素就須要作愈來愈多的工做， 可否結束一個迭代取決於用戶執行迭代的速度是否比數據集增加的速度更快。

可用版本：
    >= 2.8.0
    時間複雜度：

增量式迭代命令每次執行的複雜度爲 O(1) ， 對數據集進行一次完整迭代的複雜度爲 O(N) ， 其中 N 爲數據集中的元素數量。
返回值：
    scan 命令、 sscan 命令、 hscan 命令和 zscan 命令都返回一個包含兩個元素的 multi-bulk 回覆： 回覆的第一個元素是字符串表示的無符號 64 位整數（遊標）， 回覆的第二個元素是另外一個 multi-bulk 回覆， 這個 multi-bulk 回覆包含了本次被迭代的元素。
    scan 命令返回的每一個元素都是一個數據庫鍵。
    sscan 命令返回的每一個元素都是一個集合成員。
    hscan 命令返回的每一個元素都是一個鍵值對，一個鍵值對由一個鍵和一個值組成。
    zscan 命令返回的每一個元素都是一個有序集合元素，一個有序集合元素由一個成員（member）和一個分值（score）組成。

事務操做

redis-py 默認在執行每次請求都會建立（鏈接池申請鏈接）和斷開（歸還鏈接池）一次鏈接操做，若是想要在一次請求中指定多個命令，則可使用 pipline 實現一次請求指定多個命令，而且默認狀況下一次 pipline 是原子性操做。

import redis
 
pool = redis.ConnectionPool(host='192.168.22.132', port=6379)
conn = redis.Redis(connection_pool=pool)

# pipe = conn.pipeline(transaction=False)
pipe = conn.pipeline(transaction=True)

pipe.set('name', 'root')
pipe.set('role', 'root')

pipe.execute()