Redis Python開發指南

redis基本命令

String

set     setex     psetex    mset    mget    getset  getrange    setrange    setbit    getbit     bitcount  bittop     strlen    incr    incrfloat    decr        append 

Hash

hset    hmset    hmget  hgetall     hlen     hkeys     hvals     hexists    hdel    hincrby     hincrbyfloat     hscan    hscan_iter 

List 

lpush      rpush        lpushx      rpushx      linsert     lset      lrem      lpop    ltrim   lindex      rpoplpush       brpoplpush     blpop    自定義增量迭代

 

有序集合sort set操做

zadd  zcard zrange  zcount  zincraby  zrank  zrem  zremrangebyrank  zscore 

其餘經常使用操做

delete  exists  keys  expire   rname  randomkey  type scan  scan_iter  管道(pipeline)

 

 

Set 

set(name, value, ex=None, px=None, nx=False, xx=False)
在Redis中設置值，默認，不存在則建立，存在則修改

參數說明：
 ex，過時時間（秒）
px，過時時間（毫秒）
nx，若是設置爲True，則只有name不存在時，當前set操做才執行
xx，若是設置爲True，則只有name存在時，當前set操做才執行
1.ex，過時時間（秒） 這裏過時時間是3秒，3秒後p，鍵food的值就變成None
import redis

pool = redis.ConnectionPool(host='127.0.0.1', port=6379, decode_responses=True)
r = redis.Redis(connection_pool=pool)
r.set('food', 'mutton', ex=3)    # key是"food" value是"mutton" 將鍵值對存入redis緩存
print(r.get('food'))  # mutton 取出鍵food對應的值
2.px，過時時間（豪秒） 這裏過時時間是3豪秒，3毫秒後，鍵foo的值就變成None
import redis

pool = redis.ConnectionPool(host='127.0.0.1', port=6379, decode_responses=True)
r = redis.Redis(connection_pool=pool)
r.set('food', 'beef', px=3)
print(r.get('food'))
3.nx，若是設置爲True，則只有name不存在時，當前set操做才執行 （新建）
import redis

pool = redis.ConnectionPool(host='127.0.0.1', port=6379, decode_responses=True)
r = redis.Redis(connection_pool=pool)
print(r.set('fruit', 'watermelon', nx=True))    # True--不存在
# 若是鍵fruit不存在，那麼輸出是True；若是鍵fruit已經存在，輸出是None
4.xx，若是設置爲True，則只有name存在時，當前set操做才執行 （修改）
print((r.set('fruit', 'watermelon', xx=True)))   # True--已經存在
# 若是鍵fruit已經存在，那麼輸出是True；若是鍵fruit不存在，輸出是None
5.setnx(name, value)
設置值，只有name不存在時，執行設置操做（添加）
print(r.setnx('fruit1', 'banana'))  # fruit1不存在，輸出爲True

setex

setex(name, value, time)
設置值
參數：
time，過時時間（數字秒 或 timedelta對象）
import redis
import time

pool = redis.ConnectionPool(host='127.0.0.1', port=6379, decode_responses=True)
r = redis.Redis(connection_pool=pool)
r.setex("fruit2", "orange", 5)
time.sleep(5)
print(r.get('fruit2'))  # 5秒後，取值就從orange變成None

psetex

psetex(name, time_ms, value)
設置值
參數：
time_ms，過時時間（數字毫秒 或 timedelta對象）
r.psetex("fruit3", 5000, "apple")
time.sleep(5)
print(r.get('fruit3'))  # 5000毫秒後，取值就從apple變成None

mset

批量設置值
如：
r.mget({'k1': 'v1', 'k2': 'v2'})
r.mset(k1="v1", k2="v2") # 這裏k1 和k2 不能帶引號 一次設置對個鍵值對
print(r.mget("k1", "k2"))   # 一次取出多個鍵對應的值
print(r.mget("k1"))

mget

mget(keys, *args)
批量獲取
如：
print(r.mget('k1', 'k2'))
print(r.mget(['k1', 'k2']))
print(r.mget("fruit", "fruit1", "fruit2", "k1", "k2"))  # 將目前redis緩存中的鍵對應的值批量取出來

getset

