redis對sorted_set進行的相關操做

時間 2019-11-30

標籤 redis sorted set 進行相關欄目 Redis 简体版

原文原文鏈接

redis對sorted_set(有序集合)類型操做的相關命令以及如何在python使用這些命令

redis對sorted_set(有序集合)類型操做的命令:

命令	語法	概述	返回值
Redis Zadd 命令html	ZADD KEY_NAME SCORE1 VALUE1.. SCOREN VALUEN	向有序集合添加一個或多個成員，或者更新已存在成員的分數	被成功添加的新成員的數量，不包括那些被更新的、已經存在的成員。當 key 存在但不是有序集類型時，返回一個錯誤。
Redis Zcard 命令python	ZCARD KEY_NAME	獲取有序集合的成員數	當 key 存在且是有序集類型時，返回有序集的基數。當 key 不存在時，返回 0 。
Redis Zcount 命令redis	ZCOUNT key min max	計算在有序集合中指定區間分數的成員數	分數值在 min 和 max 之間的成員的數量
Redis Zincrby 命令spa	ZINCRBY key increment member	有序集合中對指定成員的分數加上增量 increment	member 成員的新分數值，以字符串形式表示。
Redis Zinterstore 命令.net	ZINTERSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM\|MIN\|MAX]	計算給定的一個或多個有序集的交集並將結果集存儲在新的有序集合 key 中 key 的數量以 numkeys 參數指定	保存到目標結果集的的成員數量。
Redis Zlexcount 命令code	ZLEXCOUNT KEY MIN MAX	在有序集合中計算指定字典區間內成員數量(ZLEXCOUNT myzset - +)	指定區間內的成員數量。
Redis Zrange 命令htm	ZRANGE key start stop [WITHSCORES]	經過索引區間返回有序集合成指定區間內的成員	指定區間內，帶有分數值(可選)的有序集成員的列表。
Redis Zrangebylex 命令blog	ZRANGEBYLEX key min max [LIMIT offset count]	經過字典區間返回有序集合的成員	指定區間內的元素列表
Redis Zrangebyscore 命令排序	ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]	經過分數返回有序集合指定區間內的成員	指定區間內，帶有分數值(可選)的有序集成員的列表。
Redis Zrank 命令索引	ZRANK key member	返回有序集合中指定成員的索引	若是成員是有序集 key 的成員，返回 member 的排名。若是成員不是有序集 key 的成員，返回 nil 。
Redis Zrem 命令	ZREM key member [member ...]	移除有序集合中的一個或多個成員	被成功移除的成員的數量，不包括被忽略的成員。
Redis Zremrangebylex 命令	ZREMRANGEBYLEX key min max	移除有序集合中給定的字典區間的全部成員	被成功移除的成員的數量，不包括被忽略的成員。
Redis Zremrangebyrank 命令	ZREMRANGEBYRANK key start stop	移除有序集合中給定的排名區間的全部成員	被移除成員的數量。
Redis Zremrangebyscore 命令	ZREMRANGEBYSCORE key min max	移除有序集合中給定的分數區間的全部成員	被移除成員的數量。
Redis Zrevrange 命令	ZREVRANGE key start stop [WITHSCORES]	返回有序集中指定區間內的成員，經過索引，分數從高到底	指定區間內，帶有分數值(可選)的有序集成員的列表。
Redis Zrevrangebyscore 命令	ZREVRANGEBYSCORE key max min [WITHSCORES] [LIMIT offset count]	返回有序集中指定分數區間內的成員，分數從高到低排序	指定區間內，帶有分數值(可選)的有序集成員的列表。
Redis Zrevrank 命令	ZREVRANK key member	返回有序集合中指定成員的排名，有序集成員按分數值遞減(從大到小)排序	若是成員是有序集 key 的成員，返回成員的排名。若是成員不是有序集 key 的成員，返回 nil 。
Redis Zscore 命令	ZSCORE key member	返回有序集中，成員的分數值	成員的分數值，以字符串形式表示。
Redis Zunionstore 命令	ZUNIONSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM\|MIN\|MAX]	計算給定的一個或多個有序集的並集，並存儲在新的 key 中	保存到 destination 的結果集的成員數量。
Redis Zscan 命令	ZSCAN key cursor [MATCH pattern] [COUNT count]	迭代有序集合中的元素（包括元素成員和元素分值）	返回的每一個元素都是一個有序集合元素，一個有序集合元素由一個成員（member）和一個分值（score）組成。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 redis sorted_set類型操做文檔

