Redis基礎操做命令及對應的Python操做Redis方法

爲了不每次忘了命令都要去查文檔，在這裏整理一下Redis的基本命令和Python操做Redis的基本方法。（# 後面跟的是個人註釋，$ 後面跟的是shell命令，> 後面跟的是redis命令，Python命令無前綴）

1.登錄及Python鏈接

 redis命令

# 本地登錄
$ redis-cli

# 遠程登錄
$ redis-cli -h host -p port -a password

Python命令 

import redis
# 值需本身替換
r = redis.StrictRedis(host=REDIS_HOST, port=REDIS_PORT, db=REDIS_DB, password=REDIS_PASSWORD)

2.Keys命令

redis命令

# 該命令用於在 key 存在時刪除 key
> DEL key

# 序列化給定 key ，並返回被序列化的值
> DUMP key

# 檢查給定 key 是否存在
> EXISTS key

# 爲給定 key 設置過時時間
> EXPIRE key seconds

# EXPIREAT 的做用和 EXPIRE 相似，都用於爲 key 設置過時時間。 不一樣在於 EXPIREAT 命令接受的時間參數是 UNIX 時間戳(unix timestamp)
> EXPIREAT key timestamp 

# 設置 key 的過時時間以毫秒計
> PEXPIRE key milliseconds

# 設置 key 過時時間的時間戳(unix timestamp) 以毫秒計
> PEXPIREAT key milliseconds-timestamp

# 查找全部符合給定模式( pattern)的 key
> KEYS pattern 

# 將當前數據庫的 key 移動到給定的數據庫 db 當中
> MOVE key db 

# 移除 key 的過時時間，key 將持久保持
> PERSIST key 

# 以毫秒爲單位返回 key 的剩餘的過時時間
> PTTL key 

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

# 從當前數據庫中隨機返回一個 key
> RANDOMKEY

# 修改 key 的名稱
> RENAME key newkey

# 當且僅當 newkey 不存在時，將 key 更名爲 newkey
> RENAMENX key newkey 

# 返回 key 所儲存的值的類型
> TYPE key

Python命令

# 根據刪除redis中的任意數據類型
delete(*names)

# 檢測redis的name是否存在
exists(name)

# 模糊查詢keys（相似正則表達式）
# 更多：
    # * 匹配前面的子表達式任意次，如 * 匹配全部keys
    # ? 匹配前面的子表達式零次或一次，如 y?s 匹配 ys,yes,yas等
    # [abc]  字符集合。匹配所包含的任意一個字符，如 y[ea]s 匹配 yes,yas
keys(pattern='*')

# 爲某個redis的某個name設置超時時間
expire(name ,time)

# 對redis的name重命名爲
rename(src, dst)

# 將redis的某個值移動到指定的db下
move(name, db))

# 隨機獲取一個redis的name（不刪除）
randomkey()

# 獲取name對應值的類型
type(name)

3.String命令

redis命令

# 設置指定 key 的值
> SET key value

# 獲取指定 key 的值
> GET key

# 返回 key 中字符串值的子字符
> GETRANGE key start end

# 將給定 key 的值設爲 value ，並返回 key 的舊值(old value)
> GETSET key value

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

# 獲取全部(一個或多個)給定 key 的值
> MGET key1 [key2..]

# 對 key 所儲存的字符串值，設置或清除指定偏移量上的位(bit)
> SETBIT key offset value

# 將值 value 關聯到 key ，並將 key 的過時時間設爲 seconds (以秒爲單位)
> SETEX key seconds value

# 只有在 key 不存在時設置 key 的值
> SETNX key value

# 用 value 參數覆寫給定 key 所儲存的字符串值，從偏移量 offset 開始
> SETRANGE key offset value

# 返回 key 所儲存的字符串值的長度
> STRLEN key

# 同時設置一個或多個 key-value 對
> MSET key value [key value ...]

# 同時設置一個或多個 key-value 對，當且僅當全部給定 key 都不存在
> MSETNX key value [key value ...]

# 這個命令和 SETEX 命令類似，但它以毫秒爲單位設置 key 的生存時間，而不是像 SETEX 命令那樣，以秒爲單位
> PSETEX key milliseconds value

# 將 key 中儲存的數字值增一
> INCR key

# 將 key 所儲存的值加上給定的增量值（increment）
> INCRBY key increment

# 將 key 所儲存的值加上給定的浮點增量值（increment）
> INCRBYFLOAT key increment

# 將 key 中儲存的數字值減一
> DECR key

# key 所儲存的值減去給定的減量值（decrement）
> DECRBY key decrement

