Redis常用命令

注：本文整理自《Redis实战》

Redis简介：

       Redis为内存型数据库，所以速度非常快，性能强劲，Redis为NoSQL(非关系型数据库)，可以存储键（key）与5中不同类型的值（value）之间的映射，五种数据类型分别为：STRING(字符串)、LIST(链表)、SET（集合）、HASH（散列）和ZSET(有序集合)。下面总结这五种数据结构常用的命令。

 本文选自用python 操作Redis, redis模块

 安装redis模块

pip install redis

一、字符串类型

Redis 字符串可以存储3中数据类型：字节串、整数、浮点数。

1、字节串常用命令

set(key,value)             

　　设置key值为value

get(key)                     

　　获取key对应的值

append(key, value)     

　　在值后面他添加新串value

substr(key, start, end) 

　　将key对应的值截取下标从start到end的子串，

setrange(key, index, value) 

　　将第index位置的值设置为value（如果index小于原值长度，则将替换原数据）

>>> conn.get('key')
'1311'
>>> conn.append('key', 'hello')
9L
>>> conn.get('key')
'1311hello'
>>> conn.setrange('key', 2,'how are you')
13
>>> conn.get('key')
'13how are you'
>>> conn.setrange('key', 2,'ww')
13
>>> conn.get('key')
'13www are you'

　　

　　

 

2、整数、浮点数的自增

对于整数，浮点数常用的为运算：INCR(加1)，DECR(减1)，INCRBY（加上整数），DECRBY（减去整数）, INCRBYFLOAT（加上浮点数）

>>> import redis
>>> conn = redis.Redis() # 创建连接
>>> conn.get('keys') 
>>> conn.set('keys', 10) #创建一个键为keys的存储
True
>>> conn.get('keys') # 获取keys键对应的值
'10'
>>> conn.incr('keys', 5) # 将keys对应的值加5
15
>>> conn.get('keys')
'15'
>>> conn.decr('keys', 5) # 将keys对应的值减5
10
>>> conn.get('keys')
'10'
>>> conn.set('keys', '20') # 将keys值重置为20
True
>>> conn.get('keys')
'20'
>>> conn.incr('keys') # 如果加法没写参数则默认为加1，减法同理
21

>>> conn.incrbyfloat('keys',3.3)  # 加上浮点数3.3
24.3　

　　

二、列表

RPUSH  key-name value . . .                   

　　将一个或多个值推入列表右端

LPUSH key-name value . . .                   

　　将一个值个推入键对应的列表左端

RPOP key-name                                

　　从列表右端移除并返回元素

LPOP key-name                             

　　从列表左端移除并返回元素

LINDEX key-name start end                 

　　返回列表中下标的元素

LRANGE key-name start end               

　　返回列表从start 到end的下标的所有元素

LTRIM key-name start end                   

　　对列表进切割，保留下标为start到end范围内的元素

RPOPLPUSH source-key dest-key       

　　从source-key列表中弹出最右边的元素并推入dest-key列表最左端，并返回这个元素

BRPOPLPUSH soure-key dest-key timeout 

　　作用同上，但是如果source-key为空。在timeout秒之内阻塞并等待可以弹出的元素

BLPOP                                             

　　从列表集中从左到有弹出多个元素

>>> conn.lpush('list-key', 'item')
1L
>>> conn.lpush('list-key', 'item2')
2L
>>> conn.rpush('list-key', 'last')
3L
>>> conn.lpush('list-key', 'first')
4L
>>> conn.rpush('list-key', 'new last')
5L
>>> conn.lrange('list-key', 0, -1)
['first', 'item2', 'item', 'last', 'new last']
>>> conn.lpop('list-key')
'first'
>>> conn.lpop('list-key')
'item2'
>>> conn.lrange('list-key', 0, -1)
['item', 'last', 'new last']
>>> conn.ltrim('list-key',2, -1)
True
>>> conn.lrange('list-key', 0, -1)
['new last']

