Redis

Redis

---

 

redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string（字符串），list（链表），set（集合），zset（sorted set 有序集合）和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同的方式排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave（主从同步）。

1. 使用Redis有哪些好处？
（1）速度快，因为数据存在内存中。
（2）支持丰富的数据类型，支持string，list，set，sorted set，hash
（3）支持事务，操作都是原子性，所谓的原子性就是对数据的更改要么全部执行，要么不执行。
（4）丰富的特性：可用于缓存，消息，按key设置过期时间，过期后会自动清除。

2. redis相比memcached有哪些优势？
（1）memcached所有的值均是简单的字符串，redis作为其替代者，支持更为丰富的数据类型。
（2）redis的速度要比memcached快很多
（3）redis可以持久化其数据

3. redis常见性能问题和解决方案
（1）Master最好不要做任何持久化工作，如RDB内存快照和AOF日志文件
（2）如果数据比较重要，某个Slave开启AOF备份数据，策略设置为每秒同步一次
（3）为了主从复制的速度和连接的稳定性，Master和Slave最好在同一个局域网内
（4）尽量避免在压力很大的主库上增加从库
（5）主从复制不要用图状结构，用单向链表结构更为稳定，即：Master <- Slave1 <- Slave2 <- Slave3...
这样的结构方便解决单点故障问题，实现Slave对Master的替换。如果Master挂了，可以立刻启用Slave1做Master，其他不变。

4. MySQL里有2000W数据，redis中只存20W数据，如何保证redis中的数据都是热点数据

5. Memcache与Redis的区别有哪些？
（1）存储方式
Memcache把数据全部存在内存中，断电之后数据全部丢失，数据不能超过内存大小。
（2）数据支持类型
Memcache对数据类型支持相对简单。
Redis有复杂的数据类型。
（3）value大小
redis最大可以达到1GB，而memcache只有1MB

6. Redis 常见的性能问题都有哪些？如何解决？

7. redis 最适合的场景

一、Redis安装和基本使用

wget http://download.redis.io/releases/redis-3.0.6.tar.gz
tar xzf redis-3.0.6.tar.gz
cd redis-3.0.6
make
(自编译需要准备好编译环境)

ubuntu16.04 可以直接apt-get install -y redis-server

启动服务端

src/redis-server

启动客户端

src/redis-cli
redis> set foo bar
OK
redis> get foo
"bar"

二、Python操作Redis

sudo pip install redis
or
sudo easy_install redis
or
源码安装
 
详见：https://github.com/WoLpH/redis-py

API使用

redis-py的API使用可以分类为：

• 连接方式
• 连接池
• 操作
  • String操作
  • Hash操作
  • List操作
  • Set操作
  • Sort Set操作
• 管道
• 发布订阅

1、操作模式

redis-py提供两个类Redis和StrictRedis的命令，StrictRedis用于实现大部分官方的命令，并使用官方的语法和命令，Redis是StrictRedis的子类，用于向后兼容几版本的redis-py。

import redis

r = redis.Redis(host='127.0.0.1', port=6379)
r.set('foo', 'Bar')
print(r.get('foo'))

2、连接池

redis-py使用connection pool来管理对一个redis server的所有连接，避免每次建立，释放连接的开销。默认，每个Redis实例都会维护一个自己的连接池。可以直接建立一个连接池，然后作为参数Redis，这样就可以实现多个Redis实例共享一个连接池。

import redis

pool = redis.ConnectionPool(host='192.168.175.130', port=6379)

r = redis.Redis(connection_pool=pool)

r.set('foo', 'Bar')
print(r.get('foo'))

3、操作

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

set（name，value，ex=None，px=None，nx=False，xx=False）

在Redis中设置值，默认，不存在则创建，存在则修改
参数：
    ex, 过期时间（秒）
    ps，过期时间（毫秒）
    nx，如果设置为True，则只有name不存在时，当前set操作才执行
    xx，如果设置为True，则只有name存在时，当前set操作才执行

setnx（name，value）

设置值，只有name不存在时，执行设置操作（添加）

setex（name，value，time）

设置值
参数：
    time，过期时间（数字秒 或 timedelta对象）