# 若是 key 已經存在而且是一個字符串， APPEND 命令將 value 追加到 key 原來的值的末尾
> APPEND key value

Python命令

# 在Redis中設置值，默認不存在則建立，存在則修改
'''參數：
     set(name, value, ex=None, px=None, nx=False, xx=False)
     ex，過時時間（秒）
     px，過時時間（毫秒）
     nx，若是設置爲True，則只有name不存在時，當前set操做才執行,同setnx(name, value)
     xx，若是設置爲True，則只有name存在時，當前set操做才執行'''
r.set(KEY, VALUES)

# 設置過時時間（秒）
setex(name, value, time)

# 設置過時時間（豪秒）
psetex(name, time_ms, value)

# 批量設置值
# mset()
r.mset("key1"="value1", "key2"="value2")
# 或
r.mget({"key1":"value1", "key2":"value2"})

# 批量獲取
# mget(keys, *args)
print(r.mget("key1","key2"))
# 或
k=["key1","key2"]
print(r.mget(k))

# 設置新值，打印原值
# getset(name, value)
print(r.getset("key1","value2")) # 輸出key1本來的值
print(r.get("key1")) # 輸出value1

# 根據字節獲取子序列
# getrange(key, start, end)
r.set("key1","values")
print(r.getrange("key1",0,3)) # 輸出 valu

# 修改字符串內容，從指定字符串索引開始向後替換，若是新值太長時，則向後添加
# setrange(name, offset, value)
r.set("name","value")
r.setrange("name",1,"v")
print(r.get("name")) # 輸出:vvalue
r.setrange("name",6,"zz")
print(r.get("name")) #輸出: vvaluezz

# 返回name對應值的字節長度（P.S.一個漢字3個字節）
# strlen(name)
r.set("name","value1")
print(r.strlen("name")) # 輸出:6

# 自增mount對應的值，當mount不存在時，則建立mount＝amount，不然，則自增,amount爲自增數(整數)
# incr(self, name, amount=1)
print(r.incr("mount",amount=2))# 輸出:2
print(r.incr("mount"))# 輸出:3
print(r.incr("mount",amount=3))# 輸出:6
print(r.incr("mount",amount=6))# 輸出:12
print(r.get("mount")) # 輸出:12

# 相似 incr() 自增,amount爲自增數(浮點數)
# incrbyfloat(self, name, amount=1.0)
r.incrbyfloat("mount",amount=2)

# 自減name對應的值,當name不存在時,則建立name＝amount，不然，則自減，amount爲自增數(整數)
# decr(self, name, amount=1)
r.decr("mount",amount=1)

# 在key對應的值後面追加內容
# append(key,value)
r.set("key","value")
print(r.get("key"))    # 輸出:value
r.append("name","vvv")
print(r.get("key"))    # 輸出:valuevv

4.Hash命令

redis命令

# 刪除一個或多個哈希表字段
> HDEL key field2 [field2] 

# 查看哈希表 key 中，指定的字段是否存在
> HEXISTS key field 

# 獲取存儲在哈希表中指定字段的值
> HGET key field 

# 獲取在哈希表中指定 key 的全部字段和值
> HGETALL key 

# 爲哈希表 key 中的指定字段的整數值加上增量 increment
> HINCRBY key field increment 

# 爲哈希表 key 中的指定字段的浮點數值加上增量 increment
> HINCRBYFLOAT key field increment 

# 獲取全部哈希表中的字段
> HKEYS key

# 獲取哈希表中字段的數量
> HLEN key 

# 獲取全部給定字段的值
> HMGET key field1 [field2] 

# 同時將多個 field-value (域-值)對設置到哈希表 key 中
> HMSET key field1 value1 [field2 value2 ] 

# 將哈希表 key 中的字段 field 的值設爲 value
> HSET key field value 

# 只有在字段 field 不存在時，設置哈希表字段的值
> HSETNX key field value 

# 獲取哈希表中全部值
> HVALS key 

# 迭代哈希表中的鍵值對
> HSCAN key cursor [MATCH pattern] [COUNT count]

Python命令

# name對應的hash中設置一個鍵值對（不存在，則建立，不然，修改）
# hset(name, key, value)
r.hset("singers","singer1","mj")
r.hset("singers","singer2","others")

# 在name對應的hash中根據key獲取value
# hget(name,key)
print(r.hget("china","singer1")) # 輸出:mj

# 獲取name對應hash的全部鍵值
# hgetall(name)
print(r.hgetall("singers")) # 輸出 mj others