>>> conn.blpop(['list1','list2'], 1)
>>> 
>>> conn.lpush('list1', 'hello world') 
1L
>>> conn.blpop(['list1','list2'], 1) # 从list1, list2中弹出一个元素
('list1', 'hello world')
>>> conn.lpush('list2', 'hello redis')
1L
>>> conn.blpop(['list1','list2'], 1)
('list2', 'hello redis')

　　

三、集合

Redis集合是以无序的方式存储多个不同的元素。

SADD key-name item [item ...]                       

　　将一个或多个元素添加到集合里面，并返回被添加元素当中并不存在与集合里面的元素数量

SREM key-name item [item . . . ]                     

　　从集合里面移除一个或多个元素，返回被移除的数量

SISMEMBER key-name i tem                       

　　检查元素是否存在于集合中

SCARD key-name                                             

　　返回集合包含的元素数量

SRANDMEMBER key-name count                   

     从集合里面随机地返回一个或多个数据（当count为正数时，返回的随机元素不会重复，当count为负数时，返回的元素可能重复）

SPOP key-name                                               

     随机从集合中移除一个元素，并返回被移除的元素

SMOVE source-key dest-key item                           

     如果集合source-key包含元素item，从source-key中移除item并添加到dest-key中，如果被成功移除返回1， 否则返回0

>>> conn.sadd('set-key', 'a', 'b', 'c') # 向集合中添加元素，如集合不存在，，则直接创建集合
3
>>> conn.srem('set-key', 'c', 'd')
1
>>> conn.srem('set-key', 'c', 'd')
0
>>> conn.scard('set-key')
2
>>> conn.smembers('set-key')
set(['a', 'b'])
>>> conn.smembers('set-key', 'set-key2', 'a')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: smembers() takes exactly 2 arguments (4 given)
>>> conn.smove('set-key', 'set-key2', 'a')
True
>>> conn.smove('set-key', 'set-key2', 'c')
False
>>> conn.smembers('set-key2')
set(['a'])

组合和处理多个集合

SDIFF key-name [keyname ...]                                       

　　返回存在于第一个集合、但是不存在与其他集合中的元素（差集）

SDIFFSTORE dest-key key-name [key-name ...]     

　　将存在于第一个集合但是不存在于其他集合中的元素存储到dest-key键里面

SINTER key-name [key-name . . .]                           

　　返回那些同时存在于集合中的元素（交集）

SINTERSTORE dest-key key-name [key-name . . . ] 

　　将同时存在于所有集合的元素添加到dest-key键里面

SUNION key-name [key-name . . .]                       

　　返回至少存在于一个集合中的元素（并集）

SUNIONSTORE dest-key key-name [key-name . . .] 

　　讲那些至少存在于一个集合的元素添加到dest-key键里面

>>> conn.sadd('skey1', 'a', 'b', 'c', 'd')
4
>>> conn.sadd('skey2', 'c', 'd', 'e', 'f')
4
>>> conn.sdiff('skey1','skey2')
set(['a', 'b'])
>>> conn.sinter('skey1','skey2')
set(['c', 'd'])
>>> conn.sunion('skey1', 'skey2')
set(['a', 'c', 'b', 'e', 'd', 'f'])　　

四、散列

Redis散列可以将多个键值对存储于一个Redis键里面。

HMGET key-name key [key . . . ]           

　　从散列中获取一个或多个键的值

HMSET key-name key value [key value . . .] 

　　为散列里面的一个或多个键设置值

HDEL key-name key [key . . ]                   

　　删除散列里面的一个或多个键值对， 返回成功找到并删除的键值对数量

HLEN key-name                                   

　　返回散列包含的键值对数量

>>> conn.hmset('hash-key', {'k1':'v1', 'k2':'v2', 'k3':'v3', 'k4':'v4'})
True
>>> conn.hmget('hash-key', ['k1','k2'])
['v1', 'v2']
>>> conn.hlen('hash-key')
4
>>> conn.hdel('hash-key', 'k1', 'k2') #删除k1, k2 返回删除的元素个数 
2　