psetex（name，time_ms，value）

设置值
参数：
    time_ms， （数字毫秒， 或者 timedelta对象）

mset（*args，**kwargs）

批量设置值
如：
    mset（k1='v1', k2='v2'）
    或
    mset（{'k1': 'v1', 'k2': 'v2'}）

get（name）

获取值

mget（keys，*args）

批量获取
如：
    mget（'ylr', 'wupeiqi'）
    或
    mget（['ylr', 'wupeiqi']）

getset（name，value）

设置新值并获取原来的值

getrange（name，start，end）

获取子序列（根据字节获取，非字符）
参数：
    name，redis的name
    start，起始位置（字节）
    end，结束位置（字节）
如："吴佩琪",0-3表示"吴"

setrange（name，offset，value）

修改字符串内容，从指定字节索引开始向后替换（新值太长时，则向后添加）
参数：
    offset，字节的索引（一个汉字三个字节）
    value，要设置的值
如：r.set("foo", "吴沛琪")
     print(r.get("foo").decode('utf-8'))
     >>>: 吴沛琪
     r.setrange("foo", 3, "佩")
     print(r.get("foo").decode('utf-8'))  
     >>>: 吴佩琪

getbit（name，value）

获取name对应的值的二进制表示中的某位的值（0或1）

bitcount（key，start=None，end=None）

获取name对应的值的二进制表示中1的个数
参数：
    key，Redis的name
    start，位起始位置
    end，位结束位置

bitop（operation，dest，*keys）

获取多个值，并将值做位运算，将最后的结果保存至新的name对应的值

参数：
    operation，AND(并)、OR（或）、NOT（非）、XOR（异或）
    dest，新的Redis的name
    *keys,要查找的Redis的name

如：
    bitop("AND", 'new_name', 'n1', 'n2', 'n3')
    # 获取Redis中n1,n2,n3对应的值，然后讲所有的值做位运算（求并集），然后将结果保存 new_name 对应的值中

strlen（name）

返回name对应值的字节长度

incr（self，name，amount=1）

自增 name对应的值，当name不存在时，则创建name=amount，否则，则自增

参数：
    name，Redis的name
    amount，自增数（必须是整数）

注：同incrby

incrbyfloat（self, name, amount=1.0）

自增name对应的值，当name不存在时，则创建name=amount，否则，则自增。

参数：
    name，Redis的name
    amount，自增数（浮点型）

decr（self，name，amount=1）

自减 name对应的值，当name不存在时，则创建name=amount，否则，则自减。

参数:
    name,Redis的name
    amount，自减数（整数）

append（key，value）

在redis name对应的值后面追加内容

参数：
    key：redis的name
    value：要追加的字符串

Hash操作，redis中Hash在内存中的存储格式如下图：

hset（name，key，value）

name对应的hash中设置一个键值对（不存在，则创建；否则，修改）

参数：
    name，redis的name
    key，name对应的hash中的key
    value，name对应的hash中的value

注意：hsetnx（name，key，value），当name对应的hash中不存在当前key时则创建（相当于添加）

hmset（name，mapping）

在name对应的hash中批量设置键值对

参数:
    name, redis的name
    mapping：字典，如{'k1': 'v1', 'k2': 'v2'}

如：
     # r.hmset('xx', {'k1':'v1', 'k2': 'v2'})

hget（name，key）

在name对应的hash中获取根据key获取value

hmget（name，keys，*args）

在name对应的hash中获取多个key的值

参数:
    name, redis对应的name
    keys，要获取key集合，如：['k1', 'k2', 'k3']
    *args，要获取的key，如：k1,k2,k3

如：
    r.hmget('xx', ['k1', 'k2'])
    或
    r.hmget('xx', 'k1', 'k2')

hgetall（name）

获取name对应hash的所有键值

hlen（name）

获取name对应hash中键值对的个数

hkeys（name）

获取name对应的hash中所有的key的值

hvals（name）

获取name对应的hash中所有的value的值

hexists（name，key）

检查name对应的hash是否存在当前传入的key

hdel（name，*keys）

将name对应的hash中指定key的键值对删除

hincrby（name，key，amount=1）