在python中對redis sorted_set進行的相關操做

# -*- coding: utf-8 -*-
import redis
# 鏈接本地redis
r = redis.Redis(host="127.0.0.1",port=6379)


1.Zadd 命令用於將一個或多個成員元素及其分數值加入到有序集當中。
若是某個成員已是有序集的成員，那麼更新這個成員的分數值，並經過從新插入這個成員元素，來保證該成員在正確的位置上。
分數值能夠是整數值或雙精度浮點數。
若是有序集合 key 不存在，則建立一個空的有序集並執行 ZADD 操做。
當 key 存在但不是有序集類型時，返回一個錯誤。

 
  print(r.zadd("1","1",2,"3",3)) # 輸出的結果是2 
 
  print(r.zadd("1","2",2))     # 輸出的結果是1 
 
  print(r.zadd("1","1",1))     # 輸出的結果是0 
 
  print(r.zadd("1","3",4))     # 輸出的結果是0 
 
  print(r.zrange("1",0,-1))    # 輸出的結果是 ['1', '2', '3']


2.Zcard 命令用於計算集合中元素的數量。
當 key 存在且是有序集類型時，返回有序集的基數。 當 key 不存在時，返回 0 。

print(r.zadd("1","1",1,"3",3)) # 輸出的結果是2
print(r.zadd("1","2",2))       # 輸出的結果是1
print(r.zadd("1","2",4))       # 輸出的結果是1
print(r.zcard(1))              # 輸出的結果是3
print(r.zcard(2))              # 輸出的結果是0


3.Zcount 命令用於計算有序集合中指定分數區間的成員數量。分數值在 min 和 max 之間的成員的數量。

print(r.zadd("2","1",1,"3",3)) 　　　 # 輸出的結果是2
print(r.zadd("2","2",2))     　　　　　# 輸出的結果是1
print(r.zadd("2","1",4))     　　　　　# 輸出的結果是0
print(r.zcount("2",min=0,max=5))     # 輸出的結果是3
print(r.zcount("2",min=0,max=3))     # 輸出的結果是2
print(r.zcount("2",min=1,max=3))     # 輸出的結果是2


4.Zincrby 命令對有序集合中指定成員的分數加上增量 increment
能夠經過傳遞一個負數值 increment ，讓分數減去相應的值，好比 ZINCRBY key -5 member ，就是讓 member 的 score 值減去 5 。
當 key 不存在，或分數不是 key 的成員時， ZINCRBY key increment member 等同於 ZADD key increment member 。
當 key 不是有序集類型時，返回一個錯誤。
分數值能夠是整數值或雙精度浮點數。
member 成員的新分數值，以字符串形式表示。

print(r.zadd("4","1",1,"2",2,"3",3,"4",4))   # 輸出的結果是4
print(r.zincrby(name=4,value=1,amount=5))    # 輸出的結果是6.0
print(r.zincrby(name=4,value=2,amount=55))    # 輸出的結果是57.0
print(r.zrange(name=4,start=0,end=-1,withscores=False))       # 輸出的結果是['1', '3', '2', '4']

5.Zinterstore 命令計算給定的一個或多個有序集的交集，其中給定 key 的數量必須以 numkeys 參數指定，並將該交集(結果集)儲存到 destination 。
默認狀況下，結果集中某個成員的分數值是全部給定集下該成員分數值之和。