getset(name, value)
設置新值並獲取原來的值
print(r.getset("food", "barbecue"))  # 設置的新值是barbecue 設置前的值是beef1

getrange

getrange(key, start, end)
獲取子序列（根據字節獲取，非字符）
參數：
name，Redis 的 name
start，起始位置（字節）
end，結束位置（字節）
如： 「君惜大大」 ，0-3表示 「君」
r.set("cn_name", "君惜大大") # 漢字
print(r.getrange("cn_name", 0, 2))   # 取索引號是0-2 前3位的字節 君 切片操做 （一個漢字3個字節 1個字母一個字節 每一個字節8bit）
print(r.getrange("cn_name", 0, -1))  # 取全部的字節 君惜大大 切片操做
r.set("en_name","junxi") # 字母
print(r.getrange("en_name", 0, 2))  # 取索引號是0-2 前3位的字節 jun 切片操做 （一個漢字3個字節 1個字母一個字節 每一個字節8bit）
print(r.getrange("en_name", 0, -1)) # 取全部的字節 junxi 切片操做

setrange

setrange(name, offset, value)
修改字符串內容，從指定字符串索引開始向後替換（新值太長時，則向後添加）
參數：
offset，字符串的索引，字節（一個漢字三個字節）
value，要設置的值
r.setrange("en_name", 1, "ccc")
print(r.get("en_name"))    # jccci 原始值是junxi 從索引號是1開始替換成ccc 變成 jccci2

setbit

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

getbit(name, offset)
獲取name對應的值的二進制表示中的某位的值 （0或1）
print(r.getbit("foo1", 0)) # 0 foo1 對應的二進制 4個字節 32位 第0位是0仍是1

bitcount

bitcount(key, start=None, end=None)
獲取name對應的值的二進制表示中 1 的個數
參數：
key，Redis的name
start 字節起始位置
end，字節結束位置
print(r.get("foo"))  # goo1 01100111
print(r.bitcount("foo",0,1))  # 11 表示前2個字節中，1出現的個數

bittop

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 對應的值中
r.set("foo","1")  # 0110001
r.set("foo1","2")  # 0110010
print(r.mget("foo","foo1"))  # ['goo1', 'baaanew']
print(r.bitop("AND","new","foo","foo1"))  # "new" 0 0110000
print(r.mget("foo","foo1","new"))

source = "12"
for i in source:
num = ord(i)
print(num)  # 打印每一個字母字符或者漢字字符對應的ascii碼值 f-102-0b100111-01100111
print(bin(num))  # 打印每一個10進制ascii碼值轉換成二進制的值 0b1100110（0b表示二進制）
print bin(num).replace('b','')  # 將二進制0b1100110替換成01100110

strlen

strlen(name)
返回name對應值的字節長度（一個漢字3個字節）
print(r.strlen("foo"))  # 4 'goo1'的長度是4

incr

incr(self, name, amount=1)
自增 name對應的值，當name不存在時，則建立name＝amount，不然，則自增。
參數：
name,Redis的name
amount,自增數（必須是整數）
注：同incrby
r.set("foo", 123)
print(r.mget("foo", "foo1", "foo2", "k1", "k2"))
r.incr("foo", amount=1)
print(r.mget("foo", "foo1", "foo2", "k1", "k2"))
應用場景 – 頁面點擊數
假定咱們對一系列頁面須要記錄點擊次數。例如論壇的每一個帖子都要記錄點擊次數，而點擊次數比回帖的次數的多得多。若是使用關係數據庫來存儲點擊，可能存在大量的行級鎖爭用。因此，
點擊數的增長使用redis的INCR命令最好不過了。
當redis服務器啓動時，能夠從關係數據庫讀入點擊數的初始值（12306這個頁面被訪問了34634次）
r.set("visit:12306:totals", 34634)
print(r.get("visit:12306:totals"))
每當有一個頁面點擊，則使用INCR增長點擊數便可。
r.incr("visit:12306:totals")
r.incr("visit:12306:totals")
頁面載入的時候則可直接獲取這個值
print(r.get("visit:12306:totals"))

incrfloat

