摘要：一字符串操作的模塊對字符串的主要操作函數包括在中庸同一個函數實現。的模塊實現了哈希命令行操作的幾乎全部命令，包括等命令。

Python操作Redis的redis模塊對字符串（string）的主要操作函數包括：SET、GET、GETSET、SETEX、SETNX、MSET、MSETNX、INCR(INCRBY,DECR,DECRBY在python中庸同一個函數incr實現)、APPEND、SETRANGE、STRLEN。函數說明如下：

SET： 為指定的鍵（key）設置值（value）， set(self, name, value, **kwargs)。

GET：獲取指定鍵（key）綁定的值（value），get(self, name)。

GETSET：為指定的鍵（key）設置新的值（value），并返回舊的值（old Value），getset(self, name, value)

SETEX：為指定的鍵（key）設置過期以秒（second）計的過期時間，setex(self, name, value, time)

SETNX：鍵（key）不存在時，為鍵（key）指定值（value），setnx(self, name, value)

MSET：一次性設置多個鍵-值(key-value)對,函數設置的鍵-值對（即mapping所指內容）數據要以Python字典數據類型傳入，mset(self, mapping)

MSETNX：鍵-值(key-value)對不存在時，設置鍵-值（key-value）對,msetnx(self, mapping)，mapping值參考6

INCR：自增函數，默認步長為1，通過對步長（amount）大小以及字符的控制實現了INCRBY（amount>=1）、DECR（amount=-1）、DECRBY（amount<=-1）等函數功能，incr(self, name, amount=1)

APPEND：為指定的字符串追加值，若不存在則直接創建，append(self, key, value)

SETRANGE：用 value 參數覆寫給定 key 所儲存的字符串值，從偏移量 offset 開始，setrange(self, name, offset, value)

STRLEN：返回字符串的長度，當name不存在時返回0，strlen(self, name)

示例代碼如下：

#!/usr/bin/python
# -*- coding:utf-8 -*-
# __author__ = "Jack"

pool = redis.ConnectionPool(host="127.0.0.1", port=6379)
r = redis.Redis(connection_pool=pool)
r.flushall()  # 清空Redis

r.setex("name", value="liaogx", time=2)  # 設置新值，過期時間為3s
r.mset(k1 = "v1", k2 = "v2", k3 = "v3")  # 批量設置新值
print(r.mget("k1", "k2", "k3", "k4"))  # 批量獲取新值
print(r.getset("name", "liaogaoxiang"))  # 設置新值并獲取原來的值
print(r.getrange("name", 0, 1))  # 獲取子序列 0 <= x <= 1
r.setrange("name", 0, "LIAO")  # 修改字符串內容，從指定字符串索引開始向后替換（新值太長時，則向后添加），返回值的長度
i = 0
while i < 4:
    print(r.get("name"))
    time.sleep(1)
    i += 1
source = "foo"
r.set("n1", source)
r.setbit("n1", 7, 1)
"""
注：如果在Redis中有一個對應： n1 = "foo"，
    那么字符串foo的二進制表示為：01100110 01101111 01101111
    所以，如果執行 setbit("n1", 7, 1)，則就會將第7位設置為1，
    那么最終二進制則變成 01100111 01101111 01101111，即："goo"
"""
print(r.get("n1"))
print(r.getbit("n1", 7))  # 獲取n1對應的值的二進制表示中的某位的值 （0或1）
r.set("n2", "廖高祥")
print(r.strlen("n2"))  # 返回對應的字節長度（一個漢字3個字節）
r.set("num", 1)
r.incr("num", amount=10)
r.decr("num", amount=1)
print(r.get("num"))  # 自增num對應的值，當name不存在時，則創建name＝amount，否則，則自增。
r.append("num", 111)
print(r.get("num"))  # 在redis num對應的值后面追加內容

輸出結果如下：

