Redis实战之Redis命令

时间：2022-01-31 20:30:51

　　Redis可以存储键与5种不同数据结构类型之间的映射，这5种数据结构类型分别为string（字符串），list（列表），set（集合），hash（散列），zset（有序集合），下面将分别对这5种数据类型的控制命令进行总结，熟话说好记性不如烂笔头，方便以后查看。

1. 字符串命令

　　Redis种的字符串有三种类型的值：字节，整数和浮点数

（1）命令列表

　　SET：SET key value ------设置存储在给定键种的值

　　GET：GET key value ------获取存储在给定键种的值

　　DEL：DEL key ------删除存储在给定键种的值（这个命令可以用于所有类型）

　　INCR：INCR key ------将键对应的值加1

　　DECR：DECR key ------将键对应的值减1

　　INCRBY：incrby key number ------将键对应的值加number

　　DECRBY：decrby key number ------将键对应的值减number

　　APPEND：append key value ------将值value追加到给定键key当前村粗的值的末尾

　　GETRANGE：getrange key start end ------获取从start到end范围内的字串

　　SETRANGE：setrange key offset val ------将从offset偏移量开始的字串设置指定值val

　　GETBIT：getbit key offset ------返回位串中偏移量为offset的二进制位值

　　SETBIT：setbit key offset val ------位串中偏移量为offset的二进制位值设置为val

　　BITCOUNT：biitcount key [start end] ------统计二进制位串里面值位1的二进制位数量

　　BITOP：bitop operation dest-key key1 [key2...] ------对一个或多个二进制位串执行包括并、或、异或、非在内的任意一种位运算操作

（2）示例

redis 127.0.0.1:6379> set name zhangsan
OK
redis 127.0.0.1:6379> set age 18
OK
redis 127.0.0.1:6379> get name
"zhangsan"
redis 127.0.0.1:6379> get age
"18"
redis 127.0.0.1:6379> incr age
(integer) 19
redis 127.0.0.1:6379> decr age
(integer) 18
redis 127.0.0.1:6379> incrby age 5
(integer) 23
redis 127.0.0.1:6379> decrby age 5
(integer) 18
redis 127.0.0.1:6379> append name _lisi
(integer) 13
redis 127.0.0.1:6379> get name
"zhangsan_lisi"
redis 127.0.0.1:6379> getrange name 1 0
""
redis 127.0.0.1:6379> getrange name 0 -1
"zhangsan_lisi"
redis 127.0.0.1:6379> setrange name 0 wangmazi
(integer) 13
redis 127.0.0.1:6379> get name
"wangmazi_lisi"
redis 127.0.0.1:6379> del name
(integer) 1
redis 127.0.0.1:6379> get name
(nil)

（3）注意事项

　　a. 如果对一个不存在的键或者一个保存了空串的键执行自增或自减操作，那么Redis在执行操作时会将这个键的值当作0来处理

　　b. 即使在设置键时输入的值位字符串，但只要这个值可以可以被理解为整数，就可以当作整数来处理

　　c. GETRANGE命令由以前的SUBSET命令改名而来的，如果是2.6或以上redis版本，使用getrange()方法来获取字串

2. 列表命令

（1）一些常用的列表命令

　　RPUSH：rpush key value [value1...] ------将一个或多个值添加到列表的右端

　　LPUSH：lpush key value [value1...] ------将一个或多个值添加到列表的左端

　　RPOP：rpop key ------移除并返回列表最右端的元素

　　LPOP：lpop key ------移除并返回列表最左端的元素

　　LINDEX：lindex key offset --------返回列表中偏移量为offset的元素

　　LRANGE：lrange key start end ------返回列表中偏移量在[satrt,end]范围内的元素，包括satrt和end

　　LTRIM：ltrim key start end ------对列表进行修剪，只保留从start到end范围内的元素，包括start和end

redis 127.0.0.1:6379> rpush key 1,2,3
(integer) 1
redis 127.0.0.1:6379> lpush key 4,5,6
(integer) 2
redis 127.0.0.1:6379> lrange key 0 -1
1) "4,5,6"
2) "1,2,3"
redis 127.0.0.1:6379> rpush key hello
(integer) 3
redis 127.0.0.1:6379> lrange key 0 -1
1) "4,5,6"
2) "1,2,3"
3) "hello"
redis 127.0.0.1:6379> lindex key 2
"hello"
redis 127.0.0.1:6379> ltrim key 1 2
OK
redis 127.0.0.1:6379> lrange key 0 -1
1) "1,2,3"
2) "hello"