incrbyfloat(self, name, amount=1.0)
自增 name對應的值，當name不存在時，則建立name＝amount，不然，則自增。
參數：
name,Redis的name
amount,自增數（浮點型）
r.set("foo1", "123.0")
r.set("foo2", "221.0")
print(r.mget("foo1", "foo2"))
r.incrbyfloat("foo1", amount=2.0)
r.incrbyfloat("foo2", amount=3.0)
print(r.mget("foo1", "foo2"))

decr

decr(self, name, amount=1)
自減 name對應的值，當name不存在時，則建立name＝amount，不然，則自減。
參數：
name,Redis的name
amount,自減數（整數)
r.decr("foo4", amount=3) # 遞減3
r.decr("foo1", amount=1) # 遞減1
print(r.mget("foo1", "foo4"))

append

append(key, value)
在redis name對應的值後面追加內容
參數：
key, redis的name
value, 要追加的字符串
r.append("name", "haha")    # 在name對應的值junxi後面追加字符串haha
print(r.mget("name"))

 

hash操做

 

hset

1.單個增長–修改(單個取出)–沒有就新增，有的話就修改
hset(name, key, value)
name對應的hash中設置一個鍵值對（不存在，則建立；不然，修改）
參數：
name，redis的name
key，name對應的hash中的key
value，name對應的hash中的value
注：
hsetnx(name, key, value),當name對應的hash中不存在當前key時則建立（至關於添加）
import redis
import time

pool = redis.ConnectionPool(host='127.0.0.1', port=6379, decode_responses=True)
r = redis.Redis(connection_pool=pool)

r.hset("hash1", "k1", "v1")
r.hset("hash1", "k2", "v2")
print(r.hkeys("hash1")) # 取hash中全部的key
print(r.hget("hash1", "k1"))    # 單個取hash的key對應的值
print(r.hmget("hash1", "k1", "k2")) # 多個取hash的key對應的值
r.hsetnx("hash1", "k2", "v3") # 只能新建
print(r.hget("hash1", "k2"))

hmset

 批量增長（取出）

hmset(name, mapping)
在name對應的hash中批量設置鍵值對
參數：
name，redis的name
mapping，字典，如：{‘k1’:’v1’, ‘k2’: ‘v2’}
如：
r.hmset("hash2", {"k2": "v2", "k3": "v3"})
hget(name,key)
在name對應的hash中獲取根據key獲取value

hmget

hmget(name, keys, *args)
在name對應的hash中獲取多個key的值
參數：
name，reids對應的name
keys，要獲取key集合，如：[‘k1’, ‘k2’, ‘k3’]
*args，要獲取的key，如：k1,k2,k3
如：
print(r.hget("hash2", "k2"))  # 單個取出"hash2"的key-k2對應的value
print(r.hmget("hash2", "k2", "k3"))  # 批量取出"hash2"的key-k2 k3對應的value --方式1
print(r.hmget("hash2", ["k2", "k3"]))  # 批量取出"hash2"的key-k2 k3對應的value 

hgetall

取出全部的鍵值對
hgetall(name)
獲取name對應hash的全部鍵值
print(r.hgetall("hash1"))

hlen

獲得全部鍵值對的格式 hash長度
hlen(name)
獲取name對應的hash中鍵值對的個數
print(r.hlen("hash1"))

hkeys

 

獲得全部的keys（相似字典的取全部keys）
hkeys(name)
獲取name對應的hash中全部的key的值
print(r.hkeys("hash1"))

hvals

獲得全部的value（相似字典的取全部value）
hvals(name)
獲取name對應的hash中全部的value的值
print(r.hvals("hash1"))

hexists

判斷成員是否存在（相似字典的in）
hexists(name, key)
檢查name對應的hash是否存在當前傳入的key
print(r.hexists("hash1", "k4"))  # False 不存在
print(r.hexists("hash1", "k1"))  # True 存在

 hdel

刪除鍵值對
hdel(name,*keys)
將name對應的hash中指定key的鍵值對刪除
print(r.hgetall("hash1"))
r.hset("hash1", "k2", "v222")   # 修改已有的key k2
r.hset("hash1", "k11", "v1")   # 新增鍵值對 k11
r.hdel("hash1", "k1")    # 刪除一個鍵值對
print(r.hgetall("hash1"))

hincrby