自增name对应的hash中指定的值，不存在则创建key=amount

参数：
    name，redis中的name
    key，hash对应的key
    amount，自增数（整数）

hincrbyfloat（name，key，amount=1.0）

# 自增name对应的hash中的指定key的值，不存在则创建key=amount
 
# 参数：
    # name，redis中的name
    # key， hash对应的key
    # amount，自增数（浮点数）
 
# 自增name对应的hash中的指定key的值，不存在则创建key=amount

hscan（name，cursor=0，match=None，count=None）

增量式迭代获取，对于数据大的数据非常有用，hscan可以实现分片的获取数据，并非一次性数据全部获取完，从而放置内存被撑爆

参数：
    name，redis的name
    cursor，游标（基于游标分批获取数据）
    match，匹配指定key，默认为None，表示所有的key
    count，每次分片最少获取个数，默认None表示采用redis的默认分片个数

如：
    第一次：cursor1，data1 = r.hscan('xx', cursor=0, match=None, count=None)
    第二次：cursor2, data2 = r.hscan('xx', cursor=cursor1, match=None, count=None)
    ...
    直到返回值cursor的值为0时，表示数据已经通过分片获取完毕。

hscan_iter（name，match=None，count=None）

利用yield封装hscan创建生成器，实现分批去redis中获取数据

参数：
    match，匹配指定key，默认None表示所有的key
    count，每次分片最少获取个数，默认None表示采用redis的默认分片个数

如：
    for item in r.hscan_iter('xx'):
        print(item)

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

lpush（name，values）

在name对应的list中添加元素，每个新的元素都添加到列表的最左边

如：
    r.lpush('oo', 11, 22, 33)
    保存顺序为：33,22,11

扩展：
    rpush（name，values）表示从右向左操作

lpushx（name，value）

在name对应的list中添加元素，只有name已经存在时，值添加到列表的最右边。

更多：
    rpushx（name，value）表示从右向左操作

llen（name）

name对应的list元素的个数

linsert（name，where，refvalue，value）

在name对应的列表的某一个值前或后插入一个新值

参数:
    name,redis的name
    where，BEFORE或AFTER
    refvalue，标杆值，即：在它前后插入数据
    value：要插入的数据

r.lrem（name，value，num）

在name对应的list中删除指定的值

参数:
    name, redis的name
    value, 要删除的值
    num， num=0，删除列表中所有指定的值
        num= 2，从前到后，删除2个；
        num= -2，从后向前，删除2个

 lpop(name)

在name对应的列表的左侧获取第一个元素并在列表中一出，返回值则是第一个元素

更多：
    rpop（name）表示从右到左操作

lindex（name，index）

在name对应的列表中根据索引获取列表元素

lrange（name，start，end）

在name对应的列表分片获取数据
参数：
    name，redis的name
    start，索引的起始位置
    end，索引的结束位置

ltrim（name，start，end）

在name对应的列表中一出没有在start-end索引之间的值
参数：
    name，redis的name
    start，索引的起始位置
    end，索引结束位置

rpoppush（src，dst）

从一个列表取出最右边的元素，同时将其添加到另外一个列表的最左边
参数：
    src，要取数据的列表name
    dst，要添加数据的列表name

blpop（keys，timeout）

将多个列表排序，按照从左到右去pop对应的列表的元素

参数：
    keys，redis的name集合
    timeout，超时时间，当元素所有列表的元素获取完之后，阻塞等待列表内有数据的时间（秒），0表示永远阻塞

更多：
    r.brpop（keys，timeout），从右向左获取数据

brpoplpush（src，dst，timeout=0）

从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧

参数：
    src，取出并要移除元素的列表对应的name
    dst，要插入元素的列表对应的name
    timeout，当src对应的列表中没有数据时，阻塞等待其有数据的超时时间（秒），0表示永远阻塞

自定义增量迭代

由于redis类库没有提供对列表元素的增量迭代，如果想要循环name对应的列表的所有元素，那么就需要：
    1、获取name对应的所有列表
    2、循环列表
但是，如果列表非常大，那么就有可能在第一步时就将程序的内存撑爆，所以有必要自定义一个增量迭代的功能：
    
