学习笔记

缓存

前言:

大家都听过缓存,缓存是干啥的吗?我们能够和json和pickle来讲,多少个程序之间落成新闻互相,能够透过在A程序中把多少改成json
,然后传给B程序,通过文件那一个介质。文件那一个频率异常的低。

举例说贰个是QQ,多少个是微信,大家想要达成双方的竞相,咱们此前学了rabbitMQ,能够完成新闻的传递;对于数据的分享,qq存储的数量微信能够直接获得,那些数量是位于内部存款和储蓄器中的,那大家怎么落到实处多个内部存款和储蓄器共享呢?我们要有三个供应商,经销商再运行一个独立的顺序,本人开垦一块内部存款和储蓄器,QQ和中间商创建二个socket,微信和高级中学级商业建构三个socket,这样就兑现了数量分享。这么些经销商正是缓存。

主流的缓存:mongodb,redis,memcache。

Redis

redis是贰个key-value存款和储蓄系统,辅助存款和储蓄的value类型相对比较多,包含:string,list(链表),set(集合),zset(sorted
set —
有序聚集)和hash(哈希类型)。那些数据类型都辅助push/pop,add/remove以及交并差集等丰盛的操作,况且那一个操作都以原子性的。在此基础上redis扶助各类差别排序的法子。为了保障作用,数据是保存在内部存款和储蓄器中的。同期redis会周期性的把创新的多寡写入磁盘或许把修改操作写入追加的笔录文件,而且在此基础上达成master-slave(主从)同步

安装:

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

 

伊始服务端:

src/redis-server

 

启航顾客端:

src/redis-cli

 

使用:

127.0.0.1:6379> set name xiaoming
OK
127.0.0.1:6379> set age 22
OK
127.0.0.1:6379> keys *
1) "name"
2) "age"
127.0.0.1:6379> get name
"xiaoming"
127.0.0.1:6379> get age
"22"

 

keys * :查看系统中存了稍稍个key

set key value:设置变量值;          set key value ex
2:设置变量,并且只可以存活2分钟

 

python使用redis

安装redis模块:

sudo pip install redis
or
sudo easy_install redis

 

redis-py的API使用能够分为:

  连接方式,连接池,操作(String操作,Hash操作,List操作,Set操作,Sort
Set 操作),管道,揭橥订阅

1.操作形式

多少个类:Redis和StrictRedis用于落到实处redis命令,StrictRedis用于落到实处许多官方的一声令下,并动用官方语法和下令,Redis是StrictRedis的子类,

import redis

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

 

2.连接池

redis-py使用连接池来治本对多少个redis
server的具备连接,幸免每趟创设,释放连接的支出。私下认可每种redis实例都会维护叁个融洽的连接池,能够直接构建贰个连接池,然后作为参数Redis,那样能够达成八个redis实例分享一个连接池

import redis
pool = redis.ConnectionPool(host = '192.168.1.103',port=6379)
r = redis.Redis(connection_pool=pool)
r.set('xu',123)
print(r.get('xu'))

 

3.操作

String操作,redis中的String在内存中依据key—value方式进行仓库储存:

set(name, value, ex=None, px=None, nx=False, xx=False):

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

setnx(name, value):设置值,独有name空头支票时,实践设置操作(增加)

setex(name,  time,value):设置值,time 过期时间,数字秒               
             psetex(name, time_ms, value):设置值,毫秒

mset(*args, **kwargs):

批量设置值
如:
    mset(k1='v1', k2='v2')
    或
    mget({'k1': 'v1', 'k2': 'v2'})

 

mget(keys, *args):

批量获取
如:
    mget('ylr', 'wupeiqi')
    或
    r.mget(['ylr', 'wupeiqi'])

getset(name, value):设置新值并获取原本的值

getrange(key, start, end):

# 获取子序列(根据字节获取,非字符)
# 参数:
    # name,Redis 的 name
    # start,起始位置(字节)
    # end,结束位置(字节)