（2）阻塞式的列表弹出命令以及在列表之间元素的移动

　　BLPOP blpop key1 [key2...] timeout ------从一个非空列表中弹出位于最左端的元素，或者在timeout秒之内阻塞并等待可弹出的元素

　　BRPOP

　　BPOPLPUSH bpoplpush source-key dest-key ------从原始列表弹出最右端的元素并压入目标列表左端，并返回这个元素

　　BRPOPLPUSH BRPOPLPUSH source-key dest-key timeout ------从原始列表弹出最右端的元素并压入目标列表左端，并返回这个元素,如果source-key为空阻塞等待

3. 集合命令

　　Redis的集合以无序的方式来存储多个各不相同的元素，可以快速的对集合进行添加，删除、元素检查、组合和关联等操作

（1）常用集合命令

　　SADD：sadd key item [item...] ------将一个或多个元素添加到集合中

　　SREM：srem key item [item...] ------从集合中移除一个或多个元素

　　SISMEMBER：sismember key item ------检查item是否存在于集合key里面

　　SCARD：scard key ------返回集合包含的元素的数量

　　SMEMBERS：smembers key ------返回集合包含的所有元素

　　SRANDMEMBER：srandmember key [count] ------从集合里随机的返回一个或多个元素

　　SPOP：spop key ------随机地移除几个中的一个元素，并返回被移除的元素

　　SMOVE：smove source-key dest-key item ------如果原集合包含item,从原集合移除item并将item添加到集合目标集合，成功返回1，否则返回0

（2）示例

redis 127.0.0.1:6379> sadd key 1 2 3
(integer) 3
redis 127.0.0.1:6379> smembers key
1) "1"
2) "2"
3) "3"
redis 127.0.0.1:6379> sadd key 3
(integer) 0
redis 127.0.0.1:6379> scard key
(integer) 3
redis 127.0.0.1:6379> srem key 3
(integer) 1
redis 127.0.0.1:6379> smembers key
1) "1"
2) "2"
redis 127.0.0.1:6379> srandmember key
"2"
redis 127.0.0.1:6379> smembers key
1) "1"
2) "2"
redis 127.0.0.1:6379> spop key
"1"
redis 127.0.0.1:6379> smembers key
1) "2"

（2）组合和关联命令

　　SDIFF：sdiff key1 [key2...] ------返回那些存在于第一集合key1,但不存在于其他集合中的元素

　　SDIFFSTORE：sdiffstore dest-key key1 [key2...] -------将SDIFF的结果存到目标集合中

　　SINTER：sinter key1 [key2...] ------返回那些同时存在于所有集合中的元素

　　SINTERSTORE：sinterstore dest-key key1 [key2] ------将SINTER的结果放到目标集合中

　　SUNION：sunion key1 [key2...] ------返回那些至少存在于一个集合中的元素

　　SUNIONSTORE：sunionstore dest-key key1 [key2...] ------将SUNION的结果放到表集合中

（3）示例

redis 127.0.0.1:6379> sadd key1 a b c d e
(integer) 5
redis 127.0.0.1:6379> sadd key2 c d e f
(integer) 4
redis 127.0.0.1:6379> smembers key1
1) "c"
2) "d"
3) "e"
4) "a"
5) "b"
redis 127.0.0.1:6379> smembers key2
1) "c"
2) "d"
3) "e"
4) "f"
redis 127.0.0.1:6379> sdiff key1 key2
1) "a"
2) "b"
redis 127.0.0.1:6379> sinter key1 key2
1) "c"
2) "d"
3) "e"
redis 127.0.0.1:6379> sunion key1 key 2
1) "c"
2) "d"
3) "a"
4) "e"
5) "b"

4. 散列命令

　　Redis的散列将多个键值对存储在Redis的键里面

（1）散列常用命令

　　HSET：hset key-name key value ------为散列添加键值对

　　HGET：hget key-name key ------得到散列的键值对

　　HMSET：hmset key-name key value [key name...] -------为散列设置一个或多个键值对

　　HMGET：hmget key-name key [key...] ------得到散列的一个或多个键值对

　　HDEL：hdel key-name key [key...] ------删除散列里面的一个或多个键值对

　　HLEN：hlen key-name ------返回散列包含的键值对数量

　　HEXISTS：hexists key-name key ------检查键值是否在散列中

　　HKEYS：hkeys key-name ------得到散列的所有键值

　　HVALS：hvals key-name ------得到散列的所有键对应的值

　　HGETALL：hgetall key-name ------得到散列的说有键值对