print(r.zadd("41", "a1", 6, "a2", 2,"a3",5)) # 輸出的結果是3
print(r.zadd('42', a1=7,b1=10, b2=5)) # 輸出的結果是3
# 獲取兩個有序集合的交集並放入dest集合，若是遇到相同值不一樣分數，則按照aggregate進行操做
# aggregate的值爲: SUM MIN MAX
print(r.zinterstore("43",("42","41"),aggregate="MAX")) # 輸出的結果是4
print(r.zscan("43")) # 輸出的結果是(0L, [('a1', 7.0)])


6. Zlexcount 命令在計算有序集合中指定字典區間內成員數量。

print(r.zadd("6", "a", 1, "b", 2,"c",3))     # 輸出的結果是3
print(r.zlexcount(name=6,min="-",max="+"))   # 輸出的結果是3
print(r.zadd("6", "e", 4, "f", 5,"d",6))     # 輸出的結果是3
print(r.zlexcount(name=6,min="-",max="+"))   # 輸出的結果是6
print(r.zlexcount(name=6,min="[a",max="[b"))   # 輸出的結果是2
print(r.zlexcount(name=6,min="[a",max="[f"))   # 輸出的結果是6
print(r.zlexcount(name=6,min="[a",max="[e"))   # 輸出的結果是4


7.Zrange 返回有序集中，指定區間內的成員。
其中成員的位置按分數值遞增(從小到大)來排序。
具備相同分數值的成員按字典序(lexicographical order )來排列。
若是你須要成員按值遞減(從大到小)來排列，請使用 ZREVRANGE 命令。
下標參數 start 和 stop 都以 0 爲底，也就是說，以 0 表示有序集第一個成員，以 1 表示有序集第二個成員，以此類推。
你也可使用負數下標，以 -1 表示最後一個成員， -2 表示倒數第二個成員，以此類推。

print(r.zadd("7", "1", 1, "2", 2,"3",3,"4",4,"5",5))     # 輸出的結果是5
print(r.zrange("7",start=0,end=-1,desc=False))           # 輸出的結果是['1', '2', '3', '4', '5']
print(r.zrange("7",start=0,end=2,desc=False))            # 輸出的結果是['1', '2', '3']

8. Zrangebylex 經過字典區間返回有序集合的成員。
當有序集合的全部成員都具備相同的分值時，有序集合的元素會根據成員的值（lexicographical ordering）來進行排序，而這個命令則能夠返回給定的有序集合鍵 key 中，元素的值介於 min 和 max 之間的成員
對集合中的每一個成員進行逐個字節的對比（byte-by-byte compare），並按照從低到高的順序，返回排序後的集合成員。若是兩個字符串有一部份內容是相同的話，那麼命令會認爲較長的字符串比較短的字符串要大

print(r.zadd("8", "a", 1, "b", 2,"c",3))     # 輸出的結果是3
print(r.zrangebylex(name="8",min="-",max="[c"))   # 輸出的結果是 ['a', 'b', 'c']
print(r.zrangebylex(name="8",min="-",max="(c"))   # 輸出的結果是 ['a', 'b']
print(r.zadd("8", "e", 4, "f", 5,"d",6))     # 輸出的結果是3
print(r.zrangebylex(name=8,min="[b",max="[f"))   # 輸出的結果是 ['b', 'c', 'e', 'f', 'd']
print(r.zrangebylex(name=8,min="(b",max="[f"))   # 輸出的結果是 ['c', 'e', 'f', 'd']