def list_iter(name):
    """
    自定义redis列表增量迭代
    :param name: redis中的name，即：迭代name对应的列表
    :return: yield 返回 列表元素
    """
    list_count = r.llen(name)
    for index in xrange(list_count):
        yield r.lindex(name, index)
 
# 使用
for item in list_iter('pp'):
    print item

Set操作，Set集合就是不允许重复的列表

sadd（name，values）

name对应的集合中添加元素

scard（name）

获取name对应的集合中元素个数

sdiff（keys，*args）

在第一个name对应的集合中且不在其他name对应的集合的元素集合

sdiffstore（dest，keys，*args）

获取第一个name对应的集合中且不在其他name对应的集合，再将其新加入到dest对应的集合中

sinter（keys，*args）

获取多个name对应集合的并集

sinterstore（dest，keys，*args）

获取多一个name对应集合的并集，再将其加入到dest对应的集合中

sismember（name，value）

检查value是否是name对应的集合的成员

smembers（name）

获取name对应的集合的所有成员

smove（src，dst，value）

将某个成员从一个集合中移动到另外一个集合

spop（name）

从集合的右侧（尾部）移除一个成员，并将其返回

srandmember（name，numbers）

从name对应的集合中随机获取numbers个元素

srem（name，values）

在name对应的集合中删除某些值

sunion（keys，*args）

获取多个name对应的集合的并集

sunionstore（dest，keys，*args）

获取多个name对应的集合的并集，并将结果保存到dest对应的集合中

sscan(name, cursor=0, match=None, count=None)
sscan_iter(name, match=None, count=None)

# 同字符串的操作，用于增量迭代分批获取元素，避免内存消耗太大

有序集合，在集合的基础上，为每元素排序；元素的排序需要根据另外一个值来进行比较，所以，对于有序集合，每一个元素有两个值，即：值和分数，分数专门用来做排序。

zadd（name，*args，**kwargs）

# 在name对应的有序集合中添加元素
如：
    zadd（'zz'， 'n1', 1, 'n2', 2）
    或
    zadd（'zz', n1=11, n2=22）

zcard（name）

获取name对应的有序集合元素的数量

zcount（name，min，max）

获取name对应的有序集合中分数 在 [min,max] 之间的个数

zincrby(name, value, amount)

# 自增name对应的有序集合的 name 对应的分数

r.zrange（name，start，end，desc=False，withscores=False，score_cast_func=float）

按照索引范围获取name对应的有序集合的元素

    参数：
        name：redis的name
        start：有序集合索引起始位置（非分数）
        end：有序集合索引结束位置（非分数）
        desc：排序规则，默认按照分数从小到大排序
        withscores，是否获取元素的分数，默认只获取元素的值
        score_cast_func，对分数进行数据转换的函数

    更多：
        从大到小排序
        zrevrange(name, start, end, withscores=False, score_cast_func=float)
        # 按照分数范围获取name对应的有序集合的元素
    # zrangebyscore(name, min, max, start=None, num=None, withscores=False, score_cast_func=float)
    # 从大到小排序
    # zrevrangebyscore(name, max, min, start=None, num=None, withscores=False, score_cast_func=float)

zrank（name，value）

获取某个值在name对应的有序集合中的排行（从0开始）

# 更多：
    # zrevrank(name, value)，从大到小排序

zrangebylex（name，min，max，start=None，num=None）

# 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的 值 （lexicographical ordering）来进行排序，而这个命令则可以返回给定的有序集合键 key 中， 元素的值介于 min 和 max 之间的成员
# 对集合中的每个成员进行逐个字节的对比（byte-by-byte compare）， 并按照从低到高的顺序， 返回排序后的集合成员。 如果两个字符串有一部分内容是相同的话， 那么命令会认为较长的字符串比较短的字符串要大
 
# 参数：
    # name，redis的name
    # min，左区间（值）。 + 表示正无限； - 表示负无限； ( 表示开区间； [ 则表示闭区间
    # min，右区间（值）
    # start，对结果进行分片处理，索引位置
    # num，对结果进行分片处理，索引后面的num个元素
 