自增自減整數(將key對應的value–整數 自增1或者2，或者別的整數 負數就是自減)
hincrby(name, key, amount=1)
自增name對應的hash中的指定key的值，不存在則建立key=amount
參數：
name，redis中的name
key， hash對應的key
amount，自增數（整數）
r.hset("hash1", "k3", 123)
r.hincrby("hash1", "k3", amount=-1)
print(r.hgetall("hash1"))
r.hincrby("hash1", "k4", amount=1)  # 不存在的話，value默認就是1
print(r.hgetall("hash1"))

hincrbyfloat

自增自減浮點數(將key對應的value–浮點數 自增1.0或者2.0，或者別的浮點數 負數就是自減)
hincrbyfloat(name, key, amount=1.0)
自增name對應的hash中的指定key的值，不存在則建立key=amount
參數：
name，redis中的name
key， hash對應的key
amount，自增數（浮點數）
自增name對應的hash中的指定key的值，不存在則建立key=amount
r.hset("hash1", "k5", "1.0")
r.hincrbyfloat("hash1", "k5", amount=-1.0)    # 已經存在，遞減-1.0
print(r.hgetall("hash1"))
r.hincrbyfloat("hash1", "k6", amount=-1.0)    # 不存在，value初始值是-1.0 每次遞減1.0
print(r.hgetall("hash1"))

hscan

取值查看–分片讀取
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時，表示數據已經經過分片獲取完畢
print(r.hscan("hash1"))

hscan_iter 

hscan_iter(name, match=None, count=None)
利用yield封裝hscan建立生成器，實現分批去redis中獲取數據
參數：
match，匹配指定key，默認None 表示全部的key
count，每次分片最少獲取個數，默認None表示採用Redis的默認分片個數
如：
for item in r.hscan_iter('hash1'):
    print(item)
print(r.hscan_iter("hash1"))    # 生成器內存地址

list列表操做

lpush

增長（相似於list的append，只是這裏是從左邊新增長）–沒有就新建
lpush(name,values)
在name對應的list中添加元素，每一個新的元素都添加到列表的最左邊
如：
import redis
import time

pool = redis.ConnectionPool(host='127.0.0.1', port=6379, decode_responses=True)
r = redis.Redis(connection_pool=pool)

r.lpush("list1", 11, 22, 33)
print(r.lrange('list1', 0, -1))
保存順序爲: 33,22,11
擴展：
r.rpush("list2", 11, 22, 33)  # 表示從右向左操做
print(r.llen("list2"))  # 列表長度
print(r.lrange("list2", 0, 3))  # 切片取出值，範圍是索引號0-3

rpush

增長（從右邊增長）–沒有就新建
r.rpush("list2", 44, 55, 66)    # 在列表的右邊，依次添加44,55,66
print(r.llen("list2"))  # 列表長度
print(r.lrange("list2", 0, -1)) # 切片取出值，範圍是索引號0到-1(最後一個元素)
lpushx

lpushx

往已經有的name的列表的左邊添加元素，沒有的話沒法建立
lpushx(name,value)
在name對應的list中添加元素，只有name已經存在時，值添加到列表的最左邊
更多：
r.lpushx("list10", 10)   # 這裏list10不存在
print(r.llen("list10"))  # 0
print(r.lrange("list10", 0, -1))  # []
r.lpushx("list2", 77)   # 這裏"list2"以前已經存在，往列表最左邊添加一個元素，一次只能添加一個
print(r.llen("list2"))  # 列表長度
print(r.lrange("list2", 0, -1)) # 切片取出值，範圍是索引號0到-1(最後一個元素

rpushx

往已經有的name的列表的右邊添加元素，沒有的話沒法建立
r.rpushx("list2", 99)   # 這裏"foo_list1"以前已經存在，往列表最右邊添加一個元素，一次只能添加一個
print(r.llen("list2"))  # 列表長度
print(r.lrange("list2", 0, -1)) # 切片取出值，範圍是索引號0到-1(最後一個元素)

linsert

新增（固定索引號位置插入元素）
linsert(name, where, refvalue, value))
在name對應的列表的某一個值前或後插入一個新值
參數：
name，redis的name
where，BEFORE或AFTER
refvalue，標杆值，即：在它先後插入數據
value，要插入的數據
r.linsert("list2", "before", "11", "00")   # 往列表中左邊第一個出現的元素"11"前插入元素"00"
print(r.lrange("list2", 0, -1))   # 切片取出值，範圍是索引號0-最後一個元素