# 如: "ming" ,0-2表示 "min"

 

setrange(name, offset, value):

修改字符串内容,从指定字符串索引开始向后替换(新值太长时,则向后添加)
# 参数:
    # offset,字符串的索引,字节(一个汉字三个字节)
    # value,要设置的值

setbit(name, offset, value):

对name对应值的二进制表示的位进行操作

参数:
    # name,redis的name
    # offset,位的索引(将值变换成二进制后再进行索引)
    # value,值只能是 1 或 0

注:如果在Redis中有一个对应: n1 = "foo",
        那么字符串foo的二进制表示为:01100110 01101111 01101111
    所以,如果执行 setbit('n1', 7, 1),则就会将第7位设置为1,
        那么最终二进制则变成 01100111 01101111 01101111,即:"goo"

在python中只要想要知道三个假名的二进制是稍稍,可以先用ord()转为ASCII
值,然后在用bin()转变位二进制,然后从后往前数8位,不足补0,正是这一个字母的二进制值

怎样时候会用呢?

博客园博客园在线客商会有大多,要是做多少剖判,想要看脚下有怎样客户在线,用数据库的频率是不高的。大家先看一下和命令bitcount,用来计数变量的二进制中有多少个1,如a:0b1一千01,bitcount的结果正是3

bitcount(key, start=None, end=None)

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

 

图片 1

那么数据库中种种顾客的id是并世无两的,从1开始自行抬高,参与大家有2亿的客商,有1亿在线,我们要计算那1亿客户到底是什么人在线,大家能够通过改二进制位来落到实处,即:
(n2是一个新的变量)

加盟有八个客商id为一千的客户登陆,大家设置:setbit n2 一千 1
,又登入了贰个id为555的顾客:setbit n2 555 1;顾客id为陆仟的客商:setbit
n2 5000 1;我们用bitcount来探视n2:

图片 2

表明在线客户有3个,那就落实了总计了在线客商人数,然后大家要走访毕竟是哪个人在线了,客户id是不怎么作者就取多少位,大家循环这一个二进制的值就足以看出是对应的那家伙在线,比如

我们想看客商55在不在线,大家用getbit:

图片 3

大家想看看客商555在不在线:

图片 4

小编们有2亿客户,最多也就占领2亿位,未有占多大空间,要是是用查看数据库的措施去看何人在线的话,那表的记录就卓殊大,查询起来也丰裕慢。

 

strlen(name):再次回到name对应值的字节长度(两当中华夏族民共和国字占3个字节)

incr(self, name, amount=1):

自增 name对应的值,当name不存在时,则创建name=amount,否则,则自增。
参数:
    # name,Redis的name
    # amount,自增数(必须是整数)

 decr(self, name, amount=1)

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

# 参数:
    # name,Redis的name
    # amount,自减数(整数)

 

万一我们不想总括全部客商在线的列表,你只想总结有多少客户在线,那只须求一个计数器,来四个加一个,一样也能够用redis达成,倘若先来了三个客户,大家就径直:

 图片 5

再来二个顾客:

图片 6

故此直接来一贯来:

图片 7

假若这些客商掉线了,就用decr

图片 8

也正是说使用incr 和decr 能够落实自增自减

 

incrbyfloat(self, name, amount=1.0)

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

# 参数:
    # name,Redis的name
    # amount,自增数(浮点型)

append(key, value):

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

# 参数:
    key, redis的name
    value, 要追加的字符串

图片 9

 Hash操作,在redis中hash存在于内部存储器中格式是如此的:

图片 10

hset(name, key, value)

# name对应的hash中设置一个键值对(不存在,则创建;否则,修改)

# 参数:
    # name,redis的name
    # key,name对应的hash中的key
    # value,name对应的hash中的value

# 注:
    # hsetnx(name, key, value),当name对应的hash中不存在当前key时则创建(相当于添加)

 图片 11