# 如：
    # ZADD myzset 0 aa 0 ba 0 ca 0 da 0 ea 0 fa 0 ga
    # r.zrangebylex('myzset', "-", "[ca") 结果为：['aa', 'ba', 'ca']
 
# 更多：
    # 从大到小排序
    # zrevrangebylex(name, max, min, start=None, num=None)

zrem（name，values）

删除name对应的有序集合中值是values的成员

如：
    zrem('zz', ['s1', 's2'])
 

zremrangebyrank（name，min，max）

根据排行范围删除

zremrangebyscore（name,min,max）

根据分数范围删除

zremrangebylex（name，min，max）

根据值返回删除

zscore（name，value）

获取name对应有序集合中value的对应的分数

zinterstore（dest，keys，aggregate=None）

获取两个有序集合的交集，如果遇到相同值不同分数，则按照aggregate进行操作

zunionstore（dest，keys，aggregate=None）

获取两个有序集合的并集，如果遇到相同值不同分数，则按照aggregate进行操作
aggregate的值为：SUM MIN MAX

zscan(name, cursor=0, match=None, count=None, score_cast_func=float)
zscan_iter(name, match=None, count=None,score_cast_func=float)

# 同字符串相似，相较于字符串新增score_cast_func，用来对分数进行操作

其他常用操作

delete（*name）

根据name删除redis中任意数据类型

exists（name）

检测redis的name是否存在

keys（pattern='*'）

根据模型获取redis的name

更多：
    KEYS * 匹配数据库中所有key
    KEYS h?llo    匹配hello，hello和hxllo等
    KEYS h*llo    匹配hllo和heeeeello等
    KEYS h[ae]llo 匹配hello和hallo，但不匹配hillo

expire（name，time）

为某个redis的某个name设置超时时间

rename（src，dst）

对redis的name重命名为

move（name，db）

将redis的某个值移动到指定的db下

randomkey()

随机获取一个redis的name（不删除）

type（name）

获取name对应值的类型

4、管道

redis-py默认在执行每次请求都会创建（连接池申请连接）和断开（归还连接池）一次连接操作，如果想要在一次请求中指定多个命令，则可以使用pipline实现一次请求指定多个命令，并且默认情况下 一次pipline是原子性操作

#管道（事务），要是都成功则成功，失败一个全部失败
#原理：将数据操作放在内存中，只有成功后，才会一次性全部放入redis

#!/usr/bin/env python
# -*- coding:utf-8 -*-
 
import redis
 
pool = redis.ConnectionPool(host='127.0.0.1', port=6379)
 
r = redis.Redis(connection_pool=pool)
 
# pipe = r.pipeline(transaction=False)
pipe = r.pipeline(transaction=True)
 
pipe.set('name', 'alex')
pipe.set('role', 'sb')
 
pipe.execute()

5.发布订阅

发布者：服务器

订阅者：Dashboad和数据处理

基础类：将订阅和发送集合到一个类中了

import redis

#将订阅和发送集合到一个类中了
class RedisHelper:
    def __init__(self):
        self.__conn = redis.Redis(host="localhost",port=6379)#默认端口也是6379
        self.chan_sub = "fm104.5"#接收的波段
        self.chan_pub = "fm104.5"#发送的波段

    #发布消息
    def public(self,msg):
        self.__conn.publish(self.chan_pub,msg)
        return True

    #订阅消息
    def subscribe(self):
        pub = self.__conn.pubsub()
        pub.subscribe(self.chan_sub)
        pub.parse_response()
        return pub

发布者：

一：不使用基础类直接发布

import redis


r = redis.Redis(host="127.0.0.1")
r.publish("fm104.5","dasfa")

二：使用基础类发布

from base import RedisHelper


obj = RedisHelper()
obj.public("hello")

订阅者：

一：不使用基础类：

import redis


r = redis.Redis(host="127.0.0.1")
pub = r.pubsub()    　　#定义订阅者
pub.subscribe("fm104.5")#定义其接受频段 
msg = pub.parse_response() #开始接受 
print(msg)

二：使用基础类：

obj = RedisHelper()
redis_sub = obj.subscribe()

while True:
    msg = redis_sub.parse_response()
    print(msg)   #[b'message', b'fm104.5', b'hello']