lset

修改（指定索引號進行修改）
r.lset(name, index, value)
對name對應的list中的某一個索引位置從新賦值
參數：
name，redis的name
index，list的索引位置
value，要設置的值
r.lset("list2", 0, -11)    # 把索引號是0的元素修改爲-11
print(r.lrange("list2", 0, -1))

lrem

刪除（指定值進行刪除）
r.lrem(name, value, num)
在name對應的list中刪除指定的值
參數：
name，redis的name
value，要刪除的值
num， num=0，刪除列表中全部的指定值；
num=2,從前到後，刪除2個； num=1,從前到後，刪除左邊第1個
num=-2,從後向前，刪除2個
r.lrem("list2", "11", 1)    # 將列表中左邊第一次出現的"11"刪除
print(r.lrange("list2", 0, -1))
r.lrem("list2", "99", -1)    # 將列表中右邊第一次出現的"99"刪除
print(r.lrange("list2", 0, -1))
r.lrem("list2", "22", 0)    # 將列表中全部的"22"刪除
print(r.lrange("list2", 0, -1))

lpop

刪除並返回
lpop(name)
在name對應的列表的左側獲取第一個元素並在列表中移除，返回值則是第一個元素
更多：
rpop(name) 表示從右向左操做
r.lpop("list2")    # 刪除列表最左邊的元素，而且返回刪除的元素
print(r.lrange("list2", 0, -1))
r.rpop("list2")    # 刪除列表最右邊的元素，而且返回刪除的元素
print(r.lrange("list2", 0, -1))

ltrim

刪除索引以外的值
ltrim(name, start, end)
在name對應的列表中移除沒有在start-end索引之間的值
參數：
name，redis的name
start，索引的起始位置
end，索引結束位置
r.ltrim("list2", 0, 2)    # 刪除索引號是0-2以外的元素，值保留索引號是0-2的元素
print(r.lrange("list2", 0, -1))

lindex

取值（根據索引號取值）
lindex(name, index)
在name對應的列表中根據索引獲取列表元素
print(r.lindex("list2", 0))  # 取出索引號是0的值

rpoplpush

移動 元素從一個列表移動到另一個列表
rpoplpush(src, dst)
從一個列表取出最右邊的元素，同時將其添加至另外一個列表的最左邊
參數：
src，要取數據的列表的name
dst，要添加數據的列表的name
r.rpoplpush("list1", "list2")
print(r.lrange("list2", 0, -1))

brpoplpush

移動 元素從一個列表移動到另一個列表 能夠設置超時
brpoplpush(src, dst, timeout=0)
從一個列表的右側移除一個元素並將其添加到另外一個列表的左側
參數：
src，取出並要移除元素的列表對應的name
dst，要插入元素的列表對應的name
timeout，當src對應的列表中沒有數據時，阻塞等待其有數據的超時時間（秒），0 表示永遠阻塞
r.brpoplpush("list1", "list2", timeout=2)
print(r.lrange("list2", 0, -1))

blpop

一次移除多個列表
blpop(keys, timeout)
將多個列表排列，按照從左到右去pop對應列表的元素
參數：
keys，redis的name的集合
timeout，超時時間，當元素全部列表的元素獲取完以後，阻塞等待列表內有數據的時間（秒）, 0 表示永遠阻塞
更多：
r.brpop(keys, timeout) 同blpop，將多個列表排列,按照從右像左去移除各個列表內的元素
r.lpush("list10", 3, 4, 5)
r.lpush("list11", 3, 4, 5)
while True:
    r.blpop(["list10", "list11"], timeout=2)
    print(r.lrange("list10", 0, -1), r.lrange("list11", 0, -1))

自定義增量迭代

 

因爲redis類庫中沒有提供對列表元素的增量迭代，若是想要循環name對應的列表的全部元素，那麼就須要：
獲取name對應的全部列表
循環列表
可是，若是列表很是大，那麼就有可能在第一步時就將程序的內容撐爆，全部有必要自定義一個增量迭代的功能：
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('list2'): # 遍歷這個列表
    print(item)

 