# 在name對應的hash中批量設置鍵值對,mapping:字典
# hmset(name, mapping)
singer={"singer1":"mj","singer2":"others"}
r.hmset("singers",singer)
print(r.hget("singers","singer2")) # 輸出:others

# 在name對應的hash中獲取多個key的值
# hmget(name, keys, *args)
singer=["singer1","singer2"]
print(r.hmget("singers",singer))
print(r.hmget("china","singer1","singer2"))

# 獲取hash中鍵值對的個數
# hlen(name)
print(r.hlen("singers"))

# 獲取hash中全部的key的值
# hkeys(name)
print(r.hkeys("singers"))

# 獲取hash中全部的value的值
# hvals(name)
print(r.hvals("singers"))

# 檢查name對應的hash是否存在當前傳入的key
# hexists(name, key)
print(r.hexists("singers","singer1"))#輸出:True

# 刪除指定name對應的key所在的鍵值對
# hdel(name,*keys)
r.hdel("singers","singer2")

# 自增hash中key對應的值，不存在則建立key=amount(amount爲整數)
# hincrby(name, key, amount=1)
print(r.hincrby("money","me",amount=200))

# 自增hash中key對應的值，不存在則建立key=amount(amount爲浮點數)
# hincrbyfloat(name, key, amount=1.0)
print(r.hincrby("money","me",amount=200.5))

5.List命令

redis命令

# 移出並獲取列表的第一個元素，若是列表沒有元素會阻塞列表直到等待超時或發現可彈出元素爲止
> BLPOP key1 [key2 ] timeout 

# 移出並獲取列表的最後一個元素，若是列表沒有元素會阻塞列表直到等待超時或發現可彈出元素爲止
> BRPOP key1 [key2 ] timeout 

# 從列表中彈出一個值，將彈出的元素插入到另一個列表中並返回它；若是列表沒有元素會阻塞列表直到等待超時或發現可彈出元素爲止
> BRPOPLPUSH source destination timeout 

# 經過索引獲取列表中的元素
> LINDEX key index 

# 在列表的元素前或者後插入元素
> LINSERT key BEFORE|AFTER pivot value 

# 獲取列表長度
> LLEN key 

# 移出並獲取列表的第一個元素
> LPOP key 

# 將一個或多個值插入到列表頭部
> LPUSH key value1 [value2] 

# 將一個值插入到已存在的列表頭部
> LPUSHX key value 

# 獲取列表指定範圍內的元素
> LRANGE key start stop 

# 移除列表元素
> LREM key count value 

# 經過索引設置列表元素的值
> LSET key index value 

# 對一個列表進行修剪(trim)，就是說，讓列表只保留指定區間內的元素，不在指定區間以內的元素都將被刪除
> LTRIM key start stop 

# 移除並獲取列表最後一個元素
> RPOP key 

# 移除列表的最後一個元素，並將該元素添加到另外一個列表並返回
> RPOPLPUSH source destination 

# 在列表中添加一個或多個值
> RPUSH key value1 [value2] 

# 爲已存在的列表添加值
> RPUSHX key value

Python命令

# 在name對應的list中添加元素，每一個新的元素都添加到列表的最左邊
# lpush(name,values)
r.lpush("list_name",2)
r.lpush("list_name",3,4,5)#保存在列表中的順序爲5，4，3，2


# 同lpush，但每一個新的元素都添加到列表的最右邊
rpush(name,values)

# 在name對應的list中添加元素，只有name已經存在時，值添加到列表的最左邊
lpushx(name,value)

# 在name對應的list中添加元素，只有name已經存在時，值添加到列表的最右邊
rpushx(name,value)

# name對應的list元素的個數
# llen(name)
print(r.llen("list_name"))

# 在name對應的列表的某一個值前或後插入一個新值
# linsert(name, where, refvalue, value) ; where的值爲 BEFORE（前）或AFTER（後）
r.linsert("list_name","BEFORE","B","S")# 在列表內找到第一個元素B，在它前面插入S

# 對list中的某一個索引位置從新賦值
# r.lset(name, index, value)
r.lset("list_name",0,"bbb")

# 刪除name對應的list中的指定值
# r.lrem(name, value, num) ;如num=0:刪除列表中全部的指定值;num=2:從前到後，刪除2個;num=-2:從後向前，刪除2個
# 須要注意的是，python2和python3後面兩個參數是調轉的
# Python2版本
r.lrem("list_name",0,'SS')
# Python3版本
r.lrem("list_name",'SS',0)

# 移除列表的左側第一個元素，返回值則是第一個元素
# lpop(name)
print(r.lpop("list_name"))