9.Zrangebyscore 返回有序集合中指定分數區間的成員列表。有序集成員按分數值遞增(從小到大)次序排列。具備相同分數值的成員按字典序來排列(該屬性是有序集提供的，不須要額外的計算)。
默認狀況下，區間的取值使用閉區間 (小於等於或大於等於)，你也能夠經過給參數前增長 ( 符號來使用可選的開區間 (小於或大於)。

print(r.zadd("9", "a", 1, "b", 2,"c",3)) # 輸出的結果是3
print(r.zrangebyscore("9","1","6")) # 輸出的結果是['a', 'b', 'c']
print(r.zadd("9", "c", 11, "d", 21,"e",32)) # 輸出的結果是3
print(r.zrangebyscore("9","3","16")) # 輸出的結果是['c']
print(r.zrangebyscore("9","3","36")) # 輸出的結果是['c', 'd', 'e']


10.Zrank 返回有序集中指定成員的排名。其中有序集成員按分數值遞增(從小到大)順序排列。
若是成員是有序集 key 的成員，返回 member 的排名。 若是成員不是有序集 key 的成員，返回 None 。

print(r.zadd("10", "a", 1, "b", 2, "c", 3))  # 輸出的結果是3
print(r.zadd("10", "f", 11, "d", 21,"e",32)) # 輸出的結果是3
print(r.zrank("10","a"))                     # 輸出的結果是0
print(r.zrank("10","b"))                     # 輸出的結果是1
print(r.zrank("10","e"))                     # 輸出的結果是5
print(r.zrank("10","d"))                     # 輸出的結果是4
print(r.zrank("10","h"))                     # 輸出的結果是None


11. Zrem 命令用於移除有序集中的一個或多個成員，不存在的成員將被忽略。
當 key 存在但不是有序集類型時，返回一個錯誤。

print(r.zadd("11", "a", 1, "b", 2, "c", 3))  # 輸出的結果是3
print(r.zadd("11", "f", 11, "d", 21,"e",32)) # 輸出的結果是3
print(r.zrem("11","a"))                      # 輸出的結果是1
print(r.zrem("11","f"))                      # 輸出的結果是1
print(r.zrem("11","h"))                      # 輸出的結果是0
print(r.zrange("11",start=0,end=32))         # 輸出的結果是['b', 'c', 'd', 'e'], 其中  a f 已經移除掉
print(r.zrange("11",start=2,end=32))         # 輸出的結果是['d', 'e'], 其中  a f 已經移除掉，d  e  沒有被包涵


12.Zremrangebylex 命令用於移除有序集合中給定的字典區間的全部成員。
被成功移除的成員的數量，不包括被忽略的成員。

print(r.zadd("12", "a", 1, "b", 2, "c", 3))         # 輸出的結果是3
print(r.zadd("12", "d", 11, "e", 21,"f",32))        # 輸出的結果是3
print(r.zremrangebylex("12",min="[a",max="[c"))    # 輸出的結果是3
print(r.zrange("12",0,-1))                         # 輸出的結果是 ['d', 'e', 'f']  由於  a，b，c已經被移除


13. Zremrangebyrank 命令用於移除有序集中，指定排名(rank)區間內的全部成員。

 print(r.zadd("13", "a", 1, "b", 2, "c", 3))         # 輸出的結果是3
 print(r.zadd("13", "d", 8, "e", 21,"f",32))        # 輸出的結果是3
 print(r.zremrangebyrank(name=13,min=1,max=3))       # 輸出的結果是3
 print(r.zrange("13","0","-1"))                      # 輸出的結果是['a', 'e', 'f']  由於刪除了 b，c，d


14.Zremrangebyscore 命令用於移除有序集中，指定分數（score）區間內的全部成員。

print(r.zadd("14", "a", 1, "b", 2, "c", 3))          # 輸出的結果是3
print(r.zadd("14", "d", 8, "e", 21,"f",32))          # 輸出的結果是3
print(r.zremrangebyscore(name="14",min="1",max="8")) # 輸出的結果是4,刪除的a，b，c，d
print(r.zrange(name="14",start=0,end=-1))            # 輸出的結果是 ['e', 'f']


15.Zrevrange 命令返回有序集中，指定區間內的成員。
其中成員的位置按分數值遞減(從大到小)來排列。
具備相同分數值的成員按字典序的逆序(reverse lexicographical order)排列。
除了成員按分數值遞減的次序排列這一點外， ZREVRANGE 命令的其餘方面和 ZRANGE 命令同樣。

print(r.zadd("15", "a", 1, "b", 2, "c", 3))          # 輸出的結果是3
print(r.zadd("15", "d", 8, "e", 21,"f",32))          # 輸出的結果是3
print(r.zrevrange(name="15",start=0,end=-1))         # 輸出的結果是['f', 'e', 'd', 'c', 'b', 'a']
print(r.zrevrange(name="15",start=1,end=21))         # 輸出的結果是['e', 'd', 'c', 'b', 'a']
print(r.zrevrange(name="15",start=3,end=21))         # 輸出的結果是['c', 'b', 'a']


16.Zrevrangebyscore 返回有序集中指定分數區間內的全部的成員。有序集成員按分數值遞減(從大到小)的次序排列。
具備相同分數值的成員按字典序的逆序(reverse lexicographical order )排列。
除了成員按分數值遞減的次序排列這一點外， ZREVRANGEBYSCORE 命令的其餘方面和 ZRANGEBYSCORE 命令同樣。

print(r.zadd("16", "a", 1, "b", 2, "c", 3))          # 輸出的結果是3
print(r.zadd("16", "d", 8, "e", 21,"f",32))          # 輸出的結果是3
print(r.zrevrangebyscore(name="16",max=33,min=0))    # 輸出的結果是['f', 'e', 'd', 'c', 'b', 'a']
print(r.zrevrangebyscore(name="16",max=20,min=2))    # 輸出的結果是['d', 'c', 'b']


17. Zrevrank 命令返回有序集中成員的排名。其中有序集成員按分數值遞減(從大到小)排序。
排名以 0 爲底，也就是說， 分數值最大的成員排名爲 0 。
使用 ZRANK 命令能夠得到成員按分數值遞增(從小到大)排列的排名。

print(r.zadd("17", "a", 1, "b", 2, "c", 3))          # 輸出的結果是3
print(r.zadd("17", "d", 4, "e", 5,"f",6))            # 輸出的結果是3
print(r.zrevrank(name=17,value="a"))                 # 輸出的結果是5
print(r.zrevrank(name=17,value="c"))                 # 輸出的結果是3
print(r.zrevrank(name=17,value="d"))                 # 輸出的結果是2
print(r.zrevrank(name=17,value="h"))                 # 輸出的結果是None


18.Zscore 命令返回有序集中，成員的分數值。 若是成員元素不是有序集 key 的成員，或 key 不存在，返回 None 。

print(r.zadd("18", "a", 1, "b", 2, "c", 3)) # 輸出的結果是3
print(r.zadd("18", "d", 4, "e", 5,"f",6)) 　　 # 輸出的結果是3
print(r.zscore(name="18",value="a")) # 輸出的結果是1.0
print(r.zscore(name="18",value="c")) # 輸出的結果是3.0
print(r.zscore(name="18",value="f")) # 輸出的結果是6.0
print(r.zscore(name="18",value="h")) # 輸出的結果是None


19.  Zscan 命令用於迭代有序集合中的元素（包括元素成員和元素分值）
返回的每一個元素都是一個有序集合元素，一個有序集合元素由一個成員（member）和一個分值（score）組成。

print(r.zadd("20", "a", 1, "b", 2, "c", 3))   # 輸出的結果是3
print(r.zscan(name="20"))                     # 輸出的結果是(0L, [('a', 1.0), ('b', 2.0), ('c', 3.0)])
print(r.zadd("20", "d", 4, "e", 5,"f",3))     # 輸出的結果是3
print(r.zscan(name="20"))                     # 輸出的結果是 (0L, [('a', 1.0), ('b', 2.0), ('c', 3.0), ('f', 3.0), ('d', 4.0), ('e', 5.0)])

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。