[b"v1", b"v2", b"v3", None]
b"liaogx"
b"li"
b"LIAOgaoxiang"
b"LIAOgaoxiang"
b"LIAOgaoxiang"
b"LIAOgaoxiang"
b"goo"
1
9
b"10"
b"10111"

Python操作Redis主要利用了redis模塊來實現，list表操作函數主要模擬了Redis操作命令LPUSH，LRANGE，LINDEX，BLPOP，BRPOP。函數說明如下：

lpush函數實現了從向指定redis列表頭部壓入數據功能，lpush key value

lrange獲取列表指定范圍的函數，lrange key start end

lindex根據列表下標量獲取列表元素值， lindex key index

blpop從列表頭部取出第一個元素，返回該元素值并從列表刪除（l代表left，左邊）

brpop從列表尾部取出第一個元素，返回該元素值并從列表刪除（l代表right，右邊）

LPUSHX、RPUSHX以及其他一些Redis列表（List）函數目前版本無法實現，如有可實現方法博客代碼事例將會得到更新。

示例代碼如下：

#!/usr/bin/python
# -*- coding:utf-8 -*-
# __author__ = "Jack"

pool = redis.ConnectionPool(host="127.0.0.1", port=6379)
r = redis.Redis(connection_pool=pool)
r.flushall()  # 清空Redis

r.lpush("oo", 11)  # 保存順序為: 33,22,11
r.lpushx("oo", 00)  # 在name對應的list中添加元素，只有name已經存在時，值添加到列表的最左邊
print(r.llen("oo"))  # name對應的list元素的個數

r.linsert("oo", "before", 11, 99)  # 在11之前插入值99
r.lset("oo", 1, 88)  # 對name對應的list中的某一個索引位置重新賦值
print(r.lrange("oo", 0, -1))  # 在name對應的列表分片獲取數據

r.lrem("oo", 88, num=1)  # 在name對應的list中刪除指定的值.num=0，刪除列表中所有的指定值；num=2,從前到后，刪除2個；num=-2,從后向前，刪除2個
print(r.lrange("oo", 0, -1))

print(r.lpop("oo"))  # 在name對應的列表的左側獲取第一個元素并在列表中移除，返回值則是第一個元素
print(r.lindex("oo", 0))  # 在name對應的列表中根據索引獲取列表元素
r.lpush("l1", 11)  # index為0
r.rpush("l1", 22)
r.rpush("l1", 33)
r.rpush("l1", 44)
r.rpush("l1", 55)  # index為4
r.ltrim("l1", 1, 3)  # 在name對應的列表中移除沒有在[start-end]索引之間的值
print(r.lrange("l1", 0, -1))

r.rpoplpush("l1", "l1")  # 從一個列表取出最右邊的元素，同時將其添加至另一個列表的最左邊;src要取數據的列表的name, dst要添加數據的列表的name
print(r.lrange("l1", 0, -1))

r.brpoplpush("l1", "l1", timeout=3)  # # timeout，當src對應的列表中沒有數據時，阻塞等待其有數據的超時時間（秒），0 表示永遠阻塞
print(r.lrange("l1", 0, -1))

print(r.blpop("l1", 3))  # 從列表頭部取出第一個元素，返回該元素值并從列表刪除（l代表left，左邊）
print(r.lrange("l1", 0, -1))
"""
    # 由于redis類庫中沒有提供對列表元素的增量迭代，如果想要循環name對應的列表的所有元素，那么就需要：
    # 1、獲取name對應的所有列表
    # 2、循環列表
    # 但是，如果列表非常大，那么就有可能在第一步時就將程序的內容撐爆，所有有必要自定義一個增量迭代的功能：
"""
print("自定義增量迭代：")
r.flushall()
r.lpush("l1", 11)  # index為0
r.rpush("l1", 22)
r.rpush("l1", 33)
r.rpush("l1", 44)
r.rpush("l1", 55)  # index為4

def list_iter(name):
    list_count = r.llen(name)
    for index in range(list_count):
        yield r.lindex(name, index)