较为高级的命令

HEXISTS key-name key                   

　　检查给定的键是否存在于散列中

HKEYS key-name                           

　　获取散列包喊得所有键

HVALS key-name                               

　　获取散列包含的所有值

HGETALL key-name                           

　　获取散列包含的所有键值对

HINCRBY key-name key increment     

　　将键key存储的值加上整数increment

HINCRBYFLOAL key-name key increment

　　将键key存储的值加上浮点数increment

 

>>> conn.hmset('hash-key2', {'short':'hello', 'long':1000*'1'})
True
>>> conn.hkeys('hash-key2')
['long', 'short']
>>> conn.hexists('hash-key2', 'num') # 检查元素‘num’是否在hash-key2中
False
>>> conn.hincrby('hash-key2', 'num')
1L
>>> conn.hexists('hash-key2', 'num')
True

五、有序集合

有序集合存储着成员与分值之间的映射，可以根据分值有序的获取成员和分值。

 SADD key-name score member [score member . . . ]

　　将带有给定分值的成员添加到有序集合里面

ZREM key-name member [member . . .]

　　从有序集合里面移除给定的成员， 并返回被移除成员的数量

ZINCRBY key-name increment member 

　　将member成员的分值加上increment

ZCOUNT key-name min max 

　　返回分值介于min和max之间成员数量 

ZRANK key-name member 

　　返回成员member在有序集合中的排名

ZSCORE key-name member 

　　返回成员member的分值

ZRANGE key-name start stop [WTHSCORES] 

　　返回有序集合中排名介于start和stop之间的成员，如果给定了可选的WITHSCORES选项， 那么命令会将成员的分值也一并返回

>>> import redis
re>>> conn = redis.Redis()
>>> conn.zadd('zset-key', 'a', 3, 'b', 2, 'c', 1) # 在Redis标准中先输入分值，后输入成员
3
>>> conn.zcard('zset-key') # 返回有序集合中包含的数量
3
>>> conn.zincrby('zset-key', 'c', 3) # 有序集合的增加
4.0
>>> conn.zscore('zset-key', 'b') # 获取单个成员的分值
2.0
>>> conn.zrank('zset-key', 'c') #获取指定成员的排名
2
>>> conn.zcount('zset-key', 0, 3) # 统计分值为0-3之间的成员数量
2L
>>> conn.zrem('zset-key', 'b') # 从有序集合中移除成员
1
>>> conn.zrange('zset-key', 0, -1, withscores=True) #取出有序集合中所有元素，也可以取出一部分元素
[('a', 3.0), ('c', 4.0)]　

有序集合中氛围型数据获取及删除命令

ZREVRANK key-name member

　　返回有序集合里面成员member的排名，成员按照分值大小排列

ZREVRANGE key-name start stop [WITHSCORES] 

　　返回有序集合给定排名范围内的成员，成员按照分值由大到小排列

ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]

　　返回有序集合中，分值介于min和max之间的所有成员

ZREVRANGEBYSCORE key max min [WITHSCORES] [LIMIT offset count]

　　获取有序集合中分值介于min和max之间的所有成员，并按照分值从大到小的顺序返回他们

ZREMRANGEBYRANK key-name start stop

　　移除有序集合中分值结余min和max之间的所有成员

ZREMRANGEBYSCORE key-name min max

　　移除有序集合中分值结余min和max之间的所有成员

ZINTERSTORE dest-key key-count key [key . . . ] WEIGHTS weight [weight]] [AGGREGATE SUM|MIN|MAX]

　　对给定的有序集合执行类似于集合的交集运算

ZUNIONSTORE dest-key key-count key [key . . . ] WEIGHTS weight [weight]] [AGGREGATE SUM|MIN|MAX]

　　对给定的有序集合执行类似于集合的并集运算

 

未完待续~~~

 

转载于:https://www.cnblogs.com/Frange/p/9221195.html