Redis

准备阶段

一、在Centos上安装Redis。yum install redis

二、在python中pip install redis

三、在centos命令行中常用的命令

1、set <key> <value>：设key的值为value

2、keys *：获取所有的键

3、get <key>：获取key的值

4、set <key> <value> ex <seconds>：让key的值保留seconds秒

 

连接

一、直接连接

1、建立连接redis.Redis(host)

2、设置一个键对值，r.set(<key>,<value)

3、获取一键的值.r.get(<key>)

import redis
connection = redis.Redis(host='192.168.0.50')
connection.set('foo', 'bar')
print(connection.get('foo'))

 二、连接池

import redis
pool = redis.ConnectionPool(host='192.168.0.50', port=6379)
r = redis.Redis(connection_pool=pool)
r.set('foo', 'bar')
print(r.get('foo'))

 

操作

一、String操作

类似于字典的操作，在内存中建立key-value键值对，如图

r为建立连接的实例

1、r.set(<key>,<value>, ex=None, px=None, nx=False, xx=False)：设置key的值为value，

其中ex为过期时间（秒），px为过期时间（毫秒）

nx为True时，只有当key不存在时才执行操作

xx为True时，只有当key存在时才执行操作

2、r.get(<key>)：获取key对应的值

3、setex(<key>,<value>, seconds):设置键值对，seconds秒后过期

3、setnx(key,value)：name不存在时执行操作

4、psetex(<key>, <value>, micro_seconds)：与sexex类似，时间单位为毫秒

5、mset(dict)：批量设置键值对。

6、mget(key1,key2)：批量获取

7、getset(<key>,<value>)：设置新值，但结果返回的是旧值

8、setrange(<key>, offset, <value>)：将key对应的值，从第offset的位置开始设置，用value替换。

9、setbit(<key>,<offset>,<value>)：转换成二进制，设置offset位的值为value，注意offset的值是从0开始

10、getbit(<key>,<offset>)：转换成二进制，获取offset中的值

11、bitcount(<key>,start=None,end=None)：获取从start到end中比特位是1的个数

12、strlen(<key>)：返回对应的值的大小

13、incr incrby(<key>,amount=1)：增加值

14、incrbyfloat：用小数值增加，与上类似

15、decr(<key>,amount=1)：减值

16、append(<key>,<value>)：在key对应的值上增加新值

import redis
import time
r = redis.Redis(host='192.168.0.50')
# r.set('name', 'Treelight')  # 设置'name'的值为'Treelight'
# print(r.get('name'))  # 获取name的值
# r.setex('name', 3, 'Treelight')
# for i in range(5):
#     print(r.get('name'))
#     time.sleep(1)
# r.psetex('name', 3000, 'alex')
# for i in range(5):
#     print(r.get('name'))
#     time.sleep(1)
# r.mset({'name1': 'Treelight', 'name2': 'Alex'})
# print(r.mget('name1', 'name2'))
# r.set('name', 'Chen')
# print('before set', r.getset('name', 'Treelight'))
# print('after set', r.get('name'))
# r.set('name', 'Treelight')
# r.setrange('name', 3, 'Alex')
# print(r.get('name'))
# r.setbit('age', 6, 1)
# print(r.get('age'))
# print(r.getbit('age', 7))
# r.set('name', '梁树辉')
# print(r.strlen('name'))
r.set('age', 22)
r.append('age', 'Treelight')
print(r.get('age'))

 

Hash操作

一、与字典类似，但值是存储一组关联性较强的数据

1、hset(name,key,value)、hsetnx：name对应的hash创建一对键对值

2、hget(name,key)：获取name对应的hash中键为key的值

3、hmset(name,mappings)：设置name中的多个键值对，mappings为字典类型。

4、hmget(name, keys, args)：获取name中的多个keys对应的值。

5、hgetall(name)：获取name对应的hash中所有的键值对。

6、hlen(name):获取name对应的hash中的键值对个数。