for item in list_iter("l1"):
    print(item)

輸出結果如下：

2
[b"0", b"88", b"11"]
[b"0", b"11"]
b"0"
b"11"
[b"22", b"33", b"44"]
[b"44", b"22", b"33"]
[b"33", b"44", b"22"]
(b"l1", b"33")
[b"44", b"22"]
自定義增量迭代：
b"11"
b"22"
b"33"
b"44"
b"55"

Redis 數據庫集合對象(set object)是由string類型的無重復元素的無需集合，底層編碼可以是intset或者hashtable。intset編碼的集合對象用整數集合最為底層實現，所有對象元素保存在整數集合中。Python的redis模塊實現了 SADD、SCARD 、SDIFF 、SDIFFSTORE、SINTER 、SINTERSTORE、SISMEMBER 、SMEMBERS 、SMOVE、SPOP、SRANDMEMBER、SREM、SUNION、SUNIONSTORE操作命令的基本用法。函數說明如下：

SADD：向集合對象添加成員，sadd(self, name, value)

SCARD：獲取集合元素個數，scard(self, name)

SDIFF：返回給定多個集合對象的差集(set key1-set key2..-set keyn)，從左到右計算集合差集，sdiff(self, keys, *args)

SDIFFSTORE：返回給定給定多個集合對象的差集并存儲在目標（dest）集合中，sdiffstore(self, dest, keys, *args)

SINTER：返回給定所有集合（keys, args）的交集, sinter(self, keys, args)

SINTERSTORE：返回給定所有集合（keys, args）的交集并存儲在 集合(dest) 中, sinterstore(self, dest, keys, args)

SISMEMBER：判斷 value元素是否是集合 name 的成員,返回布爾邏輯值True或者False，sismember(self, name, value)

SMEMBERS：返回集合中所元素值的Python集合類型數據，smembers(self, name)

SMOVE：將元素value從集合src移動到 集合 dest。若元素value在集合src中不存在，則集合dest中不會添加元素value， smove(self, src, dest, value)

SPOP：移除并返回集合中的一個隨機元素, spop(self, name)

SRANDMEMBER：返回集合中一個隨機數，但是不做移除操作, srandmember(self, name)。從Redis 2.6 版本開始， 在命令行下Srandmember 命令接受可選返回元素數量的參數 redis>SRANDMEMBER name count

SREM：移除集合中一個元素，srem(self, name, value)，redis模塊任然沿用Redis 2.4 版本以前的只接受單個元素的用法。

SUNION：返回所有給定集合的并集中所有元素，sunion(self, keys, *args)

SUNIONSTORE：所有給定集合的并集存儲在集合dest 中, sunionstore(self, dest, keys, *args)

SSCAN：迭代集合中的元素，sscan(self, name, cursor=0, match=None, count=None)

示例代碼如下：

#!/usr/bin/python
# -*- coding:utf-8 -*-
# __author__ = "Jack"

pool = redis.ConnectionPool(host="127.0.0.1", port=6379)
r = redis.Redis(connection_pool=pool)
r.flushall()  # 清空Redis

r.sadd("s1", "v1", "v1", "v2", "v3")  # name對應的集合中添加元素
r.sadd("s2", "v2", "v4")  # name對應的集合中添加元素
print(r.scard("s1"))  # 獲取name對應的集合中元素個數
print(r.sdiff("s1", "s2"))  #在第一個name對應的集合中且不在其他name對應的集合的元素集合

r.sdiffstore("s3", "s1", "s2")  # 獲取第一個name對應的集合中且不在其他name對應的集合，再將其新加入到dest對應的集合中
print(r.smembers("s3"))  # 獲取s3對應的集合的所有成員

print(r.sinter("s1", "s2"))  # 獲取s1, s2對應集合的交集
r.sinterstore("s4", "s1", "s2")  # 獲取s1, s2對應集合的交集，并將其存放到集合是s4中
print(r.smembers("s4"))