集合set操做

 

sadd

新增
sadd(name,values)
name對應的集合中添加元素
r.sadd("set1", 33, 44, 55, 66)  # 往集合中添加元素
print(r.scard("set1"))  # 集合的長度是4
print(r.smembers("set1"))   # 獲取集合中全部的成員

scard

獲取元素個數 相似於len
scard(name)
獲取name對應的集合中元素個數
print(r.scard("set1"))  # 集合的長度是4

smembers

獲取集合中全部的成員
smembers(name)
獲取name對應的集合的全部成員
print(r.smembers("set1"))   # 獲取集合中全部的成員
獲取集合中全部的成員–元組形式
sscan(name, cursor=0, match=None, count=None)
print(r.sscan("set1"))
1
獲取集合中全部的成員–迭代器的方式
sscan_iter(name, match=None, count=None)
同字符串的操做，用於增量迭代分批獲取元素，避免內存消耗太大
for i in r.sscan_iter("set1"):
    print(i)2

sdiff

差集
sdiff(keys, *args)
在第一個name對應的集合中且不在其餘name對應的集合的元素集合
r.sadd("set2", 11, 22, 33)
print(r.smembers("set1"))   # 獲取集合中全部的成員
print(r.smembers("set2"))
print(r.sdiff("set1", "set2"))   # 在集合set1可是不在集合set2中
print(r.sdiff("set2", "set1"))   # 在集合set2可是不在集合set1中

sdiffstore

 

差集–差集存在一個新的集合中
sdiffstore(dest, keys, *args)
獲取第一個name對應的集合中且不在其餘name對應的集合，再將其新加入到dest對應的集合中
r.sdiffstore("set3", "set1", "set2")    # 在集合set1可是不在集合set2中
print(r.smembers("set3"))   # 獲取集合3中全部的成員

sinter

交集
sinter(keys, *args)
獲取多一個name對應集合的交集
print(r.sinter("set1", "set2")) # 取2個集合的交集

sinterstore

交集–交集存在一個新的集合中
sinterstore(dest, keys, *args)
獲取多一個name對應集合的並集，再將其加入到dest對應的集合中
print(r.sinterstore("set3", "set1", "set2")) # 取2個集合的交集
print(r.smembers("set3"))

sunion

並集
sunion(keys, *args)
獲取多個name對應的集合的並集
print(r.sunion("set1", "set2")) # 取2個集合的並集1
並集–並集存在一個新的集合
sunionstore(dest,keys, *args)
獲取多一個name對應的集合的並集，並將結果保存到dest對應的集合中
print(r.sunionstore("set3", "set1", "set2")) # 取2個集合的並集
print(r.smembers("set3"))

sismember

判斷是不是集合的成員 相似in
sismember(name, value)
檢查value是不是name對應的集合的成員，結果爲True和False
print(r.sismember("set1", 33))  # 33是集合的成員
print(r.sismember("set1", 23))  # 23不是集合的成員

smove

移動
smove(src, dst, value)
將某個成員從一個集合中移動到另一個集合
r.smove("set1", "set2", 44)
print(r.smembers("set1"))
print(r.smembers("set2"))

spop

刪除–隨機刪除而且返回被刪除值
spop(name)
從集合移除一個成員，並將其返回,說明一下，集合是無序的，全部是隨機刪除的
print(r.spop("set2"))   # 這個刪除的值是隨機刪除的，集合是無序的
print(r.smembers("set2"))
11.刪除–指定值刪除
srem(name, values)
在name對應的集合中刪除某些值
print(r.srem("set2", 11))   # 從集合中刪除指定值 11
print(r.smembers("set2"))

有序集合sort set操做

redis基本命令 有序set

Set操做，Set集合就是不容許重複的列表，自己是無序的

有序集合，在集合的基礎上，爲每元素排序；元素的排序須要根據另一個值來進行比較，

因此，對於有序集合，每個元素有兩個值，即：值和分數，分數專門用來作排序。

zadd

新增
zadd(name, args, *kwargs)
在name對應的有序集合中添加元素
如：
import redis
import time

pool = redis.ConnectionPool(host='127.0.0.1', port=6379, decode_responses=True)
r = redis.Redis(connection_pool=pool)