# 根據索引獲取列表內元素
# lindex(name, index)
print(r.lindex("list_name",1))

# 獲取全部值
print(r.lrange("list_name",0,-1))

# 分片獲取元素
# lrange(name, start, end)
print(r.lrange("list_name",0,-1))

# 移除列表內沒有在該索引以內的值
# ltrim(name, start, end)
r.ltrim("list_name",0,2)

# 從一個列表取出最右邊的元素，同時將其添加至另外一個列表的最左邊
#src 要取數據的列表
#dst 要添加數據的列表
rpoplpush(src, dst)

# 同rpoplpush，多了個timeout, timeout：取數據的列表沒元素後的阻塞時間，0爲一直阻塞
# brpoplpush(src, dst, timeout=0)
r.brpoplpush("list_name","list_name1",timeout=0)

# 將多個列表排列,按照從左到右去移除各個列表內的元素
# blpop(keys, timeout);timeout爲0則表示一直阻塞
r.lpush("list_name",3,4,5)
r.lpush("list_name1",3,4,5)
while True:
    print(r.blpop(["list_name","list_name1"],timeout=0))
    print(r.lrange("list_name",0,-1),r.lrange("list_name1",0,-1))

# 同blpop，將多個列表排列,按照從右像左去移除各個列表內的元素
r.brpop(keys, timeout)

6.Set命令

redis命令

# 向集合添加一個或多個成員
> SADD key member1 [member2] 

# 獲取集合的成員數
> SCARD key 

# 返回給定全部集合的差集
> SDIFF key1 [key2] 

# 返回給定全部集合的差集並存儲在 destination 中
> SDIFFSTORE destination key1 [key2] 

# 返回給定全部集合的交集
> SINTER key1 [key2] 

# 返回給定全部集合的交集並存儲在 destination 中
> SINTERSTORE destination key1 [key2] 

# 判斷 member 元素是不是集合 key 的成員
> SISMEMBER key member 

# 將 member 元素從 source 集合移動到 destination 集合
> SMOVE source destination member 

# 移除並返回集合中的一個隨機元素
> SPOP key 

# 返回集合中一個或多個隨機數
> SRANDMEMBER key [count] 

# 移除集合中一個或多個成員
> SREM key member1 [member2] 

# 返回全部給定集合的並集
> SUNION key1 [key2] 

# 全部給定集合的並集存儲在 destination 集合中
> SUNIONSTORE destination key1 [key2] 

# 迭代集合中的元素
> SSCAN key cursor [MATCH pattern] [COUNT count]

Python命令

# 給name對應的集合中添加元素
r.sadd("set_name","aa")

# 獲取name對應的集合的全部成員
# smembers(name)
print(r.smembers("set_name")) # 輸出aa

# 獲取name對應的集合中的元素個數
# scard(name)
r.scard("set_name") # 輸出 1

# 在第一個name對應的集合中且不在其餘name對應的集合的元素集合
# sdiff(keys, *args)
r.sadd("set_name","aa","bb")
r.sadd("set_name1","bb","cc")
r.sadd("set_name2","bb","cc","dd")
print(r.sdiff("set_name","set_name1","set_name2")) # 輸出:｛aa｝

# 把sdiff獲取的值加入到dest對應的集合中
# sdiffstore(dest, keys, *args)

# 獲取多個name對應集合的並集
# sinter(keys, *args)
r.sadd("set_name","aa","bb")
r.sadd("set_name1","bb","cc")
r.sadd("set_name2","bb","cc","dd")
print(r.sinter("set_name","set_name1","set_name2")) # 輸出:｛bb｝

# 把sinter獲取到的值加入到dest對應的集合中
# sinterstore(dest, keys, *args)

# 檢查value是不是name對應的集合內的元素
# sismember(name, value)

# 將某個元素從一個集合中移動到另一個集合
# smove(src, dst, value)

# 從集合的右側移除一個元素，並將其返回
# spop(name)

# 從name對應的集合中隨機獲取numbers個元素
# srandmember(name, numbers)
print(r.srandmember("set_name2",2))

# 刪除name對應的集合中的某些值
# srem(name, values)
print(r.srem("set_name2","bb","dd"))


# 獲取多個name對應的集合的並集
# sunion(keys, *args)
r.sunion("set_name","set_name1","set_name2")

# 獲取多個name對應的集合的並集，並將結果保存到dest對應的集合中
# sunionstore(dest,keys, *args)

7.Sorted set命令

redis命令

# 向有序集合添加一個或多個成員，或者更新已存在成員的分數
> ZADD key score1 member1 [score2 member2] 