　　HINCRBY：hincrby key-name key number ------将键key的值加上整数number

　　HINCRBYFLOAT：hincrbyfloat key-name key number ------将键key的值加上浮点数number

（2）示例

redis 127.0.0.1:6379> hmset person name zhangsan age 17
OK
redis 127.0.0.1:6379> hmget person name age
1) "zhangsan"
2) "17"
redis 127.0.0.1:6379> hset person sex man
(integer) 1
redis 127.0.0.1:6379> hlen person
(integer) 3
redis 127.0.0.1:6379> hgetall person
1) "name"
2) "zhangsan"
3) "age"
4) "17"
5) "sex"
6) "man"
redis 127.0.0.1:6379> hkeys person
1) "name"
2) "age"
3) "sex"
redis 127.0.0.1:6379> hvals person
1) "zhangsan"
2) "17"
3) "man"
redis 127.0.0.1:6379> hincrby person age 8
(integer) 25
redis 127.0.0.1:6379> hget person age
"25"

5. 有序集合命令

　　和散列存储着键与值之间的映射类似，有序集合也存储着成员与分值之间的映射，并且提供了分值处理命令，以及和根据分值大小有序地获取或扫描成员和分值的命令

（1）常有有序集合命令

　　ZADD：zadd key-name score number [score number...] ------将带有分值的成员添加到有序集合

　　ZREM：arem key-name number [number...] ------从有序集合里面移除指定的成员，并返回被移除成员的数量

　　ZCARD：zcard key-name ------返回有序集合包含的成员数量

　　ZINCRBY：zincrby key-name increment number ------将number成员的分值加上increment

　　ZCOUNT：zcount key-name min max ------返回分值介于min和max之间的成员数量

　　ZRANK：zrank key-name merber ------返回成员member在有序集合中的排名

　　ZRANGE：zrange key-name start stop [withscores] ------返回排名介于start和stop之间的成员，如果给定了withscores则分值一起返回

　　ZSCORE：zscore key-name number ------返回成员number的分值

（2）示例

redis 127.0.0.1:6379> zadd ages 19 person1 20 person2 30 person3
(integer) 3
redis 127.0.0.1:6379> zcard ages
(integer) 3
redis 127.0.0.1:6379> zcount ages 0 40
(integer) 3
redis 127.0.0.1:6379> zrange ages 0 40 withscores
1) "person1"
2) "19"
3) "person2"
4) "20"
5) "person3"
6) "30"
redis 127.0.0.1:6379> zscore ages person2
"20"
redis 127.0.0.1:6379> zincrby ages 10 person3
"40"
redis 127.0.0.1:6379> zscore ages person3
"40"
redis 127.0.0.1:6379> zincrby ages -10 person3
"30"
redis 127.0.0.1:6379> zscore ages person3
"30"

（3）有序集合更高级命令

　　ZREVRANK：zrevrank key-name number ------返回有序集合里成员number的排名，按照分值从大到小的排列

　　ZREVRANGE：zrevrange key-name start stop [withscores] ---- 返回zrange的反序内容

　　ZREVRANGEBYSCORE：zrevrangebyscore key-name min max [withscores]  [limit offset count] ------返回有序集合中，分值介于min和max之间的所有成员，并按照分值大小的顺序返回

　　ZREMRANGEBYRANK：zremrangebyrank key-name satrt stop ------移除有序集合中排名介于satrt和stop之间的所有成员

　　ZREMRANGEBYSCORE：zremrangebyscore key-name min max ------移除有序集合中分值介于satrt和stop之间的所有成员

　　ZINTERSTORE：zinterstore dest-key key-count key1 [key2...] [WEIGHTS weight [weight...]] [AGGREGATE SUM|MIN|MAX] ------对给定的有序集合执行类似集合的交集运算

　　ZUNIONSTORE：zunionstore dest-key key-count key1 [key2...] [WEIGHTS weight [weight...]] [AGGREGATE SUM|MIN|MAX] ------对给定的有序集合执行类似集合的并集运算

（4）示例

redis 127.0.0.1:6379> zrank ages person1
(integer) 0
redis 127.0.0.1:6379> zrevrank ages person1
(integer) 2
redis 127.0.0.1:6379> zrevrange ages 0 40 withscores
1) "person3"
2) "30"
3) "person2"
4) "20"
5) "person1"
6) "19"
redis 127.0.0.1:6379> zcard ages
(integer) 3
redis 127.0.0.1:6379> zrevrangebyscore ages 40 0 withscores
1) "person3"
2) "30"
3) "person2"
4) "20"
5) "person1"
6) "19"