r.zadd("zset1", n1=11, n2=22)
r.zadd("zset2", 'm1', 22, 'm2', 44)
print(r.zcard("zset1")) # 集合長度
print(r.zcard("zset2")) # 集合長度
print(r.zrange("zset1", 0, -1))   # 獲取有序集合中全部元素
print(r.zrange("zset2", 0, -1, withscores=True))   # 獲取有序集合中全部元素和分數2

zcard

獲取有序集合元素個數 相似於len
zcard(name)
獲取name對應的有序集合元素的數量
print(r.zcard("zset1")) # 集合長度1

zrange

獲取有序集合的全部元素
r.zrange( name, start, end, desc=False, withscores=False, score_cast_func=float)
按照索引範圍獲取name對應的有序集合的元素
參數：
name，redis的name
start，有序集合索引發始位置（非分數）
end，有序集合索引結束位置（非分數）
desc，排序規則，默認按照分數從小到大排序
withscores，是否獲取元素的分數，默認只獲取元素的值
score_cast_func，對分數進行數據轉換的函數
3-1 從大到小排序(同zrange，集合是從大到小排序的)
zrevrange(name, start, end, withscores=False, score_cast_func=float)
print(r.zrevrange("zset1", 0, -1))    # 只獲取元素，不顯示分數
print(r.zrevrange("zset1", 0, -1, withscores=True)) # 獲取有序集合中全部元素和分數,分數倒序
3-2 按照分數範圍獲取name對應的有序集合的元素
zrangebyscore(name, min, max, start=None, num=None, withscores=False, score_cast_func=float)
for i in range(1, 30):
   element = 'n' + str(i)
   r.zadd("zset3", element, i)
print(r.zrangebyscore("zset3", 15, 25)) # # 在分數是15-25之間，取出符合條件的元素
print(r.zrangebyscore("zset3", 12, 22, withscores=True))    # 在分數是12-22之間，取出符合條件的元素（帶分數）
3-3 按照分數範圍獲取有序集合的元素並排序（默認從大到小排序）
zrevrangebyscore(name, max, min, start=None, num=None, withscores=False, score_cast_func=float)
print(r.zrevrangebyscore("zset3", 22, 11, withscores=True)) # 在分數是22-11之間，取出符合條件的元素 按照分數倒序1
3-4 獲取全部元素–默認按照分數順序排序
zscan(name, cursor=0, match=None, count=None, score_cast_func=float)
print(r.zscan("zset3"))1
3-5 獲取全部元素–迭代器
zscan_iter(name, match=None, count=None,score_cast_func=float)
for i in r.zscan_iter("zset3"): # 遍歷迭代器
    print(i)

zcount

zcount(name, min, max)
獲取name對應的有序集合中分數 在 [min,max] 之間的個數
print(r.zrange("zset3", 0, -1, withscores=True))
print(r.zcount("zset3", 11, 22))

zincrby

自增
zincrby(name, value, amount)
自增name對應的有序集合的 name 對應的分數
r.zincrby("zset3", "n2", amount=2)    # 每次將n2的分數自增2
print(r.zrange("zset3", 0, -1, withscores=True))

zrank

獲取值的索引號
zrank(name, value)
獲取某個值在 name對應的有序集合中的索引（從 0 開始）
更多：
zrevrank(name, value)，從大到小排序
print(r.zrank("zset3", "n1"))   # n1的索引號是0 這裏按照分數順序（從小到大）
print(r.zrank("zset3", "n6"))   # n6的索引號是1

print(r.zrevrank("zset3", "n1"))    # n1的索引號是29 這裏安照分數倒序（從大到小）

zrem

刪除–指定值刪除
zrem(name, values)
刪除name對應的有序集合中值是values的成員
r.zrem("zset3", "n3")   # 刪除有序集合中的元素n3 刪除單個
print(r.zrange("zset3", 0, -1))

zremrangebyrank

刪除–根據排行範圍刪除，按照索引號來刪除
zremrangebyrank(name, min, max)
根據排行範圍刪除
r.zremrangebyrank("zset3", 0, 1)  # 刪除有序集合中的索引號是0, 1的元素
print(r.zrange("zset3", 0, -1))
zremrangebyscore(name, min, max)
根據分數範圍刪除
r.zremrangebyscore("zset3", 11, 22)   # 刪除有序集合中的分數是11-22的元素
print(r.zrange("zset3", 0, -1))