print(r.sunion("s1", "s2"))  # 獲取s1, s2對應集合的并集

r.sunionstore("s5", "s1", "s2")  # 獲取s1, s2對應集合的交集，并將其存放到集合是s5中
print(r.smembers("s5"))

print(r.sismember("s4", "v4"))  # 檢查value是否是name對應的集合的成員

r.smove("s2", "s1", "v4")  # 將集合s2中成員v4移至集合s1中
print(r.smembers("s1"))
r.srem("s1", "v1")  # 在name對應的集合中刪除某些值

print(r.spop("s1"))  # 從集合的右側（尾部）移除一個成員，并將其返回 注意：集合是無序的，故結果隨機！

print(r.srandmember("s1"))  # 從name對應的集合中隨機獲取 numbers 個元素(Redis 2.6+)

輸出結果如下：

3
{b"v3", b"v1"}
{b"v3", b"v1"}
{b"v2"}
{b"v2"}
{b"v3", b"v2", b"v4", b"v1"}
{b"v3", b"v2", b"v4", b"v1"}
False
{b"v3", b"v2", b"v4", b"v1"}
b"v2"
b"v3"

示例代碼如下：

#!/usr/bin/python
# -*- coding:utf-8 -*-
# __author__ = "Jack"

pool = redis.ConnectionPool(host="127.0.0.1", port=6379)
r = redis.Redis(connection_pool=pool)
r.flushall()  # 清空Redis

r.zadd("z1", "11", 1, "22", 2, "33", 3, "44", 4, "55", 5, "66", 6, "66", 7)  # 在name對應的有序集合中添加元素
print(r.zcard("z1"))  # 獲取name對應的有序集合元素的數量
print(r.zcount("z1", 1, 2))  # 獲取name對應的有序集合中分數 在 [min,max] 之間的個數
r.zincrby("z1", "11", amount=5)  # 自增name對應的有序集合的 name 對應的分數
print(r.zrange("z1", 0, -1, desc=False, withscores=True))  # 值11被排序到最后;此處表示按元素的值升序排列

print(r.zrank("z1", 33))  # 獲取某個值在 name對應的有序集合中的排行（從 0 開始）

r.zrem("z1", "66")  # 刪除name對應的有序集合中值是values的成員
print(r.zrange("z1", 0, -1, desc=False, withscores=True))

r.zremrangebyrank("z1", 0, 1)  # 根據排行范圍刪除
print(r.zrange("z1", 0, -1, desc=False, withscores=True))

r.zremrangebyscore("z1", 4.5, 5.5)  # 根據分數范圍刪除
print(r.zrange("z1", 0, -1, desc=False, withscores=True))

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

r.zadd("zset_name", "a1", 6, "a2", 2, "a3", 5)
r.zadd("zset_name1", a1=7, b1=10, b2=5)
"""
    獲取兩個有序集合的交集并放入dest集合，如果遇到相同值不同分數，則按照aggregate進行操作
    aggregate的值為: SUM  MIN  MAX
"""
r.zinterstore("zset_name2", ("zset_name", "zset_name1"), aggregate="Sum")

print(r.zrange("zset_name2", 0, -1, desc=False, withscores=True))

輸出結果如下：

6
2
[(b"22", 2.0), (b"33", 3.0), (b"44", 4.0), (b"55", 5.0), (b"11", 6.0), (b"66", 6.0)]
1
[(b"22", 2.0), (b"33", 3.0), (b"44", 4.0), (b"55", 5.0), (b"11", 6.0)]
[(b"44", 4.0), (b"55", 5.0), (b"11", 6.0)]
[(b"44", 4.0), (b"11", 6.0)]
6.0
[(b"a1", 13.0)]

Redis 數據庫hash數據類型是一個string類型的key和value的映射表，適用于存儲對象。redis 中每個hash可以存儲鍵值對多達40億。Python的redis模塊實現了Redis哈希（Hash）命令行操作的幾乎全部命令，包括HDEL、HEXISTS、HGET、HGETALL、HINCRBY、HKEYS、HLEN 、HMGET 、HMSET 、HSET 、HSETNX 、HVALS 、HINCRBYFLOAT等命令。函數說明如下：