# 獲取有序集合的成員數
> ZCARD key 

# 計算在有序集合中指定區間分數的成員數
> ZCOUNT key min max 

# 有序集合中對指定成員的分數加上增量 increment
> ZINCRBY key increment member 

# 計算給定的一個或多個有序集的交集並將結果集存儲在新的有序集合 key 中
> ZINTERSTORE destination numkeys key [key ...] 

# 在有序集合中計算指定字典區間內成員數量
> ZLEXCOUNT key min max 

# 經過索引區間返回有序集合成指定區間內的成員
> ZRANGE key start stop [WITHSCORES] 

# 經過字典區間返回有序集合的成員
> ZRANGEBYLEX key min max [LIMIT offset count] 

# 經過分數返回有序集合指定區間內的成員
> ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT] 

# 返回有序集合中指定成員的索引
> ZRANK key member 

# 移除有序集合中的一個或多個成員
> ZREM key member [member ...] 

# 移除有序集合中給定的字典區間的全部成員
> ZREMRANGEBYLEX key min max 

# 移除有序集合中給定的排名區間的全部成員
> ZREMRANGEBYRANK key start stop 

# 移除有序集合中給定的分數區間的全部成員
> ZREMRANGEBYSCORE key min max 

# 返回有序集中指定區間內的成員，經過索引，分數從高到底
> ZREVRANGE key start stop [WITHSCORES] 

# 返回有序集中指定分數區間內的成員，分數從高到低排序
> ZREVRANGEBYSCORE key max min [WITHSCORES] 

# 返回有序集合中指定成員的排名，有序集成員按分數值遞減(從大到小)排序
> ZREVRANK key member 

# 返回有序集中，成員的分數值
> ZSCORE key member 

# 計算給定的一個或多個有序集的並集，並存儲在新的 key 中
> ZUNIONSTORE destination numkeys key [key ...] 

# 迭代有序集合中的元素（包括元素成員和元素分值）
> ZSCAN key cursor [MATCH pattern] [COUNT count]

Python命令

# 在name對應的有序集合中添加元素
# zadd(name, *args, **kwargs)，注意是先分數，再加名字的
r.zadd("zset_name", 6, "a1", 2, "a2", 2,"a3")
#或(名字=分數)
r.zadd('zset_name1', b1=10, b2=5)

# 獲取有序集合內元素的數量
# zcard(name)
print(r.zcard('zset_name'))

# 獲取有序集合中分數在[min,max]之間的個數
# zcount(name, min, max)
print(r.zcount("zset_name",1,5))

# 自增有序集合內value對應的分數
# zincrby(name, value, amount)
r.zincrby("zset_name","a1",amount=2)#自增zset_name對應的有序集合裏a1對應的分數

# 按照索引範圍獲取name對應的有序集合的元素
# zrange( name, start, end, desc=False, withscores=False, score_cast_func=float);desc:排序規則，默認按照分數從小到大排序;withscores:是否獲取元素的分數，默認只獲取元素的值;score_cast_func 對分數進行數據轉換的函數
aa=r.zrange("zset_name",0,1,desc=False,withscores=True,score_cast_func=int)
print(aa)

# 同zrange，集合是從大到小排序的
# zrevrange(name, start, end, withscores=False, score_cast_func=float)

# 獲取value值在name對應的有序集合中的排行位置（從0開始）
# zrank(name, value)、zrevrank(name, value)
print(r.zrank("zset_name", "a2"))
print(r.zrevrank("zset_name", "a2"))# 從大到小排序

# 獲取name對應有序集合中 value 對應的分數
# zscore(name, value)
print(r.zscore("zset_name","a1"))

# 刪除name對應的有序集合中值是values的成員
# zrem(name, values)
r.zrem("zset_name","a1","a2")

# 根據排行範圍刪除
# zremrangebyrank(name, min, max)

# 根據分數範圍刪除
# zremrangebyscore(name, min, max)

# 獲取兩個有序集合的交集並放入dest集合，若是遇到相同值不一樣分數，則按照aggregate進行操做
# aggregate的值爲: SUM  MIN  MAX
# zinterstore(dest, keys, aggregate=None)
r.zadd("zset_name", "a1", 6, "a2", 2,"a3",5)
r.zadd('zset_name1', a1=7,b1=10, b2=5)
r.zinterstore("zset_name2",("zset_name1","zset_name"),aggregate="MAX")
print(r.zscan("zset_name2"))

# 獲取兩個有序集合的並集並放入dest集合，其餘同zinterstore
# zunionstore(dest, keys, aggregate=None)