zscore

獲取值對應的分數
zscore(name, value)
獲取name對應有序集合中 value 對應的分數
print(r.zscore("zset3", "n27"))   # 獲取元素n27對應的分數271

 

其餘經常使用操做

delete

delete (*names)
根據刪除redis中的任意數據類型（string、hash、list、set、有序set）
r.delete("gender")  # 刪除key爲gender的鍵值對1

exists

檢查名字是否存在
exists(name)
檢測redis的name是否存在，存在就是True，False 不存在
print(r.exists("zset1"))1

keys

模糊匹配
keys(pattern=’‘)
根據模型獲取redis的name
更多：
KEYS 匹配數據庫中全部 key 。
KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。
KEYS h*llo 匹配 hllo 和 heeeeello 等。
KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo
print(r.keys("foo*"))
1

expire

設置超時時間
expire(name ,time)
爲某個redis的某個name設置超時時間
r.lpush("list5", 11, 22)
r.expire("list5", time=3)
print(r.lrange("list5", 0, -1))
time.sleep(3)
print(r.lrange("list5", 0, -1))

rname

重命名
rename(src, dst)
對redis的name重命名
r.lpush("list5", 11, 22)
r.rename("list5", "list5-1")

randomkey

隨機獲取name
randomkey()
隨機獲取一個redis的name（不刪除）
print(r.randomkey())
1

type

獲取類型
type(name)
獲取name對應值的類型
print(r.type("set1"))
print(r.type("hash2"))

scan

查看全部元素
scan(cursor=0, match=None, count=None)
print(r.hscan("hash2"))
print(r.sscan("set3"))
print(r.zscan("zset2"))
print(r.getrange("foo1", 0, -1))
print(r.lrange("list2", 0, -1))
print(r.smembers("set3"))
print(r.zrange("zset3", 0, -1))
print(r.hgetall("hash1"))

scan_iter

查看全部元素–迭代器
scan_iter(match=None, count=None)
for i in r.hscan_iter("hash1"):
    print(i)

for i in r.sscan_iter("set3"):
    print(i)

for i in r.zscan_iter("zset3"):
    print(i)8
other 方法
print(r.get('name'))    # 查詢key爲name的值
r.delete("gender")  # 刪除key爲gender的鍵值對
print(r.keys()) # 查詢全部的Key
print(r.dbsize())   # 當前redis包含多少條數據
r.save()    # 執行"檢查點"操做，將數據寫回磁盤。保存時阻塞
# r.flushdb()        # 清空r中的全部數據

管道（pipeline）

 

redis默認在執行每次請求都會建立（鏈接池申請鏈接）和斷開（歸還鏈接池）一次鏈接操做，
若是想要在一次請求中指定多個命令，則可使用pipline實現一次請求指定多個命令，而且默認狀況下一次pipline 是原子性操做。
管道（pipeline）是redis在提供單個請求中緩衝多條服務器命令的基類的子類。它經過減小服務器-客戶端之間反覆的TCP數據庫包，從而大大提升了執行批量命令的功能。
import redis
import time

pool = redis.ConnectionPool(host='127.0.0.1', port=6379, decode_responses=True)
r = redis.Redis(connection_pool=pool)

# pipe = r.pipeline(transaction=False)    # 默認的狀況下，管道里執行的命令能夠保證執行的原子性，執行pipe = r.pipeline(transaction=False)能夠禁用這一特性。
# pipe = r.pipeline(transaction=True)
pipe = r.pipeline() # 建立一個管道

pipe.set('name', 'jack')
pipe.set('role', 'sb')
pipe.sadd('faz', 'baz')
pipe.incr('num')    # 若是num不存在則vaule爲1，若是存在，則value自增1
pipe.execute()

print(r.get("name"))
print(r.get("role"))
print(r.get("num"))

管道的命令能夠寫在一塊兒，如：
pipe.set('hello', 'redis').sadd('faz', 'baz').incr('num').execute()
print(r.get("name"))
print(r.get("role"))
print(r.get("num"))

 

zadd