安装几个info变量,里面含有name,age,id 等key

 

hmset(name, mapping)

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

# 参数:
    # name,redis的name
    # mapping,字典,如:{'k1':'v1', 'k2': 'v2'}
# 如:
    # r.hmset('xx', {'k1':'v1', 'k2': 'v2'})

图片 12

 

hget(name,key):

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

图片 13

获得info里面的name值和age值

 

hmget(name, keys, *args)

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

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

 图片 14

 

hgetall(name):获取name对应``hash``的所有键值

如得到info的具备键值:

图片 15

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

图片 16

 

hkeys(name):获取name对应的hash中拥有的key的值

图片 17

查阅那几个变量下的具备key,“属性”

 

hvals(name):获取name对应的hash中有着的value的值

图片 18

 

hexists(name,
key):检查name对应的hash是或不是留存当前传遍的key,假诺存在再次回到1,荒诞不经重回0

 

hdel(name,*keys):将name对应的hash中内定key的键值对删除

hincrby(name, key, amount=1):

自增name对应的hash中的指定key的值,不存在则创建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的默认分片个数

在hash中,二个name能存200多亿个key,假设大家存了过多的key,然后经过hkeys
name抽取数据,就能够充裕的慢,那大家用hscan就起到多少个过滤的作用。

图片 19

其一意思正是在info第22中学从第0个key伊始相配到以k初阶的键值对抽出来

图片 20

其一意思乃是想要把带有a的收取来

 

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来储存

图片 21

lpush(name,values)

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

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

# 扩展:
    # rpush(name, values) 表示从右向左操作

 图片 22

安装names列表,里面有3个成分,放在列表的最左侧

有lpush,就有rpush,正是存成分是坐落列表的右端:rpush names xixi haha
hehe

图片 23

笔者们得以看见大家新存的xixi,haha,hehe是在前边依次寄放的

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,要插入的数据

 图片 24

在names中往xiaoming前边插入meimei那一个新的因素

 

r.lset(name,
index, value):

对name对应的list中的某一个索引位置重新赋值

# 参数:
    # name,redis的name
    # index,list的索引位置
    # value,要设置的值

 图片 25

正是做贰个修改数据的操作,把第6个因素退换值

 

r.lrem(name,
value, num):

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

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

 图片 26

在linux中先数据要去除的个数,然后在输入删除的值

 

lpop(name):

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

# 更多:
    # rpop(name) 表示从右向左操作

 图片 27

把names列表中的第三个因素移出了

 

lindex(name,
index):在name对应的列表中依照目录获取列表成分

 

lrange(name,
start, end):

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

 图片 28

把names列表中颇负的要素都抽取来就是0,-1.然后大家能够看看大家后边存进去的先抽出来,表明列表是先入后出

 图片 29

获得names中从第3个到第多个要素,暗中认可是从0算起的,

ltrim(name,
start, end):

在name对应的列表中移除没有在start-end索引之间的值
# 参数:
    # name,redis的name
    # start,索引的起始位置
    # end,索引结束位置

 图片 30

移出除了第2第八个要素之外的装有的要素

 

rpoplpush(src,
dst)

从一个列表取出最右边的元素,同时将其添加至另一个列表的最左边
# 参数:
    # src,要取数据的列表的name
    # dst,要添加数据的列表的name

 图片 31

把names中的最左边的xiaoming 移到了names2的最侧边

blpop(keys,
timeout):

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

# 参数:
    # keys,redis的name的集合
    # timeout,超时时间,当元素所有列表的元素获取完之后,阻塞等待列表内有数据的时间(秒), 0 表示永远阻塞

# 更多:
    # r.brpop(keys, timeout),从右向左获取数据

 图片 32

把names中的数据每一次从左往右删除,假使names里面有成分就及时删除,肩负就等候4s。