HDEL：刪除對應哈希（Hash）表的指定鍵（key）的字段，hdel(self, name, key)

HEXISTS：檢測哈希（Hash）表對應鍵（key）字段是否存在，返回布爾邏輯，hexists(self, name, key)

HGET：獲取哈希（Hash）指定鍵（key）對應的值，hget(self, name, key)

HGETALL：獲取哈希(Hash)表的鍵-值對（key-value pairs）,返回python字典類型數據，hgetall(self, name)

HINCRBY：為哈希表（Hash）指定鍵（key）對應的值（key）加上指定的整數數值（int，可為負值）hincrby(self>, name, key, amount=1)，Redis 中本操作的值被限制在 64 位(bit)有符號數字。

HKEYS：返回哈希表（Hash）對應鍵（key）的數組（Python稱之為列表List），hkeys(self, name)

HLEN： 獲取哈希表（Hash）中鍵-值對（key-value pairs）個數，hlen(self, name)

HMGET：獲取哈希表（Hash）中一個或多個給點字段的值，不存在返回nil(Redis命令行)/None(Python)，hmget(self, name, keys)，其中keys可以為列表（list）

HMSET：設置對個鍵-值對（key-value pairs）到哈希表（Hash）中，python輸入值（mapping）為字典（dictionary）類型，hmset(self, name, mapping)

HSET：為哈希表（Hash）賦值，若鍵（key）存在值（value）則覆蓋，不存在則創建，hset(self, name, key, value)

HSETNX：為哈希表（Hash）不存值（value）的鍵（key）賦值，存在操作無效，對應值（value）無變化，hsetnx(self, name, key, value)

HVALS：返回哈希表（Hash）對應值（value）的列表，hvals(self, name)

HINCRBYFLOAT：為哈希表 key 中的指定字段的浮點數值加上增量 increment ，hincrbyfloat(self, name, key, amount=1.0)

示例代碼如下：

#!/usr/bin/python
# -*- coding:utf-8 -*-
# __author__ = "Jack"

pool = redis.ConnectionPool(host="127.0.0.1", port=6379)
r = redis.Redis(connection_pool=pool)
r.flushall()  # 清空Redis

r.hset("n1", "k1", "v1")  # hset(name, key, value),name對應的hash中設置一個鍵值對（不存在，則創建；否則，修改）
print(r.hget("n1", "k1"))
r.hmset("n2", {"k1": "v1", "k2": "v2", "k3": "v3"})  # hmset(name, mapping),在name對應的hash中批量設置鍵值對
print(r.hmget("n2", "k2"))
print(r.hgetall("n2"))  # 獲取name對應hash的所有鍵值
print(r.hlen("n2"))  # 獲取name對應的hash中鍵值對的個數
print(r.hkeys("n2"))  # 獲取name對應的hash中所有的key的值
print(r.hvals("n2"))  # 獲取name對應的hash中所有的value的值
print(r.hexists("n2", "k4")) # 檢查name對應的hash是否存在當前傳入的key
r.hdel("n2", "k3")  # 將name對應的hash中指定key的鍵值對刪除
r.hset("n3", "k1", 1)
r.hincrby("n3", "k1", amount=1)  # hincrby(name, key, amount=1),自增name對應的hash中的指定key的value的值，不存在則創建key=amount
print(r.hgetall("n3"))

輸出結果如下：

b"v1"
[b"v2"]
{b"k1": b"v1", b"k2": b"v2", b"k3": b"v3"}
3
[b"k1", b"k2", b"k3"]
[b"v1", b"v2", b"v3"]
False
{b"k1": b"2"}

命令太多記不住可以參考Redis中文網，強烈建議收藏

程序員交流群，干貨分享，加我拉你入群。