6. 发布与订阅命令

　　发布（publish）与订阅（subscribe）的特点是订阅者负责订阅频道（channel），发送者负责向频道发送二进制字符串消息，每当由消息被发送到给定频道时，频道的所有订阅者都会收到消息。

　　SUBSCRIBE：subscribe channel [channel] ------订阅给定的一个或多个频道

　　UNSUBSCRIBE：unsubcribe channel [channel] ------退订给定的一个或多个频道

　　PUBLISH：publish channel [channel...] ------向给定频道发送消息

　　PSUBSCRIBE：psubscribe pattern [pattern] ------订阅与给定模式相匹配的所有频道

　　PUNSUBSCRIBE：punsubscribe pattern [pattern] ------退订给定的模式，如果执行时没有给定任何模式，那退订所有模式

7. 小试牛刀

　　简单示例：实现文章发布，获取和投票

（1）文章发布

ONE_WEEK_IN_SECOND = 7*24*60*60
def post_article(conn, user, title, link):
    '''文章发布,实现以下操作：
    (1) 获取文章id
    (2) 初始化集合管理已投票用户
    (3) 初始化文章信息散列表
    (4) 初始化分数有序集合
    (5) 初始化时间有序集合
    '''
    article_id = str(conn.incr('article:')) #得到文章id
    
    voted_key = 'voted:' + article_id  #已投票集合key
    conn.sadd(voted_key,user)  #创建集合管理已投票用户，自己不允许投票
    conn.expire(voted_key,ONE_WEEK_IN_SECOND) #设置键的过期时间
    
    now = time.time()
    article_key = 'article:' + article_id #文章信息散列key
    # 初始化文章信息散列表
    conn.hmset(article_key, {
            'title':title,
            'link:':link,
            'poster':user,
            'time':now,
            'votes':1})
    
    # 初始化分数有序集合
    conn.zadd('score:', {article_key:now+VOTE_SCORE})
    # 初始化时间有序集合
    conn.zadd('time:', {article_key:now})
    return article_id

（2）文章获取

def get_articles(conn, page, order='score:'):
    '''默认根据分数排名获取指定页的文章信息'''
    #设定每页文章数目
    ARTICLES_PER_PAGE = 5
    start = (page-1)*ARTICLES_PER_PAGE
    end = start + (ARTICLES_PER_PAGE -1)
    ids = conn.zrange(order, start, end)
    articles = []
    for id in ids:
        article_data = conn.hgetall(id)
        article_data['id'] = id
        articles.append(article_data)
        
    return articles

（3）投票

def article_vote(conn, id, user):
    '''对文章进行投票,投票规则：
    (1)投票的有效期时间为1周
    (1)一篇文章一周内用户只允许投一次票
    (2)分数计算方式为每投一次票加432分
    '''
    VOTE_SCORE = 432
    # 根据文章ID获取文章的发布时间，判断是否在投票的有效期内
    article_key = 'article:' + id
    publish_time = conn.zcore('time:', article_key)
    if publish_time + ONE_WEEK_IN_SECOND < time.time():
        return 
    else:
        #用户可以投票,用户完成投票后将该用户添加到已投票用户管理集合
        voted_key = 'voted:' + id
        if conn.sadd(voted_key, user):
            #更新score：有序集合列表分数
            conn.zincrby('socre:',article_key, VOTE_SCORE)
            #更新散列表文章信息
            conn.hincr(article_key, 'votes')

（4）对文章获取进行测试

if __name__ == '__main__':
    try:
        conn = redis.Redis()
    except:
        raise 'connect exception'
    else:
        post_article(conn,'fate0729','Redis train','https://www.cnblogs.com/')
        post_article(conn,'fate0729','Redis train','https://www.cnblogs.com/')
        post_article(conn,'fate0729','Redis train','https://www.cnblogs.com/')
        post_article(conn,'fate0729','Redis train','https://www.cnblogs.com/')
        post_article(conn,'fate0729','Redis train','https://www.cnblogs.com/')
        post_article(conn,'fate0729','Redis train','https://www.cnblogs.com/')
        
    articles = get_articles(conn, 0)
    for article in articles:
        print('-----article--------')
        for key, val in article.items():
            if isinstance(key,bytes):
                print('{}:{}'.format(key.decode(encoding='utf-8'),val.decode('utf-8')))
            else:
                print('{}:{}'.format(key,val.decode('utf-8')))

　　输出：

Redis实战之Redis命令

标签：

相关文章