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

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

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

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

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

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

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

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

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

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

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

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

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

輸出結(jié)果如下：

[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模塊來實現(xiàn)，list表操作函數(shù)主要模擬了Redis操作命令LPUSH，LRANGE，LINDEX，BLPOP，BRPOP。函數(shù)說明如下：

lpush函數(shù)實現(xiàn)了從向指定redis列表頭部壓入數(shù)據(jù)功能，lpush key value

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

lindex根據(jù)列表下標(biāo)量獲取列表元素值， lindex key index

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

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

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

示例代碼如下：

#!/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對應(yīng)的list中添加元素，只有name已經(jīng)存在時，值添加到列表的最左邊
print(r.llen("oo"))  # name對應(yīng)的list元素的個數(shù)

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

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

print(r.lpop("oo"))  # 在name對應(yīng)的列表的左側(cè)獲取第一個元素并在列表中移除，返回值則是第一個元素
print(r.lindex("oo", 0))  # 在name對應(yīng)的列表中根據(jù)索引獲取列表元素
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對應(yīng)的列表中移除沒有在[start-end]索引之間的值
print(r.lrange("l1", 0, -1))

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

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

print(r.blpop("l1", 3))  # 從列表頭部取出第一個元素，返回該元素值并從列表刪除（l代表left，左邊）
print(r.lrange("l1", 0, -1))
"""
    # 由于redis類庫中沒有提供對列表元素的增量迭代，如果想要循環(huán)name對應(yīng)的列表的所有元素，那么就需要：
    # 1、獲取name對應(yīng)的所有列表
    # 2、循環(huán)列表
    # 但是，如果列表非常大，那么就有可能在第一步時就將程序的內(nèi)容撐爆，所有有必要自定義一個增量迭代的功能：
"""
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)

輸出結(jié)果如下：

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 數(shù)據(jù)庫集合對象(set object)是由string類型的無重復(fù)元素的無需集合，底層編碼可以是intset或者h(yuǎn)ashtable。intset編碼的集合對象用整數(shù)集合最為底層實現(xiàn)，所有對象元素保存在整數(shù)集合中。Python的redis模塊實現(xiàn)了 SADD、SCARD 、SDIFF 、SDIFFSTORE、SINTER 、SINTERSTORE、SISMEMBER 、SMEMBERS 、SMOVE、SPOP、SRANDMEMBER、SREM、SUNION、SUNIONSTORE操作命令的基本用法。函數(shù)說明如下：

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

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

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

SDIFFSTORE：返回給定給定多個集合對象的差集并存儲在目標(biāo)（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集合類型數(shù)據(jù)，smembers(self, name)

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

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

SRANDMEMBER：返回集合中一個隨機(jī)數(shù)，但是不做移除操作, srandmember(self, name)。從Redis 2.6 版本開始， 在命令行下Srandmember 命令接受可選返回元素數(shù)量的參數(shù) 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對應(yīng)的集合中添加元素
r.sadd("s2", "v2", "v4")  # name對應(yīng)的集合中添加元素
print(r.scard("s1"))  # 獲取name對應(yīng)的集合中元素個數(shù)
print(r.sdiff("s1", "s2"))  #在第一個name對應(yīng)的集合中且不在其他name對應(yīng)的集合的元素集合

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

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

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

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

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

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

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

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

輸出結(jié)果如下：

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對應(yīng)的有序集合中添加元素
print(r.zcard("z1"))  # 獲取name對應(yīng)的有序集合元素的數(shù)量
print(r.zcount("z1", 1, 2))  # 獲取name對應(yīng)的有序集合中分?jǐn)?shù) 在 [min,max] 之間的個數(shù)
r.zincrby("z1", "11", amount=5)  # 自增name對應(yīng)的有序集合的 name 對應(yīng)的分?jǐn)?shù)
print(r.zrange("z1", 0, -1, desc=False, withscores=True))  # 值11被排序到最后;此處表示按元素的值升序排列

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

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

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

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

print(r.zscore("z1", 11))  # 獲取name對應(yīng)有序集合中 value 對應(yīng)的分?jǐn)?shù)

r.zadd("zset_name", "a1", 6, "a2", 2, "a3", 5)
r.zadd("zset_name1", a1=7, b1=10, b2=5)
"""
    獲取兩個有序集合的交集并放入dest集合，如果遇到相同值不同分?jǐn)?shù)，則按照aggregate進(jìn)行操作
    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))

輸出結(jié)果如下：

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

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

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

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

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

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

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

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

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

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

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

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

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

HINCRBYFLOAT：為哈希表 key 中的指定字段的浮點數(shù)值加上增量 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對應(yīng)的hash中設(shè)置一個鍵值對（不存在，則創(chuàng)建；否則，修改）
print(r.hget("n1", "k1"))
r.hmset("n2", {"k1": "v1", "k2": "v2", "k3": "v3"})  # hmset(name, mapping),在name對應(yīng)的hash中批量設(shè)置鍵值對
print(r.hmget("n2", "k2"))
print(r.hgetall("n2"))  # 獲取name對應(yīng)hash的所有鍵值
print(r.hlen("n2"))  # 獲取name對應(yīng)的hash中鍵值對的個數(shù)
print(r.hkeys("n2"))  # 獲取name對應(yīng)的hash中所有的key的值
print(r.hvals("n2"))  # 獲取name對應(yīng)的hash中所有的value的值
print(r.hexists("n2", "k4")) # 檢查name對應(yīng)的hash是否存在當(dāng)前傳入的key
r.hdel("n2", "k3")  # 將name對應(yīng)的hash中指定key的鍵值對刪除
r.hset("n3", "k1", 1)
r.hincrby("n3", "k1", amount=1)  # hincrby(name, key, amount=1),自增name對應(yīng)的hash中的指定key的value的值，不存在則創(chuàng)建key=amount
print(r.hgetall("n3"))

輸出結(jié)果如下：

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中文網(wǎng)，強(qiáng)烈建議收藏

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