7、hkeys(name)：获取name对应的hash中的所有keys。

8、hvals(name)：获取name对应的hash中的所有值。

9、hexists(*names)：获取names中存在的个数。

10、hdel(name,key)：删除name中key对应的键值对

11、hincrby(name,key,amount=1)：增加

12、hincrbyfloat(name,key,amount=1)：用小数增加

13、hscan(name,cursor=0,match=None,count=None)：从cursor位置扫描name中的key，如果匹配match则返回，每次分片最少获取count个。

14、hscan_iter(name, match=None, count=None)：生成一个迭代器，返回键值对元组

 

import redis
r = redis.Redis(host='10.62.34.22')
# r.hset('info', 'age', 22)
# print(r.hget('info', 'name1'))
# print(r.hget('info', 'age'))
r.hmset('info', {'name': "Treelight", 'age': 23})
for item in r.hscan_iter('info', '*am*'):
    print(item)

 

 

List操作

List操作，redis中的List在在内存中按照一个name对应一个List来存储。如图：

1、lpush(name,v1,v2,v3,v4...):从name的前面插入

2、rpush(name,v1,v2,v3...)：从name的后面插入

3、lrange(name, start=0, end=0)：获取从start到end中，name的值

4、lpushx(name,value)：name存在时才在前面插入

5、rpushx(name,value)：name存在时才在后面添加

6、llen(name)：查看列表长度

7、linsert(name, where, refvalue, value)：在refvalue中前或后插入一个value值，where值为'after'或'before'， refvalue是标杆值， value是新插入的值。

8、lset(name,index,value)：修改name中index位置的值为value。

9、lrem(name,count=0,value)：删除name中值为value的数据，count为0时全部删除，负数时从后往前删除，正数从前往后删除。

10、lpop(name)：从左边删除第一个值，并返回此值

11、lindex(name,index)：根据下标获取值

12、ltrim(name,start,end)：除了start到end，其它都移除。

13、rpoplpush(src,dst)：把src列表中最右边的数据移动到dst中的最左边。

14、blpop、brpop(keys,timeout=0)：keys是多个列表，从第一个的非空列表中去除最左或最右的数据。如果列表均为空，则阻塞timeout秒。如果timeout=0，则列表空时永远阻塞。

15、brpoplpush(src,dst,timeout=0)：从src列表中最右边的数据移动到dst中的最左边。但如果src中没有数据，则会阻塞timeout秒，timeout为0时永远阻塞。

 

Set操作

1、sadd(name, *values)：向name中添加多个value

2、scard(name)：获取元素的个数

3、sdiff(keys,*args)：从第一个key中找出与其它key的不同的元素。

4、sdiffstore(dst,keys):从第一个kye中找出与其它key的不同的元素，然后保存到dst。

5、sinter(keys)：获取keys中的交集

6、sinter(dst,keys)：把keys中的交集保存到dst中

7、ismember(key,value)：判断value是否在key中。

8、smembers(key)：获取key中的值

9、smove(src,dst,value)：把value从src移动到dst

10、spop(key)：把集合中最后的一个移除，并且返回。

11、srandmember(key,number)：随机从key中选出number个值

12、srem(key,value)：移动key中的value

13、sunion(keys)：并集

14、sunionstore(dst,keys)：储存并集

15、sscan(key, cursor=0, match=None,count=None)：从cursor开始扫描key，找到匹配match的，可分count次执行。

16、sscan_iter(key,cursor=0,match=None,count=None)：类似上一个，只是会生成迭代器。

 

有序集合

有序集合：对集合中的元素进行排序，根据一个数值即分数排序，所以有序集合每一个元素有两个值：分数，值

1、zadd(name,mapping,nx=False,xx=False,ch=False,incr=False)：在name中添加带有值、分数的元素，mapping就是元素，用字典格式。

nx:True时，当元素的值相同时，不改变分类；其他情况则添加元素

xx:True时，只改变某值的分数，而不添加或更改元素的值