这边有多少个使用:作者把日子设置成40,然后在起步三个redis客商端,然后在那40s之内自个儿在给names加多一个新的因素,然后那边等待的顾客端就任何时候把那个值收取来了

图片 33图片 34

今昔一定于运营了七个进程,三个足以后列表中归入值,一个足以从列表中取值,有一点像队列,想生产者花费者,因为除去的时候会重临删除的值就也正是抽取来数据

brpoplpush(src,
dst, timeout=0)

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

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

 图片 35

不怕把names2的因素移到names中,从右端移到了左端

 

自定义增量迭代

由于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集合便是差别意再一次的列表

图片 36

 

上海教室能够看看,笔者往names中插入了6个值,不过在集合中实际就唯有3个值,所以说集结是不相同意再度的列表

sadd(name,values):name对应的汇集中添英镑素

scard(name): 获取name对应的集合瓜月素的个数

sdiff(keys,
*args):在第4个name会集中且不再别的name对应的集纳中的成分集结(差集:不含B集结成分的装有A成分)

图片 37

 

sdiffstore(dest,
keys,
*args):获取第四个name对应的集聚中且别的不再name对应的聚焦,再讲其投入新的dest集合中

图片 38

 

把差集的结果存到集结n6中,

sinter(keys,
*args):(数学里的混合)

图片 39

 

sinterstore(dest,
keys, *args):获取集结之间的插花,再讲其步入到dest对应的集聚中

sismember(name,
value):检查value是还是不是是name对应的联谊的分子

smembers(name): 获取name对应的集纳的持有成员,集结不可能用切成块去取,因为它是冬季的

图片 40

收获会集names3的全体值

 

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)

 图片 41

给相应的因素设置权值,用来排序;先权值后值

 

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)

 图片 42

图片 43

 

zrank(name,
value): 

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

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

图片 44

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进行操作
# aggregate的值为:  SUM  MIN  MAX

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(*names):根据删除redis中的放肆数据类型

exists(name): 检查评定redis的name是还是不是存在

keys(pattern=’*’):

# 根据模型获取redis的name

# 更多:
    # KEYS * 匹配数据库中所有 key 。
    # KEYS h?llo 匹配 hello , hallo 和 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下

  redis暗许有15个db,从0-15 ,能够用select 进行切换

randomkey():随机获得贰个redis的name(不删除)

type(name):获取name对应值的等级次序

scan(cursor=0, match=None, count=None)
scan_iter(match=None, count=None)

同字符串操作,用于增量迭代获取key

4.管道:

redis-py私下认可在施行每回央求都会创建(连接池申请连接)和断开(归还连接池)三遍一而再操作,就算想要在一遍呼吁中内定多少个指令,则能够运用pipline完结一回呼吁钦点多少个指令,何况暗中认可意况下叁次pipline
是原子性操作。

import redis

pool = redis.ConnectionPool(host='192.168.1.101', 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', 'teacher')

pipe.execute()

 

5.通知订阅

图片 45

那那几个怎么落到实处的吗?

 1 import redis
 2 class RedisHelper:
 3     def __init__(self):
 4         self.__conn = redis.Redis(host='192.168.1.101')
 5         self.chan_sub = 'fm104.7'
 6         self.chan_pub = 'fm104.7'
 7 
 8     def public(self, msg):
 9         self.__conn.publish(self.chan_pub, msg)
10         return True
11 
12     def subscribe(self):
13         pub = self.__conn.pubsub()#打开收音机
14         pub.subscribe(self.chan_sub)#调频道
15         pub.parse_response()#准备接收 
16         return pub

 订阅:

from RedisHelper import RedisHelper

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

while True:
    msg = redis_sub.parse_response()
    print(msg)

 

发布:

from RedisHelper import RedisHelper

obj = RedisHelper()
obj.public('hello,i am testing')

 

能够八个发表新闻,通过同四个频段传给一人:

图片 46

 

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website