ch:True，显示修改的个数

2、zcard(name)：获取元素的数量

3、zcount(name,min,max)：获取name中分数从min到max的数量。

4、zincrby(name, amount, value)：为name中的value的分类增加amount

5、zrank(name,value)：获取name中带有value元素的排名

6、zrem(name,values)：删除name中的值

7、zremrangebyrank(name, min, max)：按照排名删除

8、zrange(name,start,end,desc=False, withscores=False,score_cast_func=float)：查看name中从start到end的值，desc定义排序方式， withscores定义是否带分数，score_cast_func是对分数进行转换的函数

9、zremrangebyscore(name,min,max)：按分数删除

10、zscore(name,value)：获取value的分类

11、zinterscore(dst,keys,aggrerate=None)：keys为元组，如果值相同，则用aggregate处理。aggregate的值有SUM MAX MIN，处理完毕后放到dst。

12、zunionscore(dst,key,aggrerate=None)：与上类似，是并集。

13、zscan、zscan_iter：与集合类似。

 

其他常用操作

1、deletes(names)：删除

2、exists(name)：判断是否存在

3、keys(pattern='')：根据pattern获取name的名称

4、expire(name,time)：设置name的超时时间

5、rename(src,dst)：重命名

6、move(name,db)：将name移动到另外一个数据库，默认情况下redis有16张数据库。

7、randomkey()：随机获取一个name

8、type(name)：获取类型

9、scan(cursor=0, match=None,count=None)：获取key

10、scan_iter：与scan类似

 

管道

默认情况下，redis.py每一次请求命令都会创建和断开一个连接，如果需要在一次请求中执行多个操作，可使用管道，执行原子 操作。

使用步骤：

1、通过连接池进行连接

pool = redis.ConnectionPool(host)

r = redis.Redis(connectionpool = pool)

2、创建管道

pipe = r.pipeline(transaction=True)  # 参数就表明需要执行原子操作

3、设置命令

4、调用命令：pipe.excute()

import redis
import time
pool = redis.ConnectionPool(host='10.62.34.22')
r = redis.Redis(connection_pool=pool)
pipe = r.pipeline(transaction=True)
pipe.set('name10', 'Treelight')
time.sleep(40)
pipe.set('role', 'clever')
pipe.execute()

 

发布者和订阅者

 

import redis


class RedisHelper(object):
    def __init__(self):
        """初始化函数"""
        self.conn = redis.Redis(host='192.168.0.50')
        self.pub_channel = 'fm101.7'
        self.sub_channel = 'fm101.7'

    def public(self, msg):
        """发布消息函数"""
        # 通过连接发布消息
        self.conn.publish(self.pub_channel, msg)

    def subscribe(self):
        """接收消息函数"""
        sub = self.conn.pubsub()  # 打开收音机
        sub.subscribe(self.sub_channel)  # 选择频道
        sub.parse_response()  # 准备连接
        return sub

 

from RedisHelper import RedisHelper
obj = RedisHelper()
obj.public('I am 22')

from RedisHelper import RedisHelper
obj = RedisHelper()
sub = obj.subscribe()
while True:
    msg = sub.parse_response()
    print(msg)

 一、知识点：

1、发布者：建立redis连接，然后利用这个连接实例可在定义好的频道上发布消息。

conn = redis.Redis(host)

conn.public()

2、接收者：

（1）、通过连接建立一个pubsub实例

conn=redis.Redis(host)

sub = conn.pubsub()

（2）、选择频道

sub.subscribe(channel)

(3)、准备接收

sub.parse_response()

(4)、开始接收

while True:

　　sub.parse_response()

Redis-cli客户端的操作：

删除所有keys：flushall

查看所有keys：keys *

设置key-value：set <key> <val>

设置key-list：lpush <key> 0 1 2 3 4 5

                      rpush <key> 01 2 3 4 5

查看key值：get <key>

查看key对应的list值：lrange <key> <start> <stop>